我知道动态分配/取消分配 2D 数组的算法,但我不太确定 3D 数组是否相同。
利用这些知识和一点对称性,我想出了以下代码。
(在编码过程中,我很难以 3D 形式进行可视化)。
如果有的话,请评论正确性并提出任何更好的替代方案(效率方面或直观)。
另外,我认为这些 2D 和 3D 数组都可以像 arr2D[2][3] 和
等静态数组一样正常访问
arr3D[2][3][2]。正确的?
二维码
//allocate a 2D array
int** allocate2D(int rows,int cols)
{
int **arr2D;
int i;
arr2D = (int**)malloc(rows*sizeof(int*));
for(i=0;i<rows;i++)
{
arr2D[i] = (int*)malloc(cols*sizeof(int));
}
}
//deallocate a 2D array
void deallocate2D(int** arr2D,int rows)
{
int i;
for(i=0;i<rows;i++)
{
free(arr2D[i]);
}
free(arr2D);
}
3D 代码
//allocate a 3D array
int*** allocate3D(int l,int m,int n)
{
int ***arr3D;
int i,j,k;
arr3D = (int***)malloc(l * sizeof(int **));
for(i=0;i<l;i++)
{
arr3D[i] = (int**)malloc(m * sizeof(int*));
for(j=0;j<m;j++)
{
arr3D[i][j] = (int*)malloc(n*sizeof(int));
}
}
return arr3D;
}
//deallocate a 3D array
void deallocate3D(int arr3D,int l,int m)
{
int i,j;
for(i=0;i<l;i++)
{
for(int j=0;j<m;j++)
{
free(arr3D[i][j]);
}
free(arr3D[i]);
}
free(arr3D);
}
最佳答案
您还可以分配一个数组并计算单个索引。这需要更少的分配器调用,从而减少碎片和更好的缓存使用。
typedef struct {
int a;
int b;
int* data;
} Int2d;
Int2d arr2d = { 2, 3 };
arr2d.data = malloc(arr2d.a * arr2d.b * sizeof *arr2d.data);
现在 arr2d[r][c]
变为 arr2d.data[r * arr2d.b + c]
。释放只需一个 free() 即可。作为奖励,您一定要随身携带动态数组大小。
外推到 3d:
typedef struct {
int a;
int b;
int c;
int* data;
} Int3d;
Int3d arr3d = { 2, 3, 4 };
arr3d.data = malloc(arr3d.a * arr3d.b * arr3d.c * sizeof *arr3d.data);
//arr3d[r][c][d]
// becomes:
arr3d.data[r * (arr3d.b * arr3d.c) + c * arr3d.c + d];
您应该将这些索引操作(以及与此相关的(取消)分配)封装在单独的函数或宏中。
(r、c 和 d 的名称可能更好——我要的是行、列和深度。虽然 a、b 和 c 是它们对应维度的限制,但您可能更喜欢 n1 之类的名称, n2, n3 那里,甚至为它们使用一个数组。)
关于c - 2D 和 3D 数组的动态分配/解除分配,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/1824363/