多维数组如何在内存中格式化？

在C语言中，我知道可以使用以下代码在堆上动态分配一个二维数组：

int** someNumbers = malloc(arrayRows*sizeof(int*));

for (i = 0; i < arrayRows; i++) {
    someNumbers[i] = malloc(arrayColumns*sizeof(int));
}

显然，这实际上创建了指向一堆单独的一维整数数组的一维指针数组，并且“系统”可以弄清楚我要问的意思：

someNumbers[4][2];

但是当我静态声明2D数组时，如以下行所示：

int someNumbers[ARRAY_ROWS][ARRAY_COLUMNS];

...是否在堆栈上创建了类似的结构，还是完全是另一种形式？（即它是一维指针数组吗？如果不是，它是什么，以及如何找出对其的引用？）

另外，当我说“系统”时，实际上是由什么负责的？内核？还是C编译器在编译时将其整理出来？

静态二维数组看起来像数组的数组-它只是连续排列在内存中。数组与指针不是一回事，但是由于您经常可以互换使用它们，因此有时会造成混淆。但是，编译器会正确跟踪，从而使所有内容都很好地排列在一起。您一定要小心使用您提到的静态2D数组，因为如果您尝试将一个2D数组传递给带有int **参数的函数，则会发生不好的事情。这是一个简单的例子：

int array1[3][2] = {{0, 1}, {2, 3}, {4, 5}};

在内存中看起来像这样：

0 1 2 3 4 5

完全相同：

int array2[6] = { 0, 1, 2, 3, 4, 5 };

但是，如果您尝试传递array1给此函数：

void function1(int **a);

您会收到警告（该应用将无法正确访问阵列）：

warning: passing argument 1 of ‘function1’ from incompatible pointer type

因为2D数组与相同int **。可以说，数组自动衰减为指针的过程只能“深入一层”。您需要将函数声明为：

void function2(int a[][2]);

要么

void function2(int a[3][2]);

使一切变得快乐。

这个相同的概念扩展到n维数组。但是，在您的应用程序中利用这种有趣的业务通常只会使它变得更难以理解。所以要小心。

答案是基于这样的想法，即C并不真正具有 2D数组-它具有数组数组。当您声明时：

int someNumbers[4][2];

您要求的someNumbers是一个包含4个元素的数组，其中该数组的每个元素都是类型int [2]（它本身是2 ints 的数组）。

难题的另一部分是，数组始终在内存中连续布置。如果您要求：

sometype_t array[4];

那么它将始终像这样：

| sometype_t | sometype_t | sometype_t | sometype_t |

（4个sometype_t对象彼此相邻放置，中间没有空格）。因此，在您的someNumbers数组数组中，它将如下所示：

| int [2]    | int [2]    | int [2]    | int [2]    |

每个int [2]元素本身就是一个数组，如下所示：

| int        | int        |

因此，总体而言，您得到以下信息：

| int | int  | int | int  | int | int  | int | int  |

unsigned char MultiArray[5][2]={{0,1},{2,3},{4,5},{6,7},{8,9}};

内存等于

unsigned char SingleArray[10]={0,1,2,3,4,5,6,7,8,9};

还回答您：两者，尽管编译器正在完成大部分繁重的工作。

对于静态分配的数组，“系统”将是编译器。它将为任何堆栈变量保留内存。

对于malloc的数组，“系统”将是malloc（通常是内核）的实现者。编译器将分配的全部是基本指针。

编译器将始终按照声明的类型来处理类型，但在Carl给出的示例中，它可以确定可互换的用法。这就是为什么如果将[] []传递给函数，则必须假定它是静态分配的平面，其中**被认为是指向指针的指针。

假设，我们有a1和a2定义和初始化像下面（C99）：

int a1[2][2] = {{142,143}, {144,145}};
int **a2 = (int* []){ (int []){242,243}, (int []){244,245} };

a1是在内存中具有纯连续布局的同质2D数组，表达式(int*)a1的计算结果为其第一个元素的指针：

a1 --> 142 143 144 145

a2是从异构2D数组初始化的，并且是一个指向type值的指针int*，即，解除引用表达式*a2求值为type的值int*，内存布局不必是连续的：

a2 --> p1 p2
       ...
p1 --> 242 243
       ...
p2 --> 244 245

尽管内存布局和访问语义完全不同，但是数组访问表达式的C语言语法对于同质和异质2D数组看起来完全相同：

• 表达a1[1][0]将获取值144出来的a1阵列
• 表达a2[1][0]将获取值244出来的a2阵列

当a1type 的access-expression 操作于type时int[2][2]，编译器会知道access-expression的a2操作针对type int**。生成的汇编代码将遵循同构或异构访问语义。

当类型int[N][M]类型数组被类型转换然后作为类型访问时，代码通常在运行时崩溃int**，例如：

((int**)a1)[1][0]   //crash on dereference of a value of type 'int'

要访问特定的2D数组，请考虑将内存映射用于数组声明，如以下代码所示：

    0  1
a[0]0  1
a[1]2  3

要访问每个元素，只需将您感兴趣的数组作为参数传递给函数即可。然后对列使用offset来分别访问每个元素。

int a[2][2] ={{0,1},{2,3}};

void f1(int *ptr);

void f1(int *ptr)
{
    int a=0;
    int b=0;
    a=ptr[0];
    b=ptr[1];
    printf("%d\n",a);
    printf("%d\n",b);
}

int main()
{
   f1(a[0]);
   f1(a[1]);
    return 0;
}