如何索引到 3-D 动态数组？答案

【问题标题】：How to index to a 3-D dynamic array?如何索引到 3-D 动态数组？
【发布时间】：2019-11-24 20:43:41
【问题描述】：

我以这种方式创建了一个 3-d 动态数组：

double *A = (double *)malloc(M * N * N * sizeof(int));

这相当于静态矩阵：

double A[M][N][N];

我想引用实现静态行为的每个索引：

for (j = 0; j < N; j++) {

            for(i = 0; i < N; i++) {

                    for(k = 0; k < M; k++) {

                        if (i!=j)
                            A[k][j][i] = (y[j]*gain[k][i])/gain[k][j];
                        else
                            A[k][j][i] = 0;

                            printf("%f ", A[k][j][i]);
                    }

            }
}

所以我尝试了这个：

    for (j = 0; j < N; j++) {       //matrix A

            for(i = 0; i < N; i++) {

                    for(k = 0; k < M; k++) {

                        if (i!=j)
                            *(A + k*N + j + i) = (*(y+j) * *((gain+k*N)+i)) / *((gain+k*N)+j);
                        else
                            *(A + k*N + j + i) = 0;

                            printf("%f ", *(A + k*N + j + i));
                    }

            }
}

这是正确的语法吗？

【问题讨论】：

double (*A)[N][N] = malloc(M * sizeof *A); 将等同于 double A[M][N][N];。然后你可以像A[k][j][i]一样使用它。
不。你可以分辨，因为A[k][1][0] 和A[k][0][1] 指的是同一个地方。
如果你想使用double *A，正确的索引应该是A[k*N*N + j*N + i]来模拟A[k][j][i]的3d索引。
您的内存分配是为整数分配空间，而不是double。这是个问题。
@mch 这是一个很酷的技巧，它会分配每个 [N][N] 个元素吗？不知道你能做到这一点。

标签： c arrays matrix dynamic

【解决方案1】：

用动态版本替换静态double A[M][N][N]是

double *A = (double *)malloc(M * N * N * sizeof(double)) 没有sizeof(int)。

静态A[k][j][i] 的使用将在动态分配情况下替换为

A[k * (N * N) + j * N + i].

用一些示例代码扩展答案：

#include <assert.h>
#include <stdlib.h>

int main(void) {
  int a5x3x2[5][3][2] = {{{4, 6}, {4, 6}, {4, 6}},
                         {{4, 6}, {4, 6}, {4, 6}},
                         {{4, 6}, {4, 6}, {4, 6}},
                         {{4, 6}, {4, 6}, {4, 6}},
                         {{4, 6}, {4, 6}, {4, 6}}};
  int a2x3x5[2][3][5] = {{{7, 8, 9, 10, 11}, {7, 8, 9, 10, 11}, {7, 8, 9, 10, 11}},
                         {{7, 8, 9, 10, 11}, {7, 8, 9, 10, 11}, {7, 8, 9, 10, 11}}};

  int const x = 1;
  int const y = 1;
  int const z = 1;

  a5x3x2[x][y][z] = 42;
  int *p = &a5x3x2[0][0][0];
  assert(p[x * (3 * 2) + y * (2) + z] == 42);

  a2x3x5[x][y][z] = 24;
  p = &a2x3x5[0][0][0];
  assert(p[x * (3 * 5) + y * (5) + z] == 24);

  return EXIT_SUCCESS;
}

这是一个完整的 3D 示例，展示了通用逻辑：

#include <assert.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
  enum { Xsize = 3, Ysize = 5, Zsize = 7 };
  double static3D[Zsize][Ysize][Xsize];
  double* dynamic3D = (double*)malloc(Zsize * Ysize * Xsize * sizeof(double));
  for (int z = 0; z < Zsize; ++z)
    for (int y = 0; y < Ysize; ++y)
      for (int x = 0; x < Xsize; ++x)
        static3D[z][y][x] = dynamic3D[z * (Ysize * Xsize) + y * Xsize + x] =
            (x + 1) * (y + 1) * (z + 1);
  assert(memcmp(static3D, dynamic3D, sizeof(static3D)) == 0);
  free(dynamic3D);
  return EXIT_SUCCESS;
}

【讨论】：