C++/C++ 11使用初始化列表初始化对象的静态数组/向量的高效方法,并支持基于范围的

Question

假设您想要一个与类关联的预定义值/对象(const或非const)的静态数组.可能的选项是使用std:vector,std::array或C-style array (ie. []),或.例如,

在.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
};

在.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++方式,它不会遇到为每个值调用复制构造函数的问题,因为它不需要创建副本(不确定为什么虽然完全？).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 for-range不能正常工作,因为编译器会抱怨

不能使用不完整类型'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++ for-range一起使用
• 不需要在头文件中指定
• 应该编译/工作Clang/LLVM 3.5,Visual Studio 2013 Update 4 RC和GCC 4.8.1.

EDIT1:关于无法从初始化列表中移动值的向量问题的另一篇文章

EDIT2:关于使用std :: array而不需要指定大小的更多信息,它也创建/使用make_array(),并提到有一个make_array()的提议成为标准.原创SO链接由@Neil Kirk发表评论.

编辑3:该vector方法的另一个问题(至少在这种情况下)是你不能使用const T或迭代项目T.它只允许使用const T&(当它的时候static const)和const T&/ T&(当它的时候)迭代static.这种限制的原因是什么？

描述性解决方案的答案

@ Yakk的解决方案似乎是唯一的解决方案,也适用于Visual C++ 2013 Update 4 RC.

我发现使用最新的C++ 11/14标准很难实现这样一个微不足道的问题令人震惊.

Answer 1

数据不必存储在类中.实际上,将数据存储在static类的成员中会泄漏实现细节.

您需要公开的只是数据可用,并且该数据对类类型是全局的.这不涉及公开存储详细信息:您需要公开的只是存储访问详细信息.

特别是,您希望公开for(:)循环数据的能力,并以C++ 11样式的方式对其进行操作.所以揭露那个.

将数据存储.cpp在C类样式数组中的类文件中的匿名命名空间中(或者std::array,我不在乎).

在课堂上公开以下内容:

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>是一系列迭代器,其作用类似于非拥有容器.一些tomfoolery用于阻止SFINAE级别size或非[]SFINAE级别的非常规时间呼叫. back()如果在无效迭代器上调用它,则会暴露并且无法编译.

一个make_range(Container)让range<It>更有用.

array_view<T>是一个range<T*>有连续缓冲容器的一堆构造函数,比如C-arrays,std::arrays和std::vectors.(实际上是一份详尽的清单).

这很有用,因为通过array_viewa访问与访问数组的原始指针到第一个元素一样有效,但是我们获得了容器所具有的许多好方法,并且它适用于range-for循环.一般来说,如果一个函数采用a std::vector<T> const& v,你可以用一个带有a的函数替换它,array_view<T> v它将是一个替代品.最明显的例外是operator vector避免意外分配.