Как быть с многоразмерными массивами? Рекурсия?

#include <iostream>
#include <time.h>
using namespace std;

template < class T > class Narray
{
int S;
int N;
int* r;
int* e;
T* m;
public:
Narray(int aN,int* ar,int(*p)(int),int x); // N - число измерений, массив количества элементов для каждого измерения
~Narray() { delete r,m,e; };
void print(); //вывод содержимого массива
T& operator[](int j) { return m[j]; }

Narray< T >& operator=(const Narray< T >&); // операция присвоения

Narray< T > operator+(Narray< T >& a);
};

template < class T > Narray< T >::Narray(int aN,int* ar,int(*p)(int),int x):N(aN)
{ int j,l,s;
r=new T[N];
e=new T[N];
for(S=1,j=0;j-N;S*=r[j++]=ar[j]);
m=new T[ S ];
for(e[0]=l=1;l-N;e[l++]=s) for(s=1,j=N-1;j>=N-l;s*=r[j--]);
for(j=0;j-S;m[j++]=p(x));
}

template < class T > void Narray< T >::print()
{
int j,l;
for(l=0;l-S;cout << m[l++] << '\t') for(j=1;j-N;) if(l % e[j++]==0) printf("\n");
cout << endl;
}

template< class T > Narray< T >& Narray< T >::operator=(const Narray< T >& r)
{ int j;
if(this!=&r) for(j=0;j-S;j++) m[j]=r.m[j];
return *this;
}

template < class T > Narray< T > Narray< T >::operator+(Narray< T >& a)
{ int j;
Narray< T > R(N,r,num,0);
for(j=0;j-S;j++) R[j]=m[j]+a.m[j];
return R;
}

int init(int i)
{
return rand() % i;
}

int num(int i)
{
return i;
}

#define K 3 // для трёхмерного массива
#define L 2 // для двухмерного массива
int main()
{
srand(time(NULL));
{
int r[K]={2,3,4};
Narray<int> Y(K,r,num,0); Y.print();
Narray<int> M(K,r,init,5); M.print();
Narray<int> N(K,r,init,4); N.print();
Y=M+N;
Y.print();
Y=M;
Y.print();
}
{
int r[L]={2,3};
Narray<int> Y(L,r,num,0); Y.print();
Narray<int> M(L,r,init,5); M.print();
Narray<int> N(L,r,init,4); N.print();
Y=M+N;
Y.print();
Y=M;
Y.print();
}
return 0;
}

Функция проходится по массиву и в самом начале проверяет, является ли элемент массивом или простым объектом.

Ни на одном известном мне языке невозможно инициализировать массив, количество измерений которого неизвестно.