在C语言中存储2d数组

我试图将一系列矩阵存储在一个连续的内存块中，然后检索它们。每个阵列的大小相同（n x n）

据我所知，我需要做的是：

分配并初始化我需要存储/检索的每个数组

分配一个大小为

（#数组）*sizeof（1数组）

的连续内存块，并将一个指针

***矩阵

分配到块的开头

将每个数组复制到块中的

矩阵[0]

，

矩阵[1]

通过发送

矩阵[0]

，

矩阵[1]

。。。到

矩阵\u打印

功能

现在，很明显我误解了一些事情，因为它不起作用。这是我在崩溃前得到的输出：

Matrix A is 16 bytes.
Matrix B is 16 bytes.
So, we will allocate 32 bytes in row_blocks.
Matrix A:
| 1  1 |
| 2  2 |
Matrix B:
| 2  2 |
|

以下是我正在尝试使用的测试用例的代码：

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

void matrix_print(int dim, int ***matrix);
void matrix_init(int dim, int matrix[dim][dim], int val);

int main(int argc, char *argv[])
{
    int dim = 2;

    int A[dim][dim], B[dim][dim];

    matrix_init(dim, A, 1);
    matrix_init(dim, B, 2);

    printf("Matrix A is %d bytes.\n", sizeof A);
    printf("Matrix B is %d bytes.\n", sizeof B);

    int ***matrices = malloc(sizeof A + sizeof B);

    printf("So, we will allocate %d bytes in matrices.\n\n",
            sizeof A + sizeof B);

    memcpy(matrices[0], A, sizeof (A));
    memcpy(matrices[1], B, sizeof (B));

    printf("Matrix A:\n");
    matrix_print(dim, &matrices[0]);
    printf("Matrix B:\n");
    matrix_print(dim, &matrices[1]);

    return 0;
}

void matrix_print(int dim, int ***matrix)
{
    for (int i = 0; i < dim; i++) {
        printf("|");
        for (int j = 0; j < dim; j++) {
            printf("%2d ", matrix[i][j]);
        }
        printf("|\n");
     }
}

void matrix_init(int dim, int matrix[dim][dim], int val)
{
    for (int i = 0; i < dim; i++) {
        for (int j = 0; j < dim; j++) {
            matrix[i][j] = val;
        }
     }
}

#包括
#包括
#包括
空矩阵_打印（整数尺寸，整数***矩阵）；
void matrix_init（int dim，int matrix[dim][dim]，int val）；
int main（int argc，char*argv[]）
{
int-dim=2；
int A[dim][dim]，B[dim][dim]；
矩阵_init（dim，A，1）；
矩阵_init（dim，B，2）；
printf（“矩阵A为%d字节。\n”，大小为A）；
printf（“矩阵B是%d字节。\n”，大小为B）；
int***矩阵=malloc（大小A+大小B）；
printf（“因此，我们将在矩阵中分配%d字节。\n\n”，
尺寸A+尺寸B）；
memcpy（矩阵[0]，A，sizeof（A））；
memcpy（矩阵[1]，B，sizeof（B））；
printf（“矩阵A:\n”）；
矩阵_打印（尺寸和矩阵[0]）；
printf（“矩阵B:\n”）；
矩阵打印（dim和矩阵[1]）；
返回0；
}
空矩阵_打印（整数尺寸，整数***矩阵）
{
对于（int i=0；i

C中二维矩阵的乐趣

当您将一维数组

int[dim]

传递给函数时，它会衰减为指向其第一个元素

int*

或

int[]

的指针，并在过程中丢失有关其大小的信息

二维数组

int[dim][dim]

不会退化为双指针

int**

，而是退化为指向int的

dim

行的第一个元素的指针，

int（*）[dim]

或

int[][dim]

。也就是说，因为对行大小恒定的多维数组进行了特殊处理；它们被实现为连续的数据块，其中常量大小用于计算索引。（此处的常量表示所有行和所有矩阵操作的常量；在您的案例中，此值可以是C99中的变量。）

您的

int[dim][dim]

类型的矩阵不能表示为

int**

，因此您应该调整矩阵数组的类型：

int (*matrices)[dim][dim];

matrices = malloc(sizeof A + sizeof B);

打印功能的签名也会发生变化：

void matrix_print(int dim, int matrix[dim][dim])
{
    for (int i = 0; i < dim; i++) {
        printf("|");
        for (int j = 0; j < dim; j++) {
            printf("%2d ", matrix[i][j]);
        }
        printf("|\n");
     }
}

没有操作员的地址

和

脚注：


int（*x）[dim]
是指向长度为
dim
的整数数组的指针
int*x[dim]
是指向
int
的指针的长度
dim
数组

我认为，这种特殊处理是由于Fortran如何存储多维数组。另一方面，如果已分配指针数组，则它们是
int**
。这样的数据结构可以保存参差不齐的矩阵

矩阵是具有可变长度（VLA）的C99样式数组，无法初始化，因此
malloc
必须是单独的声明和赋值

C中二维矩阵的乐趣

当您将一维数组
int[dim]
传递给函数时，它会衰减为指向其第一个元素
int*
或
int[]
的指针，并在过程中丢失有关其大小的信息

二维数组
int[dim][dim]
不会退化为双指针
int**
，而是退化为指向int的
dim
行的第一个元素的指针，
int（*）[dim]
或
int[][dim]
。也就是说，因为对行大小恒定的多维数组进行了特殊处理；它们被实现为连续的数据块，其中常量大小用于计算索引。（此处的常量表示所有行和所有矩阵操作的常量；在您的案例中，此值可以是C99中的变量。）

您的
int[dim][dim]
类型的矩阵不能表示为
int**
，因此您应该调整矩阵数组的类型：

int (*matrices)[dim][dim];

matrices = malloc(sizeof A + sizeof B);

打印功能的签名也会发生变化：

void matrix_print(int dim, int matrix[dim][dim])
{
    for (int i = 0; i < dim; i++) {
        printf("|");
        for (int j = 0; j < dim; j++) {
            printf("%2d ", matrix[i][j]);
        }
        printf("|\n");
     }
}

没有操作员的地址
和

脚注：


int（*x）[dim]
是指向长度为
dim
的整数数组的指针
int*x[dim]
是指向
int
的指针的长度
dim
数组

我认为，这种特殊处理是由于Fortran如何存储多维数组。另一方面，如果已分配指针数组，则它们是
int**
。这样的数据结构可以保存参差不齐的矩阵

矩阵是具有可变长度（VLA）的C99样式数组，无法初始化，因此
malloc
必须是单独的声明和赋值

C中二维矩阵的乐趣

当您将一维数组
int[dim]
传递给函数时，它会衰减为指向其第一个元素
int*
或
int[]
的指针，并在过程中丢失有关其大小的信息

二维数组
int[dim][dim]
n