多维阵列，不同的行的分配用malloc长度

Question

我有以下C代码：

int *a; 
size_t size = 2000*sizeof(int); 
a = (int *) malloc(size); 

工作正常。但是，如果我有以下几点：

char **b = malloc(2000*sizeof *b); 

其中b每一个元素都有不同的长度。

怎么可能为b做同样的事情，就像我为a做的那样;即以下代码将保持正确？

char *c; 
size_t size = 2000*sizeof(char *); 
c = (char *) malloc(size); 

Answer 1

首先，你需要分配的指针数组一样char **c = malloc(N * sizeof(char*))，然后用一个单独的分配每一行来电malloc，大概在循环：

/* N is the number of rows */ 
/* note: c is char** */ 
if ((c = malloc(N*sizeof(char*))) == NULL) 
{ /* error */ } 

for (i = 0; i < N; i++) 
{ 
    /* x_i here is the size of given row, no need to 
    * multiply by sizeof(char), it's always 1 
    */ 
    if ((c[i] = malloc(x_i)) == NULL) 
    { /* error */ } 

    /* probably init the row here */ 
} 

/* access matrix elements: c[i] give you a pointer 
* to the row array, c[i][j] indexes an element 
*/ 
c[i][j] = 'a'; 

如果你知道总数的元素（如N*M）你可以做到这一点一次分配。

Answer 2

如果b中的每一个元素都有不同的长度，那么你需要做的是这样的：

int totalLength = 0; 
for_every_element_in_b { 
    totalLength += length_of_this_b_in_bytes; 
} 
return (char **)malloc(totalLength); 

Answer 3

我认为2步法是最好的，因为c 2-d数组只是数组。第一步是分配一个单一的数组，然后循环遍历它为每一列分配数组。 This article给出了很好的细节。

Answer 4

对于动态分配类型T的N×M个阵列的典型形式是

T **a = malloc(sizeof *a * N); 
if (a) 
{ 
    for (i = 0; i < N; i++) 
    { 
    a[i] = malloc(sizeof *a[i] * M); 
    } 
} 

如果阵列中的每个元件具有不同的长度，然后用该元素的适当的长度更换米;例如

T **a = malloc(sizeof *a * N); 
if (a) 
{ 
    for (i = 0; i < N; i++) 
    { 
    a[i] = malloc(sizeof *a[i] * length_for_this_element); 
    } 
} 

Answer 5

另一种方法将是要分配的存储器，其包括用于指针的行头块的一个连续的块，以及主体块存储在行实际数据。然后，通过将正文中的内存地址分配给基于每行的标题中的指针来标记内存。它看起来像如下：

int** 2dAlloc(int rows, int* columns) {  
    int header = rows * sizeof(int*); 

    int body = 0; 
    for(int i=0; i<rows; body+=columnSizes[i++]) { 
    } 
    body*=sizeof(int); 

    int** rowptr = (int**)malloc(header + body); 

    int* buf = (int*)(rowptr + rows); 
    rowptr[0] = buf; 
    int k; 
    for(k = 1; k < rows; ++k) { 
     rowptr[k] = rowptr[k-1] + columns[k-1]; 
    } 
    return rowptr; 
} 

int main() { 
    // specifying column amount on per-row basis 
    int columns[] = {1,2,3}; 
    int rows = sizeof(columns)/sizeof(int); 
    int** matrix = 2dAlloc(rows, &columns); 

    // using allocated array 
    for(int i = 0; i<rows; ++i) { 
     for(int j = 0; j<columns[i]; ++j) { 
      cout<<matrix[i][j]<<", "; 
     } 
      cout<<endl; 
    } 

    // now it is time to get rid of allocated 
    // memory in only one call to "free" 
    free matrix; 
} 

这种方法的优点是存储器和使用阵列状符号来访问所得到的2D阵列的元素能力优雅释放。

Answer 6

char a[10][20]的等效存储器分配如下。

char **a; 

a=(char **) malloc(10*sizeof(char *)); 

for(i=0;i<10;i++) 
    a[i]=(char *) malloc(20*sizeof(char)); 

我希望这看起来很容易理解。

Answer 7

malloc不会在特定的边界上分配，所以必须假定它分配在一个字节边界上。

返回如果转换为任何其它类型的，因为访问该指针将可能是由CPU产生的存储器访问冲突然后不能使用指针，应用程序将被立即关闭。

Answer 8

2- d阵列动态内存分配

int **a,i; 

// for any number of rows & columns this will work 
a = (int **)malloc(rows*sizeof(int *)); 
for(i=0;i<rows;i++) 
    *(a+i) = (int *)malloc(cols*sizeof(int));