在学习C++的内存管理之前，我们先来回顾一下C语言中动态内存

int main()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	// 1.malloc/calloc/realloc的区别是什么？
	int* p2 = (int*)calloc(4, sizeof(int));//calloc 可以初始化空间为0
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);//realloc 是用来扩展空间的
	// 这里需要free(p2)吗？
	//不需要，因为如果p2后面空间够用，realloc会在p2后面直接增加空间
	//如果空间不够，那么会重新找一块足够大的空间给你，并将原先的内容拷贝过来，并释放原先的空间
	free(p3);
	return 0;
}

如果有不清楚的地方，可以去看我之前写的C语言的动态内存分配，回顾一下，有助于我们理解下面的内容

---

C++的内存管理

相较于C语言，C++创造了new和delete两个操作符来代替C语言中的几个函数，并且满足C++中创建销毁自定义类型对象时的一些需求，下面会详细介绍new和delete两个关键字的用法

一、基本的语法

1.对于内置类型，以int类型为例子，其他的一样

int main()
{
	int* p1 = new int;//开一个空间存放int，没有初始化
	int* p2 = new int(1);//开一个空间存放int,并初始化为1
	int* p3 = new int[10];//开空间存放10个int，没有初始化
	int* p4 = new int[10] {1,2};//开空间存放10个int，并将前2个初始化为1和2，剩下的为0，和数组的初始化相似

    //注意new和delete，new[]和delete[] 对应起来使用，因为不匹配的结果是未定义的
	delete p1;
	delete p2;
	delete[] p3;
	delete[] p4;
	return 0;
}

2.对于自定义类型

class A
{
private:
	int _x;
	int _y;
public:
	A(int x=1,int y=1)
		:_x(x)
		,_y(y)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	//malloc,free不会调用A的构造和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);
	cout << "--------------" << endl;
	//new,delete会调用A的构造和析构函数
	A* p2 = new A;
	delete p2;
	return 0;
}

 补充：

int main(){
	A* p1 = new A(1, 2);//初始化
	cout << "--------------" << endl;
	A* p2 = new A[5]{ A(1,2),A(1,3) };//用匿名对象初始化
	cout << "--------------" << endl;
	A* p3 = new A[5]{ 1,2,3 };//之前讲的，先发生隐式类型转换，再构造，拷贝构造，优化为直接构造
	delete p1;
	delete[] p2;
	delete[] p3;
	return 0;
}

二、operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是
系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过
operator delete全局函数来释放空间。
而这两个函数其实更贴近malloc和free函数，或者更准确的说，这两个函数的底层实现就是malloc和free，就多了一个功能会抛异常，不用我们再去判断malloc函数的返回值是否为NULL，而是直接抛异常，如下

int main()
{
	//两个函数的正常使用
	int* p = (int*)operator new(sizeof(int));
	operator delete(p);
    
    //抛异常的用法，这里就简单说一下原理，具体的可以自己找资料看看
//try里面无论是直接或间接的申请内存失败都会抛出一个异常，catch就会接收，并对异常进行打印之类的操作
//注意：只要抛了异常，那么代码会直接到catch，不会再走之后的代码
	try
	{
		int*t= (int*)operator new(0x7fffffff);

		cout << "hhhhh" << endl;
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

 这个bad allocation的意思就是空间不够

三、new和delete的总结

从上面的讲诉中，我们能够得到：

1.内置类型
new和malloc，delete和free基本类似，不同的地方是：new能初始化，malloc不能，new在申请空间失败时会抛异常，malloc会返回NULL
2.自定义类型
new能开空间，同时调用构造函数，delete能释放空间，同时调用析构函数，而malloc和free只能开空间和释放空间

四、定位new表达式（了解）

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

int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);

	A* p2 = (A*)operator new(sizeof(A));//开空间
	new(p2)A(10);//调用构造函数(这里相当于显式调用构造函数，一般情况下不能手动调用构造函数)
	p2->~A();//调用析构函数(析构函数可以手动调用)
	operator delete(p2);//释放空间
	return 0;
}

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