Создать массив с n-ым количеством измерений

int dimensions = 3;
ndspace<int, int> nds(dimensions);
    
const int val = 999;
 
std::vector<int> ix_args = { 3, 1, 7 };
 
ndspace[ix_args] = val;

#include <stack>
#include <string>
#include <cstdlib>
#include <clocale>
#include <iostream>
 
using namespace std;
 
#include <map>
#include <string>
#include <iostream>
 
using std::map;
 
template<typename T1 = int>
class ndspace : public std::map<std::string, T1>
{
    private:
        std::map<std::string, T1>* m_pndmap;
 
    public:
        ndspace() { m_pndmap = this; };
        ~ndspace() { m_pndmap = nullptr; }
 
        void show()
        {
            for (auto it = m_pndmap->begin(); it != m_pndmap->end(); it++)
            {
                std::string indexes = it->first;
                std::cout << indexes;
 
                std::cout << " => " << it->second << std::endl;
            }
        }
 
    public:
        T1& operator[](const std::string& indexes)
        {
            m_pndmap->insert(std::make_pair(indexes, -1));
            return m_pndmap->at(indexes);
        }
};
 
const int N[] = { 3, 4, 5 };
 
int main()
{
    ndspace<int> nds;
 
    int n = 0;
    for (int i1 = 0; i1 < N[0]; i1++)
        for (int i2 = 0; i2 < N[1]; i2++)
            for (int i3 = 0; i3 < N[2]; i3++)
            {
                string s_key = "\0";
                s_key.append(std::to_string(i1) + ",");
                s_key.append(std::to_string(i2) + ",");
                s_key.append(std::to_string(i3));
 
                nds[s_key] = n++;
            }
 
    nds.show();
 
    std::cin.get();
    std::cin.get();
 
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//3.
///////////////////////////////////////////////////////////////////////////////
//задается в cin по шаблону (тип в скобках) имя массива (string)
//количество измерений dim (int) количество елементов в каждом
//измерении(лист intoв через комму) цифры которые нужно поместить в массив,
//через комму. Получается что-то такое А 2 2,3 1,2,3,4,5,6 - создает
//двухмерную матрицу 2 строки 3 столбца.
//B 3 3, 2, 3 ... - трехмерную матрицу 3 на 2 на 3.
//Если dim = 1 создается вектор, 0 - скаляр.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < size_t    >   T_dimensions;
typedef std::vector     < int       >   T_values;
///////////////////////////////////////////////////////////////////////////////
const   char    COMMA_SYMB  {','};
const   char    SPACE_SYMB  {' '};
///////////////////////////////////////////////////////////////////////////////
class   T_matr
{
    //-------------------------------------------------------------------------
    T_dimensions    dimensions_;
    T_values        values_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_matr
        (
            T_dimensions    const   &   dimensions,
            T_values        const   &   values
        )
        :
        dimensions_     ( dimensions    ),
        values_         ( values        )
    {}
    //-------------------------------------------------------------------------
    T_matr( T_str   s )
    {
        std::replace
            (
                s.begin     (),
                s.end       (),
                COMMA_SYMB,
                SPACE_SYMB
            );
 
        std::istringstream  istr(s);
        int     n{};
        istr    >>  n;
 
        dimensions_.resize      (n);
        int     values_count    {1};
 
        for( auto   &   dim     :   dimensions_ )
        {
            istr    >>  dim;
            values_count    *=  dim;
        }
 
        values_.resize( values_count );
        for( auto   &   val     :   values_ )
        {
            istr    >>  val;
        }
    }
    //-------------------------------------------------------------------------
    int     &   operator()
        (
            std::initializer_list< size_t >     indexes     =   {}
        )
    {
        if  (
                    indexes     .size   ()
                !=  dimensions_ .size   ()
            )
        {
            throw   std::invalid_argument
                        (
                                T_str(__FUNCTION__)
                            +   ": incorrect number of indexes in argument"
                        );
        }//if
 
        size_t  shift{};
 
        if  (
                indexes.size()
            )
        {
            auto    it_start    =   indexes.begin();
            shift               =   *it_start;
            ++it_start;
            size_t  dim_ind{1};
 
            for (
                    auto
                    indexes_it  =   it_start;
                    indexes_it  !=  indexes.end();
                    ++indexes_it, ++dim_ind
                )
            {
                shift   *=  dim( dim_ind );
                shift   +=  *indexes_it;
            }
        }//if
 
        return  values_.at( shift );
    }
    //-------------------------------------------------------------------------
    size_t  dim( size_t     ind )
    {
        return  dimensions_.at( ind );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_str   s;
    //getline( std::cin,  s );
 
    s   =   "3 2,3,4 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24";
 
    T_matr  matr(s);
 
    for( size_t  i{}; i < matr.dim(0); ++i )
    {
        for( size_t  j{}; j < matr.dim(1); ++j )
        {
            for( size_t  k{}; k < matr.dim(2); ++k )
            {
                std::cout   <<  matr({i, j, k})  <<  '\t';
            }
 
            std::cout   <<  std::endl;
        }//for
 
        std::cout   <<  std::endl;
    }//for
 
    matr({0, 0, 0})     =   1000;
    std::cout   <<  matr({0, 0, 0})     <<  std::endl;
 
 
    s   =   "0  15";
    T_matr  matr_scalar(s);
    std::cout   <<  matr_scalar()  <<  std::endl;
 
 
    s   =   "1  6   10,20,30,40,50,60";
    T_matr  matr_vect(s);
    for( size_t  i{}; i < matr_vect.dim(0); ++i )
    {
        std::cout   <<  matr_vect({i})  <<  '\t';
    }
    std::cout   <<  std::endl;
 
 
    std::cout   <<  "\n\nDemonstration of exceptions when wrong function calls:"  <<  std::endl;
    try
    {
        std::cout   <<  matr_scalar({10, 20, 30})  <<  std::endl;
    }
    catch( std::exception   &   e )
    {
        std::cout   <<  e.what()    <<  std::endl;
    }
 
 
    try
    {
        std::cout   <<  matr_vect({1000})  <<  '\t';
    }
    catch( std::exception   &   e )
    {
        std::cout   <<  e.what()    <<  std::endl;
    }
}

#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
class Array { //объект массива
    private: 
        unsigned int numDim;
        vector<int> dimSize;
        int D0; //для скаляра
        vector<int> D1; //для вектора
        vector<vector<int> > D2; //2хмерная матрица
        vector<vector<vector<int> > > D3; //3мерная
    public:
        Array(int Dnum, int value) { //конструктор для скаляра
            int D0 = value;
            numDim = Dnum;
        }
    //для всего остального
        Array(int Dnum, vector<int> Dsize, vector<int>  values) {
 
            numDim = Dnum;
            dimSize = Dsize;
            switch(Dnum) {
                case 1: //1мерный
                    D1 = values;
                    break;
                case 2: //2мерный
                    {
                    vector<int> newCol;
                    int count = 0;  
                    for (int i = 0; i<dimSize.at(0); i++) {
                        for (int j = 0; j<dimSize.at(1); j++) {
                                newCol.push_back(values.at(count));
                                count++;
                                }
                        D2.push_back(newCol);
                        newCol.clear();
                        }
                    break;
                    }
                case 3: //3мерный
                    {
                    vector<int> newCol1;
                    vector<vector<int> > newCol2;
                    int count = 0;
                    
                    for (int i=0; i<dimSize.at(0); i++) {
                        for (int j = 0; j<dimSize.at(1); j++) {
                            for (int k = 0; k<dimSize.at(2); k++) {
                                newCol1.push_back(values.at(count));
                                count++;
                            }
                        newCol2.push_back(newCol1);
                        newCol1.clear();
                        }
                        D3.push_back(newCol2);
                        newCol2.clear();
                    }
                    break;
                    }
            
 
 
 
 
            }
        }
 
        void Print() {
            for (int i = 0; i<dimSize.at(0); i++) {
                for(int j = 0; j<dimSize.at(1); j++) {
                    for(int k = 0; k<dimSize.at(2); k++) {
 
                    cout<<D3.at(i).at(j).at(k)<<endl;
                }
            }
        }
        }
};
            
 
int main() 
{
 
 
    Array a(Dn, siz, val);
    a.Print();
 
    return 0;
}

int main()
{ int i, dd[] = {2,3};   // Размеры по измерениям
  int ii[2] = { 0, 0 };  // Массив индексов
  MAS *ms;
 
 ms = Create(2, dd); // создаем массив
 for(i=0; i<2*3; i++) ms->M[i] = i+1;  // "Простое" заполнение
 ii[0] = 1; ii[1] = 2;  // "Научное" Заполнение элемента [1][2]
 setVal(ms, ii, 6 );
 return 0;
}

///////////////////////////////////////////////////////////////////////////////
//4.
///////////////////////////////////////////////////////////////////////////////
//задается в cin по шаблону (тип в скобках) имя массива (string)
//количество измерений dim (int) количество елементов в каждом
//измерении(лист intoв через комму) цифры которые нужно поместить в массив,
//через комму. Получается что-то такое А 2 2,3 1,2,3,4,5,6 - создает
//двухмерную матрицу 2 строки 3 столбца.
//B 3 3, 2, 3 ... - трехмерную матрицу 3 на 2 на 3.
//Если dim = 1 создается вектор, 0 - скаляр.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < size_t    >   T_dimensions;
typedef T_dimensions                    T_indexes;
typedef std::vector     < int       >   T_values;
///////////////////////////////////////////////////////////////////////////////
const   char    COMMA_SYMB  {','};
const   char    SPACE_SYMB  {' '};
///////////////////////////////////////////////////////////////////////////////
class   T_matr
{
    //-------------------------------------------------------------------------
    T_dimensions    dimensions_;
    T_values        values_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_matr
        (
            T_dimensions    const   &   dimensions,
            T_values        const   &   values
        )
        :
        dimensions_     ( dimensions    ),
        values_         ( values        )
    {}
    //-------------------------------------------------------------------------
    T_matr( T_str   s )
    {
        std::replace
            (
                s.begin     (),
                s.end       (),
                COMMA_SYMB,
                SPACE_SYMB
            );
 
        std::istringstream  istr(s);
        int     n{};
        istr    >>  n;
 
        dimensions_.resize      (n);
        int     values_count    {1};
 
        for( auto   &   dim     :   dimensions_ )
        {
            istr    >>  dim;
            values_count    *=  dim;
        }
 
        values_.resize( values_count );
        for( auto   &   val     :   values_ )
        {
            istr    >>  val;
        }
    }
    //-------------------------------------------------------------------------
    int     &   operator()
        (
            std::initializer_list< size_t >     indexes
        )
    {
        return  (*this)( T_indexes( indexes ) );
    }
    //-------------------------------------------------------------------------
    int     operator()
        (
            std::initializer_list< size_t >     indexes
        )                                                                   const
    {
        return  (*this)( T_indexes( indexes ) );
    }
    //-------------------------------------------------------------------------
    size_t  dim( size_t     ind )                                           const
    {
        return  dimensions_.at( ind );
    }
    //-------------------------------------------------------------------------
    void    print()                                                         const
    {
        for( size_t  i{}; i < values_.size(); ++i )
        {
            std::cout   <<  values_[i]  <<  '\t';
 
            if  (
                    i   ==  values_.size() - 1
                )
            {
                break;
            }
 
            size_t  mod_val{1};
 
            for (
                    auto
                    it  =   dimensions_.rbegin  ();
                    it  !=  dimensions_.rend    ();
                    ++it
                )
            {
                mod_val     *=  *it;
 
                if  (
                        (i + 1)     %   mod_val     ==      0
                    )
                {
                    std::cout   <<  std::endl;
                }
            }//for
        }//for
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    int     &   operator()
        (
            T_indexes   const   &   indexes     =   {}
        )
    {
 
        return  values_.at  (
                                shift_for_indexes( indexes )
                            );
    }
    //-------------------------------------------------------------------------
    int     operator()
        (
            T_indexes   const   &   indexes     =   {}
        )                                                                   const
    {
 
        return  values_.at  (
                                shift_for_indexes( indexes )
                            );
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    size_t  shift_for_indexes
        (
            T_indexes   const   &   indexes
        )                                                                   const
    {
        if  (
                    indexes     .size   ()
                !=  dimensions_ .size   ()
            )
        {
            throw   std::invalid_argument
                        (
                                T_str(__FUNCTION__)
                            +   ": incorrect number of indexes in argument"
                        );
        }//if
 
        size_t  shift{};
 
        if  (
                indexes.size()
            )
        {
            auto    it_start    =   indexes.begin();
            shift               =   *it_start;
            ++it_start;
            size_t  dim_ind{1};
 
            for (
                    auto
                    indexes_it  =   it_start;
                    indexes_it  !=  indexes.end();
                    ++indexes_it, ++dim_ind
                )
            {
                shift   *=  dim( dim_ind );
                shift   +=  *indexes_it;
            }
        }//if
 
        return  shift;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_str   s;
    //getline( std::cin,  s );
 
    s   =   "3 2,3,4 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24";
 
    T_matr  matr(s);
 
    for( size_t  i{}; i < matr.dim(0); ++i )
    {
        for( size_t  j{}; j < matr.dim(1); ++j )
        {
            for( size_t  k{}; k < matr.dim(2); ++k )
            {
                std::cout   <<  matr({i, j, k})  <<  '\t';
            }
 
            std::cout   <<  std::endl;
        }//for
 
        std::cout   <<  std::endl;
    }//for
 
    matr({0, 0, 0})     =   1000;
    std::cout   <<  matr({0, 0, 0})     <<  std::endl;
 
 
    s   =   "0  15";
    T_matr  matr_scalar(s);
    std::cout   <<  matr_scalar()  <<  std::endl;
    matr_scalar()   =   333333;
    std::cout   <<  matr_scalar()  <<  std::endl;
 
 
 
    s   =   "1  6   10,20,30,40,50,60";
    T_matr  matr_vect(s);
    for( size_t  i{}; i < matr_vect.dim(0); ++i )
    {
        std::cout   <<  matr_vect({i})  <<  '\t';
    }
    std::cout   <<  std::endl;
 
 
    std::cout   <<  "\n\nDemonstration of exceptions when wrong function calls:"  <<  std::endl;
    try
    {
        std::cout   <<  matr_scalar({10, 20, 30})  <<  std::endl;
    }
    catch( std::exception   &   e )
    {
        std::cout   <<  e.what()    <<  std::endl;
    }
 
 
    try
    {
        std::cout   <<  matr_vect({1000})  <<  '\t';
    }
    catch( std::exception   &   e )
    {
        std::cout   <<  e.what()    <<  std::endl;
    }
 
 
    std::cout   <<  "\n\nDemonstration of function 'print':"  <<  std::endl;
    matr        .print  ();
    matr_scalar .print  ();
    matr_vect   .print  ();
}