【C++】内存管理

进击的_鹏2024-12-06 13:40

目录

前言

一、C++内存管理方式

[二、operator new与operator delete函数](#二、operator new与operator delete函数)

三、new和delete的实现原理

四、定位new表达式(placement-new)

五、malloc/free和new/delete的区别

总结

前言

本文主要讲述C++上是如何申请空间并销毁的，了解其底层原理。并与C语言的内存管理进行比较。

一、C++内存管理方式

  • C语言内存管理方式在 C++ 中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
  • C++申请空间与C语言一样，都是在堆上申请空间。

C/C++程序内存区域划分简要说明：

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

操作符：

  1. new：申请空间
  2. delete：释放空间

语法演示：

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

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

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

	//动态申请3个int类型的空间
	int* ptr3 = new int[3];

	//动态申请3个int类型的空间并初始化（c++11支持）
	int* ptr4 = new int[3] {1, 2, 3};

	//不完全初始化其余的会被初始化为0
	int* ptr5 = new int[3] {0};
	int* ptr6 = new int[3] {1};

	delete ptr1;
	delete ptr2;

    //释放连续空间需要加上[]
	delete[] ptr3;
	delete[] ptr4;
	delete[] ptr5;
	delete[] ptr6;

	return 0;
}

监视窗口：

  • 以上对于内置类型内存管理，C++相比C语言的来说可以不用强制类型转化，其余的可能区别不大。但是c++的new和delete对于自定义类型来说，比C语言的方便了很多：

对于申请自定义类型空间：

  • C语言的malloc：仅申请空间。
  • C++的new：（先）申请空间 +（后）自动调用类对象的构造函数。

对于释放自定义类型空间：

  • C语言的free：仅释放空间。
  • C++的delete：（先）自动调用类对象的析构函数 +（后）释放空间

演示：

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

class A
{
public:
	//默认构造
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << this << endl;
	}
	//析构
	~A()
	{
		cout << "~A()" << this << endl;
	}

private:
	int _a;
};

int main()
{
	//malloc：仅申请空间
	A* p1 = (A*)malloc(sizeof(A));

	//mew：申请空间+构造函数
	A* p2 = new A(2);//支持给带参构造传参
	A* p3 = new A;//可以不传参，需要有默认构造

	//free：仅释放空间
	free(p1);

	//delete：析构函数+释放空间
	delete p2;
	delete p3;

	return 0;
}

运行结果：

对于申请连续型空间：

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

class A
{
public:
	//默认构造
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << this << endl;
	}
	//析构
	~A()
	{
		cout << "~A()" << this << endl;
	}

private:
	int _a;
};

int main()
{
	//申请自定义类型数组空间
	A* p1 = new A[6];

	A aa1;
	A aa2(1);
	//同样支持初始化
	A* p2 = new A[6]{ aa1,aa2,1,2,3 };//后面3个是涉及隐式类型转换

	delete[] p1;
	delete[] p2;

	return 0;
}

运行结果：

**C++的内存管理优势举例：**对比C语言实现链表

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

//C++中class和struct基本相同，只有细微区别
typedef struct SListNode
{
public:
	SListNode(int n = 0)
		:_next(nullptr)
		,_val(n)
	{}

private:
	SListNode* _next;//C++里类型名前不用加上struct
	int _val;
}SLTNode;

int main()
{
	//比如申请结点就很方便
	SLTNode* p1 = new SLTNode(1);
	SLTNode* p2 = new SLTNode(2);
	SLTNode* p3 = new SLTNode(3);
	SLTNode* p4 = new SLTNode(4);

	delete p1;
	delete p2;
	delete p3;
	delete p4;

	return 0;
}

**优势：**相比于C语言不用专门写个申请结点的函数

二、operator new与operator delete函数

在了解new和delete原理之前，我们先了解这两个函数

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

（注意：当我们看到operator时，可能以为这是new和delete这两个运算符的重载，其实不然，这就是两个全局的库函数）

1. operator new：

  • operator new：该函数实际通过 malloc 来申请空间，当 malloc 申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。
  • 简单来说：operator new 其实就是对 malloc 的一种封装

我们可以看下 operator new 的源码：

cpp 复制代码 
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
    // try to allocate size bytes
    void *p;
    while ((p = malloc(size)) == 0)
        if (_callnewh(size) == 0)
        {
            // report no memory
            // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
            static const std::bad_alloc nomem;
            _RAISE(nomem);
        }
    return (p);
}

解释：

  1. 从以上 p = malloc(size) 就不难看出该函数就是对 malloc 的一种封装
  2. operator new 与 malloc 最大的不同就是：malloc申请失败返回0(NULL)，operaor new 申请失败会抛出异常。
  3. 异常目前无法展开来讲，在后面C++进阶会有讲

2. operator delete：

  • operator delete: 该函数最终是通过free来释放空间的

operator delete的源码：

cpp 复制代码 
void operator delete(void *pUserData)
{
    _CrtMemBlockHeader * pHead;

    RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));

    if (pUserData == NULL)
        return;

    _mlock(_HEAP_LOCK);  /* block other threads */
    __TRY

    /* get a pointer to memory block header */
    pHead = pHdr(pUserData);

    /* verify block type */
    _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));

    _free_dbg( pUserData, pHead->nBlockUse );
    __FINALLY

    _munlock(_HEAP_LOCK);  /* release other threads */
    __END_TRY_FINALLY

    return;
}

/*
free的实现
*/

#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

看不懂没关系，因为我目前也看不太懂

稍微了解下：

  • _free_dbg( pUserData, pHead->nBlockUse )这个函数，其实就是free，根据最后一段宏#define free(p) _free_dbg(p, _NORMAL_BLOCK)就能得出
  • 我们了解 operator delete 是对 free 的一种封装即可

operator new 和 operator delete 可以直接使用，毕竟是系统提供的全局函数：

不过其与 malloc 和 free 效果差不多，只不过operator new失败不是返回某一个值，而是抛出异常

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

class A
{
public:
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	//不会调用构造，但失败会抛出异常
	A* p1 = (A*)operator new(sizeof(A));

	//不会调用析构
	operator delete(p1);

	return 0;
}

小结：

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施 就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

C++这里为啥要设计成抛异常? 如果我们有了解 python java 等语言就知道，它们都有异常这个概念，算是面向对象语言的特性，具体学到后面就能理解了。

三、new和delete的实现原理

1.内置类型

  • 如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是： new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申 请空间失败时会抛异常，malloc会返回NULL。

2.自定义类型

（1）new的原理：

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

查看反汇编验证：

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

class A
{
public:
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p1 = new A(1);

	delete p1;

	return 0;
}

new的反汇编：

解释：

  • 这两条call指令就是调用 operator new 函数和 A类的构造函数

（2）delete的原理

  1. 在空间上执行析构函数，完成对象中资源的清理工作
  2. 调用operator delete函数释放对象的空间

继上段代码查看 delete的反汇编：

这条call指令调用的析构其实是对原本的析构进行了一些封装，跳两层：

这里看到的两条 call 指令就是调用 A类的析构函数 和 operator delete 函数

（3）new T[N]的原理

  1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对 象空间的申请
  2. 在申请的空间上执行N次构造函数

调试代码：

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

class A
{
public:
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p1 = new A[10];

	delete[] p1;

	return 0;
}

查看 new[] 的反汇编：

连续跳转就能看到这两条指令调用的就是 operator new 和 A()：

（4）delete[]的原理

  1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
  2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释 放空间

delete[] 的反汇编：

3.演示异常：

**例：**32位环境下大量申请空间引发异常：

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

void Func()
{
	//申请大量连续空间
	int* p1 = new int[1024 * 1024 * 100];
	cout << p1 << endl;
	int* p2 = new int[1024 * 1024 * 100];
	cout << p2 << endl;
	int* p3 = new int[1024 * 1024 * 100];
	cout << p3 << endl;
	int* p4 = new int[1024 * 1024 * 100];
	cout << p4 << endl;
	int* p5 = new int[1024 * 1024 * 100];
	cout << p5 << endl;
}

int main()
{
	//尝试，出现异常执行catch中代码
	try
	{
		Func();
	}
	catch (const exception& e)//捕获异常
	{
		cout << e.what() << endl;//显示异常
	}

	return 0;
}

解释：

  1. Func 函数中申请大量空间，1024字节 = 1kb，1024kb = 1mb，100*4 = 400mb（因为int是4字节），因此每一次申请400mb，在32位下能够申请的空间有限只有2G多左右，因此绝对会失败，new 在申请失败后就会抛出异常。
  2. 主函数中的 try -- catch 就是捕获异常

运行结果：

第五次申请时失败了，抛出了异常。

注意： 因为 new 是对 operatot new 的又一层封装，因此实际抛出异常的是 operator new 这个全局函数

四、定位new表达式(placement-new)

这里只做简单了解

概念：

  • 定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
    使用格式：

  • new (place_address) type或者new (place_address) type(initializer-list) place_address必须是一个指针，initializer-list是类型的初始化列表

简单演示：

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

class A
{
public:
	A(int n = 0)
		:_a(n)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	//这样申请的空间不会调用构造函数初始化
	A* p1 = (A*)operator new(sizeof(A));

	//C++不支持显示调用构造
	//p->A()
	new(p1)A(1);//因此定位new起到了作用

	//析构支持显示调用
	p1->~A();

	operator delete(p1);

	return 0;
}

监视窗口：

当然实际上我们不会这样去申请空间，我们还是使用更方便 new 和 delete ，这里只是了解。

而定位new真正的使用场景是：

  • 定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
    **内存池：**以现在基础只能简单了解，内存池就是顾名思义是需要内存直接去取就行的一处池子，内存池是已经在堆上申请好了的一块内存空间。当我们需要频繁申请空间时，由于堆一次只能响应一处申请，因此会出现效率问题，而内存池就是解决频繁申请空间而产生的效率问题。直接拿已经申请好的空间使用效率肯定好些。但是这里又衍生出一个问题，就是这些空间都没有初始化，而C++又不支持显示调用构造初始化，因此定位new的存在就是解决这个问题，定位new配合内存池就能解决初始化的问题，并且效率高。

五、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在释放空间前会调用析构函数完成 空间中资源的清理释放

总结

以上就是本文的全部内容，感谢支持！

相关推荐
背太阳的牧羊人25 分钟前
RAG检索中使用一个 长上下文重排序器（Long Context Reorder） 对检索到的文档进行进一步的处理和排序，优化输出顺序
开发语言·人工智能·python·langchain·rag
ITPUB-微风27 分钟前
美团MTSQL特性解析：技术深度与应用广度的完美结合
java·服务器·开发语言
Smile丶凉轩29 分钟前
数据库面试知识点总结
数据库·c++·mysql
Want59538 分钟前
C/C++跳动的爱心
c语言·开发语言·c++
水瓶丫头站住38 分钟前
Qt中QDockWidget的使用方式
开发语言·qt
laimaxgg44 分钟前
Qt常用控件之数字显示控件QLCDNumber
开发语言·c++·qt·qt5·qt6.3
蓝天扶光1 小时前
c++贪心系列
开发语言·c++
Alidme1 小时前
cs106x-lecture14(Autumn 2017)-SPL实现
c++·学习·算法·codestepbystep·cs106x
奔跑吧邓邓子1 小时前
【Python爬虫(44)】分布式爬虫：筑牢安全防线，守护数据之旅
开发语言·分布式·爬虫·python·安全
小王努力学编程1 小时前
【算法与数据结构】单调队列
数据结构·c++·学习·算法·leetcode
热门推荐
01太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04本地部署DeepSeek教程（Mac版本）05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06DeepSeek本地部署详细指南07本地部署DeepSeek后的调用与删除全攻略08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09DeepSeek r1本地安装全指南10CUDA 安装 一直卡在Installing Nsight Visual Studio Edition