C++中内存管理方式

虽然C++中兼容C语言的语法，之前我们在C语言阶段的malloc，realloc，calloc等实现动态内存管理的函数还可以使用，但是不能解决一些问题。所以C++中提出了新的内存管理方式——通过new和delete操作符进行动态内存管理。

我们结合代码来体会C++中动态管理的方式。

new/delete操作内置类型

#include<iostream>
using namespace std;
int main()
{
	int* ptr1 = new int;//开辟单个对象的空间
	char* str1 = new char;
	int* ptr2 = new int[10];//开辟多个对象的空间：创建了10个整型变量
	char* str2 = new char[10];

	return 0;
}

我们可以看到，在C++中，如果我们要进行动态内存的开辟，我们可以直接使用关键字new+类型，注意上面我们申请完空间以后，并没有对指针所指向的内容进行初始化。

如果我们想在开辟空间的同时进行初始化，应该怎么写？

#include<iostream>
using namespace std;
int main()
{
	int* ptr1 = new int(1);//在堆上开辟了一个整形大小的空间，这个整型中存放的是1

	int* ptr2 = new int[10] {1, 2, 3, 4};//在堆上开辟了大小为10的整形数组，这个数组的内容是1,2,3,4，0,0,0,0,0,0

	return 0;
}

上面代码中，如果我们只是开辟了一个空间，直接使用括号初始化即可，如果开辟了多个对象的空间，需要使用花括号进行初始化。

我们动态开辟好空间以后，如果不再使用，自然是要进行空间释放，这要怎么做？就需要使用delete关键字了。

#include<iostream>
using namespace std;
int main()
{
	int* ptr1 = new int(1);//在堆上开辟了一个整形大小的空间，这个整型中存放的是1

	int* ptr2 = new int[10] {1, 2, 3, 4};//在堆上开辟了大小为10的整形数组，这个数组的内容是1,2,3,4，0,0,0,0,0,0

	//释放有一个对象的空间
	delete ptr1;

	//释放多个对象的空间
	delete[]ptr2;
	return 0;
}

可以看到，释放只申请了一个对象的空间的写法与释放申请了多个对象的空间的写法是不相同的，这一点我们一定要注意。

申请和释放单个元素的空间，直接使用new和delete操作符；申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用，不能像下面这样：

#include<iostream>
using namespace std;
int main()
{
	int* ptr1 = new int(1);//在堆上开辟了一个整形大小的空间，这个整型中存放的是1
	delete [] ptr1;

	int* ptr2 = new int[10] {1, 2, 3, 4};//在堆上开辟了大小为10的整形数组，这个数组的内容是1,2,3,4，0,0,0,0,0,0
	delete ptr2;
	
	return 0;
}

new和delete操作自定义类型

其实刚才我们可以体会到，new和delete操作内置类型与C语言中的malloc、calloc、free等除了用法上没啥太大区别，其实，C++中引入这两个关键字是为了操作自定义类型。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int  year = 1, int month = 2, int day = 3)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int  year = 1, int month = 2, int day = 3)" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//如果像C语言那样使用malloc进行动态内存开辟
	Date* p1 = (Date*)malloc(sizeof(Date));

	//如果使用C++中的new
	Date* p2 = new Date;

	return 0;
}

以上两种写法有啥区别呢？

区别就是第二种方式会自动调用自定义类型的构造函数。

我们先来看看之前C语言的写法，我们就只是申请了一块内存空间，那我们要怎么对p1所指向对象中的成员变量进行初始化呢，日期类的成员变量是私有的呀，那我们就不可能在类外对他进行初始化了呀。

但是有了new以后，一切就顺利多了，new对于【自定义类型】除了开空间，还会调用构造函数，我们可以通过调试来观察这一点：

我们可以发现，使用new为对象开辟空间的时候，确实调用了构造函数对指针所指向的对象进行了初始化。

同理，对于C语言中的free函数与C++中的delete，它们之间最大的不同就是，delete对于【自定义类型】除了进行空间的回收，还会调用析构函数。

我们还是来通过调试观察这一点：

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int  year = 1, int month = 2, int day = 3)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int  year = 1, int month = 2, int day = 3)" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//如果像C语言那样使用malloc进行动态内存开辟
	Date* p1 = (Date*)malloc(sizeof(Date));

	//如果使用C++中的new
	Date* p2 = new Date;

	free(p1);

	delete p2;

	return 0;
}

如图，在代码运行到    delete p2以后，在按下F11，就会自动进入析构函数内部，而free函数就没有这个特点。

这样一来，我们可以尝试采用C++中的写法来写一下数据结构中链表的结构，对比一下与之前的代码有啥区别：

#include<iostream>
using namespace std;

struct ListNode
{
	ListNode* next;
	int _val;
	ListNode(int val = 1)
		:_val(val)
		, next(nullptr)
	{

	}
};

int main()
{
	//创建链表的节点
	ListNode* p1 = new ListNode(1);
	ListNode* p2 = new ListNode(2);
	ListNode* p3 = new ListNode(3);
	return 0;
}

之前我们在写链表的相关代码的时候，为链表的节点开辟好空间以后，还要写一个申请节点的方法，但是在C++中，就没必要那么麻烦，因为new直接调用了构造函数进行节点的初始化。

new和delete相较于C语言中动态内存开辟的机制，除了是否会自动调用构造函数和析构函数以外，还有内存分配失败时处理操作的不同，在我们C语言学习阶段，如果malloc或calloc或realloc内存分配失败，会返回空指针，但是new会出现抛异常，这个大家先暂时了解即可，以后我们学习到继承多态的时候会进行深入讲解。

operator new与operator delete函数

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

我们可以简单来看一下这两个全局函数的代码（不需掌握，只需简单了解）

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


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

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)

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

这也就说明，new和delete的底层也是malloc和free。

new和delete的实现原理

内置类型

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

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

自定义类型

new的原理

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

delete的原理

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

new T[N]的原理

• 调用operator new[]函数（与operate new原理类似），在operator new[]中实际调用operator new函数完成N个对象空间的申请
•  在申请的空间上执行N次构造函数

delete[]的原理

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

定位new表达式(placement-new)

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

使用格式：

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

使用场景：

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

我们可以malloc开辟内存看成是一个内存池，接下来我们将结合代码来理解一下定位new表达式的作用：

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int  year = 1, int month = 2, int day = 3)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int  year = 1, int month = 2, int day = 3)" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// p1现在指向的只不过是与Date对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	Date* p1 = (Date*)malloc(sizeof(Date));

	//使用定位new显示调用构造函数
	new(p1)Date(2025, 9, 20);

	//现在p1指向的就是一个Date对象了，在释放掉这块对象的空间之前，我们还需要调用析构函数释放相关的资源
	p1->~Date();

	//释放空间
	free(p1);

	return 0;
}

也就是说，当我们不使用new 去开辟空间的时候，申请到的空间并不会自动进行初始化，此时就要使用定位new去显示调用构造函数去进行初始化。

malloc/free和new/delete的区别

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