本章重点

为什么存在动态内存分配
动态内存函数的介绍
malloc
free
calloc
realloc
常见的动态内存错误
几个经典的笔试题
柔性数组

正文开始

1. 为什么存在动态内存分配

我们已经掌握的内存开辟方式有：

int val = 20;//在栈空间上开辟四个字节
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间

但是上述的开辟空间的方式有两个特点：

1. 空间开辟大小是固定的。

2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

2. 动态内存函数的介绍

2.1 malloc和free

C语言提供了一个动态内存开辟的函数：

void* malloc (size_t size);

其中size为要开辟的空间大小，size_t表示无符号整型，其头文件为#include<stdlib.h>

这个函数表示向内存申请一块连续可用的空间，并返回指向这块空间的指针(起始地址)。

注：

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

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

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

不仅如此，C语言提供了另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

void free (void* ptr);

ptr指向以前分配给的内存块的指针，其头文件为#include<stdlib.h>，和malloc一样。

注：

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

如果参数 ptr 是NULL指针，则free函数什么事都不用做，相当于对代码无影响。为了防止在以后写代码的过程中浪费空间或者被别人修改指针的内容，我们可以运用free函数和将指针赋值为NULL空指针来防止这些问题，例如：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	//向内存申请10个整型的空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)//判断p是否为空指针
	{
		//错误信息对应的错误码会存储在errno中
		printf("%s\n", strerror(errno));
		//strerror将错误码对应的错误信息打印出来
	}
	else//开辟空间成功
	{
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	//当动态申请的空间不再使用时，就应该还给操作系统
	free(p);//释放p所指向的动态内存
	p = NULL;//防止p所指向的内容被修改
	return 0;
}

开辟空间成功时的输出结果：

屏幕截图 2022-02-13 150007.png

开辟空间失败时的输出结果：

屏幕截图 2022-02-13 150606.png

2.2 calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

其中size_t num为元素个数，size为每个元素的类型大小，头文件为#include<stdlib.h>,跟malloc和free函数一样。

区别：

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

与函数malloc的区别只在于calloc会在返回地址之前把申请的空间中每个字节都初始化为全0。 例如：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int i = 0;
	int* p = (int*)calloc(10, sizeof(int));
	//向内存申请空间之前会先将内存中的内容初始化为0

	if (p == NULL)//判断p是否为空指针
	{
		//错误信息对应的错误码会存储在errno中
		printf("%s\n", strerror(errno));
		//strerror将错误码对应的错误信息打印出来
	}
	else//开辟空间成功
	{
		//正常使用空间
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	//当动态申请的空间不再使用时，就应该还给操作系统
	free(p);//释放p所指向的动态内存
	p = NULL;//防止p所指向的内容被修改

	return 0;
}

输出结果：

屏幕截图 2022-02-13 201832.png 所以如果我们对申请的内存空间的内容要求初始化，那么就可以很方便的使用calloc函数来完成任务。

2.3 realloc

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

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

ptr表示要调整的内存地址，size为调整之后的新大小，追加成功会返回调整之后的内存起始位置，追加失败则会返回空指针，使用时要强制类型转换，其头文件依旧为#include<stdlib.h>。

例如：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(5 * sizeof(int));
	//开辟20个字节的空间
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
		//使用malloc开辟的20个字节的空间
	}
	//假设这里，20个字节不能满足我们的使用了
	//我们希望能够有40个字节的空间
	//这里就可以使用realloc来调整动态开辟的内存
	int* p2 =(int*) realloc(p, 40);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p2 + i));
	}//打印0 1 2 3 4后出现5个随机值，说明开辟空间成功

	return 0;
}

输出结果：

屏幕截图 2022-02-14 100326.png

但是这样写代码其实会有很大的风险，所以在我们使用realloc函数时要注意：

如果p指向的空间之后有足够的内存空间可以追加，则会直接追加p指向的空间之后的空间，追加后返回p的地址；

如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间，最后返回新开辟的内存空间的地址；

为了防止开辟空间失败，我们得用一个新的指针变量来接受realloc函数的返回值。正确的写法：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(5 * sizeof(int));
	//开辟五个整型的空间
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	//为这五个整型变量赋值
	int* ptr = (int*)realloc(p, 40);
	//开辟的空间不够，使用realloc函数重新开辟空间
	//ptr存放的是开辟的新空间的地址
	if (ptr != NULL)//判断是否开辟成功
	{
		p = ptr;
		//为了防止开辟空间失败(将p赋为空指针)，
                //用一个新的指针变量ptr来接受realloc函数的返回值
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	else
	{
		printf("%s\n", strerror(errno));
	}
	free(p);//释放使用完后的空间
	p = NULL;//将使用完后的空间重新赋为空指针

	return 0;
}

输出结果：

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

错误例子：

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(INT_MAX / 4);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);

	return 0;
}

不能对空指针(NULL)进行解引用

警告：

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

错误例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	//开辟10个整型的空间
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);

	return 0;
}

报错：

屏幕截图 2022-02-14 203706.png

开辟空间时要注意空间是否足够，不够的话可以用我们之前讲的realloc函数来解决。

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

错误例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a = 10;
	int* p = &a;
	free(p);
	//此处的 p 指向的并不是动态开辟的空间的内存地址

	return 0;
}

依旧报错：

屏幕截图 2022-02-14 203706.png 并不是什么情况都要用到free函数

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

错误例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);
	//p不再指向动态内存的起始位置

	return 0;
}

还是会报错：

在使用free函数时，要注意括号中的内容必须为之前开辟的空间的起始地址

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

错误例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放

	return 0;
}

依旧会报错：

为了避免这个问题，我们每次在使用free函数释放完空间之后，可以将起始地址赋值为空指针(NULL)

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

错误例子：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		return;
	}
}
int main()
{
	test();

	return 0;
}

一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。所以一定要切记：动态开辟的空间一定要释放，并且正确释放。

4. 几个经典的笔试题

4.1 题目1：

能否拷贝成功？

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);//动态内存开辟
}

void Test(void)
{
	char* str = NULL;
	GetMemory(str);//值传递
	strcpy(str, "hello  world");//拷贝字符串
	printf(str);

}

int main()
{
	Test();

	return 0;
}

输出结果：

很显然不能，那么原因又是什么呢？

str传给GetMemory函数时是值传递，所以GetMemory函数的形参p算是str的一分临时拷贝。在GetMemory函数内部动态申请空间的地址，存放在p中，不会影响外边的str，所以当GetMemory函数返回之后，str依然是NULL,所以strcpy会拷贝失败。当GetMemory函数用完返回之后，形参p销毁，开辟的这100个字节的空间的地址也就会消失不见，使得动态开辟的100个字节存在内存泄漏，无法释放。那如果我们要让它拷贝成功，又该怎么改呢？代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char* p)
{
	p = (char*)malloc(100);
	return p;//返回动态开辟空间的地址
}

void Test(void)
{
	char* str = NULL;
	str = GetMemory(str);
	strcpy(str, "hello  world");
	printf(str);
	free(str);//释放空间，防止内存泄漏
	str = NULL;
}

int main()
{
	Test();

	return 0;
}

输出结果：

或者用二级指针来改，代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char** p)//二级指针接收
{
	*p = (char*)malloc(100);
	//p为二级指针，*p表示对&str进行解引用
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//传过去的是str的地址
	strcpy(str, "hello  world");
	printf(str);
	//这种写法没问题，括号中的str相当于字符串的首地址
	free(str);//释放空间，防止内存泄漏
	str = NULL;
}

int main()
{
	Test();

	return 0;
}

输出结果：

4.2 题目2：

运行该程序会有什么结果？

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();

	return 0;
}

输出结果：

为什么会是这么奇怪的结果呢？

因为GetMemory函数中的p相当于开辟了一块临时的局部空间来存放"hello world"，而str接收的返回值的是"hello world"的首字符地址，但是当函数使用完毕后，p开辟的那块空间就被自动销毁了，当str再想去访问那块空间的内容时，那些内容已经不见或者被覆盖了，举个通俗点的例子来说，就相当于你去开了一间牌号为301的房，你叫你朋友来住，但是你朋友来找301这间房的时候已经被你退掉了，老板已经将301租给别人了，也就是原来的那块空间的内容不见或者被覆盖了。

因为在栈上开辟空间时，已开辟的空间在出了范围之后都会自动销毁回收，因此这种问题也叫返回栈空间地址的问题。内存空间分配图如下：

4.3 题目3：

该程序有什么问题？

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.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;
}

很简单，没有free释放空间，怎么改我们在第一题就说过了，可以跳回去再看一遍。

4.4 题目4：

该程序能否运行成功？

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.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;
}

答案是不能，因为这叫非法访问，为什么这样说呢？

首先，我们动态内存开辟了100个字节的空间，hello\0确实被拷贝进str里了，这里都没问题，但要注意的是，拷贝完后free函数会将使用过后的100个字节的空间还给操作系统(被释放)，虽然这块空间还在，str也还记得那块空间的地址，但是已经不归str来维护了，当空间释放后，str如果还想去使用那块空间的话，就会被当作非法访问，这时这块空间就不会给str使用了，因此最后的world\0就会拷贝失败。因此我们使用要记住，在使用free函数后一定要将地址制空(空指针)

5. C/C++程序的内存开辟

我们之前讲过，在开辟内存时，总是在栈区、堆区以及静态区这三块空间中开辟的，但其实这种讲法说比较粗糙的，接下来我们将更深入了解内存开辟的规则，首先我们来看一张图：

结合我们上面的那张内存区域划分简图，我们可以更加清晰的了解内存的开辟规则：

栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

代码段：存放函数体（类成员函数和全局函数）的二进制代码。

有了这幅图，我们就可以更好的理解static关键字修饰局部变量的例子了：

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长。

6. 柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

typedef struct st_type1
{
	int a;
	int b[];//柔性数组成员,大小未知
}type_a;

有些编译器会报错无法编译可以改成：

typedef struct st_type2
{
	int a;
	int b[0];//柔性数组成员，大小未知
}type_b;

6.1 柔性数组的特点：

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

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

包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小; 比如说：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
typedef struct S
{
	int a;
	int b[0];//柔性数组成员
}s;

int main()
{  
	//sizeof(s)实际上计算的是int的大小，也就是柔性数组前面的成员的大小
	printf("sizeof(s)= %d\n", sizeof(s));

	return 0;
}

输出结果：

6.2 柔性数组的使用

使用柔性数组时要单独为其开辟空间

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int a;
	int arr[0];//柔性数组成员，大小未知
};

int main()
{  
	//假设我的柔性数组中要放10个整型数据，则应该这样开辟内存
	struct S* pc = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	//用自定义类型struct S*指针来接收开辟的空间的地址
	pc->a = 10;//给a赋值
	//接下来给柔性数组arr赋值
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		pc->arr[i] = i;//为arr的每个成员赋值
	}
	printf("%d\n", pc->a);//输出a的值
	for (i = 0; i < 10; i++)
	{
		printf("%d ", pc->arr[i]);//输出柔性数组arr的值
	}
	free(pc);//释放开辟的空间
	pc = NULL;//防止非法访问

	return 0;
}

输出结果：

屏幕截图 2022-02-17 115155.png

若当空间不够时也可以使用realloc函数来为其开辟更多空间：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int a;
	int arr[0];//柔性数组成员，大小未知
};

int main()
{
	//假设我的柔性数组中要放10个整型数据，则应该这样开辟内存
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	//用自定义类型struct S*指针来接收开辟的空间的地址
	ps->a = 10;//给a赋值
	//接下来给柔性数组arr赋值
	int i = 0;
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	//开辟额外需要的空间
	if (ptr != NULL)
	{
		ps = ptr;
		//若新开辟的空间的地址不为NULL,则将其地址赋值给ps作为新空间的起始地址
	}
        for (i = 0; i < 10; i++)
        {
	        ps->arr[i] = i;
        }
	free(ps);//释放开辟的空间
	ps = NULL;//防止非法访问

	return 0;
}

调试结果：

屏幕截图 2022-02-17 124616.png

6.3 柔性数组的优势

接下来我们来看下面两种写法：写法1：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	int i;
	int a[0];
}type_a;

int main()
{
	//代码1
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	//业务处理
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);

	return 0;
}

写法2：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	int i;
	int* p_a;
}type_a;

int main()
{      
        //代码2
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	//业务处理
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;


	return 0;
}

上述 代码1 和 代码2 可以完成同样的功能，但是 写法1 的实现有两个好处：

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，因此你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。第二个好处是：有利于增加访问速度 连续的内存有益于提高访问速度，也有益于减少内存碎片。

本篇的内容到这里就结束了，如果你觉得对你多少有点帮助的话可以点赞支持一波，咱们下次再见！

C语言中的动态内存管理问题

本章重点

1. 为什么存在动态内存分配

2. 动态内存函数的介绍

2.1 malloc和free

2.2 calloc

2.3 realloc

3. 常见的动态内存错误

3.1 对NULL指针的解引用操作

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

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

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

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

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

4. 几个经典的笔试题

4.1 题目1：

4.2 题目2：

4.3 题目3：

4.4 题目4：

5. C/C++程序的内存开辟

6. 柔性数组

6.1 柔性数组的特点：

6.2 柔性数组的使用

6.3 柔性数组的优势