怎样动态分配二维数组内存？

[TaichiTang]

一维数组是这样动态分配的：
int *ptr = new int[num1];

二维数组怎么分配？
例如，输入两个整数：num1,num2,要求分配intPtr[num1][num2]的空间怎么分配？

msdn上给了一个例子：
int (*ptr)[10] = new int[num1][10];
其中10的位置只能是常量。

但是我现在两个都是变量，怎么办？

[caitou123]

<More Effecitve C++>
7.6 Item M30：代理类
虽然你和你的亲家可能住在同一地理位置，但就整个世界而言，通常不是这样的。很不幸，C++还没有认识到这个事实。至少，从它对数组的支持上可以看出一些迹象。在FORTRAN、BASIC甚至是COBOL中，你可以创二维、三维乃至n维数组（OK，FORTRAN只能创最多7维数组，但别过于吹毛求疵吧）。但在C++中呢？只是有时可以，而且也只是某种程度上的。
这是合法的：
int data[10][20]; // 2D array: 10 by 20
而相同的结构如果使用变量作维的大小的话，是不可以的：
void processInput(int dim1, int dim2)
{
int data[dim1][dim2]; // error! array dimensions
... // must be known during
}
甚至，在堆分配时都是不合法的：
int *data =
new int[dim1][dim2]; // error!
l 实现二维数组
多维数组在C++中的有用程度和其它语言相同，所以找到一个象样的支持方法是很重要的。常用方法是C++中的标准方法：用一个类来实现我们所需要的而C++语言中并没有提供的东西。因此，我们可以定义一个类模板来实现二维数组：
template<class T>
class Array2D {
public:
Array2D(int dim1, int dim2);
...
};
现在，我们可以定义我们所需要的数组了：
Array2D<int> data(10, 20); // fine
Array2D<float> *data =
new Array2D<float>(10, 20); // fine
void processInput(int dim1, int dim2)
{
Array2D<int> data(dim1, dim2); // fine
...
}
然而，使用这些array对象并不直接了当。根据C和C++中的语法习惯，我们应该能够使用[]来索引数组：
cout << data[3][6];
但我们在Array2D类中应该怎样申明下标操作以使得我们可以这么做？
我们最初的冲动可能是申明一个operator[][]函数：
template<class T>
class Array2D {
public:
// declarations that won't compile
T& operator[][](int index1, int index2);
const T& operator[][](int index1, int index2) const;
...
};
然而，我们很快就会中止这种冲动，因为没有operator[][]这种东西，别指望你的编译器能放过它。（所有可以重载的运算符见Item M7。）我们得另起炉灶。
如果你能容忍奇怪的语法，你可能会学其它语言使用()来索引数组。这么做，你只需重载operator()：
template<class T>
class Array2D {
public:
// declarations that will compile
T& operator()(int index1, int index2);
const T& operator()(int index1, int index2) const;
...
};
用户于是这么使用数组：
cout << data(3, 6);
这很容易实现，并很容易推广到任意多维的数组。缺点是你的Array2D对象看起来和内嵌数组一点都不象。实际上，上面访问元素(3,6)的操作看起来相函数调用。
如果你拒绝让访问数组行为看起来象是从FORTRAN流窜过来的，你将再次会到使用[]上来。虽然没有operator[][]，但写出下面这样的代码是合法的：
int data[10][20];
...
cout << data[3][6]; // fine
说明了什么？
说明，变量data不是真正的二维数组，它是一个10元素的一维数组。其中每一个元素又都是一个20元素的数组，所以表达式data[3][6]实际上是(data[3])[6]，也就是data的第四个元素这个数组的第7个元素。简而言之，第一个[]返回的是一个数组，第二个[]从这个返回的数组中再去取一个元素。
我们可以通过重载Array2D类的operator[]来玩同样的把戏。Array2D的operator[]返回一个新类Array1D的对象。再重载Array1D的operator[]来返回所需要的二维数组中的元素：
template<class T>
class Array2D {
public:
class Array1D {
public:
T& operator[](int index);
const T& operator[](int index) const;
...
};
Array1D operator[](int index);
const Array1D operator[](int index) const;
...
};
现在，它合法了：
Array2D<float> data(10, 20);
...
cout << data[3][6]; // fine
这里，data[3]返回一个Array1d对象，在这个对象上的operator[]操作返回二维数组中(3,6)位置上的浮点数。
Array2D的用户并不需要知道Array1D类的存在。这个背后的“一维数组”对象从概念上来说，并不是为Array2D类的用户而存在的。其用户编程时就象他们在使用真正的二维数组一样。对于Array2D类的用户这样做是没有意义的：为了满足C++的反复无常，这些对象必须在语法上兼容于其中的元素是另一个一维数组的一个一维数组。
每个Array1D对象扮演的是一个一维数组，而这个一维数组没有在使用Array2D的程序中出现。扮演其它对象的对象通常被称为代理类。在这个例子里，Array1D是一个代理类。它的实例扮演的是一个在概念上不存在的一维数组。（术语代理对象（proxy object）和代理类（proxy classs）还不是很通用；这样的对象有时被叫做surrogate。）

[zhi_chong]

int **num = new int*[num1];

for(int i=0;i<num1;i++)
*(num+i)=new int(num2);

[xspf]

分配是可以这样：
int **ptr=new int*[num1];
for(int i=0;i<num1;i++)
ptr[i]=new int[num2];

清除时只要反着来就可以了：
for(int i=0;i<num1;i++)
delete []ptr[i];
delete []ptr;

[WaterWalker]

http://expert.csdn.net/Expert/topic/1127/1127593.xml?temp=.4522516