前言
开始之前，我们先来了解一下C/C 中程序内存区域划分。
在C/C 程序中，内存区域通常被划分为以下几个部分： 1.栈：
- 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等
2.堆：
- 用于动态分配的内存，程序员可以通过malloc、calloc、realloc等函数在堆上动态分配内存空间。
- 堆的分配和释放由程序员手动控制，因此需要注意避免内存泄漏和内存溢出等问题。
3.全局/静态区：
- 用于存储全局变量、静态变量以及常量字符串等。
- 全局变量和静态变量在程序启动时被分配，直到程序结束才被释放。
4.常量区：
- 存储常量字符串等不可修改的数据。
5.代码区
- 存储程序的机器指令，包括函数体的二进制代码等。
1.0 静态内存
目前有两个开辟内存的方式
代码语言：javascript复制 int a = 0;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间但是上述代码的开辟的空间有个特点：
- 开辟的空间大小是固定。
- 数组空间大小一旦确定就不能更改。
2.0 动态内存
有时候我们需要的空间⼤⼩在程序运⾏的时候才能知 道，那数组的编译时开辟空间的⽅式就不能满⾜了。因此，C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。
那么这里就需要用到四个函数，开辟空间的有：malloc、calloc、realloc；释放空间的有：free。
这四个函数需要的头文件都是#include<stdlib.h>
2.1 malloc
函数声明：
代码语言：javascript复制void* malloc (size_t size);返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。
size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。
使用：
如果开辟成功，则返回⼀个指向开辟好空间的指针。
如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。
malloc的使用方法：
代码语言：javascript复制#include <stdio.h>
#include <stdlib.h>
int main()
{
int* arr = (int*)malloc(sizeof(int) * 10);
// 分配一个整数的内存空间
//void* 需要用类型指针接收，这里选择用int*
if (arr == NULL)
{
perror("malloc fail: ");//打印错误信息
return 1;//直接返回
}
int i = 0;
for (i = 0; i < 10; i )//数组赋值
{
arr[i] = i;
}
for (i = 0; i < 10; i )//打印数组
{
printf("%d ", arr[i]);
}
//释放内存
return 0;
}输出结果：
2.2 calloc
函数声明：
代码语言：javascript复制void* calloc (size_t num, size_t size);函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
代码语言：javascript复制#include <stdio.h>
#include <stdlib.h>
int main()
{
int* num = (int*)calloc(10,sizeof(int));
if (num == NULL)
{
perror("calloc fail: ");//打印错误信息
return 1;//直接返回
}
//使用
//内存释放
return 0;
}
2.3 realloc
realloc相比malloc和calloc更加灵活，它是在内存不够的时候开辟新的内存。realloc可以做到对动态内存大小的调整。
函数声明：
代码语言：javascript复制void* realloc (void* ptr, size_t size);ptr：指向先前用malloc、calloc或realloc分配的内存块的指针，或者，这可以是一个空指针，在这种情况下，一个新的块被分配(好像malloc被调用)。
size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。
realloc有三种情况：
1.内存足够大不需要realloc额外申请。
2.空间不足
情况一：原有空间之后有⾜够⼤的空间（原地扩容）
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。
情况二：原有空间之后没有足够大的空间（异地扩容）
当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。
由于上述的两种情况，realloc函数的使⽤就要注意⼀些。
代码语言：javascript复制int main()
{
int* ptr = (int*)malloc(100);
if (ptr == NULL)
{
perror("malloc error");
return 1;
}
//动态内存不够进行扩展容量
//先将realloc函数的返回值放在p中，不为NULL，在放ptr中
int* p = realloc(ptr, 1000);
if (p != NULL)
{
perror("realloc error");
return 1;
}
ptr = p;
//如果直接赋值，realloc开辟失败返回NULL，*ptr就会出现问题
return 0;
}很明显，代码1存在问题，若realloc没开辟成功，却将空指针返回给ptr，ptr解引用则会报错。使用代码2，更加合理。
2.4 free
free函数⽤来释放动态开辟的内存。这在写代码过程中是很有必要的。
函数声明：
代码语言：javascript复制void free (void* ptr);ptr表示指向malloc，realloc，callloc开辟的动态空间内存。
使用：
如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
返回值：
不反回任何值。
代码语言：javascript复制 //malloc释放动态内存
free(arr);//释放函数
arr = NULL;//将指针置为空
//calloc释放动态内存
free(num);
num = NULL;
//realloc释放动态内存
free(ptr);
ptr = NULL;3.0 动态内存常见的错误
3.1 对空指针解引用
代码语言：javascript复制 void test()
{
int *p = (int *)malloc(INT_MAX/4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}3.2 对动态开辟空间的越界访问
代码语言：javascript复制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释放
代码语言：javascript复制void test()
{
int a = 20;
int* p = &a;
free(p);
}3.4 动态开辟内存忘记释放（内存泄漏）
代码语言：javascript复制void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while (1);
}忘记释放动态内存空间会造成内存泄漏。
3.5 对同⼀块动态内存多次释放
代码语言：javascript复制void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放
}3.6 使⽤free释放⼀块动态开辟内存的⼀部分
代码语言：javascript复制void test()
{
int* p = (int*)malloc(100);
p ;
free(p);//p不再指向动态内存的起始位置
}4.0 柔性数组
4.1 什么是柔性数组
在结构体中，最后一个
成员是数组，且数组没有指定大小，这个数组就是柔性数组
代码语言：javascript复制struct S1
{
char c;
int n;
int arr[];//柔性数组
};
struct S2
{
char c;
int n;
int arr[0];//柔性数组
};s1和s2写法不一样，但这都是柔性数组，有的编译器支持s1有的支持s2。
4.2 柔性数组的特点
- 结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。
- sizeof 返回的这种结构⼤⼩不包括柔性数组的内存。
- 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。
struct S
{
char c;
int n;
int arr[0];//柔性数组
};
int main()
{
struct s1* p = (struct s1*)malloc(sizeof(struct s1) 5 * sizeof(int));
//sizeof(struct s1)是给char c和int n申请的内存空间
//而5 * sizeof(int)是给柔性数组申请的
if(p == NULL)
{
perror("malloc error");
return 1;
}
printf("%zd", sizeof(struct s1));
return 0;
}打印结果：
realloc可以额外申请空间，这就是的数组变得可大可小，这就是柔性数组。
4.3 柔性数组的使用
代码语言：javascript复制//代码1
#include<stdio.h>
#include<stdlib.h>
struct S
{
int n;
int arr[];
};
int main()
{
struct S* p = (struct S*)malloc(sizeof(struct S) sizeof(int) * 10);
if (p == NULL)
{
perror("malloc error");
return 1;
}
p->n = 10;//初始化
for (int i = 0; i < 10; i )
{
p->arr[i] = i;
}
struct S* ptr = (struct S*)realloc(p, sizeof(struct S) 10 * sizeof(int));
//空间不够调整空间
if (ptr != NULL)
{
p = ptr;
}
printf("%d ", p->n);//打印
for (int i = 0; i < 10; i )
{
printf("%d ", p->arr[i]);
}
free(p);//释放空间
p = NULL;
return 0;
}4.4 柔性数组的优势
代码语言：javascript复制//代码2
#include<stdio.h>
#include<stdlib.h>
struct S
{
int n;
int* arr;
};
int main()
{
struct S* p = (struct S*)malloc(sizeof(struct S) sizeof(int) * 5);
if (p == NULL)
{
perror("malloc error");
return 1;
}
p->n = 11;
for (int i = 0; i < 5; i )
{
p->arr[i] = i;
}
printf("%d ", p->n);
for (int i = 0; i < 10; i )
{
printf("%d ", p->arr[i]);
}
//若空间不够调整空间
int* ptr = (int*)realloc(p->arr, 10 * sizeof(int));
if (ptr != NULL)
{
p->arr = ptr;
}
//使用...
//释放空间
free(p->arr);
free(p);
p = NULL;
}通过对两者的使用和比较，柔性数组更甚一筹。
优势有2：
1.方便内存释放：在函数给其他人使用时，代码在里面进行了二次分配，并把整个结构体返回给⽤ ⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free。如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给⽤⼾⼀个结构体指针，那么只需要free一次就能释放。
2.利于访问速度：连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你 跑不了要⽤做偏移量的加法来寻址。
感谢各位大佬莅临，如有错误欢迎指出，共同学习进步。
