C语言进阶⑰(动态内存管理)四个动态内存函数+动态通讯录+柔性数组
1. 为什么存在动态内存分配
我们已经掌握的内存开辟方式有：
int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间但是上述的开辟空间的方式有两个特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况。
有时候我们需要的空间大小在程序运行的时候才能知道，
那数组的编译时开辟空间的方式就不能满足了。
这时候就只能试试动态存分配了。
所谓动态内存分配(Dynamic Memory Allocation) 就是指在程序执行的过程中动态地
分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要
预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。
2. 动态内存函数的介绍
以下四个动态内存函数头文件都是：stdlib.h
2.1 malloc和free
C语言提供了一个动态内存开辟的函数：
void* malloc (size_t size);
size是要开辟的总字节数
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
① 如果开辟成功，则返回一个指向开辟好空间的指针。
② 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
③ 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，
具体在使用的时候使用者自己决定。（所以接收时要强制转换）
④ 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
(课后作业里：malloc(0)是允许的，也会返回一个指针，只是没有空间所以不可使用而已。)
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：
void free (void* ptr);
free函数用来释放动态开辟的内存。
① 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
② 如果参数 ptr 是NULL指针，则函数什么事都不做。
注意事项：
① 使用完之后一定要记得使用 free 函数释放所开辟的内存空间。
② 使用指针指向动态开辟的内存，使用完并 free 之后一定要记得将其置为空指针。
举个例子：
#include
#include
int main(void)
{
// 假设开辟10个整型空间
int arr[10]; // 在栈区上开辟
// 动态内存开辟
int* p = (int*)malloc(10 * sizeof(int)); // 开辟10个大小为int（40字节）的空间
// 使用这些空间的时候
if (p == NULL)
{
perror("main"); // main: 错误信息
return 0;
}
// 使用
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;// p[i]=i;也行
}
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
// 回收空间
free(p);
p = NULL; // 需要手动置为空指针
return 0;
} 为什么 free 之后，一定要把 p 置为空指针？
解析：因为 free 之后那块开辟的内存空间已经不在了，
free的功能只是把开辟的空间回收掉，但是 p 仍然还指向那块内存空间的起始位置，
这时p就是一个野指针。所以我们需要使用 p = NULL ;手动把他置成空指针。
为什么 malloc 前面要进行强制类型转换呢？
int* p = (int*)malloc(10*sizeof(int));
解析：为了和 int* p 类型相呼应，所以要进行强制类型转换。你可以试着把强转删掉，
其实也不会有什么问题。但是因为有些编译器要求强转，所以最好进行一下强转，避免不必要的麻烦。
2.2 calloc
C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：
void* calloc (size_t num, size_t size);
calloc 函数的功能实为 num 个大小为 size 的元素开辟一块空间，并把空间的每个字节初始化为 0 ，
和malloc一样：
① 如果开辟成功，则返回一个指向开辟好空间的指针。
② 如果开辟失败，则返回一个NULL指针，因此calloc的返回值也要做检查。
③ 返回值的类型是 void* ，所以calloc函数并不知道开辟空间的类型，
具体在使用的时候使用者自己决定。（所以接收时要强制转换）
④ 如果参数 size 为0，calloc的行为是标准是未定义的，取决于编译器。
（这里的size是一个num的字节）
和malloc的区别：
① malloc 只有一个参数，而 calloc 有两个参数，分别为元素的个数和元素的大小。
② 与函数 malloc 的区别在于 calloc 会在返回地址前把申请的空间的每个字节初始化为 0 。
#include
#include
int main()
{
// calloc
int* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间，40
if (p == NULL)
{
perror("main");
return 0;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i)); //这里打印了十个0，换成malloc开辟的就打印十个一样的随机值
}
free(p);
p = NULL;
return 0;
} 所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。
2.3 realloc
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，
那为了合理的使用内存，我们一定会对内存的大小做灵活的调整。
那 realloc 函数就可以做到对动态开辟内存大小的调整。
函数原型如下：
void* realloc (void* ptr, size_t size);
① ptr 为指针要调整的内存地址。
② size 为调整之后的新大小。
③ 返回值为调整之后的内存起始位置，请求失败则返回空指针。
④ realloc 函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
(课后作业里：realloc函数可以调整动态申请内存的大小，可大可小)
realloc 函数在调整内存空间时存在的三种情况：
情况1：原有空间之后有足够大的空间。
情况2：原有空间之后没有足够大的空间。
情况3：realloc 有可能找不到合适的空间来调整大小。
情况1：当原有空间之后没有足够大的空间时，直接在原有内存之后直接追加空间，
原来空间的数组不发生变化。
情况2：当原有空间之后没有足够大的空间时，会在堆空间上另找一个合适大小的连续的空间来使用。
函数的返回值将是一个新的内存地址。
情况3：如果找不到合适的空间，就会返回一个空指针。
代码演示：realloc 调整内存大小
#include
#include
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("main");
return 0;
}
for (int i = 0; i < 10; i++)
{
*(p + i) = 5;
}
// 此时，这里需要p指向的空间更大，需要20个int的空间
// realloc 调整空间
//p = (int*)realloc(p, 20 * sizeof(int)); // 调整为20个int的大小的空间
/*刚才提到的第三种情况，如果 realloc 找不到合适的空间，就会返回空指针。
我们想让它增容，他却存在返回空指针的危险，然后我们就找不到原来的空间了
解决方案：不要拿指针直接接收 realloc，可以使用临时指针判断一下。*/
int* tmp = (int*)realloc(p, 20 * sizeof(int));// 调整为20个int的大小的空间
// 如果ptmp不等于空指针，再把p交付给它
if (tmp != NULL)
{
p = tmp;
}
free(p); // 释放
p = NULL; // 置空
} 有趣的是，其实你可以把 realloc 当 malloc 用：
// 在要调整的内存地址部分，传入NULL：
int* p = (int*)realloc(NULL, 40); // 这里功能类似于malloc，就是直接在堆区开辟40个字节插入练习:把上篇通讯录改成动态的
思考后发现，我们只需要先该存放联系人的结构体，再改初始化通讯录函数和增加联系人函数，其它函数都可以不用动，最后在选0退出程序之前写一个销毁通讯录函数，释放开辟的空间就行了。
以下是基于上篇最后的代码改的：
快排不知道哪里出了问题，所以用冒泡排序代替下
test.c：
//通讯录-静态版本
//1.通讯录中能够存放1000个人的信息
//每个人的信息：
//名字+年龄+性别+电话+地址
//2. 增加人的信息
//3. 删除指定人的信息
//4. 修改指定人的信息
//5. 查找指定人的信息
//6. 排序通讯录的信息
//
//版本2：
//动态增长的版本
//1.通讯录初始化后，能存放3个人的信息
//2.当我们空间的存放满的时候，我们增加2个信息
//3+2+2+2+...
#include"contact.h"
void menu()
{
printf("****************************************\n");
printf("****** 1.add 2.del ********\n");
printf("****** 3.search 4.modify ********\n");
printf("****** 5.sort 6.print ********\n");
printf("****** 0.exit ********\n");
printf("****************************************\n");
}
enum option
{
EXIT,
ADD,
DEL,
SEARCH,
MODIFY,
SORT,
PRINTF
};
int main()
{
int input = 0;
//创建通讯录 info(信息)
contact con;
//初始化通讯录函数
init_contact(&con);
do
{
menu();
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case ADD:
add_contact(&con);
break;
case DEL:
del_contact(&con);
break;
case SEARCH:
find_contact(&con);
break;
case MODIFY:
modify_contact(&con);
break;
case SORT:
sort_contact(&con);
break;
case PRINTF:
print_contact(&con);
break;
case EXIT:
destroy_contact(&con);
printf("退出程序\n");
break;
default:
printf("选择错误，重新选择\n");
break;
}
} while (input);
return 0;
}contact.h
#include
#include
#include//qsort，perror，动态内存开辟函数
#define MAX_NAME 20
#define MAX_SEX 10
#define MAX_TELE 20
#define MAX_ADDR 30
#define DEFAULT_SZ 3 //default 默认
#define INC_SZ 2 //sz增量
//类型的定义
typedef struct peoinfo
{
char name[MAX_NAME];
char sex[MAX_SEX];
int age;
char tele[MAX_TELE];
char addr[MAX_ADDR];
}peoinfo;
静态版本通讯录
//typedef struct contact
//{
// peoinfo data[MAX];//存放添加进来的人的信息
// int sz;//记录的是当前通讯录中有效信息的个数
//}contact;
//动态版本通讯录
typedef struct contact
{
peoinfo* data;//指向动态开辟的空间，存放添加进来的人的信息
int sz;//记录的是当前通讯录中有效信息的个数
int capacity;//记录当前通讯录的最大容量，方便增容
}contact;
//初始化通讯录函数
void init_contact(contact* p);
//增加联系人函数
void add_contact(contact* p);
//销毁联系人函数
void destroy_contact(contact* p);
//打印联系人函数
void print_contact(const contact* p);
//删除联系人函数
void del_contact(contact* p);
//查找联系人函数
void find_contact(const contact* p);
//修改联系人函数
void modify_contact(contact* p);
//排序联系人函数
void sort_contact(contact* p); contact.c
#include"contact.h"
初始化通讯录函数 静态版本
//void init_contact(contact* p)
//{
// p->sz = 0;
// memset(p->data, 0, sizeof(p->data));
//}
//初始化通讯录函数 动态版本
void init_contact(contact* p)
{
p->data = (peoinfo*)calloc(DEFAULT_SZ, sizeof(peoinfo));
if (p->data == NULL)
{
perror("init_contact");
return;
}
p->sz = 0;//初始化后默认是0
p->capacity = DEFAULT_SZ;
}
增加联系人函数 静态版本
//void add_contact(contact* p)
//{
// if (p->sz == MAX)
// {
// printf("通讯录已满，无法添加");
// return;
// }
// printf("请输入要添加人的姓名：");
// scanf("%s", p->data[p->sz].name);
// printf("请输入要添加人的性别：");
// scanf("%s", p->data[p->sz].sex);
// printf("请输入要添加人的年龄：");
// scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
// printf("请输入要添加人的电话：");
// scanf("%s", p->data[p->sz].tele);
// printf("请输入要添加人的住址：");
// scanf("%s", p->data[p->sz].addr);
//
// p->sz++;
// printf("添加成功\n");
//}
//增加联系人函数 动态版本
void add_contact(contact* p)
{
if (p->sz == p->capacity)
{
peoinfo* tmp = (peoinfo*)realloc(p->data, (p->capacity + INC_SZ) * sizeof(peoinfo));
if (tmp == NULL)
{
perror("add_contact");
printf("增容失败\n");
return;
}
p->data = tmp;
p->capacity += INC_SZ;
printf("增容成功\n");
}
printf("请输入要添加人的姓名：");
scanf("%s", p->data[p->sz].name);
printf("请输入要添加人的性别：");
scanf("%s", p->data[p->sz].sex);
printf("请输入要添加人的年龄：");
scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
printf("请输入要添加人的电话：");
scanf("%s", p->data[p->sz].tele);
printf("请输入要添加人的住址：");
scanf("%s", p->data[p->sz].addr);
p->sz++;
printf("添加成功\n");
}
//销毁联系人函数
void destroy_contact(contact* p)
{
free(p->data);
p->data = NULL;
p->sz = 0;
p->capacity = 0;
}
//打印联系人函数
void print_contact(const contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法打印\n");
}
else
{
printf("%-10s %-10s %-10s %-15s %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
for (int i = 0;i < p->sz;i++)
{
printf("%-10s %-10s %-10d %-15s %-10s\n",
p->data[i].name,
p->data[i].sex,
p->data[i].age,
p->data[i].tele,
p->data[i].addr);
}
}
}
//查找函数的一部分，删除和修改也要用，只放在这就行
static int find_by_name(contact* p, char name[])
{
for (int i = 0;i < p->sz;i++)
{
if (strcmp(p->data[i].name,name)==0)
{
return i;
}
}
return -1;
}
//删除联系人函数
void del_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法删除\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要删除人的名字：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要删除的人不存在\n");
}
else
{
for (int i = pos;i < p->sz - 1;i++)
{
p->data[i] = p->data[i + 1];
}
p->sz--;
printf("删除成功\n");
}
}
}
//查找联系人函数
void find_contact(const contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法查找\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要查找人的名字：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要查找的人不存在\n");
}
else
{
printf("%-10s %-10s %-10s %-15s %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
printf("%-10s %-10s %-10d %-15s %-10s\n",
p->data[pos].name,
p->data[pos].sex,
p->data[pos].age,
p->data[pos].tele,
p->data[pos].addr);
}
}
}
//修改联系人函数
void modify_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法查找\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要修改人的姓名：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要修改的人不存在\n");
}
else
{
printf("以下是输入要修改人的新信息：\n");
printf("请输入姓名：");
scanf("%s", p->data[pos].name);
printf("请输入性别：");
scanf("%s", p->data[pos].sex);
printf("请输入年龄：");
scanf("%d", &p->data[pos].age);
printf("请输入电话：");
scanf("%s", p->data[pos].tele);
printf("请输入住址：");
scanf("%s", p->data[pos].addr);
printf("修改成功\n");
}
}
}
//排序联系人函数
int cmp(void* e1, void* e2)
{
return strcmp(((peoinfo*)e1)->name, ((peoinfo*)e2)->name);
}
void sort_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法排序\n");
}
else
{
qsort(p->data, p->sz, sizeof(peoinfo), cmp);
printf("按照姓名排序成功\n");
}
}
void sort_contact2(contact* p)//冒泡，比较麻烦，就用qsort了
{
if (p->sz == 0)
{
printf("通讯录为空，无法排序\n");
}
else
{
for (int i = 0; i < p->sz; i++)
{
for (int j = 0; j < p->sz - i - 1; j++)
{
if (strcmp((p->data[j].name), (p->data[j + 1].name)) > 0)
{
peoinfo data = p->data[j];
p->data[j] = p->data[j + 1];
p->data[j + 1] = data;
}
}
}
printf("按照姓名排序成功\n");
}
}完成静态或动态通讯录后想到怎么能把内容保存下次用呢？
这时就要用到后面学的文件，（放到文件只是学C语言的一种临时方法，后面学得更多会放到数据库中）
3. 常见的动态内存错误
3.1 对空指针的解引用操作
#include
#include
int main()
{
int* p = (int*)malloc(9999999999);//开辟失败，返回空指针
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i; // 对空指针进行解引用操作，非法访问内存
}
return 0;
}
//解决方案：对 malloc 函数的返回值做判空处理
#include
#include
int main()
{
int* p = (int*)malloc(9999999999);
// 对malloc函数的返回值做判空处理
if (p == NULL)
{
perror("main")
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
return 0;
} //记得对 malloc 函数的返回值做判空处理
3.2 对动态开辟空间的越界访问
#include
#include
int main()
{
int* p = (int*)malloc(10 * sizeof(int)); // 申请10个整型的空间
if (p == NULL)
{
perror("main");
return 1;
}
int i = 0;
// 越界访问 - 指针p只管理10个整型的空间，根本无法访问40个
for (i = 0; i < 40; i++)
{
*(p + i) = i;
}
free(p);
p = NULL;
return 0;
} //为了防止越界访问，使用空间时一定要注意开辟的空间大小。
3.3 对非动态开辟内存使用free释放
#include
#include
int main()
{
int arr[10] = { 0 }; // 在栈区上开辟
int* p = arr;
// 使用 略
free(p); // 使用free释放非动态开辟的空间
p = NULL;
return 0;
} //不要对非动态开辟的内存使用 free，否则会出现难以意料的错误。（程序可能会卡死）
3.4 使用free释放一块动态开辟内存的一部分
#include
#include
int main()
{
int* p = malloc(10 * sizeof(int));
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*p++ = i; // p指向的空间被改变了
//而且存在内存泄露风险
}
free(p);//error p不再指向动态内存的起始位置
p = NULL;
return 0;
} //注意事项：这么写代码会导致 p 只释放了后面的空间。没人记得这块空间的起始位置，
//再也没有人找得到它了，这是很件很可怕的事情，会存在内存泄露的风险。
//释放内存空间的时候一定要从头开始释放。
3.5 对同一块动态内存多次释放
#include
#include
int main()
{
int* p = malloc(10 * sizeof(int));
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
p[i] = i;
}
// 释放
free(p);
// 一时脑热或者出了函数后忘了，再一次释放（程序可能会卡死）
free(p);//error
return 0;
} //解决方案：在第一次释放后紧接着将 p 置为空指针，free对空指针释放什么都不会做
3.6 动态开辟内存忘记释放（内存泄漏）
#include
#include
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return;
}
// 使用 略
// 此时忘记释放了
}
int main()
{
test();
free(p); // 此时释放不了了，没人知道这块空间的起始位置在哪了
p = NULL;
} //malloc 这一系列函数 和 free 一定要成对使用，记得及时释放。
//你自己申请的空间，用完之后不打算给别人用，就自己释放掉即可。
//如果你申请的空间，想传给别人使用，传给别人时一定要提醒别人用完之后记得释放。
动态开辟的内存空间有两种回收方式： 1. 主动释放（free） 2. 程序结束
如果这块程序在服务器上 7x24 小时运行，如果你不主动释放或者你找不到这块空间了，
最后就会导致内存泄漏问题。内存泄漏（Memory Leak）是指程序中已动态分配的堆内存
由于某种原因程序未释放或无法释放，造成系统内存的浪费，
导致程序运行速度减慢甚至系统崩溃等严重后果。
4. 几道经典的笔试题
题目选自高质量的C++/C编程指南、Nice2016校招笔试题。
（可以当做对应课后作业使用）
（所以这篇在最后只留了没那么有关的几道编程题，已发解析在该专栏第21篇）（穿越）
4.1 题目1：
下列代码存在什么问题？请指出问题并做出相应的修改。
#include
#include
#include
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test()
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
} 解析：（笔试和面试时要能把问题用语言说出来）
str 传给 GetMemory 函数时为值传递，所以 GetMemory 函数的形参 p 是 str 的一份临时拷贝。
在 GetMemory 函数内部动态开辟的内存空间的地址存放在了 p 中，并不会影响 str。
所以当 GetMemory 函数返回之后， str 仍然是 NULL，导致 strcpy 拷贝失败。
其次，随着 GetMemory 函数的返回，形参 p 随即销毁并且没有及时的使用 free 释放，
从而导致动态开辟的100个字节存在内存泄露问题。根据经验，程序会出现卡死的问题。
代码改法1：
#include
#include
#include
// ↓ 修改返回类型为char*
char* GetMemory(char* p)
{
p = (char*)malloc(100);
return p; // 将p带回来
}
void Test()
{
char* str = NULL;
str = GetMemory(str); // 用str接收，此时str指向刚才开辟的空间
strcpy(str, "hello world"); // 此时copy就没有问题了
printf(str);//printf("hello world");传给printf函数的也是h的地址，所以没问题
// 用完之后记得free，就可以解决内存泄露问题
free(str);
str = NULL; // 还要将str置为空指针
}
int main()
{
Test();
return 0;
} 代码改法2：
#include
#include
#include
// ↓ 用char**接收
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test()
{
char* str = NULL;
GetMemory(&str); // 址传递，就可以得到地址
strcpy(str, "hello world");
printf(str);
// 记得free，就可以解决内存泄露问题
free(str);
str = NULL; // 还要将str置为空指针
}
int main()
{
Test();
return 0;
} 4.2 题目2：
请问运行Test 函数会有什么样的结果？
#include
#include
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
} 解析：
GetMemory 函数内部创建的数组实在栈区上创建的，出了函数 p 数组的空间就还给了操作系统，
返回的地址是没有实际意义的，如果通过返回的地址去访问内存，就会导致非法访问内存问题。
4.3 题目3：
请问运行Test 函数会有什么样的结果？
#include
#include
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;
} 解析：
就是对第一题的修改，但是没有 free和置空，导致内存泄露。
4.4 题目4：
请问运行Test 函数会有什么样的结果？
#include
#include
#include
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
} 解析：
free 之后没有将 str 置为空指针，
导致 if 为真，对已经释放掉的内存进行了访问，引发非法访问的问题。
改法:free 后将 str 置为空指针
5. C/C++程序的内存开辟
C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，
函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，
效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、
函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。
分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
内存区域划分图：
有了这幅图，我们就可以更好的理解在前面讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，
直到程序结束才销毁，所以生命周期变长。
栈区的特点：在上面创建的变量出了作用域就销毁。
数据段的特点：在上面创建的变量直到程序结束才销毁
6. 柔性数组flexible array
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
定义：柔性数组（Flexible Array），又称可变长数组。一般数组的长度是在编译时确定，而柔性数组对象的长度在运行时确定。在定义结构体时允许你创建一个空数组（例如：arr [ 0 ] ），该数组的大小可在程序运行过程中按照你的需求变动。
【百度百科】在 ANSI 的标准确立后，C语言的规范在一段时间内没有大的变动，
然而C++在自己的标准化创建过程中继续发展壮大。《标准修正案一》在1994年为C语言创建了一个新标准，但是只修正了一些C89标准中的细节和增加更多更广的国际字符集支持。不过，这个标准引出了1999年ISO 9899:1999的发表。被称为C99，C99被ANSI于2000年3月采用。
演示：
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;部分编译器可能会报错，可以试着将 a [ 0 ] 改为 a [ ] ：
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;6.1 柔性数组的特点：
1.结构中的柔性数组成员的前面必须至少有一个其他成员：
typedef struct st_type
{
int i;//必须至少有一个其他成员
int a[0];//柔性数组成员
}type_a;2.sizeof 计算这种结构的大小是不包含柔性数组成员的：
#include
struct S
{
int n; // 4
int arr[]; // 大小是未知的
};
int main()
{
struct S s = { 0 };
printf("%d\n", sizeof(s));//4
return 0;
} 3.包含柔性数组成员的结构，用 malloc 函数进行内存分配，
并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小：
#include
#include
struct S
{
int n;
int arr[0];
};
int main()
{
//期望arr的大小是10个整型 给n的 给arr[]的
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
// 后面+的大小就是给柔性数组准备的
return 0;
} 6.2 柔性数组的使用
代码1：使用柔性数组
#include
#include
struct S
{
int n;
int arr[0];
};
int main()
{
// 期望arr的大小是10个整型
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
if (ps == NULL)
{
printf("malloc fail\n");
return -1;
}
ps->n = 10;
// 使用
for (int i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
// 增容
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
// 再次使用 （略）
// 释放
free(ps);
ps = NULL;
return 0;
} 6.3 柔性数组的优势
代码2：直接使用指针
想让n拥有自己的空间，其实不使用柔性数组也可以实现。
#include
#include
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
printf("malloc fail\n");
return -1;
}
ps->n = 10;
ps->arr = (int*)malloc(10 * sizeof(int));
if (ps->arr == NULL)
{
printf("malloc fail\n");
return -1;
}
// 使用
for (int i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (int i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
// 增容
int* ptr = (struct S*)realloc(ps->arr, 20 * sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
// 再次使用 （略）
// 释放
free(ps->arr); // 先free第二块空间
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
} 虽然 代码2 实现了相应的功能，但是和 代码1 比还是有很多不足之处的。代码2 使用指针完成，
进行了两次 malloc ，而两次 malloc 对应了两次 free ，相比于 代码1 更容易出错
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，
所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续内存多多少少有益于提高访问速度，还能减少内存碎片。malloc 的次数越多，
产生的内存碎片越多，这些内存碎片不大不小，再次被利用的可能性很低。内存碎片越多，
内存的利用率就会降低。频繁的开辟空间效率会变低，碎片也会增加。
（其实也没多高了，反正跑不了要用做偏移量的加法来寻址）
内存碎片和内存池：
扩展阅读：
https://coolshell.cn/articles/11377.html
课后作业
1.模拟实现atoi
2.模拟实现strncat
3.模拟实现strncpy
4.找单身狗
一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。
编写一个函数找出这两个只出现一次的数字。
穿越回来贴个课后作业解析链接：
C语言进阶21收尾(编程作业)(atoi，strncpy,strncat,offsetof模拟实现+找单身狗+宏交换二进制奇偶位）_GR C的博客-CSDN博客
本章完。
