高阶C语言|动态内存管理

💬 欢迎讨论：在阅读过程中有任何疑问，欢迎在评论区留言，我们一起交流学习！
👍 点赞、收藏与分享：如果你觉得这篇文章对你有帮助，记得点赞、收藏，并分享给更多对C语言感兴趣的朋友

---

动态内存管理在 C/C++ 编程中的重要性

在编程中，内存管理是非常重要的，尤其是在 C/C++ 语言中。正确的内存管理能显著提高程序的效率和稳定性。动态内存分配是其中一个至关重要的概念，它能使程序在运行时灵活地分配和管理内存资源。在本篇博客中，我们将探讨 C/C++ 中的动态内存管理，包括常用的内存分配函数、常见错误以及如何避免内存泄漏等问题。

---

为什么需要动态内存管理？

在 C/C++ 中，内存分配有两种主要方式：静态内存分配 和 动态内存分配。

• 静态内存分配：例如，局部变量和数组在栈上分配的内存，它们的大小在编译时就已经确定。栈内存的优点是分配速度快，但它的缺点是内存容量有限，并且无法在运行时动态改变大小。

• 动态内存分配：通过动态分配内存，程序能够在运行时根据实际需求分配内存空间。这种方式的优点是更加灵活，能够有效应对内存需求不确定的情况，如处理不确定大小的数据集合等。

动态内存分配需要我们手动管理内存，包括申请和释放内存。C/C++ 提供了一些内存分配函数，如 malloc、calloc、realloc 和 free，它们帮助程序员在堆区（heap）上分配内存。

---

动态内存函数

malloc和free

动态内存开辟函数：

void* malloc (size_t size);

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

• 如果开辟成功，则返回一个指向开辟好空间的指针。
  如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{
	perror("malloc");
}

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

动态内存的释放和回收函数：

void free (void* ptr);
ptr = NULL;//与free配套使用,避免野指针

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

malloc和free都声明在 stdlib.h 头文件中。

例子：

#include <stdio.h>
int main()
{
	//代码1
	int num = 0;
	scanf("%d", &num);
	int arr[num] = {0};
	//代码2
	int* ptr = NULL;
	ptr = (int*)malloc(num*sizeof(int));
	if(NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for(i=0; i<num; i++)
		{
			*(ptr+i) = 0；
		}
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//与free配套使用,避免野指针
	return 0;
}

注意：malloc与free一定要配套使用，否则会出现内存泄漏的问题（动态开辟的内存需要释放）

calloc

动态内存开辟并初始化函数：

void* calloc (size_t num, size_t size)

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

举个例子:

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int *p = (int*)calloc(10, sizeof(int));
	if(NULL != p)
	{
	//使用空间
	}
	free(p);
	p = NULL;
	return 0;
}

![[Pasted image 20250210105717.png]]

realloc

动态内存大小调整函数：

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

• ptr是要调整的内存地址
• size调整后的大小
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。

返回值：

• 如果成功，返回新分配的内存块的指针
• 如果失败，返回NULL，原始的内存块保持有效。

调整内存空间存在两种情况

情况1

原有空间之后有足够大的空间

要扩展的内存直接在原有空间之后追加

情况2

原有空间之后没有足够大的空间

在堆空间上另找一个合适大小的连续空间来使用，函数返回一个新的内存地址

#include <stdio.h>

int main()
{
	int *ptr = (int*)malloc(100);
	if(ptr = NULL)
	{
		perror("malloc");
		return 1;
	}
	ptr = (int*)relloc(ptr,1000);
	if(ptr = NULL)
	{
		perror("realloc");
		return 1;
	}
	free(ptr);
	ptr = NULL;
	return 0;
	}

---

常见的动态内存错误

对NULL指针的解引用操作

void test()
{
	int *p = (int *)malloc(INT_MAX/4);
	*p = 20;//如果p的值是NULL，就会有问题
	free(p);
}

开辟动态内存空间一定要检查是否开辟成功，否则就会出现对NULL指针解引用的操作

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

void test()
{
	int i = 0;
	int *p = (int *)malloc(10*sizeof(int));
	if(NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for(i=0; i<=10; i++)
	{
		*(p+i) = i;//当i是10的时候越界访问
	}
	free(p);
}

注意malloc等等函数开辟空间单位是字节，切忌当做是元素个数

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

void test()
{
	int a = 10;
	int *p = &a;
	free(p);
}

会报错，free只能释放动态内存

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

void test()
{
	int *p = (int *)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置
}

这里我们要注意：

我们给p++的同时指向这一内存的指针一直在变化

  我们最后free（p）时p指向的不是内存的初始位置，所以我们开辟的这块空间并不能完全释放，会造成内存泄漏。

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

void test()
{
	int *p = (int *)malloc(100);
	free(p);
	free(p);//重复释放
}

**注意：**一块空间只能释放一次

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

void test()
{
	int *p = (int *)malloc(100);
	if(NULL != p)
	{
		*p = 20;
	}
}

int main()
{
	test();
	while(1);
}

注意：忘记释放不再使用的动态开辟的空间会造成内存泄漏。

切记：动态开辟的空间一定要释放，并且正确释放。

---

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

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码

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

---

柔性数组

结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
	//有些编译器会报错无法编译可以改成a[]
}type_a;

柔性数组特点

• 结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof 返回的这种结构大小不包括柔性数组的内存。
• 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

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);

柔性数组的优势

当然，柔性数组的作用用其他方式也可以实现

如：

typedef struct st_type
{
	int i;
	int *p_a;
}type_a;
type_a *p = (type_a*)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
for(i=0; i<100; i++)
{
	p->p_a[i] = i;
}
//释放空间
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;

但是用柔性数组有两个好处

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

结构体的内存以及其成员要的内存一次性分配好，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

**第二个好处是：**这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。

---

总结

动态内存管理为 C/C++ 程序提供了极大的灵活性，可以帮助开发者根据程序的需要动态分配和释放内存。然而，动态内存管理的错误使用会导致许多问题，如内存泄漏、悬挂指针、内存越界等。因此，开发者需要小心谨慎，确保每一块动态分配的内存都被正确管理。掌握动态内存管理的技巧将有助于提高程序的性能和可靠性。

---

希望这篇博客能够帮助你理解和掌握 C/C++ 中的动态内存管理。如果你有任何问题，欢迎留言讨论！