C++/C++11使用初始化器列表初始化对象的静态数组/向量的有效方法,并支持基于范围的
C++/C++11 Efficient way to have static array/vector of objects initialized with initializer list, and supporting range-based for
假设您想要一个预定义值/对象(常量或非常量)的静态数组与一个类相关联。可能的选项包括使用std:vector
、std::array
或C-style array (ie. [])
,或。例如,
In.hpp:
class MyClass {
public:
static const std::vector<MyClass> vec_pre; // No efficient way to construct with initializer list, since it always uses Copy Contructor, even when using std::move
static const std::array<MyClass, 2> arr_pre; // Have to specify size which is inconvenient
static const MyClass carr_pre[]; // Not compatible with C++11 for-range since size is undefined
};
In.cpp
const std::vector<MyClass> MyClass::vec_pre = { std::move(MyClass{1,2,3}), std::move(MyClass{4,5,6}) }; // NOTE: This still uses copy constructor
const std::array<MyClass, 2> MyClass::arr_pre= { MyClass{1,2,3}, MyClass{4,5,6} };
const ZwSColour ZwSColour::carr_pre[] = { MyClass{1,2,3}, MyClass{1,2,3} }
在最初写这篇文章时,我选择了std::vector
,因为我不必指定大小,我得到了向量类的所有优点,这似乎是现代C++的方法。问题:在测试时,我注意到它会调用Move构造函数,但仍然会为每个元素调用Copy构造函数。原因是std::initializer_list
只允许对其成员进行const访问,因此向量必须将它们从initializer_list复制到自己的存储中。尽管它在启动时只做过一次,这是低效的,而且似乎没有办法解决它,所以我考虑了其他选项(std::array
和C-array[]
)。
第二种选择是使用std::array
,这也是一种现代C++方式,并且它不存在为每个值调用Copy构造函数的问题,因为它不需要创建副本(不确定为什么?)。std::array
还有一个好处,即不需要将每个值封装在std::move()
中。但是,麻烦的是必须首先指定大小,所以每次添加/删除元素时,也必须更改大小。有很多方法可以解决这个问题,但没有一种是理想的。正如@Ricky65所说,你应该能够进行
std::array <int> arr = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 }; //automatically deduces its size from the initializer list :)
这给我留下了最后一个选项——好的旧C样式数组[]——它的好处是我不必指定大小,而且它的效率很高,因为它不为每个对象调用Copy构造函数。缺点是它不是真正的现代C++,最大的缺点是,如果你没有在.hpp头中指定数组的大小,那么范围的C++11就不能工作,因为编译器会抱怨
不能使用不完整的类型"const MyClass[]"作为范围
您可以通过在标头中指定数组的大小来克服此错误(但这很不方便,并且生成难以维护的代码,因为每次从初始值设定项列表中添加/删除项时都需要调整大小),或者使用constexpr
并在.hpp标头中完全声明数组和值
constexpr static MyArray my_array[] = { MyClass{1,2,3}, MyClass{4,5,6} };
注意:constexpr"变通"只适用于POD,因此在这种情况下不能用于Class对象。以上示例将导致编译时错误Invalid use of incomplete type 'MyClass'
我正在尽可能地编写最佳实践的现代C++(例如使用复制和交换习惯用法),因此想知道为类定义静态数组的最佳方法是什么。。。
- 无需指定大小
- 不需要进行复制构造(如果可能的话,也可以进行移动构造)
- 它可以与C++一起用于范围
- 不需要在头文件中指定
- 应编译/工作于Clang/LLVM 3.5、Visual Studio 2013 Update 4 RC和GCC 4.8.1
第1版:另一篇关于无法从初始值设定项列表中移动值的向量问题的文章
第2版:更多关于使用std::array而无需指定大小的信息,它还创建/使用make_array(),并提到有一个将make_arra()作为标准的建议。原创SO链接由@Neil Kirk评论提供。
EDIT3:vector
方法的另一个问题(至少在本例中是这样)是不能使用const T
或T
迭代项。它只允许使用const T&
(当它是static const
时)和const T&
/T&
(当它为static
时)进行迭代。这种限制的原因是什么?
解决方案的描述性回答
@Yakk的解决方案似乎是唯一的解决方案,也适用于Visual C++2013 Update 4 RC。
我发现使用最新的C++11/14标准很难实现这样一个微不足道的问题,这让我感到震惊。
数据不必存储在类中。事实上,将数据存储在类的static
成员中会泄露实现细节。
您所需要公开的只是数据是可用的,并且该数据对于类类型是全局的。这不涉及公开存储详细信息:您只需要公开存储访问的详细信息。
特别是,您希望在数据上向for(:)
循环公开该功能,并以C++11风格的方式对其进行操作。那就暴露出来吧。
将数据存储在C样式数组(或std::array
,我不在乎)中类的.cpp
文件中的匿名命名空间中。
在类中显示以下内容:
namespace details {
template<
class R,
class iterator_traits,
class iterator_category,
bool is_random_access=std::is_base_of<
std::random_access_iterator_tag,
iterator_category
>::value
>
struct random_access_support {};
template<class R, class iterator_traits, class iterator_category>
struct random_access_support<R, iterator_traits, iterator_category, true> {
R const* self() const { return static_cast<R const*>(this); }
template<class S>
typename iterator_traits::reference operator[](S&&s) const {
return self()->begin()[std::forward<S>(s)];
}
std::size_t size() const { return self()->end()-self()->begin(); }
};
}
template<class It>
struct range:details::random_access_support<
range<It>,
std::iterator_traits<It>,
typename std::iterator_traits<It>::iterator_category
> {
using value_type = typename std::iterator_traits<It>::value_type;
using reference = typename std::iterator_traits<It>::reference;
using iterator = It;
using iterator_category = typename std::iterator_traits<It>::iterator_category;
using pointer = typename std::iterator_traits<It>::pointer;
It begin() const { return b; }
It end() const { return e; }
bool empty() const { return b==e; }
reference front() const { return *b; }
reference back() const { return *std::prev(e); }
range( It s, It f ):b(s),e(f) {}
range()=default;
range(range const&)=default;
range& operator=(range const&)=default;
private:
It b; It e;
};
namespace details {
template<class T>
struct array_view_helper:range<T*> {
using non_const_T = typename std::remove_const<T>::type;
T* data() const { return this->begin(); }
array_view_helper( array_view_helper const& ) = default;
array_view_helper():range<T*>(nullptr, nullptr){}
array_view_helper& operator=(array_view_helper const&)=default;
template<class A>
explicit operator std::vector<non_const_T, A>() const {
return { this->begin(), this->end() };
}
std::vector<non_const_T> as_vector() const {
return std::vector<non_const_T>(*this);
}
template<std::size_t N>
array_view_helper( T(&arr)[N] ):range<T*>(arr+0, arr+N) {}
template<std::size_t N>
array_view_helper( std::array<T,N>&arr ):range<T*>(arr.data(), arr.data()+N) {}
template<class A>
array_view_helper( std::vector<T,A>&vec ):range<T*>(vec.data(), vec.data()+vec.size()) {}
array_view_helper( T*s, T*f ):range<T*>(s,f) {}
};
}
// non-const
template<class T>
struct array_view:details::array_view_helper<T> {
using base = details::array_view_helper<T>;
// using base::base in C++11 compliant compilers:
template<std::size_t N>
array_view( T(&arr)[N] ):base(arr) {}
template<std::size_t N>
array_view( std::array<T,N>&arr ):base(arr) {}
template<class A>
array_view( std::vector<T,A>&vec ):base(vec) {}
array_view( T*s, T*f ):base(s,f) {}
// special methods:
array_view( array_view const& ) = default;
array_view() = default;
array_view& operator=(array_view const&)=default;
};
template<class T>
struct array_view<T const>:details::array_view_helper<const T> {
using base = details::array_view_helper<const T>;
// using base::base in C++11 compliant compilers:
template<std::size_t N>
array_view( std::array<T const,N>&arr ):base(arr) {}
array_view( T const*s, T const*f ):base(s,f) {}
template<std::size_t N>
array_view( T const(&arr)[N] ):base(arr) {}
// special methods:
array_view( array_view const& ) = default;
array_view() = default;
array_view& operator=(array_view const&)=default;
// const T only constructors:
template<std::size_t N>
array_view( std::array<T,N> const&arr ):base(arr.data(), arr.data()+N) {}
template<std::size_t N>
array_view( std::array<T const,N> const&arr ):base(arr.data(), arr.data()+N) {}
template<class A>
array_view( std::vector<T,A> const&vec ):base(vec.data(), vec.data()+vec.size()) {}
array_view( std::initializer_list<T> il):base(il.begin(), il.end()) {}
};
其至少是一些视图类的草图。实例
然后将array_view<MyClass>
公开为类的static
成员,该类被初始化为您在.cpp
文件中创建的数组。
range<It>
是一系列迭代器,其作用类似于非拥有容器。在SFINAE级别阻止对size
或[]
的非恒定时间调用是非常愚蠢的。back()
是公开的,如果您在无效迭代器上调用它,它就无法编译。
CCD_ 32使CCD_ 33更加有用。
array_view<T>
是一个range<T*>
,它有一堆来自连续缓冲容器的构造函数,如C数组、std::array
s和std::vector
s(实际上是一个详尽的列表)。
这很有用,因为通过array_view
的访问与访问数组第一个元素的原始指针的效率差不多,但我们得到了容器所拥有的许多不错的方法,并且它适用于循环的范围。通常,如果一个函数使用std::vector<T> const& v
,则可以将其替换为使用array_view<T> v
的函数,这将是一个临时替换。最大的例外是operator vector
,它是显式的,以避免意外分配。
我个人喜欢您的constexpr static int my_array[] = {MyClass{1, 2, 3}, MyClass{1, 2, 3}};
,如果C风格的数组满足您的需求,我认为您不应该回避它。
如果你真的想使用std::vector
,你可以使用static const std::vector<MyClass*> vec_pre;
。所以你的.cpp
文件顶部会有这个:
namespace{
MyClass A{1, 2, 3}, B{1, 2, 3}, C{1, 2, 3};
}
const std::vector<MyClass*> MyClass::vec_pre{&A, &B, &C};
在DarkMatter的评论后编辑:
在阅读了您的评论之后,我的方法可能存在一些可维护性隐患。在你的.cpp
:中仍然可以这样完成
namespace{
MyClass temp[]{MyClass{1, 2, 3}, MyClass{1, 2, 3}, MyClass{1, 2, 3}};
const MyClass* pTemp[]{&temp[0], &temp[1], &temp[2]};
}
const std::vector<MyClass*> MyClass::vec_pre{begin(pTemp), end{pTemp}};
您还可以通过创建一个宏来消除条目可维护性的重复问题。
这里有一种在不复制或移动的情况下设置矢量的方法。
它没有使用有支撑的初始值设定项,但你的开头一段表明你主要关心的是避免复制和移动;而不是使用支撑初始化器的绝对要求。
// header
const std::vector<MyClass> &get_vec();
// cpp file
const std::vector<MyClass> &get_vec()
{
static std::vector<MyClass> x;
if ( x.empty() )
{
x.emplace_back(1,2,3);
x.emplace_back(4,5,6);
// etc.
}
return x;
}
- 为什么C++不支持对未初始化变量进行智能分析?
- C++20 从括号中的值列表初始化聚合,不支持内部数组
- 为什么 GCC 6.3 在没有显式 C++11 支持的情况下编译此大括号初始化列表代码
- 在上下文初始化之前查询支持的最高 OpenGL 版本?
- 为什么不支持容器适配器中元素的初始化和迭代
- 多变量初始化编译器支持
- MAC上的叮当声不支持统一初始化
- 为什么即将到来的范围库不支持一个范围的容器初始化
- 为什么具有私有成员的聚合不支持C++大括号初始化
- 聚合初始化不支持构造函数访问
- 为什么默认成员值禁止使用支持列表初始化
- Visual Studio 2012 不支持 unordered_set (C++ STL) 的列表初始化?
- 为什么clang和gcc处理结构的支持初始化与类内初始化不同
- 提升说 boost::log 不支持分叉进程。如果记录器直到分叉后才初始化,情况仍然如此吗?
- C++/C++11使用初始化器列表初始化对象的静态数组/向量的有效方法,并支持基于范围的
- 为什么自动和模板类型推导在支持初始化程序中有所不同
- 如何使我的向量类支持直接初始化/赋值
- 不支持非平凡的指定初始化程序
- 执行 std::元组和 std::p air 支持聚合初始化
- Visual Studio 2013 CTP是否支持非整型的类内静态const初始化式?