c++ - std::array 类型初始化

Question

使用 astd::array你可以像这样初始化它：

std::array<int,5> myArray = {1,2,3,4,5};

如果我在哪里尝试创建自己的数组类，我将如何做类似的事情？

Answer 1

std::array依赖聚合初始化（初始化结构的C方式），基本上这是有效的c++：

struct A {
    int values[2];
    size_t size;
};

A a = {{42, 44}, 2U}; // No constructor involved
//     |         |--- a.size
//     |--- a.values

现在，如果您删除该size属性，您将获得：

struct A {
    int values[2];
};

A a = {{42, 44}}; // Valid!

但是 c++ 给了你一些叫做括号省略的东西，我们允许你省略内括号，所以：

A a = {42, 44}; // Still valid!

现在，只需制作A一个模板：

template <typename T, size_t N>
struct A {
    T data[N];
};

A<int, 2> a = {{42, 44}};

请注意，这不initializer_list使用用于std::vector、等的哪个std::list。

另请注意：

A<int, 2> a1{42, 44}; // Not valid prior to c++14
A<int, 2> a2{{42, 44}}; // Ok even for c++11

请注意，无论您默认使用什么版本，clang 都会发出警告。

---

的极简版本std::array可能如下所示：

template <typename T, size_t N>
struct my_array {

    T _data[N];

    T& operator[] (size_t i) { return _data[i]; }
    const T& operator[] (size_t i) const { return _data[i]; }

    constexpr size_t size () const { return N; }

    T* begin () { return _data; }
    const T* begin () const{ return _data; }
    T* end () { return _data + size(); }
    T* end () const { return _data + size(); }

};

请注意，该标准std::array的内容比这多得多（很多typedefs、other methods、很多重载，...），但这是一个让您入门的小基础。

另请注意，_data必须这样才能public使聚合初始化private起作用（如果您有/protected成员，它将不起作用！）。

Answer 2

这是一个简单的实现，它支持使用元素列表进行初始化：

//template class 'array' takes 'T' (the type of the array) and 'size'
template<typename T, std::size_t size>
class array
{
public:
    //This is the concept of initializer lists (wrapper around variadic arguments, that
    //allows for easy access)
    array(std::initializer_list<T> list)
    {
        //Loop through each value in 'list', and assign it to internal array
        for (std::size_t i = 0; i < list.size(); ++i)
            arr[i] = *(list.begin() + i); //list.begin() returns an iterator to the firsts
                                          //element, which can be moved using +
                                          //(deferenced to get the value)
    }

    //Overloads operator[] for easy access (no bounds checking!)
    T operator[](std::size_t index)
    {
        return arr[index];
    }
private:
    T arr[size]; //internal array
};

然后你可以像这样使用它：

array<int, 2> a = { 2, 5 };
int b = a[0]; //'b' == '2'