为二维数组分配空间的办法有哪些？该怎么处理

为二维数组分配空间的办法有哪些？
我用这个方法分配一个二维空间：
int   **ptr;
*ptr   =   new   int*[10];
for   (   int   i   =   0;   i   <   10;   i++)
{
        ptr[i]   =   new   int[10];
}  
这样的话ptr可以当作二维数组使用，但是因为每个元素并不完全是连续存储的，所以这不是真正意义上的数组。

指针和数组本来就是不一样的，但是，有没有办法动态的给二维数组分配连续的地址空间呢？

------解决方案--------------------
template <typename _T, int _X, int _Y>
_T(*)[_X][_Y] Allocate()
{
return reinterpret_cast <_T(*)[_X][_Y]> (new _T[_X*_Y]);
}

template <typename _T, int _X, int _Y>
void Delete(_T (*x)[_X][_Y])
{
delete [] reinterpret_cast <_T*> (x);
}

int (*x)[10][10];
x = Allocate <int, 10, 10> ();

Delete(x);
------解决方案--------------------
int **ptr;
*ptr = new int*[10];
int *pBuf = new int[10*10];
for ( int i = 0; i < 10; i++)
{
ptr[i] = pBuf + 10;
}

------解决方案--------------------
如果第二维维数是固定的话，可以先分配一维数组再强制类型转换。

#include <iostream>
using namespace std;

int main()
{
const int rows=5;
const int cols=3;

int *p = new int[rows*cols];
for (int i=0; i <rows; i++)
for (int j=0; j <cols; j++)
p[i*cols+j] = i+j;

int (*a)[cols] = (int (*)[cols])p;

for (int i=0; i <rows; i++)
{
for (int j=0; j <cols; j++)
cout < < a[i][j] < < " ";
cout < < endl;
}

delete [] p;
return 0;
}


如果第二维维数不固定，那么就不能用上面的方法了。但仍然可以用一维数组模拟二维数组，写一个类封装一下就可以了
class Array2D
{
public:
Array2D(int rows, int cols):_rows(rows), _cols(cols)
{
_data = new int[rows*cols];
}
~Array2D()
{
delete [] _data;
}

int* operator[] (int i)
{
return &_data[i*cols];
}

private:
int *_data;
int _rows, _cols;
};
------解决方案--------------------
用vector吧：

const int size_1 = 20;
const int size_2 = 30;
vector <vector <int> > array(size_1,vector <int> (size_2));//20*30的int数组
------解决方案--------------------
楼主这写错了

int **ptr;
*ptr = new int*[10];

应该是

int **ptr;
ptr = new int*[10];



------解决方案--------------------
template <typename _T, int _X, int _Y>
void Allocate(_T(*&x)[_X][_Y])
{
std::cout < < "Allocate " < <_X*_Y < <std::endl;
x = reinterpret_cast <_T(*)[_X][_Y]> (new _T[_X * _Y]);
}

template <typename _T, int _X, int _Y>
void Delete(_T (*p)[_X][_Y])
{
std::cout < < "Delete " < <_X*_Y < <std::endl;
delete [] reinterpret_cast <_T*> (p);
}


int (*p)[50][2];
Allocate(p);
Delete(p);

豪不丢失类型信息.