【C++】内存管理

吗~喽2025-10-29 17:38

文章目录

前言

本文介绍了C/C++程序的内存管理机制，重点分析了内存区域的划分（栈、堆、数据段、代码段等）及其原因（管理效率、安全性、资源利用）。详细对比了C语言的动态内存管理函数（malloc/calloc/realloc/free）与C++的new/delete操作符，强调后者在操作自定义类型时会自动调用构造/析构函数的优势。通过代码示例演示了动态内存的申请、初始化及释放流程，以及要注意内存泄漏的风险。适合新手小白阅读。

在正式讲内存管理之前咱们先来了解一点额外的知识：

  1. 首先我们要知道，每一个C/C++程序，编译、链接好了都是一个一个的可执行程序，如果程序启动起来，它是以一个进程的角度在操作系统之上运行的，当程序加载到内存中时，操作系统会为其分配各种资源（内存、网络...）。
  2. 其次，每一个程序运行起来的进程都有一个叫（虚拟）进程地址空间的东西，虚拟进程地址空间的内存还要跟真实的物理内存进行映射...

C/C++中程序内存区域划分

  1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
    创建共享共享内存，做进程间通信。
  3. 堆用于程序运行时动态内存分配，堆是向上增长的。
  4. 数据段（也叫静态区）--存储全局数据和静态数据。
  5. 代码段（也叫常量区）--可执行的代码/只读常量。

再补充一个小知识：

我们在程序运行过程中，可能需要存储大量对象、动态内存分配需求等等一些原因、或者是在多线程当中，都会在堆上分配内存，所以为了满足不同情况下的内存分配需求，堆空间需要设置得较大，以避免频繁的内存不足错误。

以32位程序为例：

32位系统的CPU一次最多能处理32位数据，其内存空间最大为2^32次方字节（因为有32根地址总线，所以有 2^32 种组合），即4GB，但由于系统本身等因素，实际可使用的内存通常小于4GB。而在32位环境下，堆上的空间要接近 2GB。

为什么要把内存区域划分？

在 C/C++ 中进行内存区域划分主要有以下几个原因：

  1. 管理效率：不同的内存区域有不同的生命周期和使用方式。
  2. 安全性：通过将不同类型的数据存放在不同的区域，可以提高程序的安全性。
  3. 资源利用：合理的内存区域划分有助于更有效地利用系统资源。

总之就是为了更好地管理内存！

C语言动态内存管理方式

C语言中动态内存管理是通过 malloc/calloc/realloc/free 这四个函数来完成的，它们都包含在 stdlib.h 这个头文件中。

malloc

malloc函数是C语言提供的一个动态开辟内存的函数，函数原型如下：

cpp 复制代码 
void* malloc (size_t size);
  1. malloc函数用来向内存申请一块连续可用的空间，并返回指向这块空间的指针，空间大小为size个字节。如果空间开辟失败，则返回NULL指针，所以malloc函数的返回值一定要做检查。
  2. 因为malloc函数的返回值是void*，所以malloc函数在具体使用的时候由使用者自己决定。
  3. 如果参数size为0，那么malloc函数的行为是标准未定义的，取决于编译器。

例如申请一个 int 大小的空间：

cpp 复制代码 
int* ptr = (int*)malloc(sizeof(int));

free

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

cpp 复制代码 
void free (void* ptr);
  1. free函数用来释放动态开辟的内存，如果参数ptr是NULL指针，那么什么都不做。
  2. 如果参数ptr指向的不是动态开辟的空间，那么free函数的行为也是标准未定义的。

举例：申请 n 个整型大小的空间，然后对每个空间赋值，最后打印、释放内存。

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int n = 0;
	scanf("%d", &n);

	// 申请 n 个整型大小的空间
	int* ptr = (int*)malloc(n * sizeof(int));

	// 判断 ptr是否为空
	if (ptr == NULL)
	{
		printf("申请空间失败！");
	}

	for (int i = 0; i < n; i++)
	{
		*(ptr + i) = i;
	}
	
	for (int i = 0; i < n; i++)
	{
		printf("%d ", *(ptr + i));
	}
	printf("\n");

	// 释放 ptr 指向的动态内存
	free(ptr);

	// 将 ptr 置为空
	ptr = NULL;

	return 0;
}

运行截图：

calloc

calloc函数是C语言提供的另一个动态开辟内存的函数，函数原型如下：

cpp 复制代码 
void calloc (size_t num, size_t size);
  1. calloc函数的功能是为 num 个大小为 size 的元素开辟一块空间。
  2. 和malloc函数相比，calloc函数不仅会开辟内存，还会在返回地址之前把申请的空间的每个字节都初始化为 0。
  3. 如果空间开辟失败也会返回NULL指针。

例如我们申请 10 个整型

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* ptr = (int*)calloc(10, sizeof(int));
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	printf("\n");
	return 0;
}

输出结果：

realloc

realloc函数可以对动态开辟的内存进行大小的调整，让动态内存管理更加灵活，函数原型如下：

cpp 复制代码 
void realloc (void* ptr, size_t size);
  1. ptr 是要调整的内存地址。
  2. size 是调整之后的空间大小。
  3. 返回值为调整之后的内存起始位置。
  4. 如果空间开辟失败同样会返回NULL指针。

realloc函数在调整内存空间时有两种情况：

  1. 原有空间之后有足够大的空间，这个时候要扩展内存，在原有内存之后直接追加空间，原来空间的数据不会发生变化。
  2. 原有空间之后没有足够大的空间，这个时候扩展内存，要在堆上另找一个合适大小的连续空间来使用，这种情况函数返回的是一个新的内存地址。

举例：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* ptr = (int*)malloc(100 * sizeof(int));

	// 判断 ptr是否为空
	if (ptr == NULL)
	{
		printf("申请空间失败！");
		return 1;
	}
	else
	{
		// 业务处理
	}

	// 扩展容量

	// 代码1
	// int* ptr = (int*)realloc(ptr, 1000 * sizeof(int));

	// 代码2
	int* p = (int*)realloc(ptr, 1000 * sizeof(int));
	if (p != NULL)
	{
		ptr = p;
	}
	// 业务处理

	free(ptr);
	return 0;
}

一般我们在使用realloc函数的时候，它的返回值有可能是空指针，所以直接用 ptr接收就有可能因为调整失败将 ptr 改成空指针，从而引起内存泄漏的问题。所以代码2的写法要更好！

C++动态内存管理方式

C语言的动态内存管理方式在C++中可以继续使用，但在某些方面无能为力，且使用起来比较麻烦，尤其是在处理类时，不能很好地满足需求，所以C++提出新的内存管理方式 new和delete操作符进行动态内存管理。
new用于申请内存，delete用于释放内存。

new/delete操作内置类型

cpp 复制代码 
#include <iostream>
using namespace std;

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr1 = new int;

	// 动态申请一个int类型的空间并初始化为10
	int* ptr2 = new int(10);

	delete ptr1;
	delete ptr2;


	// 动态申请10个int类型的空间，未初始化
	int* ptr3 = new int[10];

	// 申请10个int类型的空间，初始化为0
	int* ptr4 = new int[10] {};

	// 前三个元素为1, 2, 3，后两个为0
	int* ptr5 = new int[10] { 1, 2, 3 };

	// 申请10个int类型的空间，依次初始化
	int* ptr6 = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	delete[] ptr3;
	delete[] ptr4;
	delete[] ptr5;
	delete[] ptr6;

}

int main()
{
	Test();
	return 0;
}

调试一下看看结果：

  1. 调试之前
  1. 先来看 ptr1 和 ptr2 的
  1. 再看看剩下的几个

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。

new/delete操作自定义类型

new/delete 和 malloc/free 最大的区别在于：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free则不会。

cpp 复制代码 
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* ptr1 = (A*)malloc(sizeof(A));
	A* ptr2 = new A(2);

	free(ptr1);
	delete ptr2;

	return 0;
}

调试看看：

  1. 刚开始
  1. 为 ptr1 开辟空间
  1. 为 ptr2 开辟空间
  1. 释放 ptr1 指向的空间
  1. 释放 ptr2 指向的空间
  1. 程序最后运行结果

operator new与operator delete函数（重点）

new和delete是用户进行动态内存申请和释放的操作符，而operator new 和 operator delete是系统提供的全局函数，new在底层调用operator new函数来申请空间，delete在底层通过operator delete函数来释放空间。

  1. operator new 实际也是通过 malloc 来申请空间，如果 malloc 申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。（异常部分咱还没学，这个简单了解就行）
  2. operator delete 是通过 free 来释放空间的。

new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：

new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

  • new的原理

    1. 调用operator new函数申请空间

    2. 在申请的空间上执行构造函数，完成对象的构造

  • delete的原理

    1. 在空间上执行析构函数，完成对象中资源的清理工作

    2. 调用operator delete函数释放对象的空间

  • new T[N]的原理

    1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

    2. 在申请的空间上执行N次构造函数

  • delete[]的原理

    1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

    2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

这里再补充一点：

对于自定义类型，new[]通常会在动态开辟的空间头上多开 4 个字节的空间，用来存储我们开辟空间的数据个数，这个数据个数是给 delete[] 用的（注意不是给我们用的），因为当使用 delete[] 释放该连续空间时，系统需要知道要调用多少次析构函数。而如果是内置类型则不需要调用构造函数和析构函数

cpp 复制代码 
#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* ptr1 = new A[5];

	int* ptr2 = new int[5];

	delete[] ptr1;
	delete[] ptr2;

	return 0;
}

来看这段程序的调试结果：

可以看到，在 ptr1 前面的 4 个字节中确实是5，我们也可以看看 ptr2 前面的 4 个字节中有什么

从图片当中我们看到，ptr2 前面的 4 个字节中并不是 5。

那如果我们把析构函数屏蔽了结果还会是这样吗？

cpp 复制代码 
#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* ptr1 = new A[5];

	int* ptr2 = new int[5];

	delete[] ptr1;
	delete[] ptr2;

	return 0;
}

继续调试看看结果：

我们看到，ptr1 前面的 4 个字节中并不是 5，和之前的不一样了。这主要是因为编译器默认生成的析构函数对内置类型不做处理，所以不会对开 4 个字节，编译器在这里做了优化。那如果是指针类型指向了资源的话，我们就得自己显示写析构函数了，因为指针也是内置类型，编译器默认生成的析构函数就不符合我们的要求！

定位new表达式(placement-new) （了解）

一般在类和对象中，析构函数我们是可以显示调用的，但是构造函数不行。而定位new表达式却可以让我们在已分配的原始内存空间中（未初始化的空间）调用构造函数初始化一个对象。

使用格式：
new (place_address) type或者new (place_address) type(initializer-list)

这里place_address必须是一个指针，initializer-list是类型的初始化列表

在那里用？

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定位表达式进行显示调构造函数进行初始化。

这里简单演示一下用法：

cpp 复制代码 
#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}

	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* ptr1 = (A*)operator new(sizeof(A));
	new(ptr1)A;
	
	A* ptr2 = (A*)operator new(sizeof(A));
	new(ptr2)A(10);

	ptr1->~A();
	operator delete(ptr1);

	ptr2->~A();
	operator delete(ptr2);

	return 0;
}

打个断点调试一下：

  1. 刚开始
  2. 执行完定位new表达式之后
  3. 执行完所有语句之后

程序最后的运行结果：

malloc/free和new/delete的比较

共同点：

malloc/free和new/delete都是从堆上申请空间，并且需要用户手动释放。

不同点：

  1. malloc和free是函数，new和delete是操作符
  2. malloc申请的空间不会初始化，new可以初始化
  3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，在[]中指定对象个数即可
  4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后面跟的是空间的类型
  5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new申请空间失败需要捕获异常
  6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理释放

完！

相关推荐
上去我就QWER3 小时前
解锁Qt元对象系统：C++编程的超强扩展
c++·qt
freedom_1024_3 小时前
【c++ qt】QtConcurrent与QFutureWatcher：实现高效异步计算
java·c++·qt
minji...4 小时前
C++ 模板进阶
开发语言·c++
AC是你的谎言4 小时前
c++仿muduo库实现高并发服务器--connection类
linux·服务器·c++·学习
fantasy5_54 小时前
手写一个C++字符串类：从底层理解String的实现
java·jvm·c++
江塘5 小时前
机器学习-KNN算法实战及模型评估可视化(C++/Python实现)
开发语言·c++·人工智能·python·算法·机器学习
KL41805 小时前
【QT】窗口
c++·qt
艾莉丝努力练剑5 小时前
【C++：继承和多态】多态加餐：面试常考——多态的常见问题11问
开发语言·c++·人工智能·面试·继承·c++进阶
Skrrapper5 小时前
【C++】C++11出来之后，到目前为止官方都做了些什么更新？
开发语言·c++
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Labelme从安装到标注：零基础完整指南09jdk21下载、安装（Windows、Linux、macOS）10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）