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

Question

假设您想要一个与类关联的预定义值/对象(常量或非常量)的静态数组。可能的选项是使用 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因为我不必指定大小，所以我得到了 vector 类的所有优点，这似乎是现代 C++ 的方式。问题:在测试时，我注意到它会调用 Move 构造函数，但仍然为每个元素调用 Copy 构造函数。原因是 std::initializer_list only allows const access to its members ，因此 vector 必须将它们从 initializer_list 复制到自己的存储中。即使在启动时只执行一次，这是低效的，而且似乎没有办法绕过它 ，所以我查看了其他选项( std::array 和 C-array[] )。

第二种选择是使用 std::array ，这也是一种现代 C++ 方式，它不会遇到为每个值调用 Copy Constructor 的问题，因为它不需要创建拷贝(不知道为什么？)。 std::array还有一个好处是您不需要将每个值都包装在 std::move() 中。 .但是，它有一个烦恼，您必须先指定大小，因此每次添加/删除元素时，您也必须更改大小。 There are ways around this但它们都不是理想的。正如@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 就不能工作，因为编译器会提示

Cannot use incomplete type 'const MyClass []' as a range

您可以通过在 header 中指定数组的大小来克服此错误(但这很不方便，并且会产生难以维护的代码，因为每次从初始化列表中添加/删除项目时都需要调整大小)，或者使用 constexpr并在 .hpp header 中完全声明数组和值

constexpr static MyArray my_array[] = { MyClass{1,2,3}, MyClass{4,5,6} };

注意:constexpr“变通方法”仅适用于 POD，因此在这种情况下不能用于类对象。上面的例子会导致编译时错误 Invalid use of incomplete type 'MyClass'
我正在尝试尽可能编写最佳实践的现代 C++(例如，使用 copy-and-swap idiom )，所以想知道为类定义静态数组的最佳方法是什么......

无需指定大小

不需要复制构造(或移动构造，如果可能)

可以与 C++ for-range 一起使用

不需要在头文件中指定的

应该为 Clang/LLVM 3.5、Visual Studio 2013 Update 4 RC 和 GCC 4.8.1 编译/工作。

编辑 1:Another post about vector problem of not being able to move values from initializer list

编辑2:More info on using std::array without the need to specify size ，它也创建/使用 make_array()，并提到有一个 proposal让 make_array() 成为一个标准。原始 SO 链接由@Neil Kirk 提供评论。

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

解决方案的描述性答案

@Yakk 的 solution似乎是唯一的解决方案，也适用于 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()) {}
};

这至少是一些 View 类的草图。 live example

然后暴露一个array_view<MyClass>作为 static你的类的成员，它被初始化为你在 .cpp 中创建的数组文件。
range<It>是一系列迭代器，就像一个非拥有容器。做了一些愚蠢的事情来阻止对 size 的非恒定时间调用或 []在 SFINAE 级别。 back()如果您在无效的迭代器上调用它，则会暴露并且编译失败。

一个 make_range(Container)使 range<It>更有用。
array_view<T>是 range<T*>它有一堆来自连续缓冲区容器的构造函数，比如 C 数组，std::array s 和 std::vector s。 (实际上是一个详尽的 list )。

这很有用，因为通过 array_view 访问与访问指向数组的第一个元素的原始指针一样有效，但是我们获得了容器具有的许多不错的方法，并且它可以与 range-for 循环一起使用。一般来说，如果一个函数采用 std::vector<T> const& v ，您可以将其替换为带有 array_view<T> v 的函数它将是一个临时替代品。最大的异常(exception)是 operator vector ，这是明确的，以避免意外分配。