C语言动态内存管理———超级全！快来看！
文章目录
- C语言动态内存管理———超级全！快来看！
- 一、为什么要用动态内存
- 二、动态内存函数
- 1.malloc和free
- ①malloc
- ②.free
- ③举例
- a.内存的空间
- b.栗子
- 2.calloc
- 3.realloc
- 三、动态内存分配常见错误
- 1.常见错误
- 2.经典例题
- 四、柔性数组
- 五、C/C++程序中内存区的划分
一、为什么要用动态内存
int i = 0;
int arr[10] = { 0 };
上述两种向内存申请空间的方式有一个很大的弊端，就是不能灵活的调整申请的内存空间的大小。C语言引入动态内存分配，让程序员可以自己申请和释放空间。
二、动态内存函数
1.malloc和free
①malloc
void* malloc(size_t sz);
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回⼀个指向开辟好空间的指针。
如果开辟失败，则返回⼀个NULL指针，因此malloc的返回值⼀定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。这样申请一个字节长度为0的内存空间毫无意义。
②.free
void free(void* ptr);
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。 程序会崩溃
如果参数 ptr 是NULL指针，则函数什么事都不做。
释放后的内存空间我们就没有使用权限了，但是ptr还记得这个地址，这个指针就成了野指针，我们要把他变成NULL。
③举例
a.内存的空间
动态内存的函数的头文件是<stdlib.h>
b.栗子
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
int main()
{
int* p = (int*)malloc(10 * sizeof(int));//10个整型数据的空间
if (p == NULL)//判断是否为空指针
{
perror("malloc");
}
int i = 0;
for (i = 0; i < 10; i++)
{
p[i] = i;
printf("%d ", p[i]);
}
free(p);//动态内存使用后要释放
p = NULL;
return 0;
}
2.calloc
void* calloc (size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
return 0;
}
3.realloc
对动态开辟的内存空间进行调整
void* realloc (void* ptr, size_t size);
ptr是需要调整的动态内存空间的地址，size是想要调整到的大小，返回值为调整后的内存空间的起始地址。
realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间， 要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。返回的地址和ptr是一样的。
情况2：原有空间之后没有足够大的空间， 原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小的连续空间来使用。这样函数返回的是⼀个新的内存地址。
//e.g.1 验证在情况1时 p = ptr
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int* ptr = (int*)realloc(p, 11 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
free(p);//检查如果需要结束，那么就提前把p指向的内存释放掉
p = NULL;
return 1;
}
else
{
printf("%p\n%p\n", p, ptr);
}
return 0;
}
//e.g.2
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int* ptr = (int*)realloc(p, 11 * sizeof(int));
if (ptr == NULL)//防止因为ptr是空指针直接赋给p后，就p里原先的内容弄丢。
{
perror("realloc");
return 1;
}
else
{
p = ptr;
ptr = NULL;//此处不可以free(ptr)，这样的话p也不能用了
int i = 0;
for (i = 0; i < 11; i++)
{
p[i] = i;
printf("%d ", p[i]);
}
}
free(p);
p = NULL;
return 0;
}
补充：
当realloc第一个参数是NULL时，作用相当于malloc
int main()
{
int* p = (int*)realloc(NULL, 40);//当realloc函数的第一个参数是NULL指针时，功能类似于malloc函数
}
三、动态内存分配常见错误
1.常见错误
NULL指针的解引用操作—动态内存函数申请空间失败后，会返回NULL指针，需要先检查再使用
对动态开辟空间的越界访问
对非动态开辟内存使用free释放
使用free释放⼀块动态开辟内存的一部分
对同一块动态内存多次释放—free(NULL)没事，所以free后面紧跟把指针设置成NULL
动态开辟内存忘记释放（内存泄漏）—动态开辟的空间一定要释放，并且要正确释放，内存泄漏对于一直在跑的程序来说很危险。
2.经典例题
e.g.1
void GetMemory(char* p)
{
p = (char*)malloc(100);//申请的动态内存分配给了P，但是函数结束后，p直接销毁，p的地址再也没有人记得，malloc申请的空间没有机会释放，导致内存泄漏
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");对NULL指针进行解引用，访问冲突，导致程序崩溃
printf(str);
}
int main()
{
Test();
return 0;
}
e.g.2
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();//出了函数后p创建的空间已经被销毁了，返回栈空间（局部变量）地址，str已经是野指针
printf(str);
}
int main()
{
Test();
return 0;
}
e.g.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);
}
int main()
{
Test();
return 0;
}
e.g.4
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");//内存空间已经被释放，非法访问
printf(str);
}
}
四、柔性数组
C99 中，结构中的最后⼀个元素允许是未知大小的数组，这就叫做柔性数组成员。
struct Stu
{
int i;
char a;
int arr[0];//或者是int arr[];
};
结构中的柔性数组成员前面必须至少⼀个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
struct Stu
{
int i;
char a;
int arr[0];
};
int main()
{
printf("%zd\n", sizeof(struct Stu));//8,最大对齐数的整数倍
struct Stu* p = (struct Stu*)malloc(sizeof(struct Stu) + 10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
p->i = 100;
for (i = 0; i < 10; i++)
{
p->arr[i] = i;
printf("%d ", p->arr[i]);//0-9
}
free(p);
p = NULL;
return 0;
}
其实下面的代码也能实现相同的效果
typedef struct st_type
{
int i;
int *p_a;
}type_a;
int main()
{
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//业务处理
for(i=0; i<100; i++)
{
p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;
return 0;
}
但是柔性数组有以下两点优势：
1.只需要free一次，方便内存释放。
2.减少内存碎片，提高访问速度。
五、C/C++程序中内存区的划分
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。如果递归层次太深，会导致栈溢出，也就是栈区空间不够用了。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
代码段：存放函数体（可执行代码和只读常量）的⼆进制代码。e.g.常量字符串
内核空间，用户不能读写，是操作系统的东西。
