在C中为三维数组分配空间

Question

here已经回答了这个问题，但是对我来说，有些事情仍然没有解决，而且讨论的时间太长了，任何人都不能回答评论，而且我想问一下我的实现中有什么问题。

不管怎么说，问题的背景。我想为维3, h, w的三维数组分配空间。我所做的是：

int ***a = (int***)malloc(3 * sizeof(int*));
for (int i = 0; i < 3; i++)
{
   a[i] = (int **) malloc(height * sizeof(int*)); 
}

我理解这是为三个3 int**创建第一个空间，然后分配高度int**；然后：

for (int i = 0; i < 3; i++)
{
  a[i][0] = (int *) malloc(height * width * sizeof(int *));
  for (int j = 1; j < height; j++)
   {
     a[i][j] = a[i][j-1] + width;
   }
}

因此，现在我认为每个a[i][0]基本上都是一个大小、高度和宽度的二维数组的空间；此外，j != 0的其余部分被初始化为a[i][0]的j th行；

然后通过以下方法初始化值：

for (int c = 0; c < 3; c++){
  for (int i = 0; i < height; i++){
    for (int j = 0; j < width; j++){
      a[c][i][j] = i+j+c;

然而，这是不正确的。我想要这样做，作为一个扩展练习，以下列方式分配一个2D数组：

int *a[height]; 
a[0] = (int*)malloc(height * width * sizeof(int));
for (int i = 1; i < height; i++){
  a[i] = a[i-1] + widht;
}

这样，a是长度为高度的指针数组，a[0]分配给整个2D数组，随后的指针指向它们各自的行，我只需调用a[i][j] = some number;就可以写入它们。

我想要做的是把这个2D想法扩展到3D场景，但我很遗憾地失败了。

Answer 1

让我们想象一下您首先要做的事情，然后我将展示实现该目标的代码：

  int ***         int **                int *                  int 

  +---+           +---+                 +---+                  +---+
a |   | ---> a[0] |   | ------> a[0][0] |   | ----> a[0][0][0] |   |
  +---+           +---+                 +---+                  +---+
             a[1] |   | ----+   a[0][1] |   | -+    a[0][0][1] |   |
                  +---+     |           +---+  |               +---+
             a[2] |   |     |            ...   |                ...
                  +---+     |           +---+  |               +---+
                            | a[0][h-1] |   |  |  a[0][0][w-1] |   | 
                            |           +---+  |               +---+
                            |                  |
                            |           +---+  |               +---+
                            +-> a[1][0] |   |  +--> a[0][1][0] |   |
                                        +---+                  +---+
                                a[1][1] |   |       a[0][1][1] |   |
                                        +---+                  +---+
                                         ...                    ...
                                        +---+                  +---+
                              a[1][h-1] |   |     a[0][1][w-1] |   |
                                        +---+                  +---+

类型：

• 每个a[i][j][k]都有int型；
• 每个a[i][j]指向int对象序列的第一个元素，因此它必须具有int *类型；
• 每个a[i]指向int *对象序列的第一个元素，因此它必须具有int **类型；
• a指向int **对象序列的第一个元素，因此它必须具有int ***类型。

由于您正在执行分段嵌套分配，因此需要检查每个malloc调用的结果，如果出现错误，您将希望在纾困之前清理以前分配的任何内存，否则将有可能导致内存泄漏。不幸的是，没有真正干净而优雅的方法可以做到这一点--你要么带着一个旗子，然后做一些额外的测试，要么你再加上几个goto。我要展示两种不同的方法，它们都不是那么漂亮。

第一种方法--在分配每个a[i]时，我们还分配每个a[i][j] (“深度优先”方法)并初始化每个a[i][j][k]。如果a[i][j]上的分配失败，我们必须通过a[i][j-1]释放所有的a[i][0]，然后释放a[i]，然后通过a[i-1]对每个a[0]重复这个过程。

/**
 * Depth-first approach: allocate each a[i][j] with each a[i]
 */
int ***alloc1( size_t pages, size_t height, size_t width )
{
  size_t i, j, k;

  int ***a = malloc( sizeof *a * pages ); // allocate space for N int **
                                          // objects, where N == pages

  if ( !a )
    return NULL;

  for ( i = 0; i < pages; i++ )
  {
    a[i] = malloc( sizeof *a[i] * height );  // for each a[i], allocate space for
    if ( !a[i] )                             // N int * objects, where N == height
      goto cleanup_1;

    for ( j = 0; j < height; j++ )
    {
      a[i][j] = malloc( sizeof *a[i][j] * width ); // for each a[i][j], allocate      
      if ( !a[i][j] )                              // space for N int objects,
        goto cleanup_2;                            // where N == w

      for ( k = 0; k < width; k++ )
        a[i][j][k] = initial_value( i, j, k );
    }
  }
  goto done;

/**
 * Free all of a[i][0] through a[i][j-1], then free a[i]
 */
cleanup_2:
  while ( j-- )
    free( a[i][j] );
  free( a[i] );

/**
 * Free all of a[0] through a[i-1], then free a
 */
cleanup_1:
  while ( i-- )
  {
    j = height;
    goto cleanup_2;
  }
  free( a );
  a = NULL;

done:
  return a;  // at this point, a is either a valid pointer or NULL.
}

是的，这段代码包含goto，它违反了我喜欢的规则之一(绝不向后分支)。但是，在分配代码和清理代码之间有一个相当清晰的分离，并且我们不会在清理部分重复自己。cleanup_2与页面本身一起释放页面中的所有行；cleanup_1释放所有页面。cleanup_2“通过”进入cleanup_1。

下面是第二种方法--首先在分配任何a[i]之前分配所有a[i][j]，然后在初始化数组内容之前确保成功地分配了所有a[i][j]。

/**
 * Breadth-first approach; allocate all a[i], then all a[i][j], then initialize
 */
int ***alloc2( size_t pages, size_t height, size_t width )
{
  size_t i, j, k;

  /**
   * Allocate space for N int ** objects, where N == pages
   */
  int ***a = malloc( sizeof *a * pages );

  if ( !a )
    return NULL;                        // allocation failed for initial sequence, return NULL

  for ( i = 0; i < pages; i++ )  // For each a[i], allocate N objects of type
  {                              // int *, where N == height
    a[i] = malloc( sizeof *a[i] * height );
    if ( !a[i] )
      break;
  }

  if ( i < pages )
  {
    while ( i-- )                       // allocation of a[i] failed, free up a[0] through a[i-1]
      free( a[i] );
    free( a );                          // free a
    return NULL;
  }

  for ( i = 0; i < pages; i++ )    
  {
    for ( j = 0; j < height; j++ )
    {
      a[i][j] = malloc( sizeof *a[i][j] * width ); // for each a[i][j], allocate    
      if ( !a[i][j] )                             // space for N int objects, 
        break;                                    // where N == width
    }
  }

  if ( j < h )
  {
    do
    {
      while ( j-- )                     // allocation of a[i][j] failed, free up a[i][0] through a[i][j-1]
        free( a[i][j] );                // repeat for all of a[0] through a[i-1].
      free( a[i] );
      j = h;
    } while ( i-- );
    free( a );                          // free a
    return NULL;
  }

  /**
   * All allocations were successful, initialize array contents
   */    
  for ( i = 0; i < pages; i++ )
    for ( j = 0; j < height; j++ )
      for ( k = 0; k < width; k++ )
        a[i][j][k] = initial_value( i, j, k );

  return a;
}

没有gotos！但国际海事组织的代码并没有“流动”。在分配和清理代码之间没有那么清晰的分离，清理部分之间也有一些重复。

注意，对于这两种方法，内存都不是连续的--紧跟在a[0][0][h-1]后面的元素不会是a[0][1][0]。如果需要所有数组元素在内存中相邻，则需要使用其他数组元素所显示的方法：

int (*a)[h][w] = malloc( sizeof *a * 3 );

请注意，如果h和w很大，则可能没有足够的连续分配内存来满足请求。

Answer 2

int ***a = (int***)malloc(3 * sizeof(int*));

这没有分配任何有意义的东西。特别是，它不分配3D数组，甚至不分配3D数组的一部分。它为3个整数指针分配空间，这没有任何意义。int***也没有任何意义。

相反，分配一个3D数组：

int (*a)[y][z] = malloc( sizeof(int[x][y][z]) );

for(int i=0; i<x; i++)
  for(int j=0; j<y; j++)
    for(int k=0; k<z; k++)
      a[i][j][k] = something;

free(a);

编辑(以下文字中的任何讽刺语气都是故意的)

对于那些拒绝接受少于三个间接方向的解决方案的三星级程序员来说，下面是一个如何正确地进行三星级编程的例子。

不幸的是，它还没有包含非条件分支向上，内存泄漏或复杂指针算法.但是对于一个三星级程序员来说，这些快乐的东西当然是琐碎的，以后再加。但是，它确实保证数据缓存没有命中，因此程序将作为一个没有任何数据缓存的系统以相同的性能运行。

还可以考虑将分配的指针到指针作为参数传递，从而实现4颗星星！

正如所述，指针到指针的方法是非常糟糕的做法，但是如果您出于未知的原因坚持使用它，您最好还是正确地使用它。

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


void free_int_3d (int*** ppp, size_t X, size_t Y, size_t Z)
{
  (void)Z;

  if(ppp == NULL)
  {
    return ;
  }

  for(size_t x=0; x < X; x++)
  {
    if(ppp[x] != NULL)
    {
      for(size_t y=0; y < Y; y++)
      {
        if(ppp[x][y] != NULL)
        {
          free(ppp[x][y]);
        }
      }
      free(ppp[x]);
    }
  }
  free(ppp);
}


#define malloc_with_cleanup(ptr, size)     \
ptr = malloc(size);                        \
if(ptr == NULL)                            \
{                                          \
  free_int_3d(result, X, Y, Z);            \
  return NULL;                             \
}

int*** int_alloc_3d (size_t X, size_t Y, size_t Z)
{
  int*** result = NULL;

  malloc_with_cleanup(result, sizeof(int**[X]));
  for(size_t x=0; x<X; x++)
  {
    malloc_with_cleanup(result[x], sizeof(int*[Y]));
    for(size_t y=0; y<Y; y++)
    {
      malloc_with_cleanup(result[x][y], sizeof(int[Z]));
    }
  }
  return result;
}


int main (void)
{
  const size_t X = 5;
  const size_t Y = 3;
  const size_t Z = 4;

  int*** ppp = int_alloc_3d(X, Y, Z);

  for(size_t i=0; i<X; i++)
  {
    for(size_t j=0; j<Y; j++)
    {
      for(size_t k=0; k<Z; k++)
      {
        ppp[i][j][k] = (int)k;
        printf("%d ", ppp[i][j][k]);
      }
      printf("\n");
    }
    printf("\n");
  }

  free_int_3d(ppp, X, Y, Z);

  return 0;
}

输出：

0 1 2 3
0 1 2 3
0 1 2 3

0 1 2 3
0 1 2 3
0 1 2 3

0 1 2 3
0 1 2 3
0 1 2 3

0 1 2 3
0 1 2 3
0 1 2 3

0 1 2 3
0 1 2 3
0 1 2 3

Answer 3

为了解决OP的更高目标，我认为指向2D数组的指针已经足够@mch了

int (*a)[height][width] = malloc(sizeof *a * 3);

 a[c][i][j] = i + j + c;

但根据OP的要求..。

..。为3D数组分配空间..。

代码通常如何创建三维数组？

下面的代码使用C99中可用的可变长度数组实现了这一点。

(VLA在C11中可选地支持)

int a1[3][height][width];
// and assign it accordingly
for (int c = 0; c < 3; c++) {
  for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++) {
      a1[c][i][j] = i + j + c;

然而OP希望为这样一个数组分配空间。

malloc()返回一个指针。指向分配内存的指针。所以我们需要创建一个指向这样一个数组的指针。一旦我们这样做了，分配和元素分配就很容易了。

int (*a2)[3][height][width] = malloc(sizeof *a2);

// 3 nested for loop as above
    (*a2)[c][i][j] = i + j + c;

示例代码

void VT_3_dimensional_array(int height, int width) {
  assert(height > 0 && width > 0);

  int (*a2)[3][height][width] = malloc(sizeof *a2);
  printf("%p %zu\n", (void*) a2, sizeof *a2);
  if (a2 == NULL) {
    perror("Out of memory");
    exit(EXIT_FAILURE);
  }
  for (int c = 0; c < 3; c++) {
    for (int i = 0; i < height; i++) {
      for (int j = 0; j < width; j++) {
        (*a2)[c][i][j] = i + j + c;
      }
    }
  }

  // use a;
  for (int c = 0; c < 3; c++) {
    for (int i = 0; i < height; i++) {
      putchar('(');
      for (int j = 0; j < width; j++) {
        printf(" %X", (*a2)[c][i][j]);
      }
      putchar(')');
    }
    puts("");
  }

  free(a2);
}

int main() {
  VT_3_dimensional_array(5, 7);
  return 0;
}

输出

0x80071980 420
( 0 1 2 3 4 5 6)( 1 2 3 4 5 6 7)( 2 3 4 5 6 7 8)( 3 4 5 6 7 8 9)( 4 5 6 7 8 9 A)
( 1 2 3 4 5 6 7)( 2 3 4 5 6 7 8)( 3 4 5 6 7 8 9)( 4 5 6 7 8 9 A)( 5 6 7 8 9 A B)
( 2 3 4 5 6 7 8)( 3 4 5 6 7 8 9)( 4 5 6 7 8 9 A)( 5 6 7 8 9 A B)( 6 7 8 9 A B C)

注意，从技术上讲OP的代码使用的是错误的大小。通常sizeof(int*)和sizeof(int**)是一样的，所以没有太大的伤害。然而，这确实表明了对分配的困惑。

// wrong type  -----------------------v  should be int**
int ***a = (int***)malloc(3 * sizeof(int*));