C 中的 malloc，但使用多维数组语法

Question

有没有办法 malloc 一个大数组，但用 2D 语法引用它？我想要类似的东西：

int *memory = (int *)malloc(sizeof(int)*400*200);
int MAGICVAR = ...;
MAGICVAR[20][10] = 3; //sets the (200*20 + 10)th element

---

更新：这很重要：我只想拥有一个连续的内存块。我只是不想写一个像这样的宏：

#define INDX(a,b) (a*200+b);

然后像这样引用我的 blob：

memory[INDX(a,b)];

我更喜欢：

memory[a][b];

---

更新：我知道编译器无法按原样知道。我愿意提供额外的信息，例如：

int *MAGICVAR[][200] = memory;

不存在这样的语法吗？请注意，我不只使用固定宽度数组的原因是它太大而无法放在堆栈上。

---

更新：好的，伙计们，我可以这样做：

void toldyou(char MAGICVAR[][286][5]) {
  //use MAGICVAR
}

//from another function:
  char *memory = (char *)malloc(sizeof(char)*1820*286*5);
  fool(memory);

我收到警告，passing arg 1 of toldyou from incompatible pointer type，但代码有效，并且我已验证可以访问相同的位置。有什么方法可以在不使用其他功能的情况下做到这一点？

Answer 1

是的，你可以这样做，不，你不需要另一个指针数组，就像大多数其他答案告诉你的那样。您想要的调用只是：

int (*MAGICVAR)[200] = malloc(400 * sizeof *MAGICVAR);
MAGICVAR[20][10] = 3; // sets the (200*20 + 10)th element

---

如果你想声明一个返回这样一个指针的函数，你可以这样做：

int (*func(void))[200]
{
    int (*MAGICVAR)[200] = malloc(400 * sizeof *MAGICVAR);
    MAGICVAR[20][10] = 3;

    return MAGICVAR;
}

或者使用typedef，这样会更清楚一点：

typedef int (*arrayptr)[200];

arrayptr function(void)
{
    /* ... */

Answer 2

使用指向数组的指针：

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

int main()
{
    int (*arr)[10];

    arr = malloc(10*10*sizeof(int));
    for (int i = 0; i < 10; i++)
        for(int j = 0; j < 10; j++)
            arr[i][j] = i*j;

    for (int i = 0; i < 10; i++)
        for(int j = 0; j < 10; j++)
            printf("%d\n", arr[i][j]);
    free(arr);
    return 0;
}

Answer 3

如果不需要额外的间接性，您可以使用指针数组。

编辑

这是@Platinum Azure 的答案的一个变体，它不会对 malloc 进行太多调用。除了更快的分配，所有元素都保证是连续的：

#define ROWS 400
#define COLS 200

int **memory = malloc(ROWS * sizeof(*memory));
int *arr = malloc(ROWS * COLS * sizeof(int));

int i;
for (i = 0; i < ROWS; ++i)
{
    memory[i] = &arr[i * COLS];
}

memory[20][10] = 3;

Answer 4

与 Cogwheel 的回答一样，这是一个（有点肮脏的）技巧，只调用一次 malloc()：

#define ROWS 400
#define COLS 200
int** array = malloc(ROWS * sizeof(int*) + ROWS * COLS * sizeof(int));
int i;
for (i = 0; i < ROWS; ++i)
    array[i] = (int*)(array + ROWS) + (i * COLS);

这会用指向紧随其后的连续数组数据中每一行的指针填充缓冲区的第一部分。

Answer 5

#define ROWS 400
#define index_array_2d(a,i,j) (a)[(i)*ROWS + (j)]
...
index_array_2d( memory, 20, 10 ) = -1;
int x = index_array_2d( memory, 20, 10 );

编辑：

数组和指针看起来非常相似，但是编译器对它们的处理却大不相同。让我们看看数组索引和取消引用带有偏移量的指针需要做什么：

1. 假设我们声明了一个静态数组（堆栈上的数组只是稍微复杂一点，与寄存器的固定偏移量，但本质上是一样的）：

   static int array[10];

2. 还有一个指针：

   static int* pointer;

3. 然后我们按如下方式取消尊重：

   x = array[i];
x = pointer[i];

需要注意的是array 的开头地址以及pointer 的地址（不是其内容）在链接/加载时固定。编译器然后执行以下操作：

1. 对于array 取消引用：
   • 加载i的值，
   • 将其与array的值相加，即其固定地址，形成目标内存地址，
   • 从计算的地址加载值
2. 对于pointer 取消引用：
   • 加载i的值，
   • 加载pointer的值，即其地址的内容，
   • 将两个值相加形成有效地址
   • 从计算的地址加载值。

2D 数组也是如此，需要加载第二个索引并将其乘以行大小（这是一个常数）。这一切都是在编译时决定的，在运行时没有办法用一个代替另一个。

编辑：

@caf 这里有正确的解决方案。毕竟语言中有一种合法的方法可以将指针索引为二维数组。

Answer 6

编译器和运行时无法仅通过 malloc 调用中的乘法来了解您的预期维度容量。

您需要使用双指针来实现两个索引的功能。应该这样做：

#define ROWS 400
#define COLS 200

int **memory = malloc(ROWS * sizeof(*memory));

int i;
for (i = 0; i < ROWS; ++i)
{
    memory[i] = malloc(COLS * sizeof(*memory[i]);
}

memory[20][10] = 3;

确保检查所有 malloc 返回值是否返回 NULL，表示内存分配失败。

Answer 7

根据 Tim 和 caf 的答案，我将把它留在这里以供后代使用：

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

void Test0() {
    int                             c, i, j, n, r;
    int                             (*m)[ 3 ];

    r = 2;
    c = 3;

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test1( int r, int c ) {
    int                             i, j, n;

    int                             (*m)[ c ];

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test2( int r, int c ) {
    int                             i, j, n;

    typedef struct _M {
        int                         rows;
        int                         cols;

        int                         (*matrix)[ 0 ];
    } M;

    M *                             m;

    m = malloc( sizeof(M) + r * c * sizeof(int) );

    m->rows = r;
    m->cols = c;

    int                             (*mp)[ m->cols ] = (int (*)[ m->cols ]) &m->matrix;

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            mp[ i ][ j ] = n++;
            printf( "m->matrix[ %d ][ %d ] == %d\n", i, j, mp[ i ][ j ] );
        }
    }

    free( m );
}

int main( int argc, const char * argv[] ) {
    int                             cols, rows;

    rows = 2;
    cols = 3;

    Test0();
    Test1( rows, cols );
    Test2( rows, cols );

    return 0;
}

Answer 8

int** memory = malloc(sizeof(*memory)*400); 
for (int i=0 ; i < 400 ; i++) 
{
    memory[i] = malloc(sizeof(int)*200);
}