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

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

虽然上面提到的函数的实现很顺利，但我还是停留在了实现这个类的“开始”，也就是初始化数组... 我的问题如下：

1. 有没有这样的构造函数，这样不同深度的嵌套初始化列表创建不同的数组，比如：

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

2. 编译器很容易推断出以下数组的类型：

   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% 可能是从 initilizer_list 中提取数据的源代码，它有点 hacky。整个技巧是使用正确的类型隐式调用构造函数。

#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