Tukukkk

For some reasons I have to implement a multidimensional array class in C++.
The array in question is something like this:

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 is the type of elements stored in the array, and that the dimensions of the array is not templated since the user should be able to reshape the array, for example:

Array<int> array = Array<int>::zeros(3, 2, 4);

array.reshape(4, 6);

Though implementation of the functions mentioned above went quite smoothly, I stuck at the "beginning" of implementing this class, that is to initialize the array...
My questions are as follows:

1. 
   

   Is there any method to have an constructor like this, such that nested initializer lists of different depths create different arrays, like:

   
   
   

   Array<int> a = {1, 2}; // Dimension: 1, Shape: 2
   
   Array<int> b = {{1}, {2}}; // Dimension: 2, Shape: 2x1
   
   

   
   
   

   My approach to implement the constructors made these two arrays the same, which is not what I want. Plus, clang complained about the braced scalars, which seem to be the problem. Currently my naive approach which suffers from the problem above looks like this

   
   
   

   ...
   
       Array() :data_(0), shape_{0} {}
   
       Array(std::initializer_list<T> list) :data_(list), shape_{list.size()} {}
   
       Array(std::initializer_list<Array> lists)
   
       {
   
           // Implementation
   
       }
   
   ...
   
   

   
   


2. 
   

   It's easy for the compiler to deduct the types for the following arrays:

   
   
   

   Array c = {1, 2}; // T = int
   
   Array d = {1.0, 2.0}; // T = double
   
   

   
   
   

   But I failed to write a working deduction guide for multidimensional ones:

   
   
   

   Array e = {{1, 2}, {3, 4}}; // Expects T = int
   
   Array f = {{1.0, 2.0}, {3.0, 4.0}}; // Expects T = double
   
   

   
   
   

   Is there any way to write a type deduction guide for this class?

   
   

The only possible solution that would only involve initializer_list would be to declare a number of constructors that equals the number of possible dimensions:

template<class T>

Array(std::initializer_list<T>)



template<class T>

Array(std::initializer_list<std::initializer_list<T>>)



...

The reason is given in [temp.deduc.call]/1: (P the template parameter)

If removing references and cv-qualifiers from P gives std::initializer_­list [...] and the argument is a non-empty initializer list ([dcl.init.list]), then deduction is performed instead for each element of the initializer list, taking P' as a function template parameter type and the initializer element as its argument [...]
Otherwise, an initializer list argument causes the parameter to be considered a non-deduced context

So if the function parameter is std::initializer_list<T> the nested element of the initializer list argument can not be itself an initializer list.

If you don't want to declare that many constructors, the other option is to explictly specify that the argument is of type std::initializer_list in order to avoid template argument deduction. Below I use a class named "nest" just because its name is shorter:

#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}}};

  }