动态内存管理 前篇

  • 1. 为什么存在动态内存管理
  • 2. 动态内存函数
    • ‍♂️（1）空指针
    • ‍♂️（2）malloc
    • ‍♂️（3）calloc
    • ‍♂️（4）realloc
    • ‍♂️（5）free
  • 3. 常见的动态内存错误
    • ‍♂️（1）对NULL指针的解引用操作
    • ‍♂️（2）对动态开辟空间的越界访问
    • ‍♂️（3）对非动态开辟内存使用free释放
    • ‍♂️（4）使用free释放动态开辟内存的一部分
    • ‍♂️（5）对同一块动态内存多次释放
    • ‍♂️（6）动态开辟内存忘记释放（内存泄漏）

1. 为什么存在动态内存管理

C语言中的数据结构通常是固定大小的。例如，一旦程序完成编译，数组元素的数量就是固定的。
说到这里，有人就要说：变长数组呢？在C99中，变长数组的长度在运行时确定，但在数组的生命周期内仍然是固定的，因为在编写程序时强制选择了大小，所以固定大小的数据结构可能会有问题。也就是说，在不修改程序并且再次编译程序的情况下无法改变数据结构的大小

对于空间的需求,有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。
这时候就只能试试动态存开辟了。

2. 动态内存函数

‍♂️（1）空指针

在调用内存分配函数时，总存在这样的可能性：找不到我们需要的足够大的内存块。那这样的话，函数就会返回空指针（NULL）

  1. 空指针就是“不指向任何地方的指针”
  2. 区别于所有有效指针的特殊值
  3. 名为NULL的宏有定义的头文件：、、、、、（C99）
  4. 数测试真假的方法：0为假，非0为真；指针测试真假的方法：空指针为假，非空为真

注意：
1. 程序员的任务是测试任意内存分配函数的返回值，并且要在返回值为空指针时采取适当措施
2. 通过空指针访问内存的行为是未定义的，程序可能会出现崩溃

‍♂️（2）malloc

在介绍具体的内存分配函数之前，先了解一下他们的功能：

  • malloc：分配内存块，但是不对内存块进行初始化
  • calloc：分配内存块，并且对内存块进行清零
  • realloc：调整先前分配的内存块大小
  • free ：释放内存块
  • 所有函数的头文件都是
void* malloc (size_t size);这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针
#include#include#includeint main(){//申请10个整形类型int* p = (int*)malloc(10 * sizeof(int));//int* p=(int*)malloc(40);//判断是否申请空间成功if (p == NULL){printf("%s\n", strerror(errno));return 1;}//使用 存放1-10for (int i = 0; i < 10; i++){*(p + i) = i + 1;}//打印for (int i = 0; i < 10; i++){printf("%d ", *(p + i));}//释放申请的空间free(p);p = NULL;return 0;}

在这里解释一下：

  • malloc函数申请空间：
  1. 如果开辟成功，则返回一个指向开辟好空间的指针
  2. 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查
  • void* :是通用型指针类型：
  1. 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
  2. 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器
  • free函数：
  1. free函数是释放动态开辟的空间（堆区上的空间），否则是未定义的行为。如果参数是空指针，那么free函数什么事都不用做
  2. malloc函数和free函数搭配使用
  • 判断是否申请空间成功：
  1. 程序员的任务是测试任意内存分配函数的返回值，并且要在返回值为空指针时采取适当措施
  2. 通过空指针访问内存的行为是未定义的，程序可能会出现崩溃
  • 一旦p指向动态分配的内存块，就可以忽略p是指针的事实，可以把它看成数组的名字。上面代码的使用和打印部分就是利用了这一特点

当然了，有人还有疑问：为什么一定要释放申请的内存空间？释放了空间之后，为什么要置为空指针？
在这里，我来单独解释：

  1. 向堆区申请了空间，当然要还了 （还给操作系统）
  2. free函数的作用是切断操作系统与该变量之间的联系
  3. 所以，光是将空间还给操作系统是不行的，因为该变量还保留着起始位置的地址，需要我们手动置空

    有人又有疑问了：博主，你申请空间的时候，怎么写了两种方法？那种更推荐？
    其实，个人而言，我更推荐第一种，原因是：
    计算变量类型所需要的空间数量时，始终要使用sizeof运算符，如果不能分配足够的空间，将会产生严重的后果。比如，不同的机器上，int类型的大小就不一样，有的是2字节，有的是4字节…
    假如：你写的是第二种 p = (int*) malloc(38); 你所用的机器上int是4个字节，这种情况下，就会产生分配错误的结果。

‍♂️（3）calloc

void* calloc (size_t num, size_t size);
#include#includeint main(){int* p = calloc(10, sizeof(int));if (p == NULL){perror(p);return 1;}for (int i = 0; i < 10; i++){printf("%d ", p[i]);}free(p);p = NULL;return 0;}//运行结果：******0 0 0 0 0 0 0 0 0 0 *****

malloc 和 calloc

  • 相同：
  1. 堆区上申请空间
  2. 返回起始地址
  3. 由于是申请空间，不用的话，要释放内存并置空
  • 不同：
  1. malloc一个参数，calloc两个参数，相当于 40（总字节大小） = 10（变量个数） * 4（每个变量的大小）
  2. malloc没有初始化，calloc会把空间初始化为0 – 故malloc比calloc的效率高

‍♂️（4）realloc

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整

void* realloc (void*ptr, size_t size)
  • ptr是要调整的内存地址
  • size是调整之后的大小
  • 返回值是调整之后的内存起始地址
  • realloc在调整内存空间是存在两种情况：
  1. 情况1：原有空间之后有足够大的空间
    要扩展内存就直接在原有内存之后追加空间，原来空间的数据不发生变化，并返回旧空间的起始地址
  2. 情况2：原有空间之后没有足够的空间
    在堆空间上另外找一个大小合适的连续空间来使用，将原有数据拷贝到这个新空间上，释放掉就空间，并返回新空间的起始地址
#include#includeint main(){int* p = malloc(10 * sizeof(int));//判断malloc函数是否开辟成功if (p == NULL){perror(p);return 1;}int* ptr = realloc(p, 5 * sizeof(int));//判断realloc函数是否开辟成功if (ptr != NULL){p = ptr;}for (int i = 0; i < 5; i++){printf("%d ", p[i]);}free(p);p = NULL;return 0;}//运行结果：*****5个随机数*****

看到这里，有人就有疑问了：realloc函数如果开辟失败，原有内存中的数据会怎么变化？为什么不是直接让p来接收realloc的结果？
解释：

  • 如果realloc函数不能按照要求来进行扩展，那么就会返回NULL，原有数据都不会发生变化
  • realloc的结果一定要让一个新指针来接收。因为：
  1. realloc函数可能将内存块移动到堆区上的其他位置
  2. 如果开辟失败返回NULL，那么以后进行的操作就会导致系统崩溃

此外，realloc函数还需要注意：

  • 传给realloc函数的第一个指针必须来自于先前malloc、calloc 或 realloc的调用，如果不是这样的指针，程序导致崩溃
  • realloc函数不会对添加进内存块的函数进行初始化
  • 第一个参数如果是NULL，那么相当于调用malloc函数
  • 第二个参数是0，将会释放掉该内存块

‍♂️（5）free

void free (void* ptr);
  • free函数是专门来释放动态开辟的内存
  • 如果参数ptr不是指向动态开辟来的空间，将会导致程序崩溃
  • 如果参数ptr是NULL，函数将什么事都不会做

3. 常见的动态内存错误

‍♂️（1）对NULL指针的解引用操作

#include#includeint main(){int* p = (int*)malloc(INT_MAX );*p = 20;//如果p的值是NULL，就会有问题free(p);return 0;}

补充一下：
INT_MAX：2147483647

‍♂️（2）对动态开辟空间的越界访问

void test(){int i = 0;int* p = (int*)malloc(10 * sizeof(int));if (NULL == p){exit(EXIT_FAILURE);}for (i = 0; i <= 10; i++){*(p + i) = i;//当i是10的时候越界访问}free(p);}

申请空间的单位一般都是字节

‍♂️（3）对非动态开辟内存使用free释放

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

free函数是专门来释放动态开辟的内存空间的

‍♂️（4）使用free释放动态开辟内存的一部分

void test(){int* p = (int*)malloc(100);p++;free(p);//p不再指向动态内存的起始位置}

free函数的参数是要释放动态内存空间的起始地址

‍♂️（5）对同一块动态内存多次释放

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

对同一个空间释放两次了 – 因为p一直保留着起始位置的地址

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

这种不是对同一个空间释放空间两次 – 因为p已经置为空了，对空指针进行free操作是没有意义的

‍♂️（6）动态开辟内存忘记释放（内存泄漏）

void test(){int* p = (int*)malloc(100);p++;free(p);//p不再指向动态内存的起始位置}void test(){int* p = (int*)malloc(100);if (NULL != p){*p = 20;}}int main(){test();while (1);}

动态开辟的空间一定要释放，并且要正确释放，否则会造成内存泄漏

码文不易，各位看官一键三连哦
各位的鼓励与支持是我前进最大的动力