C++ C++/C++；11使用初始值设定项列表初始化静态数组/向量对象的有效方法，并支持基于范围的_C++_C++11_For Loop_Static

C++ C++/C++；11使用初始值设定项列表初始化静态数组/向量对象的有效方法，并支持基于范围的

c++ c++11 for-loop

C++ C++/C++；11使用初始值设定项列表初始化静态数组/向量对象的有效方法，并支持基于范围的,c++,c++11,for-loop,static,C++,C++11,For Loop,Static,假设您想要有一个与类关联的预定义值/对象（常量或非常量）的静态数组。可能的选择是使用std:vector、std:：array或C样式数组（即.[]），或。比如说, 在水电站： class MyClass { public: static const std::vector<MyClass> vec_pre; // No efficient way to construct with initializer list, since it always uses Copy Co

假设您想要有一个与类关联的预定义值/对象（常量或非常量）的静态数组。可能的选择是使用

std:vector

、

std:：array

或

C样式数组（即.[]）

，或。比如说,

在水电站：

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

这就剩下最后一个选项了——好的旧C样式数组[]，它的优点是我不必指定大小，而且效率很高，因为它不会为每个对象调用复制构造函数。缺点是它不是真正的现代C++，最大的缺点是如果你不指定.Hpp报头中数组的大小，那么C++的11范围不适用于编译器抱怨

无法将不完整类型“const MyClass[]”用作范围

您可以通过在标头中指定数组的大小来克服此错误（但这很不方便，并且产生难以维护的代码，因为每次从初始值设定项列表中添加/删除项时都需要调整大小），或者使用

constexpr

并在.hpp头中完全声明数组和值

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

注意：constexpr“变通”仅适用于POD，因此在这种情况下不能用于类对象。上述示例将导致编译时错误

不完整类型“MyClass”的无效使用
<>我试图在可能的情况下编写最佳实践C++（例如使用），因此想知道为类定义静态数组的最好方法是什么？

无需指定大小
不需要复制构造（或移动构造，如果可能）
可用于C++的范围< /LI>
不需要在头文件中指定
应编译/使用Clang/LLVM 3.5、Visual Studio 2013更新4 RC和GCC 4.8.1

编辑1：
EDIT2:，它还创建/使用make_array（），并提到make_array（）将成为标准。原始SO链接由@Neil Kirk评论提供
EDIT3:vector
方法的另一个问题（至少在本例中）是不能使用const T
或T
对项目进行迭代。它只允许使用常量T&
（当它是静态常量时）和常量T&
/T&
（当它是静态时）进行迭代。这种限制的原因是什么
对解决方案的描述性回答
YAKK的出现似乎是唯一的解决方案，并且也适用于Visual C++ 2013更新4 RC。
使用最新的C++11/14标准很难实现这样一个小问题，这让我感到震惊。
数据不必存储在类中。事实上，将数据存储在类的静态成员中正在泄漏实现细节
您需要公开的只是数据可用，并且该数据对于类类型是全局的。这并不涉及公开存储详细信息：只需公开存储访问详细信息
特别是，您希望公开（：）
在数据上循环的能力，并以C++11风格对其进行操作。因此，请确切地揭露这一点
将数据存储在C样式数组中类的.cpp
文件中的匿名命名空间中（或者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()) {}
};

名称空间详细信息{
模板<
R类，
类迭代器，
类迭代器_类，
bool is_random_access=std:：is_base_of<
std:：随机访问迭代器标记，
迭代器类
>：：价值
>
结构随机访问支持{}；
模板
结构随机访问支持{
R const*self（）const{return static_cast（this）；}
模板
类型名迭代器特征：：引用运算符[]（S&&S）常量{
返回self（）->begin（）[std:：forward（s）]；
}
std:：size_t size（）const{return self（）->end（）-self（）->begin（）；}
};
}
模板
结构范围：详细信息：：随机访问\u支持<
范围
迭代器特征，
类型名称std:：迭代器特征：：迭代器类别
> {
使用value\u type=typename std:：iterator\u traits:：value\u type；
使用reference=typename std:：iterator\u traits:：reference；
使用迭代器=It；
使用iterator_category=typename std:：iterator_traits:：iterator_category；
使用pointer=typename std:：iterator\u traits:：pointer；
它的begin（）常量{return b；}
It end（）常量{return e；}
bool empty（）常量{返回b==e；}
reference front（）常量{return*b；}
reference back（）常量{return*std:：prev（e）；}
范围（It s，It f）：b（s），e（f）{}
range（）=默认值；
范围（范围常数&）=默认值；
范围和运算符=（范围常数&）=默认值；
私人：
它是b；它是e；
};
命名空间详细信息{
模板
结构数组\视图\辅助对象：范围{
使用non_const_T=typename std:：remove_const:：type；
T*data（）常量{返回此->开始（）；}
数组\视图\辅助对象（数组\视图\辅助对象常量&）=默认值；
数组\视图\辅助对象（）：范围（nullptr，nullptr）{
数组\视图\辅助对象和运算符=（数组\视图\辅助对象常量&）=默认值；
模板
显式运算符std:：vector（）常量{
返回{this->begin（），this->end（）}；
}
std:：vector as_vector（）常量{
返回std：：vector（*this）；
}
模板
数组\u视图\u辅助对象（T（&arr）[N]）：范围（arr+0，arr+N）{
模板
array\u view\u helper（std:：array&arr）：范围（arr.data（），arr.data（）+N）{
模板
数组\视图\辅助对象（std:：vector&vec）：范围（vec.data（），vec.data（）+vec.size（））{
数组视图辅助对象（T*s，T*f）：范围（s，f）{}
};
}
//非常量
模板
结构数组\视图：详细信息：：数组\视图\辅助对象{
使用base=details:：array\u view\u helper；
//在符合C++11的编译器中使用base:：base：
模板
数组视图（T（&arr）[N]）：基（arr）{
模板
阵列视图（std:：arr）
constexpr static MyArray my_array[] = { MyClass{1,2,3}, MyClass{4,5,6} };

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()) {}
};

namespace{
    MyClass A{1, 2, 3}, B{1, 2, 3}, C{1, 2, 3};
}
const std::vector<MyClass*> MyClass::vec_pre{&A, &B, &C};

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