C语言之动态内存管理
文章目录
- C语言之动态内存管理
- 1. 为什么要有动态内存管理
- 2. malloc 和 free
- 2.1 malloc
- 2.2 free
- 2.3 例子
- 3. calloc 和 realloc
- 3.1 calloc
- 3.2 realloc
- 4. 常见的动态内存错误
- 4.1 对NULL指针的解引⽤操作
- 4.2 对动态开辟空间的越界访问
- 4.3 对⾮动态开辟内存使⽤free释放
- 4.4 使⽤free释放⼀块动态开辟内存的⼀部分
- 4.5 对同⼀块动态内存多次释放
- 4.6 动态开辟内存忘记释放（内存泄漏）
- 5. 总结
1. 为什么要有动态内存管理
我们已经掌握的内存开辟⽅式有：
#include <stdio.h>
int main()
{
int val = 20;
int arr[10] = { 0 };
return 0;
}
上述的开辟空间的⽅式有两个特点：
• 空间开辟大小是固定的
•数组在申明的时候，必须指定数组的⻓度，数组空间⼀旦确定了⼤⼩不能调整
所以C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间
2. malloc 和 free
malloc和free函数都是在stdlib.h头文件中声明的
2.1 malloc
C语言中提供了一个动态内存开辟的函数：
void* malloc (size_t size);
其中size为要开辟的内存空间的大小，单位为字节
这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针
•如果开辟成功，则返回一个指向开辟好的内存空间的指针
•如果开辟失败，则返回一个NULL指针
•返回类型为void *，因为malloc函数不知道要开辟什么类型的内存空间，只知道要开辟的大小
•如果参数为0,malloc函数的行为标准是未定义的，取决于编译器
2.2 free
C语言还提供了一个的函数，专门用来做动态内存的释放和回收的：
void free (void* ptr);
ptr为要释放内存空间的指针
•如果参数ptr指向的内存空间不是动态开辟的，那么free函数的行为是未定义的
•如果参数ptr是NULL，则函数什么都不做
如果不对malloc calloc realloc 开辟的空间进行释放，即使出了作用域也不会销毁，有可能导致内存泄漏
释放的方式
1. free
2. 直到程序结束，由操作系统释放
2.3 例子
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int* p = (int*)malloc(10 * sizeof(int)); //开辟40个字节的空间
//判断是否为NULL指针
if (p == NULL)
{
perror("malloc fail\n"); //perror为错误信息打印
return 1;
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
//*p = i; //如果使用这种方法，p指针向后走了，在下面打印时，就找不到首元素的地址了
//p++;
}
//打印
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p); //释放
p = NULL; //将指针置NULL，如果不置NULL，下面解引用p时，p就是野指针
return 0;
}
代码运行结果:>
0 1 2 3 4 5 6 7 8 9
malloc开辟空间时，是不会给空间初始化的，如果直接打印，会打印出随机值
3. calloc 和 realloc
3.1 calloc
C语⾔还提供了⼀个函数叫 calloc ， calloc 函数也⽤来动态内存分配
void* calloc (size_t num, size_t size);
num为要开辟的元素个数
size为开辟元素的元素大小，单位为字节
•calloc为开辟num个大小为size元素的内存空间，并且将内存中每个字节初始化为0
•calloc的使用方法和malloc一样，主要区别在于calloc会初始化元素
例子：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int* p = (int*)calloc(10 ,sizeof(int));
//判断是否为NULL指针
if (p == NULL)
{
perror("calloc fail\n");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
代码运行结果:>
0 0 0 0 0 0 0 0 0 0
3.2 realloc
C语言中有一个函数用来调整动态内存开辟后的大小
void* realloc (void* ptr, size_t size);
ptr为要调整的内存地址
size为调整后的内存大小
• realloc函数的出现让动态内存管理更加灵活
• 当我们发现我们使用malloc calloc realloc申请的内存空间不够时，我们可以使用realloc进行扩容
•返回值为调整之后的内存的起始位置（不一定是原内存地址）
•如果开辟失败则返回一个NULL
•如果开辟成功则分以下两个情况：
情况1:原有空间之后有⾜够⼤的空间
情况2：原有空间之后没有⾜够⼤的空间
情况1：在原有内存后边直接追加空间，原来的空间的数据不变
情况2：原有内存之后的空间不足以最加空间，那么realloc会在堆区中找到一块足够开辟新大小的空间，将旧空间中的数据拷贝到新空间，并且将旧空间释放，同时返回新空间起始位置的地址
realloc的用法除了为开辟的内存进行扩容，也可以和malloc一样
例子：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
//判断是否为NULL指针
if (p == NULL)
{
perror("malloc fail\n");
return 1;
}
int* tmp = (int*)realloc(p, 100*sizeof(int));
if (tmp != NULL)
{
p = tmp;
}
else
{
perror("relloc fail\n");
return 1;
}
//使用
//..........
free(p);
p = NULL;
return 0;
}
这次的运行结果就是情况2（开辟100个字节的大小时，可能会出现），当后面的空间不够时， realloc就会找一块新的空间
这次只开辟了40个字节的空间，属于情况1，后面的空间足够时， realloc会直接在后面追加空间
4. 常见的动态内存错误
4.1 对NULL指针的解引⽤操作
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(40);
*p = 20; //如果malloc开辟空间失败，p可能是NULL，此时p为野指针
return 0;
}
在VS2022中，编译器会进行提示，我们得对可能出现NULL的情况进行处理
在使用malloc calloc realloc开辟空间时，最好对返回值进行判断，当不为NULL再使用
4.2 对动态开辟空间的越界访问
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc fail\n");
return 1;
}
int i = 0;
for (i = 0; i <= 10; i++) //只有10个元素的空间，却访问了第11个元素，访问越界了
{
*(p + i) = i;
}
free(p);
p = NULL;
return 0;
}
4.3 对⾮动态开辟内存使⽤free释放
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a = 10;
int* p = &a;
free(p);
return 0;
}
当用free释放了不是由malloc calloc realloc开辟的空间时，就会报错
4.4 使⽤free释放⼀块动态开辟内存的⼀部分
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int a = 10;
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc fail\n");
return 1;
}
//使用
//......
p++;
free(p);
p = NULL;
return 0;
}
当用free释放了开辟空间的一部分时，就会报错
4.5 对同⼀块动态内存多次释放
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int a = 10;
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc fail\n");
return 1;
}
//使用
//......
free(p);
free(p);
p = NULL;
return 0;
}
对一块动态开辟的内存进行多次free释放
在上述代码中如果free释放NULL，则没有问题，因为free的参数为NULL时，则什么都不做
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int a = 10;
int* p = (int*)malloc(40);
if (p == NULL)
{
perror("malloc fail\n");
return 1;
}
//使用
//......
free(p);
p = NULL;
free(p);
p = NULL;
return 0;
}
4.6 动态开辟内存忘记释放（内存泄漏）
#include <stdio.h>
#include <stdlib.h>
void test()
{
int* p = (int*)malloc(100);
if (p != NULL)
{
*p = 20;
}
}
int main()
{
test();
while (1); //死循环，让程序不结束
return 0;
}
当动态开辟的内存不释放时，就会一存在，在上述代码中，调用了test函数，开辟了100个字节的空间，同时赋值，出函数时，p被销毁了，但是开辟的空间并没有被销毁，没人可以使用，也没人可以释放，就会导致内存泄漏
5. 总结
一丶
在使用malloc calloc realloc开辟的空间时，要对其进行判断，当不为NULL的再进行使用
二丶
当不使用动态开辟的内存时，将其free释放，同时将指针置NULL，防止可能出现的内存泄露和野指针
三丶
不对不是动态开辟的空间free，不连续对动态开辟的空间free，同时free动态开辟的空间时，要给开辟的起始地址，不能free部分空间
