Question

由于某些原因，我必须在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
```
我实现构造函数的方法使这两个数组相同，这不是我想要的。另外，c抱怨抱怨标量，这似乎是问题所在。目前，我遇到上述问题的幼稚方法看起来像这样
```
...
    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

有什么办法为此类编写类型推导指南吗？

Answer 1

仅涉及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}}};
  }

Answer 2

我可能有点晚了，但它 100% 可能没有下面的多个构造函数是从 intilizer_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

如果您不想创建张量或多维数组，我建议将所有内容存储为列表，那么一维数组中条目的引用非常复杂。这段代码应该仍然是一个很好的起点。可以在以下位置找到一些小细节和技巧：https://github.com/martinpflaum/multidimensional_array_cpp

嵌套的initializer_list用于初始化多维数组

2 个答案: