前言
作者：小蜗牛向前冲
名言：我可以接收失败，但我不能接收放弃
如果觉的博主的文章还不错的话，还请 
点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。 大家好啊！小蜗牛又来为大家分享新的文章了。不知道大家有没有在使用数组时发现超出空间的情况，这时我们往往要重新定义数组的大小。那么这个数组的空间到底定义多大呢？定小了可能等下数组空间又不够了，定大了可能会存在许多内存空间的浪费。那么有什么更好的办法解决吗？
有的，那就是动态内存分配，下面博主会为大家一一道来。
一为什么存在动态内存分配
我们以往开辟空间的方式：
int a = 0;//在栈区开辟4个字节的空间 int arr[10] = { 0 };//在栈区开辟40个字节连续的空间
特点：
1 开辟的空间大小是固定的。
2数组在声明时，必须指数组大小或者直接初始化数组，它所需要的内存在编译时分配
但有时侯，对于空间的需求在我们写代码的时候是并不知道的，要编译完之后才会知道，这就导致我们可能又要去修改分配内存空间的大小，这是不便的。这时候我们便可以试试用动态内存分配来解决这个问题。
二动态内存函数的介绍
1 malloc函数
C语言提供了一个动态内存开辟的函数：
参数
stze:
内存块的大小，以字节为单位。
size_t是无符号整数类型。
返回值
成功时，指向函数分配的内存块的指针。
此指针的类型始终为 void*，可以将其转换为所需类型的数据指针，以便可取消引用。
如果函数未能分配请求的内存块，则返回空指针。
注意：
malloc函数成功开辟空间返回的是，指向开辟空间的指针。
开辟失败的时候返回的是，一个空指针(NULL),所以在用malloc函数开辟空间时一定要去判断是否能否开辟成功。
返回值是void*，所以在接收用malloc开辟的空间时，要强转为自己需要的类型。
如果参数stez是0，malloc的行为是标准是未定义的，取决于编译器。
2 free函数
C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：
参数
ptr
指向先前使用 malloc、calloc 或 realloc 分配的内存块的指针。
注意：
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
alloc和free都声明在 stdlib.h 头文件中。
代码举例：
int main() { //动态内存的开辟 int* ptr= (int *)malloc(40); //判断空间是否开辟成功 int i = 0; if (ptr != NULL) { //使用 for (i = 0;i < 10;i++) { *(ptr + i) = i; } } for (i = 0;i < 10;i++) { printf("%d ", *(ptr+i)); } free(ptr);//回收空间 ptr = NULL;//防止出现野指针 return 0; }
3 calloc函数
C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：
作用
分配和零初始化数组
为 num 元素数组分配一个内存块，每个元素的大小都长字节，并将其所有位初始化为零。
有效结果是分配了零初始化的（数字*大小）字节的内存块。
如果 size 为零，则返回值取决于特定的库实现（它可能是也可能不是空指针），但返回的指针不应被取消引用
参数 
num
要分配的元素数。
size
每个元素的大小。
size_t 是无符号整数类型。
代码举例：
int main() { int i = 0; scanf("%d", &i);//要分配的元素数 int* data = (int*)calloc(i, sizeof(int)); //判断 if (data == NULL) { perror(data); return 1; } //使用 int j = 0; for (j = 0;j < i;j++) { data[j] = j; printf("%d ", data[j]); } //释放 free(data); data = NULL; return 0; }
首先我来看道calloc函数的第一个功能，能将分配空间中的元素都初始化为0。
其次，否真的分配的内存空间。
所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。
4 realloc函数
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时 候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小 的调整。
函数原型如下：
功能
更改 ptr 所指向的内存块的大小。
该函数可以将内存块移动到新位置（其地址由函数返回）。
内存块的内容将保留到新旧大小中较小的一个，即使该块被移动到新位置也是如此。如果新大小较大，则新分配部分的值不确定。
如果 ptr 是空指针，则该函数的行为类似于 malloc，分配一个新的大小字节块并返回指向其开头的指针。
参数
ptr
指向先前使用 malloc、calloc 或 realloc 分配的内存块的指针。
或者，这可以是一个空指针，在这种情况下，分配一个新块（就像调用malloc一样）。
size
内存块的新大小，以字节为单位。
size_t是无符号整数类型
realloc函数调整空间后存在二种情况
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间
对于情况1要扩展的空间直接在原有空间之间后扩展，原空间的数据不发生变化。
对于情况2由于后续空间不足以扩展，所以realloc函数会重新在堆区找足够大一块空间，把原空间的数据放到新空间中，并让ptr重新指向新空间。
代码举例：
int main() { int* ptr = (int*)calloc(5, sizeof(int)); if (ptr != NULL) { int i = 0; for (i = 0;i < 5;i++) { *(ptr + i) = i; printf("%d ", *(ptr + i)); } } else { perror(ptr);//报错信息 } printf("\n"); //增容 int* p = NULL; p = realloc(ptr, 10 * sizeof(int)); printf("增容成功\n"); if (p != NULL) { ptr = p; int i = 0; for (i = 0;i < 10;i++) { *(ptr + i) = i; printf("%d ", *(ptr + i)); } } //释放 free(ptr); ptr = NULL; return 0; }
三 常见的动态内存错误
虽然我们在使用malloc,calloc和realloc开辟动态空间很方便，但也容易引起一些错误。下面我们就一起看看吧。
1 对NULL指针的解引用操作
void test() { int* p = (int*)malloc(INT_MAX); *p = 20;//如果p是NULL,就会有问题 free(p);//释放 }
其中INT_MAX是一个比较大的数，内存分配可能会失败，当分配空间失败时，p被置为NULL,后面对空指针解引用是不可以取的。
我们可以这样避免
void test() { int* p = (int*)malloc(INT_MAX); if (p == NULL) { return 1; } *p = 20;//如果p是NULL,就会有问题 free(p);//释放 }
2 对动态开辟空间的越界访问
void test() { int i = 0; int* p = (int*)malloc(10 * sizeof(int)); if (NULL == p) { perror(p); } for (i = 0; i <= 10; i++) { *(p + i) = i;//当i是10的时候越界访问 } free(p); p = NULL;
这里就告诉我们在写代码还是要多思考。
3对非动态开辟内存使用free释放
void test() { int a = 10; int *p = &a; free(p);//ok? }
这里我们是对非动态空间继续释放，这肯定是不可取的，a变量开辟的空间是在栈区是，而free释放的空间是在堆区。
4使用free释放一块动态开辟内存的一部分
void test() { int *p = (int *)malloc(100); p++; free(p);//p不再指向动态内存的起始位置 }
这里程序会崩溃。
5 对同一块动态内存多次释放
void test() { int *p = (int *)malloc(100); free(p); free(p);//重复释放 }
哈哈，别认为这不存在噢，当我们写代码写多了，会有的噢。
6动态开辟内存忘记释放（内存泄漏）
void test() { int *p = (int *)malloc(100); if(NULL != p) { *p = 20; } } int main() { test(); while(1); }
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记： 动态开辟的空间一定要释放，并且正确释放 。
四几个经典的笔试题
学完上面的知识点，我们来实战在训练一下。
题目1：
void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); }
请问运行Test 函数会有什么样的结果？
我们发现什么都没打印，为什么呢？
其中在于p变量是个形参，出函数就会销毁，那么分配的空间就找不到了，使用str并没有分到内存空间，就无法完成拷贝。
其实我们稍作改动将可以完成代码的实现，将传值调用改为传址调用就可以了。
题目2：
char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
请问运行Test 函数会有什么样的结果？
我们发现打印出来了随机值，为什么呢？
这是因为函数使用完后就会销毁，p其实是个野指针，p指向的空间在出函数后就会被回收。
题目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 函数会有什么样的结果？
虽然结果是对的，但大家发现没malloc函数开辟的空间并没有被回收，这会造成内存空间的泄漏，所以我们在使用完动态函数开辟的空间后一定要回收内存。
题目4：
void Test(void) { char *str = (char *) malloc(100); strcpy(str, "hello"); free(str); if(str != NULL) { strcpy(str, "world"); printf(str); } }
请问运行Test 函数会有什么样的结果？
怎么会是world呢？不少会一疑问，str空间不是被free释放吗？
其实空间虽然是释放了，但str仍然记得那块空间的地址，我们*还是能找到那块空间，但是那块空间已经是不属于我们了，这时str相当于野指针是相当危险的。为了避免这种错误的结果出现，我们最好在free释放了str所指向的空间时，在将str置为空指针(str=NULL).
五 C/C++程序的内存开辟
这里简单和大家分享一下，C/C++程序的内存开辟。
C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分 配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
六 柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
下面就是柔性数组：
typedef struct s { int a; int arr[];//柔性数组 }s;
1 柔性数组的特点
结构中的柔性数组成员前面必须至少有一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
我们可以看到，这个结构体的大小是不包含柔性数组的大小的。
2 柔性数组的使用
//代码1 typedef struct s { int a; int arr[];//柔性数组 }s; int main() { //代码1 int i = 0; s* p = (s*)malloc(sizeof(s) + 100 * sizeof(int));//为结构体和柔性数组开辟空间 //业务处理 p->a = 100; for (i = 0; i < 100; i++) { p->arr[i] = i; } free(p); p = NULL; return 0; }
用malloc为柔性数组开辟的100的连续的空间。
3 柔性数组的优势
下面我们在另外一个方式，实现代码1的结果。
//代码2 struct s { int n; int* arr; }; int main() { struct s* p = (struct s*)malloc(sizeof(struct s));//为结构体开辟空间 if (p == NULL) { return 1; } p->n = 100; p->arr = (int*)malloc(40);//为arr指针开辟空间 if (p->arr == NULL) { perror("");//报错信息 return 1; } //使用 int i = 0; for (i = 0;i < 10;i++) { p->arr[i] = i; } //空间释放 free(p->arr); free(p); p = NULL; }
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好 了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。
总结
在这篇博客中，我们主要学习了动态内存函数和柔性数组，对于动态内存函数我们主要还是要注意，使用后一定要记得用free释放空间，柔性数组的优点方便内存释放和提高访问速度。
最后送大家于自己一句话：
纸上得来终觉浅 绝知此事要躬行！
