二维数组的动态分配与释放

合集下载

C语言中多维数组的内存分配和释放(malloc与free)

C语言中多维数组的内存分配和释放(malloc与free)的方法
写代码的时候会碰到多维数组的内存分配和释放问题，在分配和释放过程中很容易出现错误。

下面贴上一些示例代码，以供参考。

如果要给二维数组(m*n)分配空间，代码可以写成下面：
（注意红色部分）
释放应该是：
如果为三维数组(m*n*p)分配空间呢，应该是：
释放代码为逆过程，具体代码为：
三维以上的多维数组的分配和释放，原理与上面的一样。

C中如何为第二维长度固定的二维数组分配内存
在所写的代码中，有时需要为一个二维数组分配内存，该二维数组的第一维长度不定，而第二维是固定（类似arr[n][3]的数组）。

我们可以想到的是用双指针代替数组，当然可以；也可以直接对n赋值后，直接定义arr[n][3] （C99标准支持），但这里要说的是另一种方法。

这里以将点云数据读入二维数组为例，由于点云点数n不定，可以确定的是，点是三维点，可以用以下方式定义并分配内存：
double (*arr)[3] = malloc (n*3*sizeof(double));
但在VC编译环境下，将会报错——无法从“void *”转换为“double (*)*3+” ，此时应该在malloc函数之前进行类型转换，应该如何转换呢？怎样转换才能成double (*)[3]类型呢，可以进行如下转换：
double (*arr)[3] = (double ((*)[3]))malloc (n*3*sizeof(double));。

二维数组分配内存

C 二维数组动态分配和释放(1)已知第二维Code-1char (*a)[N];//指向数组的指针a = (char (*)[N])malloc(sizeof(char *) * m);printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//N，一维数组free(a);(2)已知第一维Code-2char* a[M];//指针的数组int i;for(i=0; i<M; i++)a[i] = (char *)malloc(sizeof(char) * n);printf("%d\n", sizeof(a));//4*M，指针数组printf("%d\n", sizeof(a[0]));//4，指针for(i=0; i<M; i++)free(a[i]);(3)已知第一维，一次分配内存(保证内存的连续性)Code-3char* a[M];//指针的数组int i;a[0] = (char *)malloc(sizeof(char) * M * n);for(i=1; i<M; i++)a[i] = a[i-1] + n;printf("%d\n", sizeof(a));//4*M，指针数组printf("%d\n", sizeof(a[0]));//4，指针free(a[0]);(4)两维都未知Code-4char **a;int i;a = (char **)malloc(sizeof(char *) * m);//分配指针数组for(i=0; i<m; i++){a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组}printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//4，指针for(i=0; i<m; i++){free(a[i]);}free(a);(5)两维都未知，一次分配内存(保证内存的连续性)Code-5char **a;int i;a = (char **)malloc(sizeof(char *) * m);//分配指针数组a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间for(i=1; i<m; i++){a[i] = a[i-1] + n;}printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//4，指针free(a[0]);free(a);2.C++动态分配二维数组(1)已知第二维Code-6char (*a)[N];//指向数组的指针a = new char[m][N];printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//N，一维数组delete[] a;(2)已知第一维Code-7char* a[M];//指针的数组for(int i=0; i<M; i++)a[i] = new char[n];printf("%d\n", sizeof(a));//4*M，指针数组printf("%d\n", sizeof(a[0]));//4，指针for(i=0; i<M; i++)delete[] a[i];(3)已知第一维，一次分配内存(保证内存的连续性)Code-8char* a[M];//指针的数组a[0] = new char[M*n];for(int i=1; i<M; i++)a[i] = a[i-1] + n;printf("%d\n", sizeof(a));//4*M，指针数组printf("%d\n", sizeof(a[0]));//4，指针delete[] a[0];(4)两维都未知Code-9char **a;a = new char* [m];//分配指针数组for(int i=0; i<m; i++){a[i] = new char[n];//分配每个指针所指向的数组}printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//4，指针for(i=0; i<m; i++)delete[] a[i];delete[] a;(5)两维都未知，一次分配内存(保证内存的连续性)Code-10char **a;a = new char* [m];a[0] = new char[m * n];//一次性分配所有空间for(int i=1; i<m; i++){a[i] = a[i-1] + n;//分配每个指针所指向的数组}printf("%d\n", sizeof(a));//4，指针printf("%d\n", sizeof(a[0]));//4，指针delete[] a[0];delete[] a;多说一句：new和delete要注意配对使用，即有多少个new就有多少个delete，这样才可以避免内存泄漏！3.静态二维数组作为函数参数传递如果采用上述几种方法动态分配二维数组，那么将对应的数据类型作为函数参数就可以了。

c语言申请二维数组

在C语言中，你可以使用以下几种方式来申请一个二维数组：1. 静态二维数组：在声明时就分配内存。

```cint arr[3][4]; // 声明一个3x4的二维数组```2. 动态二维数组：使用`malloc`或`calloc`函数在运行时分配内存。

```cint arr;int rows = 3;int cols = 4;arr = malloc(rows * sizeof(int *)); // 为行指针分配内存for(int i=0; i<rows; i++) {arr[i] = malloc(cols * sizeof(int)); // 为每一行的元素分配内存}```3. 使用指针和指向指针的指针：这是动态分配二维数组的一种更复杂的方式。

```cint rows = 3;int cols = 4;int arr = malloc(rows * sizeof(int *)); // 声明行指针数组for(int i=0; i<rows; i++) {arr[i] = malloc(cols * sizeof(int)); // 为每一行分配内存}```4. 使用固定大小的数组：如果你知道数组的大小是固定的，你可以直接使用静态数组。

但如果你需要动态改变大小，那么你需要使用动态内存分配。

5. 使用结构体：如果你需要存储更复杂的数据，例如不仅有数值还有字符串或其它结构，你可以使用结构体。

6. 使用标准库中的二维数组类型：在某些编译器或库中，可能提供二维数组类型，这使得处理二维数据更加方便。

但是，C语言标准并没有提供这样的类型。

当你不再需要这些数组时，记得释放分配的内存，以避免内存泄漏。

对于动态分配的二维数组，首先释放每一行的内存，然后再释放行指针的内存。

C语言中动态分配二维数组

puts("");
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
for(k=0;k<n3;k++)
free(array[i][j][k]);//释放第四维指针
}
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
free(array[i][j]);//释放第三维指针
}
} array[][][]（整型常量）
当然，你可以把它们整合在一起为：
int i,j,k;
int n1,n2,n3;
int ***array;
scanf("%d%d%d",&n1,&n2,&n3);
array=(int***)calloc(n1,sizeof(int**));
for(i=0;i<n1;i++)
for(k=0;k<n3;k++)
{
array[i][j][k]=i+j+k+1;
printf("%d\t",array[i][j][k]);
}
puts("");
}
puts("");
}
for(i=0;i<n1;i++)
{
for(j=0;j<n2;j++)
{
free(array[i][j]);//释放第三维指针

如何解决C C 中stack overflow问题

如何解决C/C++中stack overflow问题一般遇到这个问题，有两个常见的情况，一个是存在函数的递归调用，另一个是函数中定义了一个较大的数组或者别的变量。

1、在函数的递归调用中，函数中定义的局部变量所占的空间要直到递归结束才能被释放，这样函数不停的递归，堆栈早晚会被用完，解决这一问题的办法是在递归函数中每次动态的分配变量的内存，在使用结束的时候释放内存。

遇到这种情况更改堆栈的最大空间大小是没有用的，要从代码的优化入手。

下面以二维数组的动态分配为例：p=new double*[1000];for (int m=0;m<1000;m++){p[m]=new double[5000];}for(int n=0;n<1000;n++) {delete[] p[n];} delete[] p;2、堆栈的大小只有1M，如果在函数中定义了一个占用内存比较大的变量，那么也会导致堆栈溢出。

这种情况只需在定义的时候定义为静态变量就行了，因为静态变量是不占用堆栈内存的。

如：void main（）{int；}在函数内定义的变量默认auto类型，也就是栈变量，运行时使用的是栈空间，函数结束后自动清理返回内存。

这里在函数内定义如此大的一个数组，已经超过了单个函数可使用的最大栈空间，所以也会提示stack overflow。

解决办法是将其定义为static int型的静态变量，这样就不占用栈空间了。

void main（）{static int}3、除此之外还可以通过修改堆栈的最大空间来解决问题，把project设置里的堆栈加大就可以了,默认是1M,你可以加大到10M试试. 具体如下：。

对于遇到这样的问题建议从代码方面去解决，不要盲目的依靠修改堆栈空间来解决，毕竟有的问题靠修改空间是解决不了的，如递归中产生的stack overflow。

数组的动态分配特点

数组的动态分配特点
1. 大小灵活：动态分配数组的大小可以根据需要动态调整，不受静态数组的固定大小限制。

这样就可以根据需求动态地调整数组的大小，提高内存的利用率。

2. 内存管理灵活：动态分配数组的内存分配和释放由程序员手动管理，可以根据实际情况在需要的时候申请内存，并在不需要的时候释放内存，从而提高内存的利用效率。

3. 动态扩展：动态分配数组可以进行动态扩展，即在原来的数组基础上扩展新的空间。

这样可以方便地添加新的元素，并避免了静态数组需要重新定义大小的麻烦。

4. 灵活访问：动态分配数组可以通过索引随机访问数组中的元素，可以根据索引值直接访问数组中的元素，提高了数据的读取效率。

5. 灵活修改：动态分配数组可以根据需要随时修改数组中的元素，可以修改数组中的元素的值，方便处理和管理数据。

C 二维动态数组的申请与_释放

一维数组是指针，可将二维数组看作是指针的指针：每一行是一个一维数组，而列是指向行的指针。

在动态创建时，先分配指向行的指针空间，再循环维每一行申请空间。

#include <iostream>using namespace std;int main(){//[3]4] //三行四列的二维数组int x,y;int i,n,k;x=3;y=4;int **p;p = new int*[x]; //行 //申请行的空间//每行的列申请空间for(i=0; i<x;i++){p[i] = new int [y];}//赋值，k=0;for(i=0;i<x;i++){for(n=0;n<y;n++){p[i][n] = k;k++;}}//显示刚才的赋值for(i=0;i<x;i++){for(n=0;n<y;n++){cout << p[i][n] << "\t";}cout << endl;}//删除刚才申请的内存for(i=0;i<x;i++){delete [] p[i];}delete [] p;return 0;今天归纳总结了一下，希望以后的朋友可以少走些弯路：）一：关于指针和堆的内存分配先来介绍一下指针：指针一种类型，理论上来说它包含其他变量的地址，因此有的书上也叫它：地址变量。

既然指针是一个类型，是类型就有大小，在达内的服务器上或者普通的ＰＣ机上，都是４个字节大小,里边只是存储了一个变量的地址而已。

C语言中二维数组的动态申请与释放

C语⾔中⼆维数组的动态申请与释放有时根据题意需得根据输⼊的⼆维数来动态的创建⼆维数组，那么此时就不能想以前⼀样直接定义多少⾏多少列了。

因为不知道⾏列多少，假如设定太⼤浪费空间，申请太⼩完成不了程序的数据存储。

因此需要合理的开辟⼆维空间。

以下的两种⽅法都可以建⽴动态的⼆维空间数组。

⽅法⼀：int i,j;int r,c;int **a; //创建⼆维指针来指向数组scanf("%d%d",&r,&c);a = (int **) malloc(sizeof(int *) * r);//注意申请的指针格式for (j=0;j<r;j++){a[j] = (int *) malloc(sizeof(int) * c);…………}释放为：for (j=0;j<r;j++)free(a[j]);//先释放⼀维指针free(a);//最后释放我⼆维指针⽅法⼆：建⽴链表来存放⼆维数组。

typedef struct arr{int *array;}arr;main(){arr *array1;int rowx,rowy;int i,j,k=0;scanf("%d %d",&rowx,&rowy);array1=(arr *)malloc(sizeof(arr)*rowx);//创建链表数组for(i=0;i<rowx;i++)//再在每⼀个链表中创建⼀维数组，这样整体就构成⼆维数组array1[i].array=(int *)malloc(sizeof(int)*rowy);…………释放同上：for (j=0;j<rowx;j++)free(array1[j].array);free(array);｝。

C++二维动态数组的申请与_释放

一维数组是指针，可将二维数组看作是指针的指针：每一行是一个一维数组，而列是指向行的指针。

在动态创建时，先分配指向行的指针空间，再循环维每一行申请空间。

#include <iostream>using namespace std;int main(){//[3]4] //三行四列的二维数组int x,y;int i,n,k;x=3;y=4;int **p;p = new int*[x]; //行 //申请行的空间//每行的列申请空间for(i=0; i<x;i++){p[i] = new int [y];}//赋值，k=0;for(i=0;i<x;i++){for(n=0;n<y;n++){p[i][n] = k;k++;}}//显示刚才的赋值for(i=0;i<x;i++){for(n=0;n<y;n++){cout << p[i][n] << "\t";}cout << endl;}//删除刚才申请的内存for(i=0;i<x;i++){delete [] p[i];}delete [] p;return 0;今天归纳总结了一下，希望以后的朋友可以少走些弯路：）一：关于指针和堆的内存分配先来介绍一下指针：指针一种类型，理论上来说它包含其他变量的地址，因此有的书上也叫它：地址变量。

既然指针是一个类型，是类型就有大小，在达内的服务器上或者普通的ＰＣ机上，都是４个字节大小,里边只是存储了一个变量的地址而已。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

二维数组的动态分配与释放
1. C语言动态分配二维数组
(1)已知第二维
Code-1
char (*a)[N];//指向数组的指针
a = (char (*)[N])malloc(sizeof(char) * M*N); //注意M为数组的行，N为数组的列printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//N*sizeof(char)，一维数组
free(a);
(2)已知第一维
Code-2
char* a[M];//指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d\n", sizeof(a));//4*M，指针数组
printf("%d\n", sizeof(a[0]));//4，指针
for(i=0; i<M; i++)
free(a[i]);
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-3
char* a[M];//指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M，指针数组
printf("%d\n", sizeof(a[0]));//4，指针
free(a[0]);
(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//4，指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间for(i=1; i<m; i++) //定义每个指针指向的空间大小
{
a[i] = a[i-1] + n;
}
printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//4，指针
free(a[0]); //只需要释放a[0]
free(a);
2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N];//指向数组的指针
a = new char[m][N];
printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//N，一维数组
delete[] a;
(2)已知第一维
Code-7
char* a[M];//指针的数组
for(int i=0; i<M; i++)
a[i] = new char[n];
printf("%d\n", sizeof(a));//4*M，指针数组
printf("%d\n", sizeof(a[0]));//4，指针
for(i=0; i<M; i++)
delete[] a[i];
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-8
char* a[M];//指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M，指针数组
printf("%d\n", sizeof(a[0]));//4，指针
delete[] a[0];
(4)两维都未知
Code-9
char **a;
a = new char* [m];//分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n];//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//4，指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n];//一次性分配所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n;//分配每个指针所指向的数组
}
printf("%d\n", sizeof(a));//4，指针
printf("%d\n", sizeof(a[0]));//4，指针
delete[] a[0];
delete[] a;
多说一句：new和delete要注意配对使用，即有多少个new就有多少个delete，这样才可以避免内存泄漏！。

二维数组的动态分配与释放

C语言中多维数组的内存分配和释放(malloc与free)

最新C++二维动态数组的申请与_释放汇总

二维数组分配内存

c语言 申请二维数组

C语言中动态分配二维数组

如何解决C C 中stack overflow问题

数组的动态分配特点

C 二维动态数组的申请与_释放

C语言中二维数组的动态申请与释放

C++二维动态数组的申请与_释放

c语言申请二维数组