为二维整数数组分配内存，但它应该是连续的答案

【问题标题】：Allocate memory for two dimensional array of integers but it should be continuous为二维整数数组分配内存，但它应该是连续的
【发布时间】：2016-01-13 09:48:54
【问题描述】：

我想给int类型的二维数组分配内存，但是内存应该是连续的。

只需拨打free( ptr ) 即可释放它。我应该不需要对每个内存块调用 free。

【问题讨论】：

乘以M * N * sizeof (int) 并为这样的内存块做malloc。 M 和 N 是每个维度中的元素数。

标签： c arrays pointers multidimensional-array malloc

【解决方案1】：

正式的做法是这样的：

int (*arr_ptr) [x][y] = malloc( sizeof(int[x][y]) );

(*arr_ptr)[i][j] = something; // access one element

free(arr_ptr);

但是，这使得访问元素有点不方便：(*arr_ptr)[i][j] 有点难以阅读。避免这种情况的一个技巧是省略数组指针的一维，而是将其视为一维数组的数组：

int (*arr_ptr) [y] = malloc( sizeof(int[x][y]) );

arr_ptr[i][j] = something; // access one element

free(arr_ptr);

如果你有一个古老的编译器，你必须创建一个更丑陋、“错位”的二维数组：

int* ptr = malloc( sizeof(int) * x * y );

ptr[i*y + j] = something; // access one element

free(ptr);

【讨论】：

使用像这样的可变长度数组真的很酷。不知道的，“古编译器”是指MSVC等“pre C99编译器”。

【解决方案2】：

如果您的编译器支持可变长度数组 (VLA)，那么您可以编写如下方式

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

int main( void )
{
    size_t m = 3;
    size_t n = 4;

    int ( *a )[n] = malloc( m * n * sizeof( int ) );

    for ( size_t i = 0; i < m; i++ )
    {
        for ( size_t j = 0; j < n; j++ ) a[i][j] = i * n + j;
    }        

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

    free( a );

    return 0;
}

程序输出是

 0  1  2  3 
 4  5  6  7 
 8  9 10 11

否则n 必须是一个常数。例如

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

#define N 4

int main( void )
{
    size_t m = 3;

    int ( *a )[N] = malloc( m * N * sizeof( int ) );

    for ( size_t i = 0; i < m; i++ )
    {
        for ( size_t j = 0; j < N; j++ ) a[i][j] = i * N + j;
    }        

    for ( size_t i = 0; i < m; i++ )
    {
        for ( size_t j = 0; j < N; j++ ) printf( "%2d ", a[i][j] );
        printf( "\n" );
    }        

    free( a );

    return 0;
}

【讨论】：

【解决方案3】：

另一种可能性是将一维数组用作二维数组，如下例所示：

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

#define N 2
#define M 3

/*
   array has N * M elemts:

   |    N    |    N    |    N    |
   v         v         v         v
   |----|----|----|----|----|----|


   array[i][j] == array[i*N + j]
*/

#define GET(i,j) (i*N + j)


int main(int argc, char **argv) {

    int *array;
    int i, j;

    array = malloc(N * M *sizeof(int));


    for (i = 0; i < N; i++)
        for (j = 0; j < M; j++)
            array[i*N + j] = i+j;

    for (i = 0; i < N; i++)
        for (j = 0; j < M; j++)
            printf("array[%d][%d] = %d\n", i, j, array[i*N + j]);

    printf("Using the macro:\n");
    for (i = 0; i < N; i++)
        for (j = 0; j < M; j++)
            printf("array[%d][%d] = %d\n", i, j, array[GET(i,j)]);

    free(array);

    return 0;
}

我还定义了一个宏GET(i,j) 以便代码更具可读性，实际上这仅用于处理比二维更复杂的情况。

【讨论】：