1.为什么存在动态内存管理
当然我们已经掌握的内存开辟方式：
int a=10;//局部变量-在栈空间上开辟了四个空间
int g_a=10;//全局变量-静态区
但是上述的开辟空间的方式有两个特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编 译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。
注意：有人会说c语言是可以创建变长数组的我们可以这样写：
struct stu{ char name[20]; int age; } int main(){ int n=0; scanf("%d",&n); struct stu arr[n]; return 0; }
的确在C99中引入了这个标准，但是很多编译器不支持此标准，从而会报错，故此方法不可行。
2.动态内存函数的介绍
2.1malloc和free
动态内存开辟的函数代码示例：
void* malloc(size_t size);
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
- 如果开辟成功，则返回一个指向开辟好空间的指针。
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用自己来决定。
C 语言提供了另外一个函数 free ，专门是用来做动态内存的释放和回收的，函数原型如下：
void free ( void* ptr );
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的.
如果参数 ptr 是 NULL 指针，则函数什么事都不做。
malloc 和 free 都声明在 stdlib.h 头文件中。代码示例：
#include<stdio.h> #include<stdlib.h> int main() { //向内存申请10个整型的空间 int* p = (int*)malloc(10 * sizeof(int));//int*强制类型转化为整型 if (p == NULL) { //开辟空间失败，打印错误原因 printf("%s\n", strerror(errno)); } else { //正常使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d", *(p + i)); } } //当动态内存空间不在使用的时候 //就应该还给操作系统 free(p); p = NULL; return 0; }
2.2calloc
calloc函数动态内存分配。原型如下：
void* calloc(size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0 。 代码如下：
2.3realloc
- realloc函数的出现让动态内存管理更加灵活。
- 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存， 我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。 函数原型 如下：
void* realloc ( void* ptr , size_t size );
ptr 是要调整的内存地址 ,size 调整之后新大小 ,返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
realloc使用的注意事项:
1.如果p指向的空间之后有足够大的内存空间可以追加，则直接追加，后返回0
2.如果p指向的空间之后没有足够大的内存空间可以追加，则realloc函数会重新找一个新的内存区域开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间,最后返回新开辟的内存空间地址。
3.得到新的变量来接受realloc函数的返回值，防止relloc开辟空间失败将前面开辟好的空间也销毁
代码如下：
#include<stdio.h> #include<stdlib.h> int main() { //向内存申请10个整型的空间 int* p = (int*)malloc(20);//int*强制类型转化为整型 if (p == NULL) { //开辟空间失败，打印错误原因 printf("%s\n", strerror(errno)); } else { //正常使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } } int* ptr = realloc(p, 40); if (ptr != NULL) { p = ptr; int i = 0; for (i = 5; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d", *(p + i)); } } free(p); p = NULL; return 0; }
3.常见的动态内存错误
- 对NULL指针的解引用操作
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } free(p); p = NULL; return 0; }
万一malloc开辟空间失败，则p将被赋值为空指针，所以malloc使用时一定要对其返回值判断是否为空指针。
- 对动态开辟空间的越界访问
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(5 * sizeof(int)); if (p == NULL) { return 0; } else { int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } } free(p); p = NULL; return 0; }
malloc只开辟了5个整型元素，而for循环访问10个造成越界访问，程序崩溃。
- 对非动态开辟内存使用free释放
#include<stdio.h> #include<stdlib.h> int main() { int a = 10; int* p = &a; *p = 20; free(p); return 0; }
- 使用free释放一块动态开辟内存的一部分
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { return 0; } else { int i = 0; for (i = 0; i < 10; i++) { *p++ = i; } } free(p); p = NULL; return 0; }
p在此过程中已经发生变化，则不是我们完整的开辟空间，如果要释放只能从开辟的起始位置释放，故错误。
- 对同一块动态内存多次释放
void test() { int *p = (int *)malloc(100); free(p); free(p);//重复释放 }
- 动态开辟内存忘记释放（内存泄漏）
void test() { int *p = (int *)malloc(100); if(NULL != p) { *p = 20; } } int main() { test(); while(1); }
用过之后没有释放空间，会不断消耗内存，有可能会导致服务器崩溃。
切记： 动态开辟的空间一定要释放，并且正确释放 。
4.柔性数组
4.1柔性数组的概念
也许你从来没有听说过 柔性数组（ flflexible array ） 这个概念，但是它确实是存在的。 C99 中，结构中的最
后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员
代码如下：
typedef struct st_type { int i; int a[];//柔性数组成员 }type_a;
4.2柔性数组的特点
- 结构中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存.
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应 柔性数组的预期大小。
4.3柔性数组的使用
代码1：
#include<stdio.h> struct S { int n; int arr[0]; }; int main() { struct S* s = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int)); int i = 0; for (i = 0; i < 5; i++) { s->arr[i] = i; } struct S* ps = realloc(s, 44); if (ps!= NULL) { s = ps; for (i = 5; i < 10; i++) { s->arr[i] = i; } } for (i = 0; i < 10; i++) { printf("%d", s->arr[i]); } free(s); s = NULL; return 0; }
代码2：
#include<stdio.h> struct S { int n; int* arr; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int)); ps->arr = malloc(5 * sizeof(int)); int i = 0; for (i = 0; i < 5; i++) { ps->arr[i] = i; } for (i = 0; i < 5; i++) { printf("%d\n", ps->arr[i]); } int* ptr = realloc(ps->arr, 10 * sizeof(int)); if (ptr!= NULL) { ps->arr = ptr; for (i = 5; i < 10; i++) { ps->arr[i] = i; } } for (i = 0; i < 10; i++) { printf("%d ", ps->arr[i]); } free(ps->arr); free(ps); ps = NULL; return 0; }
4.4柔性数组的的优势
通过对比上述的代码1和代码2，代码1的实现有俩个好处：
1.方便内存释放
2.有利于访问速度
