Question

这个问题已经回答了here，但对我来说，有些事情仍未解决，讨论太旧，任何人都无法回复评论，此外我想问一下我的实施中出了什么问题。

无论如何，问题设置。我想为尺寸为3, h, w的3D数组分配空间。我在做什么：

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]基本上是一个尺寸高度和宽度的2D数组的空间;此外，a[i][j]的{{1}}的其余部分初始化为j != 0的{{1}}行;

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

j th

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

a[i][0]

这种方式a是一个长度为高度的指针数组，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; }即可写入它们。

我想要做的是将这个2D想法扩展到3D案例，但我遗憾地失败了。

Answer 1

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

输出：

Answer 2

为了解决OP的更高目标，我怀疑指向2D数组的指针就足够了@mch

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

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

但根据OP的要求......

...为3D阵列分配空间......

代码通常如何创建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*));

Answer 3

让我们先看看你想要做什么，然后我会展示代码来实现目标：

  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 s。我将展示两种不同的方法，两者都不是那么漂亮。

第一种方法 - 在我们分配每个a[i]时，我们还会分配每个a[i][j]（“深度优先”方法）并初始化每个a[i][j][k]。如果a[i][j]上的分配失败，我们必须将所有a[i][0]解除分配到a[i][j-1]，然后取消分配a[i]，然后为a[0]到a[i-1]重复此过程{1}}：

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

没有goto！但是代码并不像IMO那样“流动”。在分配和清理代码之间没有那么清晰的分离，并且清理部分之间存在一些重复性。

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

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

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

在C

3 个答案: