如何分配动态内存在功能二维数组？我想是这样的：

int main()
{
  int m=4,n=3;
  int** arr;
  allocate_mem(&arr,n,m);
}


void allocate_mem(int*** arr,int n, int m)
{
  *arr=(int**)malloc(n*sizeof(int*));
  for(int i=0;i<n;i++)
    *arr[i]=(int*)malloc(m*sizeof(int));
}

但是，这是行不通的。

Answer 1:

您的代码是错误的，在*arr[i]=(int*)malloc(m*sizeof(int)); 由于优先级的的[]操作者比更高*遵从操作者：在表达式*arr[i]第一arr[i]被评估然后*被施加。你需要的是相反的（解引用arr ，再申请[]

使用括号像这样： (*arr)[i]来覆盖运算符优先级。现在，你的代码应该是这样的：

void allocate_mem(int*** arr, int n, int m)
{
  *arr = (int**)malloc(n*sizeof(int*));
  for(int i=0; i<n; i++)
    (*arr)[i] = (int*)malloc(m*sizeof(int));
}

为了进一步了解在上面的代码中会发生什么，读这个答案。

您始终明确解除分配动态分配的内存一旦你完成它的工作是很重要的。以释放上述功能分配的内存，你应该这样做：

void deallocate_mem(int*** arr, int n){
    for (int i = 0; i < n; i++)
        free((*arr)[i]);
    free(*arr); 
}

此外，更好的方法来创建一个二维数组是分配连续的存储与单个malloc()如下函数调用：

int* allocate_mem(int*** arr, int n, int m)
{
  *arr = (int**)malloc(n * sizeof(int*));
  int *arr_data = malloc( n * m * sizeof(int));
  for(int i=0; i<n; i++)
     (*arr)[i] = arr_data + i * m ;
  return arr_data; //free point
}

要取消此分配内存：

void deallocate_mem(int*** arr, int* arr_data){
    free(arr_data);
    free(*arr);
}

请注意，在第二种技术的malloc被称为只有两次，所以在自由的释放代码被称为与其说这是在一个循环只有两次。因此，这种技术应该更好。

Answer 2:

如果阵列并不需要被调整（嗯，你可以，但金正日会更复杂一点），还有就是建立C.二维数组更容易/更有效的方式

看看http://c-faq.com/aryptr/dynmuldimary.html 。

第二种方法（对被称为数组2阵列）是相当简单的，痛苦少（尝试添加用于mallocs'返回值的测试），和方式更加高效。

我刚刚基准它，对于黑白200x100阵列，分配和释放10万次：

方法1：1.8秒
方法2：47ms

以及阵列中的数据将是更加连续的，这可以加快东西（你可能会得到一些更有效的技术来复制，重...数组分配这种方式）。

Answer 3:

想想看：只是单一的分配

int** allocate2D(int m, int n)
{
    int **a = (int **)malloc(m * sizeof(int *) + (m * n * sizeof(int)));

    int *mem = (int *)(a + m);

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

    return a;
}

免费：

free(a);

Answer 4:

而在许多不同的块分配存储器，一个能在存储器的连续的块分配此。请执行下列操作：

int** my2DAllocation(int rows,int columns)
{
   int i;
   int header= rows *sizeof(int *);
   int data=rows*cols*sizeof(int);
   int ** rowptr=(int **)malloc(header+data);
   if(rowptr==NULL)
   {
      return NULL:
   }
   int * buf=(int*)(rowptr+rows);
   for(i=0;i<rows;i++)
   {
      rowptr[i]=buf+i*cols;
   } 
   return rowptr;
}

Answer 5:

即用于阵列分配空间的不必要的复杂的方式。试想一下：

int main(void) {
    size_t m = 4, n = 3;
    int (*2D_array)[m];
    2D_array = malloc(n * sizeof *2D_array);
    free(2D_array);
    return 0;
}

Answer 6:

我曾尝试用于分配存储器到2维阵列下面的代码。

    #include<stdio.h>
    #include<malloc.h>
    void main(void)
    {
    int **p;//double pointer holding a 2d array
    int i,j;
    for(i=0;i<3;i++)
    {
    p=(int**)(malloc(sizeof(int*)));//memory allocation for double pointer
    for(j=(3*i+1);j<(3*i+4);j++)
    {
    *p = (int*)(malloc(sizeof(int)));//memory allocation for pointer holding integer array
    **p = j;                  
    printf(" %d",**p);//print integers in a row 
    printf("\n");
    p++;
    }
    }
    }

上面的代码的输出是： -

1 2 3

4 5 6

7 8 9

为了理解二维数组中三分球方面，我们需要了解它是如何将在内存中分配的，它应该是这样的： -

                1    2    3
    1000 -->   100  104  108

                4    5    6
    1004 -->   200  204  208

                7    8    9
    1008 -->   300  304  308

从上述情况，我们理解的是，当我们分配内存以指针p是一个双指针，它指向一个整数数组，所以在这个例子中，我们看到，0x1000的是指针p。

这个指针指向整数指针* P是整数数组，当存储器在内部内分配用于循环，第一次迭代的指针是指向整数值为1 0x100的，当我们分配** P = j的期间。类似地，将指向2和3在循环的下一次迭代。

外循环的下一次迭代之前，双指针被递增，下一次迭代内，如在此示例中可见的指针现在是在西班牙语 - 多米尼加共和国和指向整数指针，它是整数4,5,6和类似的阵列在循环的下一次迭代。

Answer 7:

试试下面的代码：

 void allocate_mem(int*** arr,int n, int m)
{
  *arr=(int**)malloc(n*sizeof(int*));
  for(int i=0;i<n;i++)
    *(arr+i)=(int*)malloc(m*sizeof(int));
}

Answer 8:

2D阵列动态阵列使用malloc：

int row = 4;
int column = 4;
int val = 2;
// memory allocation using malloc   

int **arrM = (int**)malloc (row*sizeof(int*));

for (int i=0;i<row;i++)
{
    arrM[i] = (int*)malloc(column*sizeof(int));
    // insert the value for each field
    for (int j =0;j<column;j++,val++)
    {
      arrM[i][j]     = val;
    }
}

// De-allocation

for (int i=0;i<row;i++)
{
    free(arrM[i]);
}
free(arrM);
arrM = 0;

//
// Now using New operator:
//

int **arr = new int*[row];
int k = 1;
for (int i=0;i<row;i++)
{
    arr[i] = new int[column];
    // insert the value for each field
    for (int j =0;j<column;j++,k++)
    {
      arr[i][j]  = k;
    }
}
cout<<"array value is = "<<*(*(arr+0)+0)<<endl;
cout<<"array value is = "<<*(*(arr+3)+2)<<endl;

// Need to deallcate memory;

for (int i=0;i<row;i++)
{
delete [] arr[i];
}
delete []arr;
arr = 0;

文章来源: Allocate memory 2d array in function C