动态内存管理
1. 为什么存在内存分配
2. 动态内存函数的介绍
2.1 malloc和free
2.2 calloc
2.3 realloc
3. 常见的动态内存错误
3.1 对NULL指针的解引用操作
3.2 对动态开辟空间的越界访问
3.3 对非动态开辟内存使用free释放
3.4 使用free释放一块动态开辟内存的一部分
3.5 对同一块动态内存多次释放
3.6 动态开辟内存忘记释放（内存泄漏）
4. 几个经典的笔试题
4.1 题目1：
4.2 题目2：
4.3 题目3：
4.4 题目4：
5.C/C++程序的内存开辟
6.柔性数组
6.1 柔性数组的特点
6.2 柔性数组的使用
6.3 柔性数组的优势
7.总结
1. 为什么存在内存分配
我们已经掌握的开辟方式有：
int val = 20;//在栈空间开辟两个字节 char arr[10] = {0};//在栈空间开辟10个字节的连续空间
但是上述的开辟方式有两个特点：
- 1.空间开辟大小是固定的。
- 2.数组在申明的时候，必须指定数组长度，它所需要的内存在编译时分配。
- 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态内存开辟了。
2. 动态内存函数的介绍
2.1 malloc和free
C语言提供了一个动态内存开辟的函数：
void* malloc(size_t size);
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数size为0，malloc的行为是标准还是未定义的，取决于编译器。
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：
void free(void* ptr);
free函数用来释放动态开辟的内存。
- 如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
- 如果参数ptr是NULL指针，那么函数什么事都不做。
举个例子：
#include <stdio.h> int main() { //代码1 int num = 0; scanf("%d",&num); int arr[num] = {0}; //代码2 int* ptr = NULL; ptr = (int*)malloc(num*sizeof(int)); if(NULL!=ptr)//判断ptr指针是否为空 { int i = 0; for(i=0;i<num;i++) { *(ptr+i) = 0; } } free(ptr);//释放ptr所指向的动态内存 ptr = NULL;//可有可无 return 0; }
当然，代码1为变长数组，开辟空间在栈区，在c99环境下是可以的，但是由于大部分环境不为c99，因此，代码2才是我们应该选择的，其开辟的空间在堆区。
2.2 calloc
C语言还提供了一个函数叫calloc，calloc函数也用来动态内存分配。原型如下：
void* calloc(size_t num,size_t size);
- 函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0.
与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0.
- 举个例子：
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)calloc(10,sizeof(int));//开辟10个整形的空间 if(NULL == p) { printf("%s\n",strerror(errno)); return 1; } //打印 for(int i=0;i<10;i++) { printf("%d ",*(p+i)); } free(p); p = NULL; return 0; }
故可以看成 calloc = malloc + memset
2.3 realloc
- realloc函数的出现让动态内存管理更加灵活。
- 有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的申请内存，我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。
函数原型如下：
void* realloc(void* ptr,size_t size);
- ptr是要调整的内存地址
- size调整之后的新的大小
- 返回值为调整之后的内存起始位置。
- 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
- realloc在调整内存空间时存在两种情况：
- 情况1：原有空间之后有足够大的空间
- 情况2：原有空间之后没有足够大的空间
情况1： 当是情况1的时候，要扩展内存就直接在原有内存之后直接追加空间，原来空间的数据不发生变化。
情况2： 当是情况2的时候，原有的空间之后没有足够多的空间时，扩展的方法是： 在堆空间上另找一个合适大小的连续空间来使用，将原有的数据先拷贝到新的空间，并且继续在此后追加。这样函数返回的是一个新的内存地址。
举个例子:
#include<stdio.h> int main() { int* p = (int*)malloc(40); if(NULL == p) { printf("%s\n",strerror(errno)); return 1; } //使用 // 1 2 3 4 5 6 7 8 9 10 int i = 0; for(i=0;i<10;i++) { *(p+i) = i+1; } //扩容 int* ptr = (int*)realloc(p,80); if(ptr!=NULL) { p = ptr; } //使用 for(i=0;i<10;i++) { printf("%d ",*(p+i));//会打印1到10 } free(p); p = NULL; return 0; }
我们发现，开辟之后，新开辟的ptr的地址与p的地址相同，这就是情况1。 当然，情况2也是有可能的，我们把原有的变成4000，开辟的变成8000,，即我们申请的空间变大时：
发现变成了情况2，但此时，为什么只free掉p了呢，这是因为realloc函数会自动的把原本的空间释放掉，不需要再手动释放，因此，p原本指向的空间不用二次free。
那我们直接将realloc返回的地址赋值给原地址不行吗？
#include<stdio.h> int main() { int* p = (int*)malloc(40); if(NULL == p) { printf("%s\n",strerror(errno)); return 1; } //使用 // 1 2 3 4 5 6 7 8 9 10 int i = 0; for(i=0;i<10;i++) { *(p+i) = i+1; } //扩容 p = (int*)realloc(p,80); return 0; }
我们知道，realloc存在开辟失败的可能性，若把返回值赋值给原地址，一旦开辟失败，不仅不会开辟新的空间，反而会丢失掉原来的地址，因此上述的代码存在风险，我们应该创建新的指针变量ptr，如果开辟成功，再赋值给原指针变量p。
3. 常见的动态内存错误
3.1 对NULL指针的解引用操作
void test() { int* p = (int*)malloc(INT_MAX/4); *p = 20; free(p); }
直接*p = 20是不安全的，一旦p开辟失败，p是空指针，不能被解引用，因此，我们需要判断是否为空。
3.2 对动态开辟空间的越界访问
void test() { int* p = (int*)malloc(40); if(p == NULL) { printf("%s\n",strerror(errno)); return 1; } //方式 int i = 0; for(i=0;i<=10;i++) { p[i] = i; } free(p); p = NULL; }
这样的越界与非动态开辟的都是错误的。
3.3 对非动态开辟内存使用free释放
void test() { int a = 10; int* p = &a; free(p); }
出现这种情况也是可能的，emm……,或许是喝多了。
3.4 使用free释放一块动态开辟内存的一部分
void test() { int* p = (int*)malloc(40); if(p == NULL) { return 1; } //使用 int i = 0; for(i=0;i<10;i++) { *p = i; p++; } //释放 free(p); p = NULL; }
我们知道，p是int*类型，因此，其每次++都会跳过一个整形大小，因此，这样给p[i]赋值是没有问题的，但是由于其p指向的地址发生变化，当我们free§的时候，相当于free掉了从这个位置开始一直到空间结束的位置，其前面的空间并没有被free掉，这就造成了内存泄漏。
3.5 对同一块动态内存多次释放
或许是又喝多了，free两次一定会报错，解决的方法一是去掉一个free，其二是如上，p=NULL之后第二个free§的时候相当于free(NULL),这样的free相当于什么都没做，没有任何影响。
3.6 动态开辟内存忘记释放（内存泄漏）
void test() { int* p = (int*)malloc(40); if(p == NULL) { //…… } free(p); p = NULL//其二 //…… free(p); }
这种是最常见的错误，一旦内存泄漏过多并且不free掉，在任务管理器中会看到创建的这个项目占用了大量的系统空间，这将会造成很大的影响，因此一定要记得释放，并且正确释放。
***注：***当我们刷一系列oj题比如Leetcode,，会经常存在着不free的情况，这种情况不必担心，其上面的隐藏处理会帮助free掉。
4. 几个经典的笔试题
4.1 题目1：
void GetMemory(char* p) { p = (char*)malloc(100); } void test() { char* str = NULL; GetMemory(str); strcpy(str,"hello world"); printf(str); }
会有什么结果？
记住：形参只是实参的一份临时拷贝，改变形参，实参并不会发生改变。因此，出现的错误：
1.内存泄漏，即GetMemory结束后p的地址再也找不到，free再也找不到对应的地址。
2.test()中的str没有被改变，仍为NULL,strcpy拷贝到空指针程序会崩溃。
那么如何修改呢？
//改法1： void GetMemory(char** p) { *p = (char*)malloc(100); } void test() { char* str = NULL; GetMemory(&str); //str存放的就是动态开辟的100字节的地址 strcpy(str,"hello world"); printf(str); free(str); str = NULL; } //改法2 char* GetMemory(char* p) { p = (char*)malloc(100); } void test() { char* str = NULL; str = GetMemory(); strcpy(str,"hello world"); printf(str); free(str); str = NULL; } int main() { test(); }
- 1.通过二级指针修改
- 2.通过返回值修改
4.2 题目2：
char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
其错误是：由于p为GetMemory内部的局部变量，当函数结束时，p自动销毁，因此str接收的为野指针。
4.3 题目3：
void GetMemory(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); //修改如下 //free(str); //str = NULL printf(str); }
这块代码出现的问题仅仅是没有free，可以打印出hello，只需要加上free即可修改。
4.4 题目4：
void Test(void) { char *str = (char *) malloc(100); strcpy(str, "hello"); free(str); if(str != NULL) { strcpy(str, "world"); printf(str); } }
看到这里，没错，这又是一个野指针的问题，free()之后，str指向的一个空间已经被释放掉，str的地址没变，但是当strcpy拷贝world到str时，相当于找不到那个能够存放的下的空间。
5.C/C++程序的内存开辟
C/C++程序内存分配的几个区域：
1.栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2.堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3.数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4.代码段：存放函数体（类成员函数和全局函数）的二进制代码。
有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁。
所以生命周期变长
6.柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
例如：
typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a;
有些编译器会报错无法编译可以改成：
typedef struct st_type { int i; int a[];//柔性数组成员 }type_a;
6.1 柔性数组的特点
- 1 .结构中的柔性数组成员前面必须至少一个其他成员。
- 2.sizeof返回的这种结构大小不包括柔性数组的内存。
- 3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应大于结构的大小，以适应柔性数组的预期大小。
例如：
//code1 typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a; printf("%d\n", sizeof(type_a));//输出的是4
6.2 柔性数组的使用
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> struct S { int n; int arr[];//柔性数组成员 }; int main() { //柔性数组的使用 struct S* ps = (struct S*)malloc(sizeof(struct S) + 40); if (ps == NULL) { //.... return 1; } ps->n = 100; int i = 0; for (i = 0; i < 10; i++) { ps->arr[i] = i; } for (i = 0; i < 10; i++) { printf("%d ", ps->arr[i]); } struct S* ptr = (struct S*)realloc(ps, sizeof(struct S)+80); if (ptr != NULL) { ps = ptr; ptr = NULL; } //... //释放 free(ps); ps = NULL; return 0; }
对于所谓的柔性，就是其内部的数组可以通过realloc可大可小，即在结构体内部仍然可以动态开辟内部数组。
当然，我们也可以将结构体中的整型变量与数组分开进行开辟：
struct S { int n; int* arr; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S)); if (ps == NULL) { return 1; } ps->n = 100; ps->arr = (int*)malloc(40); if (ps->arr == NULL) { //.... return 1; } //使用 int i = 0; for (i = 0; i < 10; i++) { ps->arr[i] = i; } for (i = 0; i < 10; i++) { printf("%d ", ps->arr[i]); } //扩容 int*ptr = (int*)realloc(ps->arr, 80); if (ptr == NULL) { return 1; } //使用 //释放 free(ps->arr); free(ps); ps = NULL; return 0; }
需要注意的是要先释放内部的数组，再释放结构体，否则会找不到对应数组的
地址出现内存泄漏。
6.3 柔性数组的优势
//代码1 int i = 0; type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int)); //业务处理 p->i = 100; for(i=0; i<100; i++) { p->a[i] = i; } free(p); //代码2 typedef struct st_type { int i; int *p_a; }type_a; type_a *p = (type_a *)malloc(sizeof(type_a)); p->i = 100; p->p_a = (int *)malloc(p->i*sizeof(int)); //业务处理 for(i=0; i<100; i++) { p->p_a[i] = i; } //释放空间 free(p->p_a); p->p_a = NULL; free(p); p = NULL;
第一个好处是： 方便内存释放。
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度。
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）
7.总结
以上这篇文章就分享到这里啦，希望对你们有所帮助呀，看完记得动动你们发财的小手给博主支持呀！
