C语言学习笔记——动态内存分配

1 动态内存分配常用库函数

1.1 free

free 的函数声明如下：

void free (void* ptr);

作用
将动态开辟的空间进行回收

参数部分
指向动态分配内存空间的指针，若该指针为空指针，则 free 不会做任何事情

返回值
该函数没有返回值

一般来说，在使用了 malloc 等函数开辟动态内存空间后，若这块空间不需要使用，就要用 free 函数来进行回收，并将指针置为空，防止内存泄露和野指针问题

1.2 malloc

malloc 的函数声明如下：

void* malloc (size_t size);

作用
向操作系统申请 size 个字节大小的连续内存空间

参数部分
要分配的空间大小，以字节为单位

返回值
如果空间开辟成功，会返回这块连续内存空间的首地址，用户可以根据自己的需要，将返回的 void* 类型的指针进行强制类型转换，但是如果开辟失败，会返回空指针，所以用户应该在使用 malloc 后，检查指针的值是否为空，防止对空指针进行使用

举例：向操作系统申请 20 个字节大小的空间用于存储 int 类型数据

#include <stdlib.h>
int main()
{int* p = (int*)malloc(sizeof(int) * 5); if (p == NULL) //防止对空指针进行使用{perror("malloc");return 1;}free(p); //回收开辟的空间p = NULL; //防止野指针return 0;
}

int 类型大小 4 个字节，乘以 5 就是 20 个字节，由于要存放 int 类型数据，所以返回的指针强制类型转换为了 int*

申请了空间就需要使用，那么怎么使用这块空间呢？
在使用动态开辟的内存空间时，可以当成数组来使用，通过数组的遍历方式来使用这块空间

举例：开辟20个字节的空间存放 1 2 3 4 5 并输出

#include <stdlib.h>
int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}for (int i = 0;i < 5;++i){*(p + i) = i + 1; //*(p + i) = p[i]}for (int i = 0;i < 5;++i){printf("%d ", *(p + i)); }free(p);p = NULL;return 0;
}

图解：

1.3 calloc

callo 的函数声明如下：

void* calloc (size_t num, size_t size);

作用
开辟 num 个大小为 size 的空间，并初始化为全 0

参数部分
num指元素个数
size指一个元素的大小

返回值
开辟成功返回指向动态开辟空间的指针，开辟失败则返回空指针

举例：开辟20个字节的空间存放 1 2 3 4 5 并输出

int main()
{int* p = (int*)calloc(5, sizeof(int)); //开辟5个大小为4个字节的空间if (p == NULL){perror("malloc");return 1;}for (int i = 0;i < 5;++i){*(p + i) = i + 1; //*(p + i) = p[i]}for (int i = 0;i < 5;++i){printf("%d ", *(p + i)); }free(p);p = NULL;return 0;
}

1.4 realloc

realloc 的函数声明如下：

void* realloc (void* ptr, size_t size);

作用
如果 ptr 为空，则开辟 size 个大小的空间，单位是字节
如果 ptr 不为空，则将 ptr 所指向的空间扩张至 size 个大小

参数部分
ptr 为指向动态开辟空间的指针
size 为新空间大小

返回值
开辟成功返回空间首地址的指针，开辟失败返回空指针

realloc 在重新分配空间时使用的方法
第一种：原空间后方的空间余量够扩大到 size 个时，则直接向后扩张即可
比如说，现在已经动态分配了 20B 的内存空间，想要扩张至 40B，在已分配空间后方还有 20B，够扩张到 40B，那么，就会直接向后扩张
图解：

**第二种:**原空间后方的空间余量不够扩大到 size 个时，则需要另找一片空间，重新分配
比如，现在已经动态分配了 20B 的内存空间，想要扩张至 40B，但是已分配空间后方不够 20B，不够扩张到 40B，那么，就会寻找一片 40B 的空间进行分配，将原空间的数据复制到里面，返回指向新空间的指针

举例：开辟20个字节的空间存放 1 2 3 4 5 后，将其扩大到 40B，再存放 6 7 8 9 10 并输出

#include <stdlib.h>
#include <stdio.h>
int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}for (int i = 0;i < 5;++i) //存放1 2 3 4 5{*(p + i) = i + 1; //*(p + i) = p[i]}int* p2 = (int*)realloc(p, 40);if (p2 == NULL) //检查新空间是否开辟成功{perror("realloc");return 1;}p = p2; //开辟成功再改变指针指向p2 = NULL;for (int i = 5;i < 10;++i){*(p + i) = i + 1;}for (int i = 0;i < 10;++i){printf("%d ", *(p + i));}free(p);p = NULL;return 0;
}

2 常见的动态内存错误

2.1 对NULL指针的使用

int main()
{int* p = (int*)malloc(INT_MAX * 2);*p = 10; //p若为NULL，不能解引用free(p);p = NULL;return 0;
}

为了防止这个问题，需要对指针进行检查

int main()
{int* p = (int*)malloc(INT_MAX * 2);if (p == NULL) //防止空指针问题{perror("malloc");return 1;}*p = 10; //p若为NULL，不能解引用free(p);p = NULL;return 0;
}

2.2 越界访问

int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}for (int i = 0;i <= 5;++i) //只有5个元素，但是下标遍历到了6{*(p + i) = i;}free(p);p = NULL;return 0;
}

2.3 对非动态开辟的空间进行释放

int main()
{int arr[] = { 1,2,3,4,5 };free(arr); //arr不是动态开辟的空间return 0;
}

2.4 对动态开辟的空间重复释放

int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}free(p);free(p);p = NULL;return 0;
}

为了防止这个问题，应该在第一次释放后，将指针置为空

int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}free(p);p = NULL;free(p);return 0;
}

2.5 释放部分动态开辟的空间

int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}p++;free(p);p = NULL;return 0;
}

2.6 忘记释放动态开辟的内存空间

int main()
{int* p = (int*)malloc(sizeof(int) * 5);if (p == NULL){perror("malloc");return 1;}return 0;
}

3 柔性数组

柔性数组是通过结构体来实现的，具体实现方法为：

• 将结构体的最后一个成员设置为数组，该数组前一定要有一个或多个成员变量
• 此数组不设大小

struct S
{int a;int arr[]; //柔性数组成员
};

当结构体内有柔性数组，使用 sizeof 在计算类型大小时，不会将柔性数组的大小计算入内，只会计算柔性数组之前成员的大小，因此就可以使用动态分配的方式指定数组的空间大小

举例：分配大小为 20B 的空间给柔性数组

struct S
{int a;int arr[]; //柔性数组成员
};int main()
{int* p = (int*)malloc(sizeof(struct S) + sizeof(int) * 5); //先分配柔性数组前成员变量的空间，再分配柔性数组的空间if (p == NULL){perror("malloc");return 1;}free(p);p = NULL;return 0;
}

图解：

如果想要更改柔性数组的大小，只需要使用 realloc 即可

举例：将 20B 的柔性数组变成 40B

struct S
{int a;int arr[]; //柔性数组成员
};int main()
{int* p = (int*)malloc(sizeof(struct S) + sizeof(int) * 5); if (p == NULL){perror("malloc");return 1;}int* p2 = (int*)realloc(p, sizeof(struct S) + sizeof(int) * 10); //更改为40Bif (p2 == NULL){perror("malloc");return 1;}p = p2;p2 = NULL;free(p);p = NULL;return 0;
}

图解：
假设后方有空间