C>>#define VT std::string

C>>int _tmain(int argc, _TCHAR* argv[])
C>>{
C>>    multiarray<VT> ar(3,10);
C>>    multiarray<VT> ar2(3,10);
    
C>>    ar[10][4][1] = "First";    

C>>    ar2 = ar;

C>>    VT s = ar2[10][4][1];
        
C>>    printf("[ value = %s]
C>>",s.c_str());

C>>    return 0;
C>>}

C>>
GC>

   // Добавлено в класс определение
  typedef typename VAL_TYPE value_type;
   

  typedef multiarray<std::string> StringArray;

  void someFunction( StringArray &ar )
  {
      StringArray::value_type s = ar[2][2];  // value_type - добавлено в классе ( typedef typename VAL_TYPE value_type )
      fprintf(stdout,"At 2,2 = %s",s.c_str());
  }

  ...
   StringArray sa(4,4);
   
   sa[2][2] = "Hello";
   
   someFunction ( sa );
 ...

 StringArray sa(4,4);
 std::string ***pStr = sa; // !?

GC>

YourContainer::operator=(YourContainer const& src)
{
    if(this == &src) return;
    YourContainer(src).swap(*this);
}

#include <boost/multi_array.hpp>
#include <boost/smart_ptr.hpp>

template<typename element, size_t NumDims>
class multi_array_multi_pointer
{
  template<size_t I>
  struct dim_impl;

  template<>
  struct dim_impl<1>
  {
    typedef typename element * pointer_type; 
    pointer_type ptr;

    void init(element ** pointer, size_t const* dim) 
    {
      ptr = *pointer;
      (*pointer) += *dim;
    }

    pointer_type get() const
    { 
      return ptr;
    }
  };

  template<size_t I>
  struct dim_impl
  {
    typedef dim_impl<I - 1> Inner;
    typedef typename Inner::pointer_type inner_pointer, * pointer_type; 
    boost::scoped_array<Inner> data;
    boost::scoped_array<inner_pointer> pointers;

    void init(element ** pointer, size_t const* dim)
    {
      data.reset(new Inner[*dim]);
      pointers.reset(new inner_pointer[*dim]);
      ptr = pointers.get();
      for (size_t i = 0; i != *dim; ++i)
      {
        data[i].init(pointer, dim + 1);
        pointers[i] = data[i].ptr;
      }
    }

    pointer_type get() const
    { 
      return pointers.get();
    }
  };

  typedef dim_impl<NumDims> dims_t;
  dims_t dims;

public:
  typedef typename dims_t::pointer_type pointer_type;

  multi_array_multi_pointer(element * data, size_t const (&extents)[NumDims])
  {
    dims.init(&data, extents);
  }

  pointer_type get()
  {
    return dims.get();
  }
};

int main()
{
  // Create a 3D array that is 3 x 4 x 2
  typedef boost::multi_array<double, 3> array_type;
  typedef array_type::index index;
  array_type a(boost::extents[3][4][2]);

   // Обращение к элементам
  a[0][0][0] = 1;
  a[2][0][1] = 2;
  a[0][3][0] = 3;
  a[2][3][1] = 4;
  double * i = a.origin();
  
  size_t ss[] = {3, 4, 2};
  multi_array_multi_pointer<double, 3> mp(i, ss);
  
  double *** mp_raw = mp.get();
  printf("%f %f %f %f",
    mp_raw[0][0][0],
    mp_raw[2][0][1],
    mp_raw[0][3][0],
    mp_raw[2][3][1]);
  
  return 0;
}

template<class MultiArray>
class multi_array_raw_pointer
{
  public:
    explicit multi_array_raw_pointer(MultiArray const& array); // принимает класс, реализующий boost::multi_array.
    // плюс неявное копирование и присваивание.
    pointer_type get(); // возвращает T***
    /*  operator pointer_type() - этого не надо */
}

template<class MultiArray>
multi_array_raw_pointer make_raw_pointer(MultiArray const& array)
{
  return multi_array_raw_pointer<MultiArray>(array);
}

void legacy_api(double***);
typedef boost::multi_array<double, 4> A;
A a;

legacy_api(make_raw_pointer(a).get());

или
multi_array_raw_pointer<A> rp(a);
legacy_api(rp.get());

{
     //Размерность первая
    const unsigned int s1 = 4;
     //Размерность вторая
    const unsigned int s2 = 8;
     //Временный массив для передачи данных функции
    int **arr = new int*[s1];
    for(unsigned int i=0; i<s1; i++)
        arr[i] = new int[s2];
        
     //Заполняем массив
    for(unsigned int i=0; i<s1; i++)
        for(unsigned int j=0; j<s2; j++)
            d[i][j] = <какое-то значение>;
            
     //Вызываем некий метод некого объекта(это всё не важно, главное что ему
     //требуется указатель на указатель, являющийся массивом целых чисел)
     //прототипа навроде такого: setAD2(int** a, unsgined int size1, unsigned int size2)
    fv.setAD2(arr, s1, s2);
     //Метод забрал часть данных из двухмерного массива в своё внутренее хранилище,
     //о котором мы ничего не знаем и знать не хотим, массив нам больше не нужен
        
     //Освобождаем память
    for(unsigned int i=0; i<s1; i++)
        delete[] arr[i];
    delete[] arr;
}

{
     //Объявили массив и выделили память
    Array<int> a(10);

     //Заполняем массив
    for(unsigned int i=0; i<a.size(); i++)
        d[i] = <какое-то значение>;
    
     //Вызвали функцию требующу указатель на инт, являющийся массивом и размер массива
    funcAr(a.getPoint(), a.size());
    
     //Деструктор вызовется автоматически и 
     //беспокоится о не освобождении памяти не нужно
}

template <typename type> class A
{
  private:
     type *arr;
  public:
    A() : arr(0) {};
    A(int x) {arr = new type[x];};
   type& opertor [] (int index) {return arr[index];};
};

{
    A<A<int> > ob1(10);   //Получается память будет выделена только под одно измерение, как выделить под другое?
    a[3][8] = 5;  //ошибка, обращаемся к памяти по "левому" адресу
     //Возможно сделать некий метод класса А под названием getMem, выделяющий память и вызывать его так:
    for(unsigned int i=0; i<ob1.getSize(); i++)
        ob1[i].getMem(10);

    a[3][8] = 5;
     //всё отлично, память выделена
    assert(a[3][8] == 5);
}

template <typename type, unsigned int size> class A
{
  private:
     type *arr;
  public:
    A() : {arr = new type[size];};
   type& opertor [] (int index) {return arr[index];};
};

{
  A<A<int, 10>, 10> ob1; 
  a[3][8] = 5;  //всё отлично, память выделена
}

template <size_t len2, typename U> Arr<T, len> & operator= (Arr<U, len2> & arr2)
{
    for (int j = 0; j < len2; ++j)
        arr[j] = arr2[j];
    return *this;
}

{
    Array<Array<int>> a; //Здесь каким-то образом задаю обе размерности
    a[7][5] = 5;
    std::cout << a[7][5] << endl;
    Array<Array<int>> b; //Другого размера, нежели a
    b = a; //Копирует значения (те которые поместятся, т.к. размер может быть и меньше)
    b.reSize(50); //Перевыделяет память и копирует значения
    a.newSize(100); //Освобождает занятую память и выделяет новый блок под сто элементов
    Array<Array<int>> c(b); //Конструктор копирования, если у c и b разные мерности,
     //то хочется чтобы такой код был определён как ошибачный на стадии компиляции
     //И главная цель - вызов функции с прототипом похожим на вот такой func(int** a, int s1, int s2),
     //каким-нибудь простым способом, например таким:
    func(a.getPoint(), a.size(), a[0].size());    
}

   // Create a 3D array that is 3 x 4 x 2
  typedef boost::multi_array<double, 3> array_type;
  typedef array_type::index index;
  array_type A(boost::extents[3][4][2]);

   // Обращение к элементам
  A[0][0][0] = 1;

GC>Необходимо сделать объект — оболочку для массивов, для удобства работы с массивами. (Проблема стара как мир )

GC>{
GC>     //Размерность первая
GC>    const unsigned int s1 = 4;
GC>     //Размерность вторая
GC>    const unsigned int s2 = 8;
GC>     //Временный массив для передачи данных функции
GC>    int **arr = new int*[s1];
GC>    for(unsigned int i=0; i<s1; i++)
GC>        arr[i] = new int[s2];
        
GC>     //Заполняем массив
GC>    for(unsigned int i=0; i<s1; i++)
GC>        for(unsigned int j=0; j<s2; j++)
GC>            d[i][j] = <какое-то значение>;
            
GC>     //Вызываем некий метод некого объекта(это всё не важно, главное что ему
GC>     //требуется указатель на указатель, являющийся массивом целых чисел)
GC>     //прототипа навроде такого: setAD2(int** a, unsgined int size1, unsigned int size2)
GC>    fv.setAD2(arr, s1, s2);
GC>     //Метод забрал часть данных из двухмерного массива в своё внутренее хранилище,
GC>     //о котором мы ничего не знаем и знать не хотим, массив нам больше не нужен
        
GC>     //Освобождаем память
GC>    for(unsigned int i=0; i<s1; i++)
GC>        delete[] arr[i];
GC>    delete[] arr;
GC>}
GC>

GC>Утомляет всё это писать, хочется написать выделение и освобождение памяти раз и навсегда ( для всех массивов), чтобы можно было так:

GC>{
GC>     //Объявили массив и выделили память
GC>    Array<int> a(10);

GC>     //Заполняем массив
GC>    for(unsigned int i=0; i<a.size(); i++)
GC>        d[i] = <какое-то значение>;
    
GC>     //Вызвали функцию требующу указатель на инт, являющийся массивом и размер массива
GC>    funcAr(a.getPoint(), a.size());
    
GC>     //Деструктор вызовется автоматически и 
GC>     //беспокоится о не освобождении памяти не нужно
GC>}
GC>

GC>template <typename type> class A
GC>{
GC>  private:
GC>     type *arr;
GC>  public:
GC>    A() : arr(0) {};
GC>    A(int x) {arr = new type[x];};
GC>   type& opertor [] (int index) {return arr[index];};
GC>};
GC>

GC>{
GC>    A<A<int> > ob1(10);   //Получается память будет выделена только под одно измерение, как выделить под другое?
GC>    a[3][8] = 5;  //ошибка, обращаемся к памяти по "левому" адресу
GC>     //Возможно сделать некий метод класса А под названием getMem, выделяющий память и вызывать его так:
GC>    for(unsigned int i=0; i<ob1.getSize(); i++)
GC>        ob1[i].getMem(10);

GC>    a[3][8] = 5;
GC>     //всё отлично, память выделена
GC>    assert(a[3][8] == 5);
GC>}
GC>

GC>template <typename type, unsigned int size> class A
GC>{
GC>  private:
GC>     type *arr;
GC>  public:
GC>    A() : {arr = new type[size];};
GC>   type& opertor [] (int index) {return arr[index];};
GC>};
GC>

GC>{
GC>  A<A<int, 10>, 10> ob1; 
GC>  a[3][8] = 5;  //всё отлично, память выделена
GC>}
GC>

GC>template <size_t len2, typename U> Arr<T, len> & operator= (Arr<U, len2> & arr2)
GC>{
GC>    for (int j = 0; j < len2; ++j)
GC>        arr[j] = arr2[j];
GC>    return *this;
GC>}
GC>

GC>{
GC>    Array<Array<int>> a; //Здесь каким-то образом задаю обе размерности
GC>    a[7][5] = 5;
GC>    std::cout << a[7][5] << endl;
GC>    Array<Array<int>> b; //Другого размера, нежели a
GC>    b = a; //Копирует значения (те которые поместятся, т.к. размер может быть и меньше)
GC>    b.reSize(50); //Перевыделяет память и копирует значения
GC>    a.newSize(100); //Освобождает занятую память и выделяет новый блок под сто элементов
GC>    Array<Array<int>> c(b); //Конструктор копирования, если у c и b разные мерности,
GC>     //то хочется чтобы такой код был определён как ошибачный на стадии компиляции
GC>     //И главная цель - вызов функции с прототипом похожим на вот такой func(int** a, int s1, int s2),
GC>     //каким-нибудь простым способом, например таким:
GC>    func(a.getPoint(), a.size(), a[0].size());    
GC>}
GC>

GC>(Я уже давно е...сь с этой идеей. (е...сь — еграюсь ))

template < typename VAL_TYPE >
class multiarray {
public:
    multiarray ( int dimension,int elements )
        :dim_(dimension)
        ,elem_(elements)
        ,arr ( 0 )
        ,x(0)
    {
        totalSize_ =  ( dim_ + 1 ) *  ( sizeof ( VAL_TYPE ) *  ( elem_ ) );
        arr = new VAL_TYPE [ totalSize_ ];
    }

    ~multiarray()
    {
        delete[] arr;
    }

    multiarray& operator [] (int i)
    {
        ep = i;
        x += i * elem_;        
        return *this;
    }
    
    operator VAL_TYPE& ()
    {
        int p = x - ( elem_ - ep );
        x = 0;
        return arr[p];
    }

    multiarray& operator = ( VAL_TYPE val )
    {
        int p = x - ( elem_ - ep );
        x = 0;

        arr[p] = val;
        return *this;
    }

    multiarray& operator = ( multiarray& rhs )
    {
        x     = ep = 0;
        dim_  = rhs.dim_;
        elem_ = rhs.elem_;
        for ( int i = 0; i< totalSize_;i++ )
            arr[i] = rhs.arr [ i ];
        return *this;
    }

private:
    int ep;
    int x;
    VAL_TYPE *arr;
    int dim_;
    int elem_;
    int totalSize_;
};

#define VT std::string

int _tmain(int argc, _TCHAR* argv[])
{
    multiarray<VT> ar(3,10);
    multiarray<VT> ar2(3,10);
    
    ar[10][4][1] = "First";    

    ar2 = ar;

    VT s = ar2[10][4][1];
        
    printf("[ value = %s]
",s.c_str());

    return 0;
}

C>#define VT std::string

C>int _tmain(int argc, _TCHAR* argv[])
C>{
C>    multiarray<VT> ar(3,10);
C>    multiarray<VT> ar2(3,10);
    
C>    ar[10][4][1] = "First";    

C>    ar2 = ar;

C>    VT s = ar2[10][4][1];
        
C>    printf("[ value = %s]
C>",s.c_str());

C>    return 0;
C>}

C>

C> typedef multiarray<std::string> StringArray;

C> void someFunction( StringArray &ar )
C> {
C> StringArray::value_type s = ar[2][2]; // value_type — добавлено в классе ( typedef typename VAL_TYPE value_type )
C> fprintf(stdout,"At 2,2 = %s",s.c_str());
C> }

C> ...
C> StringArray sa(4,4);

C> sa[2][2] = "Hello";

C> someFunction ( sa );

C>C> StringArray sa(4,4);
C> std::string ***pStr = sa; // !?

{
int* ar1;
Array<int> tmp_ar1(10);
ar1 = tmp_ar1.getPoint();

int** ar2;
Array<Array<int>> tmp_ar2(10,20);
ar2 = tmp_ar2.getPoint();

int*** ar3;
Array<Array<int>> tmp_ar3(10,20,5);
ar3 = tmp_ar3.getPoint();

....

int***....** arN; //Здесь указатель на указатели на указатель... в кол-ве N штук
Array<Array<Array<Array<******Array<int>*****>>> tmp_arN(10,20,5, ....,50,10); //Здесь N параметров — размер для каждой мерности
arN = tmp_arN.getPoint();
}

AG>void legacy_api(double***);
AG>

class test
{
    private:
        static unsigned int val;
    public:
        int x;
        test() {x = ++val;};
};

unsigned int test::val = 0;

//Обратите внимание на то что для каждой размерности
//память выделяется совершенно одинаково,
//не зависимо от типа элементов массива
//и от итоговой общей размерности массива
//Это я и положу в основу многомерного массива.

int main()
{      
    const unsigned int S = 3;
    int *b = new int[S];
    test ****a = reinterpret_cast<test****>(b);
    int *b_psev;
    int *c;
        
    for(unsigned int i=0; i<S; i++)
    {
        c = new int[S];
        b_psev = reinterpret_cast<int*>(b);
        b_psev[i] = reinterpret_cast<int>(c);
        
        for(unsigned int j=0; j<S; j++)
        {
            c = new int[S];
            b_psev = reinterpret_cast<int*>(b[i]);
            b_psev[j] = reinterpret_cast<int>(c);
            
            for(unsigned int k=0; k<S; k++)
                a[i][j][k] = new test[S];
        }
    }
    
    for(unsigned int i=0; i<S; i++)
    {
        for(unsigned int j=0; j<S; j++)
        {
            for(unsigned int k=0; k<S; k++)
            {
                for(unsigned int l=0; l<S; l++)
                    cout << setw(3) << a[i][j][k][l].x << " ";
                cout << " | " << endl;
            }
            cout << " ||| " << endl;
        }
        cout << endl;
    }
}