动态内存管理

目录

1. 为什么要有动态内存分配

2. malloc 和 free

2.1 malloc

2.2 free

3. calloc 和 realloc

3.1 calloc

3.2 realloc

4. 常见动态内存的错误

4.1 对NULL指针的解引用操作

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

4.3 对非动态开辟内存使用free释放 或 对同一块空间释放两次

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

4.5 对同一块空间释放两次

4.6 忘记释放开辟的动态内存 或 在释放前返回

4.6.1 忘记释放开辟的动态内存

4.6.2 在释放前返回

---

1. 为什么要有动态内存分配

我们已经掌握的内存开辟方式为创建变量去开辟空间。

但是这种开辟空间的方法有两个特点：

1. 空间开辟大小是固定的 。
2. 数组声明的时候，必须指定数组长度，且数组大小一旦确定就无法调整。

但是有时候会出现所需空间远小于数组空间的大小，导致大量空间的浪费；或者是所需空间大于数组空间的大小，无法存入数据这两种情况，那么使用数组的我们就会处于尴尬的境地。

所以C语言引入了动态内存开辟，可以自由申请和释放空间，就比较灵活了。

2. malloc 和 free

2.1 malloc

void* malloc (size_t size);

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

• 如果开辟成功，则返回一个指向该空间的指针
• 如果开辟失败，则返回一个NULL指针
• 返回类型是void*，所以在使用前要根据自身需求强制转换返回值
• 如果size为0，malloc的行为标准是未定义的，取决于编译器

2.2 free

void free (void* ptr);

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

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么都不做。

#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请20个字节的空间
	int* p = (int*)malloc(5 * sizeof(int));
	
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用该空间
	int i = 0;
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

    //释放空间
    free(p);
    p = NULL;

	return 0;
}

注意p的值不适合++，因为free（p）释放的是从p开始的空间内存，这会导致内存的浪费。

3. calloc 和 realloc

3.1 calloc

void* calloc(size_t num, size_t size);

• 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节都初始化为0.
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0

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

	return 0;
}

3.2 realloc

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

• ptr 是要调整的内存地址
• size 是调整后的大小
• 返回值为调整之后的起始内存
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间
• realloc在调整内存空间时存在三种情况：
  情况1：原有空间之后有足够大的空间：
  此时会将后面的空间补至调整后的空间大小，再返回调整前的地址
  
  情况2： 原有空间之后没有足够大的空间：
  1. 找一块空间足够大的内存空间，申请一块调整后大小的空间
  2. 再将原来空间的数据拷贝一份到新空间
  3. 释放旧的空间
  4. 返回新的内存空间的起始地址
  
  情况3：调整失败了，返回的是NULL

因为realloc会出现调整大小失败的情况，所以不建议直接用p去接受函数返回值，而是新创建一个 ptr 指针，在判定返回值不为NULL时，将 ptr 的值赋值给 p 。

#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请20个字节的空间
	int* p = (int*)malloc(5 * sizeof(int));

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用该空间
	int i = 0;
	for (int i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

	//将空间调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)
	{
		p = ptr;
		for (int i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
	}
	else
	{
		perror("realloc");
	}

	free(p);
	p = NULL;

	return 0;
}

4. 常见动态内存的错误

4.1 对NULL指针的解引用操作

也就是上面讲的 realloc 函数返回NULL的情况，这里不再讲述

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

正如数组越界一样，动态开辟的空间也会有越界访问的问题。

当你申请了十个整型大小的空间，利用循环赋值时却使用了for(int i = 0; i <= 10; i++)这样的操作，那么就会导致越界访问的问题。因该情况与数组越界访问过于相似，这里也不做过多解释

4.3 对非动态开辟内存使用free释放 或 对同一块空间释放两次

int main()
{
	int a;
	int* p = &a;
	free(p);
	
	return 0;
}

因为 a 变量是在栈上开辟的空间，而 free 函数释放的是堆上面的空间，所以该情况错误

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

也就是上面说的p++的问题，p的值改变会使p指针指向动态内存的非起始位置，此时使用free会导致释放空间不完全，也就出现了所谓的内存泄漏问题。

4.5 对同一块空间释放两次

int main()
{
	int a;
	int* p = (int*)malloc(40);
	free(p);
	free(p);
	return 0;
}

相当于对野指针进行操作，肯定也是错误的

4.6 忘记释放开辟的动态内存 或 在释放前返回

4.6.1 忘记释放开辟的动态内存

内存泄漏问题

4.6.2 在释放前返回

void test()
{
	int* p = (int*)malloc(100);

	int n = 3;
	if (n > 3)
		return;

	free(p);
	p = NULL;
}