C++ 使用可变模板的任意维数组

如何在C++11中创建一个数组类，它可以像

Array < int, 2, 3, 4> a, b; 
Array < char, 3, 4> d; 
Array < short, 2> e;

我还需要重载运算符作为

T &operator[size_t i_1][size_t i_2]...[size_t i_D]; 

---

这是不存在的。我该怎么做呢？

最简单的方法是嵌套

std:：array

：

#include<array>

template<class T, size_t size, size_t... sizes>
struct ArrayImpl {
    using type = std::array<typename ArrayImpl<T, sizes...>::type, size>;
};

template<class T, size_t size>
struct ArrayImpl<T, size> {
    using type = std::array<T, size>;
};

template<class T, size_t... sizes>
using Array = typename ArrayImpl<T, sizes...>::type;

#包括
模板
结构ArrayImpl{
使用type=std:：array；
};
模板
结构ArrayImpl{
使用type=std:：array；
};
模板
使用Array=typename ArrayImpl:：type；

在此解决方案中，

Array

与

std:：Array

-由更小维度的数组组成的数组相同

这还显示了如何为多个维度实现

操作符[]

<对象的代码>运算符[]需要返回还为其定义了

运算符[]

的对象。在这种情况下，它引用的是更小维度的数组。

请尝试以下操作：

#include <iostream>

template <typename T, int N1, int... N2>
class Array
{

public:

    Array() {}

    ~Array() {}

    Array<T,N2...>& operator[](int index)
    {
        return data[index];
    }

private:

    Array<T,N2...> data[N1];
};

template<typename T, int N>
class Array<T,N>
{

public:

    Array() {}

    ~Array() {}

    T& operator[](int index)
    {
        return data[index];
    }

private:

    T data[N];
};

int main()
{
    Array < int, 2, 3, 4> a, b;
    Array < char, 3, 4> d;
    Array < short, 2> e;

    a[0][1][2] = 15;
    d[1][2]    = 'a';

    std::cout << "a[0][1][2] = " << a[0][1][2] << std::endl;
    std::cout << "d[1][2]    = " << d[1][2]    << std::endl;

    return 0;
}

#包括
模板
类数组
{
公众：
数组（）{}
~Array（）{}
数组和运算符[]（整数索引）
{
返回数据[索引]；
}
私人：
数组数据[N1]；
};
模板
类数组
{
公众：
数组（）{}
~Array（）{}
T&运算符[]（整数索引）
{
返回数据[索引]；
}
私人：
T数据[N]；
};
int main（）
{
数组a，b；
数组d；
数组e；
a[0][1][2]=15；
d[1][2]=“a”；
标准：：cout
#include <iostream>

template <typename T, int N1, int... N2>
class Array
{

public:

    Array() {}

    ~Array() {}

    Array<T,N2...>& operator[](int index)
    {
        return data[index];
    }

private:

    Array<T,N2...> data[N1];
};

template<typename T, int N>
class Array<T,N>
{

public:

    Array() {}

    ~Array() {}

    T& operator[](int index)
    {
        return data[index];
    }

private:

    T data[N];
};

int main()
{
    Array < int, 2, 3, 4> a, b;
    Array < char, 3, 4> d;
    Array < short, 2> e;

    a[0][1][2] = 15;
    d[1][2]    = 'a';

    std::cout << "a[0][1][2] = " << a[0][1][2] << std::endl;
    std::cout << "d[1][2]    = " << d[1][2]    << std::endl;

    return 0;
}