C语言笔记（动态内存管理）-CSDN博客

本文链接：https://blog.csdn.net/XNewP/article/details/148893417

（一）为什么要有动态内存分配

1、变量和数组的方式不够灵活。

2、使用动态内存分配可以自己来维护内存的使用生命周期。

int main()
{
	//创建变量的本质是向内存申请空间
	//1.
	int a = 10;//申请4个字节的空间
	//2
	int arr[10];//申请一块连续的空间——40个字节
	//不够了？能变大吗？不能
	//太多了？能变小吗？不能
	int math[30];//20人，10个空间浪费了，35人，不够

	return 0;
}

上述给出的代码开辟空间的方式有两个特点：

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

2、数组在声明的时候，必须指定数组的⻓度，数组空间⼀旦确定了大小不能调整。

而有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了，因此C语言引入了动态内存开辟，让程序员自己可以申请和释放内存。

（二）malloc 和 free

2.1 malloc

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

void malloc(size_t size);

如果开辟成功，则返回⼀个指向开辟好空间的指针。
如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。

下面给出malloc函数应用的例子，即申请40个字节的内存空间，用来存放10个整数并打印出来：

#include <stdlib.h>
int main()
{
	//申请40个字节的内存空间，存放10个整数
	//申请内存
	int* p = (int*)malloc(40);//malloc返回的是void*类型指针，需要强制转换为int*类型指针
	if (p == NULL)
	{
		perror("malloc");//malloc:xxxxxxxx
		return 1;//申请内存失败返回
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;//给每个元素赋值
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));

	}
	//释放内存
	return 0;//正常返回
}

上述为VS最终打印出来的结果。（注意一下perror函数会帮助返回错误信息）

2.2 free

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

void free(void* ptr);

free函数用来释放动态开辟的内存。

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

如果函数p是NULL指针，则函数什么事都不。

[注] malloc 和 free 函数声明都在stdlib.h头文件中。

下面给出例子：

int main()
{
	//申请40个字节的内存空间，存放10个整数
	//申请内存
	int* p = (int*)malloc(40);//malloc返回的是void*类型指针，需要强制转换为int*类型指针
	if (p == NULL)
	{
		perror("malloc");//malloc:xxxxxxxx
		return 1;//申请内存失败返回
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;//给每个元素赋值
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));

	}
	//释放内存
	free(p);//释放p所指的动态内存
	p = NULL; //防止野指针
	return 0;//正常返回
}

需要注意的是：

(三)calloc 和realloc

3.1 calloc

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

void* calloc(size_t num, size_t size);

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

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

3.2 realloc

1、realloc函数的出现让动态内存管理更加灵活。

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

realloc函数原型如下：

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

• ptr 是要调整的内存地址。
• size 调整之后新⼤小。
• 返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
• realloc在调整内存空间的是存在两种情况（如下图）：

注意：realloc函数在调整内存空间的时候，有可能失败，失败的时候返回的是NULL指针！

int main()
{
	//申请5个整型空间
	int* p = (int*)malloc(5*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");//malloc:xxxxxxxx
		return 1;//申请内存失败返回
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

	//空间不够，希望存放1～10
	//申请更多的空间——调整空间
	int* ptr = (int*)realloc(p, 10 * sizeof(int));//调整p所指的动态内存空间大小为10个整型空间

	if (ptr != NULL)
	{
		p = ptr;//将ptr的地址赋值给p，p指向新的动态内存空间
	}
	else
	{
		perror("realloc");
		return 1;//调整内存失败返回
	}
	for (i = 5; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	free(p);//释放内存
	p = NULL; //防止野指针

	return 0;//正常返回
}

（四）常见的动态内存错误

4.1对NULL指针的解引用操作

例如：

int main()
{
	int* p = (int*)malloc(40);
	malloc函数开辟空间失败时返回NULL
	//if (p == NULL)
	//{
	//	perror("malloc");//malloc:xxxxxxxx
	//	return 1;//申请内存失败返回
	//}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}

	free(p);
	p = NULL;
	return 0;
}

4.2 对动态开辟内存的越界访问

对上面代码稍加修改给出这个例子：

即将for循环中 i < 10 修改为 i <= 10

通过调试查看内存，正常内存写入到0a结束，这次却持续写入到0b，最终vs报错并提示（CRT detected that the application wrote to memory after end of heapbuffer.）意思是CRT检测到应用程序在堆缓冲区结束后写入内存，即“越界访问”。

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

来看一个例子：

需要注意对非动态开辟的内存使用free也会导致内存错误。

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

比如如下图中例子所示：

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

见下图例子：

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	
	int i = 0;
	//给前20个字节放 1 2 3 4 5
	for (i = 0; i < 5; ++i)
	{
		*(p + i) = i + 1;
		p++;
	}
	free(p);
	//p就是野指针
	p = NULL;//将p置为NULL，防止野指针

	//.........


	free(p);//free的参数如果是NULL，则什么都不做。
	p = NULL;
	return 0;//正常返回
}

需要注意的是，使用free函数时最好一并将空指针NULL赋值给p (即p = NULL)，否则p是野指针，多次释放程序会出现错误。

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

下面看一个内存泄漏的例子：

void test()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return;
	//使用
	int flag = 0;
	scanf("%d", &flag);//0
	if (flag == 0)
		return;

	//释放
	free(p);
	p = NULL;
}

int main()
{
	test();
	//
	return 0;

}

这个例子中可以看出当 flag 等于 0 时，系统判定为真，直接return，此时跳过了后续free函数释放内存，等到整个程序结束，这部分内存地址既没有被释放，也找不到这部分内存的地址，因此相当于这部分内存被白白占用，造成内存泄漏，而且这也是最常见的动态内存错误，需要格外注意！