C语言——动态内存管理
大家好，我是残念，希望在你看完之后，能对你有所帮助，有什么不足请指正！共同学习交流
本文由：残念ing原创CSDN首发，如需要转载请通知
个人主页：残念ing-CSDN博客，欢迎各位→点赞 + 收藏⭐️ + 留言
系列专栏：残念ing 的C语言系列专栏——CSDN博客
-----------------------------------------------------------CSDN-------------------------------------------------------------
目录
前言：
1. malloc 和free（ ）
1.1 malloc
1.2 free
2. calloc 和 realloc
2.1 calloc
2.2 realloc
3. 常见的动态内存的错误
3.1 对NULL指针的解引用操作
3.2 对动态开辟空间的越界访问
3.3 对非动态开辟内存使用free释放
3.4 使用free释放一块动态开辟内存的一部分
3.5 对同一块动态内存多次释放
3.6 动态开辟内存忘记释放（内存泄漏）
4. 动态内存经典笔试题分析
题目1：
题目2：
题目3：
题目4：
5. 柔性数组
5.1 柔性数组的特点
5.2 关于柔性数组的使用
5.3 柔性数组的优点
6. C/C++中程序内存区域划分
前言：
为什么要有动态内存管理？？？
我们平时在开辟空间时是这样的：
int a=10;//在栈空间上开辟4个字节
char arr[10]={0};//在栈空间上开辟10个字节的连续空间这样开辟的空间有两个弊端：
1、空间开辟是固定不变的
2、数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整
我们会遇到很多情况，有时候我们需要的空间大小在程序运行的时候才知道，这时开劈好的空间会不能满足，或者开辟多了，会导致大量的空间浪费。
这就有了动态内存开辟，让程序员可以自己申请需要的空间和释放不需要的空间，这就比较灵活了。
1. malloc 和free（ ）
1.1 malloc
这是一个动态内存开辟的函数：
void* malloc(size_t size);作用：可以向内存申请一块连续可用的空间，并返回指向这块空间的指针。
注意：如果开辟成功，则返回一个指针开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做判断。
返回值的指针类型是void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数size 为0，malloc的行为标准是未定义的，取决于编译器。
补充：malloc 申请的空间是在内存的堆区的
malloc的使用：
1.2 free
C语言还为我们提供了一个专门用来做动态内存的释放和回收的函数 free ：
void free (void* ptr);作用：用来释放动态开辟的内存。
注意：1、如果参数 ptr 指向的空间不是动态开辟的，那么 free 函数的行为是未定义的。
2、如果参数 ptr 是NULL指针，则函数什么都不做。
补充：free 只是会把 ptr 指向的空间释放了，但是 ptr 里面还存着那块空间的起始地址，我们为了防止 ptr 后面会成为野指针，我们必须要把 ptr 制为空指针。
free 的使用：
2. calloc 和 realloc
2.1 calloc
除了malloc外 还有一个 calloc 函数，它也是用来动态内存开辟的：
void* calloc(size_t num,size_t size);
注意：函数的功能是 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始为0。
与函数malloc的区别只在于calloc会返回地址之前把申请的空间的每个字节初始化为全0。
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
int i = 0;
for(i=0; i<10; i++)
{
printf("%d ", *(p+i));
}
}
free(p);
p = NULL;
return 0;
}作用：对申请的内存空间进行初始化。
2.2 realloc
有时候我们会发现之前申请的空间太小了，有时候我们会觉得申请的空间过大了，为了合理的使用内存，我们会对内存的大小作合理的调整，realloc 函数就可以做到对动态开辟内存大小的调整。
void* realloc(coid* ptr,size_t size);ptr ：要调整的内存地址。
size：调整之后新大小。
注意：返回值为调整之后的内存的起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存的数据移动到新的空间。
realloc 在调整内存空间的说存在两种情况：
情况1：在已经开辟好的空间后边，没有足够的空间，直接进行空间的扩大。在这种情况下，realloc 函数会在内存的堆区重新找一个空间（满足新的空间的大小需求的）同时会把旧的数据拷贝到新的空间，然后释放旧的空间，同时返回新的空间的起始地址。
情况2：在已经开辟好的空间后面，有足够的空间，直接进行扩大。扩大空间后，直接返回旧的空间的起始地址。
补充：我们不能直接把realloc的返回值放到目标指针中，因为如果申请失败，那之前的空间也会找不到。我们一般要先将realloc函数的返回值放在一个临时指针中，判断是不是NULL指针，再放到目标指针中。
举例：
#include
#include
int main()
{
int* ptr = (int*)malloc(100);
if (ptr != NULL)
{
perror("malloc");
}
else
{
return 1;
}
//扩展容量
int* p = (int*)realloc(ptr, 1000);
if (p != NULL)
{
ptr = p;
}
else
{
perror("realloc");
}
//业务处理
free(ptr);
return 0;
} 3. 常见的动态内存的错误
3.1 对NULL指针的解引用操作
void test()
{
int* p = (int*)malloc(INT_MAX / 4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}如果一定要这样的话：就必须先判断一下p是不是NULL指针。
3.2 对动态开辟空间的越界访问
void test()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
{
exit(EXIT_FAILURE);
}
for (i = 0; i <= 10; i++)
{
*(p + i) = i;//当i是10的时候越界访问
}
free(p);
}3.3 对非动态开辟内存使用free释放
void test()
{
int a = 10;
int* p = &a;
free(p);//p指向的空间不是在堆区上
}补充：malloc、calloc、 realloc 申请的空间，如果不主动释放，出了作业域是不会销毁的
释放的方式：1、free主动释放 2、直到程序结束，才由操作系统回收
3.4 使用free释放一块动态开辟内存的一部分
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}3.5 对同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放
}3.6 动态开辟内存忘记释放（内存泄漏）
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while (1);
}忘记释放不再使⽤的动态开辟的空间会造成内存泄漏。 切记：动态开辟的空间⼀定要释放，并且正确释放。
4. 动态内存经典笔试题分析
题目1：
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}出错的点：
1、GetMemory函数采用值传递的方式，无法将malloc 开辟空间的地址，返回放在str 中，调用结束后str 依然是NULL指针。
2、strcpy 中使用了str，就是对NULL指针解引用操作，程序崩溃。
3、内存泄漏。
解决方法：
1、
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;
}2、
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;
}题目2：
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}出错的点：在出GetMemory函数后，存储 hello world 的空间被回收了，就不能在使用了，str 也成为了野指针。（放回栈空间地址的问题）如果要改，只能在数组前加 static。
题目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：
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}出错的点： free 后str为野指针了。再访问就非法访问了。
5. 柔性数组
在我们的认识范围内，也许我们从来没有听说过柔性数组这个概念，但是它确实是存在的。
在结构体中的最后一个元素允许是未知大小的数组，这就叫做 柔性数组 成员。
struct st_type
{
int i;
int a[0];//柔性数组成员
};struct st_type
{
int i;
int a[];//柔性数组成员
};5.1 柔性数组的特点
1、结构体中的柔性数组成员前面至少一个其他成员。比如：int char等一些变量
2、sizeof 返回这种结构体的大小不包括柔性数组的内存。
3、包含柔性数组成员的结构体用malloc() 函数进行内存的分配，并且分配的内存一个大于结构体的大小，一适应柔性数组的预期大小。
struct st
{
int i;
int a[0];//柔性数组成员
};
int main()
{
printf("%d\n", sizeof(struct st));//输出的是4
return 0;
}5.2 关于柔性数组的使用
//代码1
#include
#include
struct st
{
int i;
int a[0];//柔性数组成员
};
int main()
{
struct st* p = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));//为结构体分配空间+为柔性数组分配空间
p->i = 30;
for (int i = 0; i < 10; i++)
{
p->a[i] = i;
}
//分配的空间不足时
struct st* ptr = (struct st*)realloc(p, sizeof(struct st) + 20 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
return -1;
}
else
{
p = ptr;
}
//再使用
for (int i = 10; i < 20; i++)
{
p->a[i] = i;
}
for (int i = 0; i < 20; i++)
{
printf("%d ", p->a[i]);
}
printf("\n%d\n", p->i);
//销毁
free(p);
p = NULL;
return 0;
} 5.3 柔性数组的优点
我们先看一下下面的代码，这个结构体的设计也可以完成同样的效果。
#include
#include
struct st2
{
int i;
int* p_a;
};
int main()
{
struct st2* pt=(struct str2*)malloc(sizeof(struct st2));
pt->i = 10;
pt->p_a=malloc(sizeof(int) * 10);//单独让其指向一个分配好的空间
//使用
for (int i = 0; i < 10; i++)
{
pt->p_a[i] = i;
}
//空间不足
int* ptr=(int*)realloc(pt->p_a, sizeof(int) * 20);
if (ptr == NULL)
{
perror("raslloc");
return -1;
}
else
{
pt->p_a = ptr;
}
//再使用
for (int i = 10; i < 20; i++)
{
pt->p_a[i] = i;
}
for (int i = 10; i < 20; i++)
{
printf("%d ", pt->p_a[i]);
}
return 0;
} 上述代码其实完成了同样的功能，但是代码1的实现更突出且有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，只能里面做了两次内存分配，并把整个结构体返回给用户。用户调用free 可以释放结构体，但是用户并不知道这个结构体的成员也需要 free，所以你不能指望用户来发现这件事。所以，如果我们把结构体的内存以及成员一次性分配好内存，并且返回给用户一个结构体指针，用户做一次 free 就可以把所有内存都释放掉了。
第二个好处是：有利于访问速度
连续的承诺有益于提高访问速度，也有益于减少内存碎片（少几个中间商）
6. C/C++中程序内存区域划分
C/C++程序内存分配的⼏个区域：
1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时 这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内 存容量有限。 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。 2. 堆区（heap）：⼀般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配⽅ 式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。
