由于某些原因，我不得不在C++中实现一个多维数组类。有问题的数组是这样的：
template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
class Array final
{
private:
std::vector<size_t> shape_;
std::vector<T> data_;
public:
// Some public methods
}
T是存储在数组中的元素类型，并且数组的维度没有模板化，因为用户应该能够重塑数组，例如：
Array<int> array = Array<int>::zeros(3, 2, 4);
array.reshape(4, 6);
尽管上面提到的函数的实现非常顺利，但我还是停留在实现这个类的"开始"，即初始化数组。。。我的问题如下：
有没有什么方法可以有这样的构造函数，这样不同深度的嵌套初始值设定项列表就可以创建不同的数组，比如：
Array<int> a = {1, 2}; // Dimension: 1, Shape: 2 Array<int> b = {{1}, {2}}; // Dimension: 2, Shape: 2x1我实现构造函数的方法使这两个数组相同，这不是我想要的。此外，clang抱怨了支撑标量，这似乎是问题所在。目前，我的天真方法，上面的问题看起来像这个
... Array() :data_(0), shape_{0} {} Array(std::initializer_list<T> list) :data_(list), shape_{list.size()} {} Array(std::initializer_list<Array> lists) { // Implementation } ...编译器很容易推导出以下数组的类型：
Array c = {1, 2}; // T = int Array d = {1.0, 2.0}; // T = double但我没能为多维推理写一个有效的推理指南：
Array e = {{1, 2}, {3, 4}}; // Expects T = int Array f = {{1.0, 2.0}, {3.0, 4.0}}; // Expects T = double有没有办法为这门课写一本类型推导指南？
只涉及initializer_list的唯一可能的解决方案是声明与可能维度数量相等的构造函数数量：
template<class T>
Array(std::initializer_list<T>)
template<class T>
Array(std::initializer_list<std::initializer_list<T>>)
...
原因在[temp.deduc.call]/1:(p模板参数(中给出
如果从p中删除引用和cv限定符会得到std:：initializer_list[…]，并且参数是非空的初始值设定项列表([dcl.init.list](，则会对初始值设定值列表的每个元素执行推导，将p'作为函数模板参数类型，将初始值设定器元素作为其参数[…]否则，初始值设定项列表参数会导致该参数被视为非推导上下文
因此，如果函数参数是std::initializer_list<T>，则初始化器列表参数的嵌套元素本身不能是初始化器列表。
如果不想声明那么多构造函数，另一种选择是显式指定参数的类型为std::initializer_list，以避免模板参数推导。下面我使用了一个名为"nest"的类，只是因为它的名称较短：
#include<initializer_list>
using namespace std;
template<class T>
struct nest{
initializer_list<T> value;
nest(initializer_list<T> value):value(value){}
};
template<class T>
nest(initializer_list<T>)->nest<T>;
struct x{
template<class T>
x(initializer_list<T>);
};
int main(){
x a{1,2,3,4};
x b{nest{1,2},nest{3,4}};
x c{nest{nest{1},nest{2}},nest{nest{3},nest{4}}};
}
i可能有点晚了，但如果没有多个构造函数，它是100%可能的。下面是从initializer_list中提取数据的源代码，这有点麻烦。整个技巧是使用正确的类型隐式调用构造函数。
#include <initializer_list>
#include <iostream>
using namespace std;
class ShapeElem{
public:
ShapeElem* next;
int len;
ShapeElem(int _len,ShapeElem* _next): next(_next),len(_len){}
void print_shape(){
if (next != nullptr){
cout <<" "<< len;
next->print_shape();
}else{
cout << " " << len << "n";
}
}
int array_len(){
if (next != nullptr){
return len*next->array_len();
}else{
return len;
}
}
};
template<class value_type>
class ArrayInit{
public:
void* data = nullptr;
size_t len;
bool is_final;
ArrayInit(std::initializer_list<value_type> init) : data((void*)init.begin()), len(init.size()),is_final(true){}
ArrayInit(std::initializer_list<ArrayInit<value_type>> init): data((void*)init.begin()), len(init.size()),is_final(false){}
ShapeElem* shape(){
if(is_final){
ShapeElem* out = new ShapeElem(len,nullptr);
}else{
ArrayInit<value_type>* first = (ArrayInit<value_type>*)data;
ShapeElem* out = new ShapeElem(len,first->shape());
}
}
void assign(value_type** pointer){
if(is_final){
for(size_t k = 0; k < len;k ++ ){
(*pointer)[k] = ( ((value_type*)data)[k]);
}
(*pointer) = (*pointer) + len;
}else{
ArrayInit<value_type>* data_array = (ArrayInit<value_type>*)data;
for(int k = 0;k < len;k++){
data_array[k].assign(pointer);
}
}
}
};
int main(){
auto x = ArrayInit<int>({{1,2,3},{92,1,3}});
auto shape = x.shape();
shape->print_shape();
int* data = new int[shape->array_len()];
int* running_pointer = data;
x.assign(&running_pointer);
for(int i = 0;i < shape->array_len();i++){
cout << " " << data[i];
}
cout << "n";
}
输出
2 3
1 2 3 92 1 3
shape((函数将返回每个维度上张量的形状。数组在写入时会完全保存。创建类似形状的东西真的很重要，因为这会给你元素的顺序。
如果你想从张量中得到一个特定的索引，比如说a[1][2][3]正确的位置在1*a.shape[1]a.shape[2]+2a.shape[2]+3
如果你不想创建张量或多维数组，我建议将所有内容存储为列表，那么1D数组中的条目引用就非常复杂了。这个代码应该仍然是一个很好的起点。一些小细节和技巧可以在中找到：https://github.com/martinpflaum/multidimensional_array_cpp