2D和3D数组的动态分配/取消分配

Question

我知道动态分配/取消分配二维数组的算法，但我对三维数组的相同性不太确定。
利用这些知识和一些对称性，我想出了下面的代码。
（在编码过程中，我很难在3D中进行可视化）。

请评论正确性，并建议任何更好的选择（效率明智或直观），如果有的话。
此外，我认为这些二维和三维阵列可以像arr2D [2] [3]和 arr3D [2] [3] [2]这样的静态阵列正常访问。对？

代码2D

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

Answer 1

您也可以分配一个数组并计算各个索引。这需要更少的分配器调用，并且导致碎片减少和缓存使用更好。

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]。取消分配是单个免费（）。作为奖励，你一定要随时保持你的动态数组大小。

外推到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，甚至为他们使用数组。）

Answer 2

arr3d应该是一个三重的指针，而不是只是一个int。否则看起来不错：

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

arr3D是一个指针到指针到指针，所以arr3D [i]是一个指针到指针和arr3D [i] [j]只是一个指针。首先释放循环中的最小尺寸是正确的，然后爬上尺寸直到arr3D本身被释放。

另外它更隐喻地给出malloc指向类型的sizeof。相反的：

arr3D[i] = (int**)malloc(m * sizeof(int*)); 

让它：

arr3D[i] = (int**)malloc(m * sizeof(*arr3D[i])); 

是的，这种动态分配的多维数组可以被访问，就像静态分配的多维数组。

Answer 3

你可以看到下面的代码：

#include <stdio.h> 
#include <stdlib.h> 

void main() 
{ 
    // Array 3 Dimensions 
    int x = 4, y = 5, z = 6; 

    // Array Iterators 
    int i, j, k; 

    // Allocate 3D Array 
    int *allElements = malloc(x * y * z * sizeof(int)); 
    int ***array3D = malloc(x * sizeof(int **)); 

    for(i = 0; i < x; i++) 
    { 
     array3D[i] = malloc(y * sizeof(int *)); 

     for(j = 0; j < y; j++) 
     { 
      array3D[i][j] = allElements + (i * y * z) + (j * z); 
     } 
    } 

    // Access array elements 
    for(i = 0; i < x; i++) 
    { 
     printf("%d\n", i); 

     for(j = 0; j < y; j++) 
     { 
      printf("\n"); 

      for(k = 0; k < z; k++) 
      { 
       array3D[i][j][k] = (i * y * z) + (j * z) + k; 
       printf("\t%d", array3D[i][j][k]); 
      } 
     } 

     printf("\n\n"); 
    } 

    // Deallocate 3D array 
    free(allElements); 
    for(i = 0; i < x; i++) 
    { 
     free(array3D[i]); 
    } 
    free (array3D); 
} 

欲了解更多详情，请参阅此链接3d array

Answer 4

这是一个版本的问题的想法，但仅使用一个malloc的，由其他的启发答案。它可以直接使用方括号并且易于清洁。我希望它不会让任何编译器实现具体的假设。

int main(int argc, char *argv[]) 
{ 
    int **array, i, j; 
    array = allocate2d(3, 4); 
    for (i = 0; i < 3; i++) 
    { 
    for (j = 0; j < 4; j++) 
    { 
     array[i][j] = j + i + 1; 
    } 
    } 
    for (i = 0; i < 3; i++) 
    { 
    for (j = 0; j < 4; j++) 
    { 
     printf("array[%d][%d] = %d\n", i, j, array[i][j]); 
    } 
    } 
    free(array); 
    return EXIT_SUCCESS; 
} 

int **allocate2d(int x, int y) 
{ 
    int i; 
    int **array = malloc(sizeof(int *) * x + sizeof(int) * x * y); 
    for (i = 0; i < x; i++) 
    { 
    array[i] = ((int *)(array + x)) + y * i; 
    } 
    return array; 
}