C++内存管理(new 和 delete 的使用)

在C语言中，我们使用 malloc / calloc / realloc / free 动态管理内存。虽然C语言内存管理方式在C++中可以继续使用，但有些地方却无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过 new/delete 操作符进行动态内存管理。

基础用法(操作内置类型)

new 和 delete 是搭配使用的。

#include<iostream>
using namespace std;

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

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

	//动态申请10个int类型的空间
	int* p3 = new int[10] {0};

	//释放空间
	delete p1;
	delete p2;

	//释放多个内存空间要加[],搭配使用
	delete[] p3;
}

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

操作自定义类型

new/delete 可以操作内置类型，但其用处更多在于操作自定义类型。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1 = 1, int a2 = 1)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a1;
	int _a2;
};

int main()
{
	//缺省函数初始化
	A* p1 = new A;
	A* p2 = new A();

	//自定义初始化
	A* p3 = new A(2, 2);

	delete p1;
	delete p2;
	delete p3;

	return 0;
}

同样，我们还可以一次定义多个。

​
#include<iostream>
using namespace std;

class A
{
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1 = 1, int a2 = 1)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a1;
	int _a2;
};

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

    delete[] p1;

	return 0;
}

自定义类型的类在调用时，除了会申请空间，还会在 new 时调用构造函数，在 delete 时调用析构函数。而 malloc/free 则不会。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1 = 1, int a2 = 1)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a1;
	int _a2;
};

int main()
{
	A* p3 = new A(2, 2);
	A* p4 = new A[3];

	delete p3;
	delete[] p4;
	return 0;
}

该程序会调用五次构造和析构函数。

operator new 函数和 operator delete 函数

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

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

所以说 new/delete 最终还是通过 malloc/free 来实现的。