目录
前言
一、动态内存管理
二、动态内存函数
2.1 malloc
2.2 free
2.3 calloc
2.4 realloc
三、动态内存常见的6个使用错误
3.1 接收malloc/calloc返回的参数后未及时检查是否为NULL
3.2 越界访问动态内存空间
3.3 对非动态开辟的内存使用free释放
3.4 使用free只释放了动态内存的一部分
3.5 对同一块动态内存多次释放
3.6 忘记释放动态内存造成内存泄露
四、动态内存经典笔试题
4.1 题目1
4.2 题目2
4.3 题目3
4.4 题目4
五、柔性数组
六、C/C++中程序内存区域划分
前言
本篇主要讨论以下问题：
动态内存基础知识点：
1. 为什么会出现动态内存的概念
2. 与动态内存有关的4个函数它们分别的作用、函数的参数、返回类型以及要注意的地方是什么
3. 理解动态开辟的内存是在堆区开辟空间的，如果不主动使用free释放开辟的动态内存空间，那么只能等程序结束后由操作系统释放了。(不可取，一定要记得自己用free去释放)
动态内存避坑指南：
4. 动态内存开辟和使用过程中常见有哪6大错误
5. 动态内存经典笔试题，找出代码中错误的点
柔性数组：
6. 怎样的数组才能被称为柔性数组，含柔性数组的结构体如何开辟内存空间，如何找到结构体变量的成员变量的
了解内存有哪几个重要的区域：
7.内存有哪几个重要的区域
一、动态内存管理
1. 在没有学习动态内存管理前 ，我们知道的为变量开辟内存的方式有两种：① 一次申请一个变量的空间 ② 一次申请一块连续的空间，但这两种申请内存空间的方式有一个明显的缺点，就是申请的空间大小一旦确定就无法更改了，于是C语言中引入了动态内存的概念，我们可以利用4个与动态内存有关的函数，实现动态开辟内存空间的效果。
二、动态内存函数
1. 4个与动态内存有关的函数所需的头文件都是<stdlib.h>。
2.1 malloc
1. malloc函数的作用：开辟size字节的动态内存空间。
2. 语法形式：void* malloc (size_t size)
size_t size：表示向堆区一次性申请几个比特位的空间。
void*：返回类型之所以是void*(void*可接收任意类型的地址)是因为malloc只知道向内存的堆区申请几个字节的空间，并不知道将会存放什么类型的数据，但是程序员是知道的，所以在用malloc开辟动态内存后，一般会立即强制类型转换，直接用其他类型的指针变量接收。
3. 如果malloc开辟内存成功，则返回一个指向开辟好空间的指针。
如果malloc开辟内存失败，则返回一个NULL指针，因此在用指针接收malloc返回的地址后，需要检查指针内的地址是否为NULL。
4. 如果malloc函数的参数size为0，这是标准未定义的，完全取决于编译器如何处理。
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存
int* ps = (int*)malloc(10 * sizeof(int));//强制转换后再接收
if (ps == NULL)//判断是否开辟失败
{
perror("malloc");
return 1;//异常返回，返回非0
}
return 0;
}2.2 free
1. free函数的作用：用于回收malloc/calloc/realloc开辟的动态内存空间。
2. 语法形式：void free (void* ptr)
void* ptr：表示指向malloc/calloc/realloc开辟的动态内存空间的指针。
3. free函数只是回收了ptr所指向的动态内存空间，但此时ptr中仍然存放着指向刚刚已被回收的动态内存空间的地址，因此在使用free函数后，应立即在后面一行中写上将ptr置NULL的操作，防止ptr野指针被使用。
4. 如果free函数的参数 ptr 指向的空间不是动态开辟的内存空间，这是标准未定义的，完全取决于编译器如何处理。
如果free函数的参数是NULL，则free函数将什么都不会做。
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存
int* ps = (int*)malloc(10 * sizeof(int));//强制转换后再接收
if (ps == NULL)//判断是否开辟失败
{
perror("malloc");
return 1;//异常返回，返回非0
}
//使用动态内存
//释放动态内存
free(ps);
ps = NULL;
return 0;
}2.3 calloc
1. calloc函数的作用：为num个大小为size字节的元素开辟一块动态内存空间， 与malloc不同的是calloc会对开辟的空间每个字节都初始化为0。
2. 语法形式：void* calloc (size_t num, size_t size)
size_t mun：表示要分配的元素个数。
size_t size：表示每个元素的大小，单位是比特位。
void*：和malloc函数的原因一致，在用calloc开辟动态内存后，一般会立即强制类型转换，直接用其他类型的指针变量接收。
3. 如果calloc开辟内存成功，则返回一个指向开辟好空间的指针。
如果calloc开辟内存失败，则返回一个NULL指针，因此在用指针接收malloc返回的地址后，需要检查指针内的地址是否为NULL。
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存
int* ps = (int*)calloc(10, sizeof(int));//强制转换后再接收
if (ps == NULL)//判断是否开辟失败
{
perror("calloc");
return 1;//异常返回，返回非0
}
//使用动态内存,看看calloc默认初始化的值
for (int i = 0; i < 10; i++)
{
printf("%d ", *(ps + i));//屏幕上打印出了10个0
}
//释放动态内存
free(ps);
ps = NULL;
return 0;
}2.4 realloc
1. realloc函数的作用：调整用malloc/calloc/realloc开辟过的动态内存空间大小。
2. 语法形式：void* realloc (void* ptr, size_t size)
void* ptr：表示指向malloc/calloc/realloc开辟的动态内存空间的指针。
size_t size：表示想要重新调整到的动态内存空间的大小，单位是比特位。
void*：和malloc函数的原因一致，在用calloc开辟动态内存后，一般会立即强制类型转换，直接用其他类型的指针变量接收。
3. 如果realloc调整内存大小成功，则返回非NULL指针。
如果realloc调整内存大小失败，则返回一个NULL指针，此时如果直接用ptr接收realloc返回的地址，会使得ptr连原本的动态内存空间都无法找到，也无法将原本的动态内存空间释放，所以在用realloc调整动态内存空间后，不会直接用ptr接收，而是会建立一个临时指针去接收，临时的指针接收后，判断如果临时指针不为NULL，则把临时指针内的地址赋值给ptr，并把临时的指针赋值为NULL；如果为NULL，则进行报错。
4. 关于realloc函数返回的地址是什么的问题：
情况一：原有空间之后有⾜够⼤的空间可以扩充，此时要扩展内存就直接会在原有内存之后直接追加空间，原来空间的数据不发⽣变化，realloc返回的地址值与ptr内的值一致。
情况二：原有空间之后没有⾜够⼤的空间可以扩充，扩展的⽅法是，在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤，同时把旧数据拷贝到新的空间，并释放旧的空间，这样函数返回的是⼀个新的内存地址。
5. realloc函数的隐藏技能：如果realloc函数的参数void* ptr部分传参为NULL，效果等同于malloc函数。
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态空间
int* ps = (int*)malloc(10 * sizeof(int));
if (ps == NULL)
{
perror("malloc");
return 1;
}
//调整动态空间
int* ps2 = (int*)realloc(ps, 20 * sizeof(int));
if (ps2 != NULL)
{
ps = ps2;
ps2 = NULL;
}
else
{
perror("realloc");
return 1;
}
//释放动态内存
free(ps);
ps = NULL;
return 0;
}三、动态内存常见的6个使用错误
3.1 接收malloc/calloc返回的参数后未及时检查是否为NULL
#include <stdio.h>
#include <stdlib.h>
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
*p = 20;//err
return 0;
}3.2 越界访问动态内存空间
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 12; i++)
{
*(p + i) = i;//err
}
//释放动态内存空间
free(p);
p = NULL;
return 0;
}3.3 对非动态开辟的内存使用free释放
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a = 10;
int* pa = &a;
free(pa);//err
pa = NULL;
return 0;
}3.4 使用free只释放了动态内存的一部分
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用动态空间
for (int i = 0; i < 5; i++)
{
*p = i;
p++;
}
//释放动态内存空间
free(p);//err
p = NULL;
return 0;
}3.5 对同一块动态内存多次释放
#include <stdio.h>
#include <stdlib.h>
int main()
{
//开辟动态内存空间
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用动态空间
free(p);
p = NULL;
//释放动态内存空间
free(p);//err
p = NULL;
return 0;
}3.6 忘记释放动态内存造成内存泄露
#include <stdio.h>
#include <stdlib.h>
void Test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
perror("malloc");
return 1;
}
else
{
*p = 20;
}
//err,未释放动态内存
}
int main()
{
test();
return 0;
}四、动态内存经典笔试题
4.1 题目1
题目分析：代码的目的是想让字符串拷贝到动态开辟的内存中。
错误分析：① 采用了传值调用，改变形参，实参不受影响。
② NULL不能被使用。
③ 没有free动态内存。
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);//传值调用
strcpy(str, "hello world");//str==NULL，err
printf(str);
}
int main()
{
Test();
return 0;
}//修改代码
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p)
{
*p = (char*)malloc(100);
if (*p == NULL)//
{
perror("malloc");
}
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//
strcpy(str, "hello world");
printf(str);
free(str);//
str = NULL;//
}
int main()
{
Test();
return 0;
}4.2 题目2
错误分析：① 自定义函数返回了局部变量的地址
#include <stdio.h>
#include <stdlib.h>
char* GetMemory(void)
{
char p[] = "hello world";//err
//static char p[] = "hello world";//修改代码：将上一行替换
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}4.3 题目3
错误分析：① 没有判断malloc是否返回的NULL
② 没有用free释放动态内存空间
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
int main()
{
Test();
return 0;
}//修改代码
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p, int num)
{
*p = (char*)malloc(num);
if (*p == NULL)//
{
perror("malloc");
}
}
void Test(void)
{
char* str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);//
free(str);//
str = NULL;
}
int main()
{
Test();
return 0;
}4.4 题目4
错误分析：① 没有判断malloc是否返回的NULL
② free后没有及时将str置NULL
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf("str");
}
}
int main()
{
Test();
return 0;
}//修改代码
#include <stdio.h>
#include <stdlib.h>
void Test(void)
{
char* str = (char*)malloc(100);
if (str == NULL)
{
perror("malloc");
return 1;
}
strcpy(str, "hello");
free(str);
str = NULL;
//无意义代码
if (str != NULL)
{
strcpy(str, "world");
printf("str");
}
}
int main()
{
Test();
return 0;
}五、柔性数组
1. C99中，结构体至少2个成员变量，若最后一个成员变量是一个未知大小的数组，则这个数组叫做柔性数组。（ 未知大小的数组写法：① int arr[]; ② int arr[0]; ）
2. 柔性数组的特点：
① 结构体中柔性数组成员前必须至少有1个其他成员变量。
② sizeof计算含柔性数组的结构体大小时，计算的结果不包含柔性数组的大小，因为柔性数组的大小是未知的。
③ 包含柔性数组的结构体在申请内存空间时要采用动态内存开辟的方式，并且开辟的动态内存空间应大于结构体内存的大小，以适应柔性数组的预期大小（总之，在创建有柔性数组的结构体变量时，不要采用struct St s；传统的方式，这样创建的结构体变量中柔性数组成员变量是没有大小的，我们应采用
struct St* p = (struct St*) malloc(sizeof(struct St)+10* sizeof(int)；类似的方式创建结构体变量，找结构体成员变量时直接用(->)操作符即可，这种写法下相当于不同的结构体指针变量，代表着不同的结构体变量)
3. 使用动态内存为含柔性数组的结构体开辟空间的方式，而不用平常为结构体变量开辟空间的方式的好处：① 方便内存释放 ② 访问数组相对较快 ③ 利于减少内存碎片(动态内存之间未利用到的内存称为内存碎片)
#include <stdio.h>
#include <stdlib.h>
struct St
{
float a;
int arr[0];
};
int main()
{
struct St* p = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
scanf("%f", &(p->a));
printf("%f", p->a);
for (int i = 0; i < 10; i++)
{
scanf("%d", &(p->arr[i]));
printf("%d ", p->arr[i]);
}
//释放
free(p);
p = NULL;
return 0;
}六、C/C++中程序内存区域划分
本篇文章已完结，谢谢支持！！！
