目录
情况1：如果不使用free释放:程序结束之后，也会由操作系统回收🚩
情况2：如果不使用free释放，程序也不结束,内存泄露🏳🌈
1. 为什么存在动态内存分配❓
int val = 20 ; // 在栈空间上开辟四个字节char arr [ 10 ] = { 0 }; // 在栈空间上开辟 10 个字节的连续空间
但是上述的开辟空间的方式有两个特点:
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
2. 动态内存函数的介绍
2.1 malloc和free✅
C语言提供了一个动态内存开辟的函数:void* malloc (size_t size);
假设有人在内存中申请20个字节的空间写成这样是肯定没错的:
void* p= malloc (20);
- 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
void*指针需要注意的特点有:
1.可以接收任意类型的地址(也就是无具体类型的指针)
2.不能+-*/，不能解引用操作，非常麻烦
并且如果在这20个byte里面存放1，2，3，4，5五个整型,那就应该用整型指针接收
int* p=(int*) malloc (20);
这里再提一下内存:
关于malloc的使用的整体的过程:①申请②使用③释放
整体呈现的代码:
int main()
{ //申请
int* p = (int*)malloc(20);
//使用
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
int i = 0;
//初始化:
for (i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
//释放
free(p);
//置为空指针
p = NULL;
return 0;
}
①申请:1️⃣
int* p = (int*)malloc(20);
- 这个函数向内存申请一块连续可用的空间，如果开辟成功,并返回指向这块空间的指针。
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
- 由于malloc是可能申请失败的，失败的原因有：
1.申请开辟的内存空间过大
2.可能内存不足（设计到linux，不便阐述）
虽然申请了空间，但是操作系统并没有真正的给使用者，只是一个虚拟空间的映射，当使用者真正用到的时候，才会使用内存
3.不确定的地方⁉❎
- malloc申请0个字节的空间?!
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
②使用：2️⃣
写法一:指针解引用
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
在内存窗口地址处输入p即可监视值的变化
写法二:想象成数组
for (i = 0; i < 5; i++)
{
p[i] = i + 1;
}
for (i = 0; i < 5; i++)
{
printf("%d ",p[i]);
}
两种写法的运行结果都是:
需要注意的点是:malloc申请的空间不初始化，打印是随机值
#include<stdio.h>
#include<errno.h>
int main()
{
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", *(p + i));
}
free(p);
return 0;
}
换成16进制打印:
printf("%x ", *(p + i));
③释放：3️⃣
void free ( void* ptr );
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
意思是ptr指向的那块空间一定是动态内存开辟到的一块空间，要是ptr随便指向一块空间，让它free一下，那是不行的
如果参数 ptr 是NULL指针，则函数什么事都不做。
要是ptr本来就是一个空指针，那free之后什么事情都不会发生
free之前，可以看到p的地址
free之后,地址没有改变!💢
如果有使用者去使用p的话，那它就是一个野指针了,free这个函数不会帮指针p置空的⭕
- 要避免野指针问题:free完要主动置为空指针, 这两步不要忘记了:
free(p);//1
p=NULL;//2
2.2 calloc
C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：
void* calloc (size_t num, size_t size);
#include<stdio.h>
int main()
{
int* p = (int*)calloc(5, sizeof(int));
if (p == NULL)
{
printf("calloc()-->%s\n", strerror(errno));
return 1;
}
//使用
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", p[i]);
}
//释放
free(p);
p = NULL;
return 0;
}注意：这段代码是没有初始化任何元素的
执行:
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0：
可以看到里面20个字节全部初始化为0了
🧨与malloc的区别:
👓因为calloc要初始化元素，所以效率是没有malloc高的，根据实际情况去选择吧。👓
2.3 realloc
void* realloc ( void* ptr , size_t size );
- ptr 是要调整的内存地址
- size 调整之后新大小
- 返回值为调整之后的内存起始位置。
- 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
🎃本地扩容:
realloc不会释放空间,free的就是旧的地址(p指向的那块的空间),这块空间地址是连续的，所以会根据地址的顺序连续释放掉
⇨情况2：原有空间之后没有足够大的空间
🎩异地扩容:
1.realloc会找更大的空间
2.将原来的数据拷贝到新的空间3.释放旧的空间 --> realloc函数会自己处理，不用我们手动释放(不用手动free)
重新找了一片空间（ptr指向那块空间）进行扩容，那realloc会先将数据拷贝到(ptr指针指向的)新地址处，再将旧(p指向)的空间释放掉
4.返回新空间的地址realloc返回的是新的地址-->(ptr指针存的地址)
3.常见的动态内存错误
3.1 对NULL指针的解引用操作
#include<stdio.h>
int main() {
int* p = (int*)malloc(20);
//可能出现对NULL指针的解引用操作
//所以malloc函数的返回值要判断
int i = 0;
for (i = 0; i < 5; i++)
{
p[i] = i;
}
free(p);
p = NULL;
return 0;
}malloc有可能申请失败,返回NULL指针,可能出现对NULL指针的解引用操作,所以malloc函数的返回值要判断
🎇3.2 对动态开辟空间的越界访问
#include<stdio.h>
int main() {
int* p = (int*)malloc(20);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
//可能出现对NULL指针的解引用操作
//所以malloc函数的返回值要判断
int i = 0;
//越界访问
for (i = 0; i < 10; i++)
{
p[i] = i;
}
free(p);
p = NULL;
return 0;
}打开内存监视可以发现:
✨发现:
这里越界了，等于甚至超过下标为5它依旧会初始化，但不会发生错误，只有到程序执行到free那一步才会发生错误
个人理解:
这个是因为vs对于越界的检查是不太严格的,可以理解为抽查,可能会检查到,也可能检查不到。
3.3对非动态开辟内存使用free释放🍕
arr创建这个变量在栈上，不在堆上
注意:数组也是变量,可以理解为它是一种特殊的变量类型，是由同一类型的元素组成的
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5 };
int* p = arr;
free(p);
p = NULL;
return 0;
}free函数用来释放动态开辟的内存。
- 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
3.4使用free释放一块动态开辟内存的一部分🍟
#include<stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p = NULL)
{
printf("%s\n", strerror(errno));
return 0;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*p = i + 1;
p++;
}
//释放
free(p);
return 0;
}
原因：申请了40个字节，如果要释放整块空间，必须提供起始位置地址才能释放掉，如果提供中间位置地址，那程序会崩溃的。
3.5 对同一块动态内存多次释放🍔
错误代码:
int main()
{
int* p = (int*)malloc(20);
if (p == NULL)
{
return 1;
}
//使用
free(p);
free(p);
p = NULL;
return 1;
}
重复释放malloc申请开辟的空间会导致程序崩溃
解决方法🍚
free(p);
p=NULL;//这是解决的方法🍭
free(p); //置空之后,这里什么事情都不干
p=NULL;
🎈3.6 动态开辟内存忘记释放（内存泄漏）?
写一下前面malloc，calloc，realloc的共同之处:
malloc--calloc--realloc
1️⃣所申请的空间，如果不想使用，需要free释放❗❗❗
2️⃣如果不使用free释放:程序结束之后，也会由操作系统回收
注意:函数结束和程序结束不是一回事，整个程序的生命周期到了结束了，它会释放这个内存的。
3️⃣如果不使用free释放，程序也不结束,内存泄露
情况1：如果不使用free释放:程序结束之后，也会由操作系统回收🚩
#include<stdio.h>
test()
{
int* p = (int*)malloc(20);
}
int main()
{
test();
return 0;
}
情况2：如果不使用free释放，程序也不结束,内存泄露🏳🌈
问:什么时候程序不结束?
答:死循环
#include<stdio.h>
test()
{
int* p = (int*)malloc(20);
}
int main()
{
test();
while (1);
return 0;
}main函数中,死循环 程序没有结束 那么那段空间也就一直没有释放
死循环那是因为：
while（1）; 相当于while(1){};条件是1永远是真，while（1）一直运行，那就是死循环了
4. 几个经典的笔试题
4.1 题目1： 对NULL指针追加字符串
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;
}
注意点:
1.str是值传递，不是地址，可以理解为一个特殊的变量
2.如果在GetMemory函数里面free的话，又违背了这题的初衷，因为它就想返回动态内存开辟的空间，然后让strcpy函数将字符串追加到首地址上去
解决问题:
🌈写法一:通过返回值的方式带回100个字节的地址
char* GetMemory(char* p)
{
p = (char*)malloc(100);
return p;//修改位置
}
void Test(void)
{
char* str = NULL;
str=GetMemory(str);//修改位置
strcpy(str, "hello world");
printf(str);
free(str);//修改位置
str = NULL; //修改位置
}
int main()
{
Test();
return 0;
}把申请的100个字节的起始地址返回来，由指针变量str接收
⚡简洁写法:不需要传参
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str=GetMemory();
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}💧写法二:通过二级指针的方式
插叙一条重要的知识点:
#include<stdio.h>
int main()
{
char* p = "hehe\n";//这里是把"hehe\n"放到p里面去了？不是，把这个表达式（字符串）首字符h的地址，放到p里面去了
printf("hehe\n");//这里其实是把字符串首字符的地址传给了printf
return 0;
}
回到原题:
这题的问题出现在哪?str是值传递，传给p的时候p是str的一份临时拷贝，对形参的修改不会影响str，把指针变量的str的地址取出来，写成&str,那形参就该写成char**p,这样的处理方法是不用通过返回值也能把地址带回来
void* GetMemory(char**p)
{
* p = (char*)malloc(100);//这里*p就是str
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);//关于这里的疑惑可以看上面插叙的知识
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}以上三种写法结果都是:
4.2 题目2：数组在栈空间创建的销毁问题🎉
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test()
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}
执行结果:
返回栈空间地址的问题：
GetMemory函数内部创建的数组是临时的，虽然返回了数组的起始地址给了str，但是数组的内存出了GetMemory函数就被回收了，而str依然保存了数组的起始地址，这时如果使用str，str就是野指针
看到这是不是觉得跟某一题很眼熟🥽
关于左右两段代码，区别是一个在堆区，一个在栈区，左边位于堆区的那个GetMemory函数出了函数，那段空间还保留着,没有销毁，而右边位于栈区的那段空间,出了GetMemory函数就由操作系统回收了
简单提一下函数栈帧的现象:
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}
由上面提到的知识我们可知这个p是野指针，但是依然记得这块空间的地址，并且打印该值
可是加上了这一段之后，p的值就改变了
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();
printf("hehe\n");//添加的
printf("%d\n", *p);
return 0;
}
4.3 题目3：程序正常执行但内存泄露🎯
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}执行结果:
错误:
内存泄露
该注意的点:
这题是可以正常执行的,内存泄露看的是:空间有没有正常释放,不看程序结束之后的结果
申请的内存由于某种原因没有被及时释放，导致内存空间被占用但无法再被程序使用或回收，导致内存泄露
4.4 题目4：野指针使用问题🎮
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}执行:
free是将空间还给操作系统了，但是地址是没有销毁的，这个str还是保存的之前的地址，但
是继续这样访问是不对的，因为空间已经不属于str了
简单来说就是：空间是销毁还给操作系统了,地址还记着,依旧使用
图解:
代码修改:
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);str=NULL;//修改位置
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
接下来还有柔性数组等的知识，欢迎大佬补充
1103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
