动态开辟内存的这些知识你知道了吗？了解柔性数组吗？超详细画图以及文字讲解，干货满满
Posted 小赵小赵福星高照～
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了动态开辟内存的这些知识你知道了吗？了解柔性数组吗？超详细画图以及文字讲解，干货满满相关的知识，希望对你有一定的参考价值。
动态内存分配
前言
数组的元素存储内存中在连续的位置上，它所需要的内存在编译时就被分配，但是我们也可以使用动态内存分配在运行时为它分配内存，下面博主将以以下内容介绍动态内存分配。
为什么存在动态内存分配
之前我们了解的有两种内存分配方式：
-
创建变量
-
创建数组
int main()
{
int a=10;//创建变量
char c = 'w';
char arr[200]={0};//创建数组
int arr2[5]={0};
return 0;
}
这种分配的方法优点是简单，但是它有好几个缺点，这种内存分配是不灵活的，分配好，内存大小就不会改变。如果程序需要使用的元素数量超过了声明的长度，它就无法处理这种情况，这时需要将数组声明大一些，但是我们在使用数组元素数量较少时，内存空间就大大浪费了。所以就出现了动态内存分配，这种内存分配是比较灵活的。
动态内存函数的介绍
首先动态内存开辟的空间是位于哪里的呢？
如图解释，局部变量以及函数形参是位于栈区，动态内存开辟是在堆区，而全局变量以及静态变量是位于静态区。
接下来我们首先介绍malloc函数：
malloc
- 函数原型以及参数解释
我们再来看一看malloc函数关于返回值void*的解释：
这段话的大致意思是，malloc函数会返回一个void*的指针，如果开辟成功，则该void*指针指向开辟好的空间的起始地址，若开辟失败，将返回一个NULL指针。
接下来我们来看一看malloc函数的使用
int *p = (int*)malloc(100);
我们想要用malloc函数在堆区开辟100个字节的空间，并且这100字节的空间是连续的，用什么类型的指针取决于你想要怎么使用这块空间，你想要以整形使用，那就用int*类型指针来接收，malloc函数返回的为void*的指针，当我们以整形的方式使用空间时，我们需要将它强制类型转换为int*。
下面代码是malloc函数开辟空间以及使用空间
int main()
{
//动态内存开辟
int *p = (int*)malloc(100);
if(p==NULL)
{
perror("malloc");
}
else
{
int i=0;
for(i=0;i<25;i++)
{
*(p+i)=i;
}
for(i=0;i<25;i++)
{
printf("%d ",*(p+i));
}
}
return 0;
}
我们想要使用malloc函数在堆区开辟100个字节的空间，用整形的方式使用它，再使用这块空间时，我们需要判断空间是否开辟成功，所以我们判断指针p是否为NULL，若为NULL，则开辟失败，打印错误信息，若不为NULL，我们则利用指针p指向起始空间地址使用该块空间。
开辟成功的情况：
开辟失败的情况：
注意：
int *p = malloc(0);
这样不是错误的，但是没有什么意义，也不能使用空间。
当我们确定内存不再使用时，我们需要回收释放内存，这时我们就用到了free函数
free
- 函数原型以及参数解释
int main()
{
//动态内存开辟
int *p = (int*)malloc(100);
if(p==NULL)
{
perror("malloc");
}
else
{
int i=0;
for(i=0;i<25;i++)
{
*(p+i)=i;
}
for(i=0;i<25;i++)
{
printf("%d ",*(p+i));
}
//回收-释放内存
free(p);//free不能将p置为NULL指针
p=NULL;
}
return 0;
}
在使用完空间后，我们需要将此块空间还给操作系统，在使用free释放内存后，free函数只是将这块空间还给操作系统了，而p指针所指向的地址是不会变的，所以我们需要将p置为空，以防有人想通过p访问刚刚开辟的100个字节空间时，这时就非法访问空间了。
需要注意的是！！！
int main()
{
int a=10;
int *p = &a;
free(p);//error
return 0;
}
这种做法是错误的，free的参数必须要么是NULL，要么是一个先前从malloc、calloc、realloc（稍后讲解）返回值，向free传递一个NULL参数不会参数任何效果
calloc
- 函数原型以及参数解释
calloc和malloc的一个区别是calloc会初始化分配好的内存为0，calloc和malloc之间的另一个区别就是它们请求内存数量的方式不同，calloc的参数包括所需元素的数量和每个元素的字节数，根据这些值，它能够计算处总共分配的内存。
返回值
malloc不会初始化分配好的内存：
int main()
{
int *p = (int*)malloc(40);
if(p==NULL)
{
return 1;
}
int i=0;
for(i=0;i<10;i++)
{
printf("%d\\n",p[i]);//打印出随机值
}
free(p);
p=NULL;
return 0;
}
malloc函数分配好的内存不会初始化，值为随机值
calloc会初始化分配好的内存：
int main()
{
int *p = (int*)calloc(10,4);
if(p==NULL)
{
return 1;
}
int i=0;
for(i=0;i<10;i++)
{
printf("%d\\n",p[i]);//打印出都是0
}
free(p);
p=NULL;
return 0;
}
而calloc会将每个元素初始化为0
接下来我们介绍最核心的函数realloc：
realloc
realloc是这几个函数中最核心的函数
- 函数原型以及参数解释
realloc函数让动态内存管理更加灵活，你可以使一块内存扩大或缩小。realloc的返回值不确定，可能会返回原先内存块的地址，可能会返回新内存块的地址，原因后面解释。
接下来我们看realloc函数的使用
int main()
{
int *p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("malloc");
return 0;
}
int i=0;
for(i=0;i<10;i++)
{
p[i]=i+1;//p[i]等价于*(p+i)
}
//调整空间的大小
p = (int*)realloc(p,20*sizeof(int));//error
//如果找不到合适的空间来调整大小，realloc会返回空指针，这里就将NULL赋给p，将原空间也毁掉了
int *ptr = (int*)realloc(p,20*sizeof(int));
if(ptr==NULL)
{
perror("realloc");
}
else
{
p=ptr;
ptr=NULL;
}
for(i=10;i<20;i++)
{
p[i]=i+1;
}
for(i=0;i<20;i++)
{
printf("%d ",p[i]);
}
//释放
free(p);
p=NULL;
return 0;
}
realloc调整空间存在两种情况
-
当要调整的原有空间后面空间够需要调整的大小时，就直接在后面增加空间，返回起始空间的地址
-
当要调整的原有空间后面空间不够需要调整的大小时，它会新开辟要调整的大小的空间，然后将旧空间的内容拷贝到新空间，最后将旧空间释放掉，然后返回新空间的起始地址
返回地址可能返回旧地址，也可能返回新地址
如果realloc函数的第一个参数是NULL，那么它的行为就和malloc一模一样：
int main()
{
int *p = (int*)realloc(NULL,40);//可以传NULL指针，和malloc功能类似，会开辟40个字节的空间
return 0;
}
常见的动态内存错误
- 对NULL指针进行解引用
int main()
{
int *p=(int*)malloc(100);
*p=0;
return 0;
}
若开辟成功，没什么问题，但是开辟失败，此时p为NULL，对NULL指针解引用非法操作了
- 对动态开辟内存的越界访问
int main()
{
int *p=malloc(10*sizeof(int));
if(p==NULL)
{
perror("malloc");
return 0;
}
int i=0;
//对动态开辟内存的越界访问
for(i=0;i<=10;i++)
{
p[i]=i;
}
for(i=0;i<=10;i++)
{
printf("%d",p[i]);
}
free(p);
p=NULL;
}
在我们开辟好10个整形的内存后，在使用内存时，当i=10时，p[10]等价于(p+10)，到达p+10时，我们*(p+10)访问到了我们申请的空间后面的一块空间，此时越界访问了。*
- 对非动态开辟内存使用free释放
void test()
{
int a=0;
int *p=&a;
free(p);//不ok
}
变量a是在栈区上开辟的空间，free函数只能释放在堆区上的空间
- 使用free释放一块动态开辟内存的一部分
int main()
{
int *p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("malloc");
return 0;
}
int i=0;
//释放动态开辟内存空间的一部分
for(i=0;i<5;i++)
{
*p=1;
p++;
}
free(p);//此时p不是指向空间的起始地址
p=NULL;
return 0;
}
在使用空间时，我们使得p++了，我们的指向分配空间起始地址的指针发生了改变,所以在free§时，就会出问题，我们不能释放动态开辟内存的一部分，并且我们开辟的这块空间起始地址不知道了，这块空间就找不到了，会造成内存泄漏
- 对同一块动态开辟的内存多次释放
int main()
{
int *p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("malloc");
return 0;
}
//使用空间
//对同一块动态开辟的内存多次释放
free(p);//忘记将p置为NULL
//...
free(p);//再次释放，此时会错误
p=NULL;
return 0;
}
在free§时，忘记将p置为NULL，当我们写代码的过程中忘记前面free过了，要是再次free就会出错的。
保险起见我们可以这样写free时，必须将指针置为NULL，就不会出现上面的问题了，再次释放，free传NULL指针什么事都不会发生，这种不会出错误：
free(p);
p=NULL;//将p置为NULL
//...
free(p);//再次释放，free传NULL指针什么事都不会发生，这种不会出错误
- 动态开辟内存忘记释放(内存泄漏)
int main()
{
int *p=(int*)malloc(10*sizeof(int));
if(p==NULL)
{
perror("malloc");
return 0;
}
else
{
*p=10;
}
return 0;
}
开辟了内存没有进行释放，防止错误，我们的malloc、calloc、realloc需要与free成对出现，但是成对出现不一定不发生错误
例如：
void test()
{
int *p=(int*)malloc(12);
if(p==NULL)
return;
//使用空间
if(1)
return;//此时已经返回，开辟的空间并没有释放
free(p);
p=NULL;
}
int main()
{
test();
return 0;
}
test函数中还没有释放就返回，虽然free出现了，但是根本没有到达free后面的代码，函数就返回了，所以也是错误的。
函数内部动态开辟空间忘记free释放
void test()
{
int *p=(int*)malloc(100);
if(p==NULL)
{
return;
}
}
int main()
{
test();
return 0;
}
p是局部变量，出函数会销毁，函数内部没有释放p所指向的空间，那么出了函数之后没人能找到那块空间，就造成了内存泄漏。
动态开辟的空间，两种回收方式:
- 主动free
- 程序结束
接下来我们看几个经典的笔试题，满满的干货哦：
几个经典的笔试题
- 笔试题1
#include<string.h>
#include<stdlib.h>
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
Test函数和GetMemory函数的精彩对决：
代码会挂，首先调用test函数，首先创建了一个str指针，里面放了NULL指针，之后调用GetMemory，将str传过去(值传递)，GetMemory函数中，形参p是str的一份临时拷贝，此时是NULL指针，动态内存开辟了一块空间用p指针维护，不会影响外面的str，函数调用结束后，str依然是NULL，会拷贝失败，又因为GetMemory函数调用结束后，p会销毁，并且会发生内存泄漏
笔试题1的第一种改错方法：传地址过去
//改错
#include<string.h>
#include<stdlib.h>
void GetMemory(char **p)
{
*p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
将str的地址传过去，这样就可以用str来维护堆区的这段内存，最后释放即可
笔试题1的第二种改错方法：
返回动态开辟内存的起始地址，用str来接收
#include<string.h>
#include<stdlib.h>
char* GetMemory以上是关于动态开辟内存的这些知识你知道了吗？了解柔性数组吗？超详细画图以及文字讲解，干货满满的主要内容，如果未能解决你的问题，请参考以下文章