2D & 的动态分配/解除分配3D阵列 [英] dynamic allocation/deallocation of 2D & 3D arrays

问题描述

我知道动态分配/取消分配 2D 数组的算法，但是对于 3D 数组我不太确定.
使用这些知识和一点对称性，我想出了以下代码.
(我在编码期间很难在 3D 中进行可视化).

I know about algorithms to allocate/deallocate a 2D array dynamically, however I'm not too sure about the same for 3D arrays.
Using this knowledge and a bit of symmetry, I came up with the following code.
(I had a hard time visualizing in 3D during coding).

请评论正确性并建议任何更好的替代方案(效率方面或直觉上)，如果有的话.
另外，我认为这些 2D 和 3D 数组都可以像 arr2D[2][3] 和
这样的静态数组一样正常访问arr3D[2][3][2].对?

Please comment on the correctness and suggest any better alternative (efficiency-wise or intuitively), if any.
Also, I think both these 2D and 3D arrays can be accessed normally like static arrays like arr2D[2][3] and
arr3D[2][3][2]. Right?

二维代码

//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);
}

推荐答案

您还可以分配一个数组并计算单个索引.这需要更少的分配器调用，从而减少碎片并更好地使用缓存.

You can also allocate one array and compute individual indices. This requires fewer allocator calls and results in both less fragmentation and better cache use.

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() 距离.作为奖励，您一定要随身携带动态数组大小.

Now arr2d[r][c] becomes arr2d.data[r * arr2d.b + c]. Deallocation is a single free() away. As a bonus you're sure to always keep your dynamic array sizes with you.

外推到 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];

您应该将这些索引操作(以及与此相关的(解除)分配)封装在单独的函数或宏中.

You should encapsulate these index operations (and the (de-)allocations for that matter) in a separate function or macro.

(r、c 和 d 的名称可能会更好——我要的是行、列和深度.虽然 a、b 和 c 是它们对应维度的限制，但您可能更喜欢 n1 之类的名称，n2，n3 那里，甚至为他们使用一个数组.)

(The names for r, c, and d could be better—I was going for row, column, and depth. While a, b, and c are the limits of their corresponding dimensions, you might prefer something like n1, n2, n3 there, or even use an array for them.)

这篇关于2D & 的动态分配/解除分配3D阵列的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！