P>А как быть с двумерным (и более) массивом. Как перевести char a[5][7] в nxm динамический массив.

const int width=5,height=7;
int **a;
// создание
a=malloc(sizeof(int*)*width);
for(int i=0;i<width;i++)a[i]=malloc(sizeof(int)*height);

a[1][1]=10;
a[4][6]=1;

// удаление
for(i=0;i<width;i++)free(a[i]);
free(a);

class Array
{
    int n, m;
    char** p;
public:
    Array(int nRow, int nCol)
    {
        n = nRow;
        m = nCol;
        p = new char* [n];
        for(int i = 0; i < n; i++)
            p[i] = new char[m];
    }
    ~Array()
    {
        for(int i = 0; i < n; i++)
        {
            delete []p[i];
            p[i] = NULL;
        }
        delete []p;
    }
    char Get(int i, int j)
        {return p[i][j];}
    char Set(int i, int j, char ch)
        {return p[i][j] = ch;}
};

    char ** s = &p;
    s[i][j] = p[i*N+j];

P>Не чувствую, что в этом более здорового .

template<typename T>
class Arr
{
   T* m_pData;
   int m_nRows;
   ...
public:
   Arr(int nRows, int nColumns) : m_nRows(nRows) { m_pData = new T[nRows*nColumns]; }

   ...

   T* operator[] (size_t n) { return m_pData + n*m_nRows; }
   ...
};

Arr<int> arr(5, 7);
arr[1][2] = 3;

P>Не чувствую, что в этом более здорового .

class xxx
{
    char data;
public:
    char& operator [](int i) {return data;}
};
//...
xxx * p = new xxx [M * N];
p[i][j] = 0;
//...

char **a=(char**)malloc(n);
for(int i=0; i<n; i++)
   a[i]=(char*)malloc(m);

B>template<typename T>
B>class Arr
B>{
B>   T* m_pData;
B>   int m_nRows;
B>   ...
B>public:
B>   Arr(int nRows, int nColumns) : m_nRows(nRows) { m_pData = new T[nRows*nColumns]; }

B>   ...

B>   T* operator[] (size_t n) { return m_pData + n*m_nRows; }
B>   ...
B>};
B>

B>Arr<int> arr(5, 7);
B>arr[1][2] = 3;
B>

template <typename T>  class Array2
{
protected:
    T * m_pData;
    int m_nColumns;
    int m_nRows;

    class Proxy
    {
    public:
        Proxy(T * p, int nRows)
        {
            m_nRows = nRows;
            m_pData = p;
        }
        ~Proxy()
        {
        }

        T operator [] (int n) const
        {
            ASSERT ((UINT)n < (UINT)m_nRows);
            return m_pData[n];
        }

        T& operator [] (int n)
        {
            ASSERT ((UINT)n < (UINT)m_nRows);
            return m_pData[n];
        }

    private:
        T * m_pData;
        int m_nRows;
    };
public:
    Array2(int nColumns,  int nRows)
    {
        m_nRows = nRows;
        m_nColumns = nColumns;
        m_pData = new T [nColumns * nRows];
    }
    ~Array2()
    {
        delete [] m_pData;
    }

    Proxy operator [] (int m)
    {
        ASSERT ((UINT)m < (UINT)m_nColumns);
        return Proxy(m_pData + m * m_nRows, m_nRows);
    }

    // или Так без проверки Rows    
        /*
    T * operator [] (int m)
    {
        ASSERT ((UINT)m < (UINT)m_nColumns);
        return m_pData + m * m_nRows;
    }
    */
};


    Array2<int> arr(5, 6);

    arr[3][4] = 123;
    int i34 = arr[3][4];

#include <stdio.h>
#include <stdlib.h>

typedef int T;

T **Allocate(size_t m, size_t n)
{
  int **a;
  int *p;
  size_t Row;
  a = malloc(m * n * sizeof **a + m * sizeof *a);
  if(a != NULL)
  {
    for(Row = 0, p = (T *)a + m; Row < m; Row++, p += n)
    {
      a[Row] = p;
    }
  }
  return a;
}