✨✨欢迎👍👍点赞☕️☕️收藏✍✍评论
个人主页：秋邱'博客
所属栏目：C语言
前言
开始之前，我们先来了解一下C/C++中程序内存区域划分。
在C/C++程序中，内存区域通常被划分为以下几个部分：
1.栈：
- 栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等
2.堆：
- 用于动态分配的内存，程序员可以通过malloc、calloc、realloc等函数在堆上动态分配内存空间。
- 堆的分配和释放由程序员手动控制，因此需要注意避免内存泄漏和内存溢出等问题。
3.全局/静态区：
- 用于存储全局变量、静态变量以及常量字符串等。
- 全局变量和静态变量在程序启动时被分配，直到程序结束才被释放。
4.常量区：
- 存储常量字符串等不可修改的数据。
5.代码区
- 存储程序的机器指令，包括函数体的二进制代码等。
1.0 静态内存
目前有两个开辟内存的方式
int a = 0;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间
但是上述代码的开辟的空间有个特点：
- 开辟的空间大小是固定。
- 数组空间大小一旦确定就不能更改。
2.0 动态内存
有时候我们需要的空间⼤⼩在程序运⾏的时候才能知 道，那数组的编译时开辟空间的⽅式就不能满⾜了。因此，C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间，就⽐较灵活了。
那么这里就需要用到四个函数，开辟空间的有：malloc、calloc、realloc；释放空间的有：free。
这四个函数需要的头文件都是#include
2.1 malloc
函数声明：
void* malloc (size_t size);
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。
size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。
使用：
如果开辟成功，则返回⼀个指向开辟好空间的指针。
如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。
malloc的使用方法：
#include
#include 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
函数声明：
void* calloc (size_t num, size_t size);
函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
#include
#include 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可以做到对动态内存大小的调整。
函数声明：
void* realloc (void* ptr, size_t size);
ptr：指向先前用malloc、calloc或realloc分配的内存块的指针，或者，这可以是一个空指针，在这种情况下，一个新的块被分配(好像malloc被调用)。
size_t 用于表示内存大小的数据类型，是一个无符号整数类型。malloc中size表示字节个数。
realloc有三种情况：
1.内存足够大不需要realloc额外申请。
2.空间不足
情况一：原有空间之后有⾜够⼤的空间（原地扩容）
当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。
情况二：原有空间之后没有足够大的空间（异地扩容）
当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。
由于上述的两种情况，realloc函数的使⽤就要注意⼀些。
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函数⽤来释放动态开辟的内存。这在写代码过程中是很有必要的。
函数声明：
void free (void* ptr);
ptr表示指向malloc，realloc，callloc开辟的动态空间内存。
使用：
如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
返回值：
不反回任何值。
//malloc释放动态内存 free(arr);//释放函数 arr = NULL;//将指针置为空 //calloc释放动态内存 free(num); num = NULL; //realloc释放动态内存 free(ptr); ptr = NULL;
3.0 动态内存常见的错误
3.1 对空指针解引用
void test() { int *p = (int *)malloc(INT_MAX/4); *p = 20;//如果p的值是NULL，就会有问题 free(p); }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 = 20; int* p = &a; free(p); }3.4 动态开辟内存忘记释放（内存泄漏）
void test() { int* p = (int*)malloc(100); if (NULL != p) { *p = 20; } } int main() { test(); while (1); }忘记释放动态内存空间会造成内存泄漏。
3.5 对同⼀块动态内存多次释放
void test() { int* p = (int*)malloc(100); free(p); free(p);//重复释放 }3.6 使⽤free释放⼀块动态开辟内存的⼀部分
void test() { int* p = (int*)malloc(100); p++; free(p);//p不再指向动态内存的起始位置 }
4.0 柔性数组
4.1 什么是柔性数组
在结构体中，最后一个
成员是数组，且数组没有指定大小，这个数组就是柔性数组
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 柔性数组的使用
//代码1 #include
#include 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 柔性数组的优势
//代码2 #include
#include 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.利于访问速度：连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你 跑不了要⽤做偏移量的加法来寻址。
感谢各位大佬莅临，如有错误欢迎指出，共同学习进步。
![[工业自动化-1]：PLC架构与工作原理](https://img-blog.csdnimg.cn/ce10a1471ed14382bc58364cf8bd5209.png)
还没有评论，来说两句吧...