常见的错误
- 对NULL指针的解引用操作
void test() { int *p = (int *)malloc(INT_MAX/4); *p = 20; free(p); }
使用p时并没有进行判断，如果p的值是NULL，就会有问题。
- 对动态开辟空间的越界访问
void test() { int i = 0; int *p = (int *)malloc(10*sizeof(int)); if(NULL == p) { return ; } for(i=0; i<=10; i++) { *(p+i) = i; } free(p); }
malloc开辟的空间用完，没有及时扩容，当i是10的时候越界访问。
- 对非动态开辟内存使用free释放
void test() { int a = 10; int *p = &a; free(p); }
这种做法也是错误的，free函数只能释放动态内存函数开辟的空间。
- 使用free释放一块动态开辟内存的一部分
void test() { int *p = (int *)malloc(100); p++; free(p);//p不再指向动态内存的起始位置 }
这种做法也是错误的，释放空间时必须将开辟的空间完整释放。
- 对同一块动态内存多次释放
void test() { int *p = (int *)malloc(100); free(p); free(p);//重复释放 }
这种情况也是错误的，程序会出现报错，为了避免这样的问题，要养成良好的习惯，释放空间后，将p及时置为NULL。
- 动态开辟内存忘记释放（内存泄漏）
void test() { int *p = (int *)malloc(100); if(NULL != p) { *p = 20; } } int main() { test(); while(1); }
这里在test函数中进行动态内存开辟，但是出来test函数p就被销毁了，但在堆区开辟的空间并没有，这就导致无法找到开辟空间的具体位置进行释放，程序不结束，申请的空间就再也无法使用。
在实际场景中是非常恶心的，在大多数的程序中，服务器都是每天24小时运行，动态开辟内存忘记释放就会导致可用内存逐渐减小，最后到上限，程序崩溃。
注意：动态申请的内存不会因为出了作用域就自动销毁释放（内存还给操作系统），只有两种释放方式：
- free
- 程序结束（退出）
经典笔试题目
题目1：
void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } int main() { test(); return 0; }
这段代码运行结果是什么？
程序会挂掉，原因是访问空指针。为什么呢？
GetMemory函数传过去的是str，而并非是&str，这就是传值调用，并不会对str有影响。所以strcpy复制时访问的就是空指针，程序就挂掉了。
这个程序存在两个问题：
- 对NULL指针进行解引用操作，程序崩溃
- 没有释放空间，内存泄露问题
题目2：
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，返回数组的首元素地址，但是一旦出了GetMemory函数，存放hello world的空间就可能会被覆盖，所以输出结果会是乱码。
题目3：
void GetMemory(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); }
运行 test函数结果是什么？
输出是：hello，这段代码看起来似乎并没有什么错误，但仔细的观察我们就会发现，没有释放空间。
应该在打印之后将str释放，并置为NULL。
题目4：
void Test(void) { char *str = (char *) malloc(100); strcpy(str, "hello"); free(str); if(str != NULL) { strcpy(str, "world"); printf(str); } }
test函数运行结果是什么？
或许大多数人看到的第一反映是：free的太早了，但是我们如果把free放在输出之后，又会显得很突兀，为什么突然判断是否为空？str指向的空间虽然被释放了，但str并不为NULL，无论怎么判断，str都不为NULL，被释放后的str就变成了野指针，这样是很危险的。
所以这道题根本错误点在于：空间释放之后，并没有将str及时置为NULL。
这些题目都出自于一本书——《高质量的C-C++编程》，在早些年线下笔试时，有不少的公司笔试时出的都是这几到中的原题。所以希望大家能够好好的理解，并掌握这部分知识。
二、C/C++程序的内存开辟
趁着动态内存函数来向大家讲解一下C程序中内存的开辟
如上图，C/C++内存分配的几个区域：
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
- 堆区：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
- 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码
有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。
三、柔性数组
或许大多数人从来没有听说过柔性数组这个概念，但是它确实是存在。 C99 中，结构中的最
后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
注意：一个结构体中，只允许创建一个柔性数组
例如：
typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a;
或者：
typedef struct st_type { int i; int a[];//柔性数组成员 }type_a;
柔性数组的特点：
- 结构中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如：
typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a; printf("%d\n", sizeof(type_a));//输出的是4
这与指针也有所不同，在创建的结构中，包含指针变量时，sizeof计算会计算上，指针变量的大小，而柔性数组不会被计算大小。
柔性数组的使用
柔性数组如何体现它的柔性呢？
这就要配合malloc动态内存函数使用，例如：
struct S { int n; int arr[0]; }; int main() { struct S* pc = (struct S*)malloc(sizeof(struct S) + 40); if (pc == NULL) { perror("malloc"); return 1; } pc->n = 10; for (int i = 0; i < 10; i++) { pc->arr[i] = 1 + i; } for (int i = 0; i < 10; i++) { printf("%d ", pc->arr[i]); } free(pc); pc = NULL; return 0; }
malloc(sizeof(struct S) + 40);后边加的40就是开辟40个字节，也就是开辟10个整形空间给数组arr。可能有人会想，这有什么好讲的，变长数组不也可以吗？想开多打开多大。
对于柔性数组，当你觉得开辟的空间不够用时，还可以使用realloc去扩容。
例如：
struct S { int n; int arr[0]; }; int main() { struct S* pc = (struct S*)malloc(sizeof(struct S) + 40); if (pc == NULL) { perror("malloc"); return 1; } pc->n = 10; for (int i = 0; i < 10; i++) { pc->arr[i] = 1 + i; } //空间不够扩容 struct S* ptr = (struct S*)realloc(pc, sizeof(struct S) + 60); if (ptr == NULL) { perror("realloc"); return 1; } pc = ptr; pc->n = 15; for (int i = 0; i < 15; i++) { printf("%d ", pc->arr[i]); } //释放 free(pc); pc = NULL; return 0; }
运行结果：
后五个没有进行初始化，所以是随机数。
柔性数组的优势
对于上述的柔性数组，我们还可以这样模仿实现：
struct S { int n; int* arr; }; int main() { struct S* pc = (struct S*)malloc(sizeof(struct S)); if (pc == NULL) { perror("malloc"); return 1; } pc->n = 10; pc->arr = (int*)malloc(40); if (pc->arr == NULL) { perror("pc->arr"); return 1; } for (int i = 0; i < 10; i++) { pc->arr[i] = 1 + i; } //空间不够扩容 int* ptr = (int*)realloc(pc->arr, 60); if (ptr == NULL) { perror("realloc"); return 1; } pc->arr= ptr; pc->n = 15; for (int i = 0; i < 15; i++) { printf("%d ", pc->arr[i]); } //释放 free(pc->arr); pc->arr = NULL; free(pc); pc = NULL; return 0; }
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现比较好，有两个好处：
- 方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
- 有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。
总结
动态内存管理函数是C语言中非常重要的一部分，掌握它们对于程序员来说至关重要。希望本文能够对读者有所启发和帮助
