目录

1.动态内存分配存在的原因

2.动态内存函数介绍

malloc()

free()

calloc()

realloc() 

3. 常见的动态内存错误

对NULL指针的解引用操作

对动态开辟空间的越界访问

对非动态开辟内存使用free释放

使用free释放一块动态开辟内存的一部分

对同一块动态内存多次释放

动态开辟内存忘记释放（内存泄漏）

4. 柔性数组 

 柔性数组的特点

 柔性数组的使用

柔性数组的优点 

1.动态内存分配存在的原因

内存分配的方式有种：1、静态内存分配，2、动态内存分配。

静态内存分配按照内存开辟的位置又可分为两种，一种为局部变量，由系统在栈区上开辟，另一种为全局变量和静态变量，由系统在静态区上开辟。例如：

#include    int b = 10;//全局变量，在静态区开辟四个字节int main(){    int a = 20;//局部变量，在栈区开辟四个字节    int arr[10] = { 0 };//在栈区开辟10个字节的连续空间    return 0;}

上述的开辟内存的方式有两个共有的特点：

1. 空间开辟大小固定；

2. 数组在申明的时候，必须指定数组的长度，它所需的内存在编译时分配。

但是有时候我们并不知道需要开辟多大的空间或者在程序运行中我们才发现内存申请的不够，在这种用情况下，上述的静态内存分配就不能满足我们的需求，这是我们就只能选择动态内存分配。

2.动态内存函数介绍

malloc()

头文件： 或者

void* malloc( size_t size) 

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

需要注意点如下：

①如果开辟成功，则返回一个指向开辟好空间的指针；

②如果开辟失败，则返回一个NULL指针，因此使用malloc函数一定要检查返回值；

③返回值的类型为void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候要根据具体情况来进行类型转换；

④如果参数size为0，malloc的行为是标准未定义的，取决于编译器。

举个例子：

#include#includeint main(){int* prr = NULL;prr = (int*)malloc(4 * sizeof(int));//开辟16个字节free(prr);//(释放空间函数，下一个介绍)prr = NULL;//将指针置为空。return 0;}

free()

头文件： 或者

void free( void* ptr )

free()函数用来释放动态开辟的内存、

使用free（）函数需要注意的由两点：

① 如果参数ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的；

② 如果参数ptr是NULL指针，则函数什么事情都不做。

例子：

#include#includeint main(){int* arr = NULL;int n = 0;scanf("%d", &n);//开辟几个整型变量int* p = (int*)malloc(n * sizeof(int));if (p != NULL) //判断是否开辟成功{arr = p;for (int i = 0; i < n; i++)//赋值{*arr = i;arr++;}}else{perror("malloc");//若开辟不成功，输出错误信息}//打印arr = p;for (int i = 0; i < n; i++){printf("%d  ",*arr++);}free(p);//对开辟的空间进行释放p = NULL;//要将指向开辟的那块空间的指针置为UNLL，不然将成为野指针arr = NULL;return 0;}

calloc()

头文件： 或者

void* callpc( size_t num, size_t size )

calloc函数与malloc函数用法类似，但需要注意两点：

①calloc函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初试化为0

②与malloc函数的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为0.

举个例子：

realloc() 

头文件： 或者

void* realloc( void* ptr, size_t size )

realloc函数让动态开辟内存更加方便，当我们在发现之前开辟的内存空间不够使，可以直接使用realloc函数进行扩大空间，当然了，如果之前开辟的空间过大也可用realloc函数进行调整，使用注意点如下：

① ptr是要调整的内存的地址；

② size是调整之后的大小单位是字节；

③ 返回值为调整后的内存起始位置；

④ 这个函数调整原内存空间大小的基础上，还会将原来的内存中的数据移动到新的空间；

⑤ 如果ptr为空指针，那么realloc的功能和malloc相似；

⑥ realloc函数在调整内存空间时存在两种情况：

        情况1：原有空间之后有足够大的空间。在这种情况下直接在内存空间后面追加空间，原来空间的数据不发生变化。

        情况2：原有空间之后没后足够大的空间。这种情况下，扩大空间的办法是：在堆区上另外找一个合适大小的连续的空间来使用。函数返回的是一个新的内存地址。（原来内存空间的数据会移动到新的空间）

举例：

#include#includeint main(){int* ptr = NULL;ptr = (int*)malloc(10);if (NULL != ptr){}else{perror("malloc");}//扩大内存//代码1ptr = (int*)realloc(ptr, 100);//这种方法正确吗？如果开辟失败会发生什么？//这样方法进行扩大空间是不正确的，当开辟失败时，realloc返回空指针//那么prr将变为空指针，那之前malloc开辟的空间也就没有指针指向它，//即在也找不到这块空间，也无法释放空间，进而造成内存泄漏。//正确做法int* p = NULL;p = (int*)realloc(ptr, 100);if (NULL != p){ptr = p;}else{perror("realloc");}free(ptr);p = NULL;ptr = NULL;return 0;}

3. 常见的动态内存错误

对NULL指针的解引用操作

void test(){    int* p = (int*)malloc(4);    *p = 20;//如果p的值为NULL，就会出问题，所以开辟之后一定要判断是否为空    free(p);}

对动态开辟空间的越界访问

void test(){int i = 0;int* p = (int*)malloc(10 * sizeof(int));if (NULL != p){for (i = 0; i <= 10; i++){*(p + i) = i;//当i = 10时，会发生越界访问 }}else{perror("malloc");}free(p);}

对非动态开辟内存使用free释放

void test(){int a = 10;int* p = &a;free(p);//错误}

使用free释放一块动态开辟内存的一部分

void test(){int* p = (int*)malloc(100);p++;free(p);//p不在指向动态内存的起始位置//从哪里开始开辟；就要从哪里开始释放}

对同一块动态内存多次释放

void test(){int* p = (int*)malloc(100);free(p);free(p);//重复释放}

动态开辟内存忘记释放（内存泄漏）

#include #includeint main(){int* p = (int*)malloc(10);if (NULL != p){*p = 20;}else{perror("malloc");}return 0;}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

4. 柔性数组 

结构体中的最后一个元素允许是未知大小的数组，这个就叫做柔性数组成员。

struct st1{int i;int arr1[0];//柔性数组成员};//有些编译器会报错无法编译可改为：struct st2{int i;int arr2[]//柔性数组成员};

 柔性数组的特点

① 结构中的柔性数组成员前面必须至少有一个其他成员；

② sizeof返回的这种结构的大小不包括柔性数组的内存；

③ 包括柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

如：

 柔性数组的使用

#include#includetypedef struct st1{int i;int arr1[0];}st1;int main(){int  i = 0;st1* p = (st1*)malloc(sizeof(st1) + 10 * sizeof(int));if (NULL == p){perror("malloc");return 0;}p->i = 100;for (i = 0; i arr1 + i) = i;}free(p);p = NULL;return 0;}

 柔性数组arr1相当于获得10个整型元素的连续空间。

柔性数组的优点 

 上述的st1结构也可设计为下面的形式：

#include#includetypedef struct st1{int i;int *arr1;}st1;int main(){st1* p = (st1*)malloc(sizeof(st1));if (NULL == p){perror("malloc");return 0;}p->i = 100;p->arr1 = (int*)malloc(10 * sizeof(int));if (NULL == p->arr1){perror("malloc");return 0;}for (int i = 0; i arr1 + i ) = i;}free(p->arr1);p->arr1 = NULL;free(p);p = NULL;return 0;}

不难发现两段代码实现的功能相同；但是使用第一段代码也就是柔性数组有两个好处：

① 方便内存释放，我们能够看到在第二段代码里我们需要释放两次；

② 有利于访问速度，使用第二段代码的方式，两次开辟的空间不一定是连续的，而第一段代码开辟的空间是连续，连续的内存空间有利于提高访问速度，也有利于减少内存碎片。 

本博客的内容就到这了，以上若有错误恳请大佬指正！！！感激不尽^_^