我有以下C 代码：
int *a;
size_t size = 2000*sizeof(int);
a = malloc(size);
效果很好。但如果我有以下情况：
char **b = malloc(2000*sizeof *b);
b 的每个元素都有不同的长度。
怎么可能为b 做同样的事情，就像我为a 做的一样；即以下代码是否正确？
char *c;
size_t size = 2000*sizeof(char *);
c = malloc(size);
【问题讨论】：
首先，您需要分配像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），您可以在一次分配中完成此操作。
【讨论】：
malloc 一个free。您必须循环释放它们的 char* 变量，然后释放 char**。
动态分配 T 类型的 NxM 数组的典型形式是
T **a = malloc(sizeof *a * N);
if (a)
{
for (i = 0; i < N; i++)
{
a[i] = malloc(sizeof *a[i] * M);
}
}
如果数组的每个元素都有不同的长度，则将 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);
}
}
【讨论】：
free分配的内存的顺序？
a[i]，然后释放 a。
char a[10][20] 的等效内存分配如下。
char **a;
a=malloc(10*sizeof(char *));
for(i=0;i<10;i++)
a[i]=malloc(20*sizeof(char));
我希望这看起来很容易理解。
【讨论】：
另一种方法是分配一个连续的内存块，包括用于指向行的指针的标题块以及用于将实际数据存储在行中的主体块。然后只需通过在每行基础上将正文中的内存地址分配给标题中的指针来标记内存。如下所示：
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;
}
这种方法的优点是优雅地释放内存并能够使用类似数组的符号来访问生成的二维数组的元素。
【讨论】：
double 的未对齐边界上开始双精度行的第一列。考虑到这一点非常很重要，因为不正确的数据对齐很容易导致总线错误。一个通用的解决方案应该确保数据行从 8 字节边界开始，在将行指针分配给主指针段时做出额外的分配空间并进行相应调整。
columnSizes[]？
如果 b 中的每个元素都有不同的长度，那么您需要执行以下操作：
int totalLength = 0;
for_every_element_in_b {
totalLength += length_of_this_b_in_bytes;
}
return malloc(totalLength);
【讨论】：
我认为两步方法是最好的，因为 c 二维数组只是数组的数组。第一步是分配一个数组，然后循环遍历它，为每一列分配数组。 This article 提供了很好的细节。
【讨论】：
二维数组动态内存分配
int **a,i;
// for any number of rows & columns this will work
a = malloc(rows*sizeof(int *));
for(i=0;i<rows;i++)
*(a+i) = malloc(cols*sizeof(int));
【讨论】：
malloc 不会在特定的边界上分配，因此必须假定它是在字节边界上分配的。
如果转换为任何其他类型，则返回的指针将无法使用，因为访问该指针可能会导致 CPU 违反内存访问，并且应用程序将立即关闭。
【讨论】：