实际上，C语言中没有二维数组，至少对二维数组没有直接的支持，取而代之的是“数组的数组”，二维数组可以看成是由指向数组的指针构成的数组。对于一个二维数组p[i][j]，编译器通过公式*(*(p+i)+j)求出数组元素的值：
1、p+i 计算行指针。
2、*(P+i) 具体的行，是一个指针，指向该行首元素地址。
3、*(P+i)+j 得到具体元素的地址。
4、*(*(p+i)+j) 得到元素的值。
基于上述原理，我们可以通过分配一个指针数组，再对指针数组的每一个元素分配空间实现动态分配二维数组。
实现
下面是本人写的一个动态分配二维数组的实现，适用于任何类型的二维数组，可以直接使用。
类型定义和错误代码
| typedef unsigned char MK_Byte; #define SUCCESS 0 /*No error*/ #define MFAILED 1 /*General failure*/ #define MNOMEMORY 2 /*Out of memory*/ 声明 //确保初始化 #define DeclareTwoDArray(ATYPE, iname) ATYPE ** iname = NULL //定义自己的malloc和free，确保内存正确操作 #define MKMALLOC(nsize) malloc(nsize) #define MKFREE(name) / if (NULL != name)/ free(name);/ name = NULL |
实现
| int MKCreatArray(int nsize, int X, int Y, void *** parray) { void ** tdarray = NULL; MK_Byte * tmparray = NULL; int i = 0; *parray = NULL; //分配指针数组 if (!(tdarray = (void **)MKMALLOC(sizeof(MK_Byte *) * Y))) { return MNOMEMORY; } //分配实际数组空间 if (!(tmparray = (MK_Byte * )MKMALLOC(nsize * (X * Y)))) { MKFREE(tdarray); return MNOMEMORY; } //初始化内存 memset(tmparray, 0x00, nsize * (X * Y)); //指针数组赋值 for (i = 0; i < Y; i++) tdarray[i] = (tmparray + (i * X) * nsize); *parray = tdarray; return SUCCESS; } void MKFreeArray(void *** parray) { if (*parray) { MKFREE((*parray)[0]); MKFREE((*parray)); } } |
使用
| void testTwoDArray() { //声明数组 DeclareTwoDArray(int, a); DeclareTwoDArray(float,b); //创建整型数组 MKCreatArray(sizeof(int), 3, 2, &a); a[1][2] = 10; a[0][1] = 23; printf("%d,%d/n",a[1][2],a[0][1]); //使用完一定要FREE MKFreeArray(&a); //重新分配数组 MKCreatArray(sizeof(int), 6, 6, &a); a[5][5] = 234; a[4][0] = 567; printf("%d,%d/n",a[5][5],a[4][0]); MKFreeArray(&a); //创建浮点数组 MKCreatArray(sizeof(float),2,2,&b); b[0][0] = 0.5f; b[1][1] = 0.006f; printf("%g,%g/n",b[0][0],b[1][1]); MKFreeArray(&b); } |
----------------------------------------------------------------------
其他讨论：
摘自：动态二维数组如何定义？
我在程序中需要使用一个动态的二维数组，行和列的值都需要传入。我在程序中使用了如下的方法：
#include "malloc.h"
...
double *t,**y;
t=(double *)calloc(r*c,sizeof(double)); //r,c是传入的行和列的值
y=(double **)calloc(r,sizeof(double *));
for(int i=0;i<r;i++) y[i]=&t[c*i];
...
结果在编译时没有问题，但运行时就回产生一个内存使用错误。
希望大家能够帮忙解决一下，或者有其他的解决方法也可以。谢谢！
---------------------------------------------------------------
可以这样使用二维数组：
假设前面已经定义了r行 和 c列
/*指向座标为（x,y）的单元的指针*/
＃define M_pV(pHead, x, y) (pHead+c*y+x)
double *pArray=(double*)malloc(r*c*sizeof(double));
到时候可以这样用：
＊M_pV(pArray, 1, 2)=9;
double temp=＊M_pV(pArray, 1, 2);
---------------------------------------------------------------
用MFC的CArray模板为例，你也可以使用STL的vector等
做一个2维的动态int数组
typedef CArray<int,int> INTARRAY;
typedef CArray<INTARRAY,INTARRAY> Int2DArray;
---------------------------------------------------------------
一个二维数组，其实可以用一个一维指针来访问的。
如：int iMatrix[10][10];
int *piMatrix;
piMatrix = iMatrix; //数组名就是数组首地址
那么就有 *piMatrix[2*10+3] = iMatrix[2][3]
所以定义一个一维指针就可以了
int piMatrix;
piMatrix = (int*)malloc(r*c*sizeof(int));
for (i=0;i<r;i++)
for(j=0;j<c;j++)
piMatrix[i*r+j]
(当然，也可以定义一个2维数组，跟Kevin_qing()一样)
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
动态分配二维数组的若干方法
动态分配二维数组，方法很多，在这里我说一下我想到的。针对二维数组两
个维的不同，可用不同的方法处理。
一、两维都固定：
这种是最简单，如下：
// 有点困惑的方法：
int (*a)[M][N]; // M、N 为常量
a = new int[1][10][20]; // 为什么要这样呢？
delete[] a;
// typedef 法，但一样的困惑
typedef int array_two[10][20];
array_two* a = new array_two[1]; // 还是多了“一维”
delete[] a;
唉，这个有点失败，使用时还要这样：(*a)[m][n]，或者 a[0][m][n]，这
还是二维的吗？没办法，只有另想办法了。
// 退一步，声明似乎少了一维 TYPE_1
int (*a)[N];
a = new int[M][N];
a[var_m][var_n] = 0;
delete[] a;
这样似乎不错，只是在声明时却少了一维，但使用起来简单，形式一样。
二、只有一维固定：
如果只有一维固定，分两种形式：[M][n] 和 [m][N]，以后者较简单。对于
N 固定的，我们只要这样就可以了：
// [m][N] 型 TYPE_2
int (*a)[N];
a = new int[m][N];
a[var_m][var_n] = 0;
delete[] a;
这个看起来与 TYPE_1 很相似，比较二维数组作为函数的参数传递时，第一
维也是不重要的。看一下 new，出来的类型都是 int (*)[N]。
对于 [M][n] 这种，能过把下标交换一下，就可以利用 TYPE_2 这种了，确
实是不错。如果坚持用 [M][n] 的话，看一下有什么方法。
// [M][n] 型，直接的方法 TYPE_3
int* a[M];
for (int i = 0; i < M; ++i)
a[i] = new int[n];
a[var_m][var_n] = 0;
for (int i = M; i > 0;)
delete[] a[--i];
事实上，我们可以改进一下，只用一次 new：
// [M][n] 型，改进 TYPE_4
int* a[M];
a[0] = new int[M*n];
for (int i = 1; i < M; ++i)
a[i] = a[i-1] + n;
a[var_m][var_n];
delete[] a[0];
这样改进的好处是，减少 new 所带来的固有开销；如果失败，无需对前面
已分配的再 delete[]。当然，如果内存比较碎的话，那就没办法了。
三、二维都是动态确定：
二维都是动态确定的话，可以这样：
// [m][n]，直接的方法 TYPE_5
int** a;
a = new (int*)[m];
for (int i = 0; i < m; ++i)
a[i] = new int[n];
a[var_m][var_n] = 0;
for (int i = m; i > 0;)
delete[] a[--i];
delete[] a;
类似改进 TYPE_3，我们也可以将 TYPE_5 改进：
// [m][n]，改进 TYPE_6
int** a;
a = new (int*)[m];
a[0] = new int[m*n];
for (int i = 1; i < m; ++i)
a[i] = a[i-1] + n;
a[var_m][var_n] = 0;
delete[] a[0];
delete[] a;
好了，这就是我所想到的办法，当然你可以 std::vector 来搭建二维数组，
只是效率似乎没人满意。实际上，可以只分两种情况：最后一维确定，或不确定。
最后一维确定，只需一次分配；否则，一般要两次。
---------------------------------------------------------------
// [M][n] 型，改进 TYPE_4
int* a[M];
a[0] = new int[M*n];
for (int i = 1; i < M; ++i)
a[i] = a[i-1] + n;
a[var_m][var_n];
delete[] a[0];
这里似乎有些问题，是不是应该改成a[i] = a[i-1] + sizeof(int)*n;
---------------------------------------------------------------
有价值。
up
---------------------------------------------------------------
up
---------------------------------------------------------------
int (*a)[M][N]; // M、N 为常量
a = new int[1][10][20]; // 为什么要这样呢？
这里的a不应该是一个三维数组吗？不知道是楼主弄错了还是我理解得不对？
另外，用vector来构建二维数组我觉得没有什么不好，不知道为什么楼主认为效率不令人满意？
---------------------------------------------------------------
楼上的意见我认可
*a[][]逻辑上已经是三维了
至于你的typedef int array_two[10][20];
array_two* a = new array_two[1]; // 还是多了“一维”
这样定义了 array_two本身是二维数组，定义它的指针也应该是首先分配的是二维数组指针的空间
typedef 定义对象指针
有一个好处就是new的时候不会调用构造函数
class Object{...
}
typedef Object* OFun[1];
OFun = new Object[1];
---------------------------------------------------------------
学习...
---------------------------------------------------------------
mark
---------------------------------------------------------------
int (*a)[M][N]; // M、N 为常量
a = new int[1][10][20]; // 为什么要这样呢？
逻辑上是三维了,感觉就是用起来会方便一点吧,是作为指针来用了,作为一个二维指针,不过自己还没用到过这么困难的东西,看了是不少书,理论也不少了,可还是没实践,学习,
---------------------------------------------------------------
还有，我最推荐的是TYPE_5，这个东西可以搭建的就不只是m*n的数组了，而是一堆大小不同的一维数组的集合
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
摘自：动态申请二维数组
// allocate memory
p = (int**)malloc(row_x * sizeof(int*));
for (i=0; i<row_x; i++)
{
p[i] = (int*)malloc(row_y * sizeof(int));
}
// use them
for (i=0; i<row_x; i++)
for (j=0; j<row_y; j++)
p[i][j] = i+j;
// free allocated memory
for (i=0; i<row_x; i++)
{
free(p[i]);
}
free(p);
4055
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
