C++中new和delete匹配使用过程详解

#include <iostream>
using namespace std;
class Demo
{
public:
	Demo(int a1 = 10, int a2 = 20)
		: _a1(a1)
		, _a2(a2)
	{
		cout << "Demo()" << endl;
	}
	void print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
	~Demo()
	{
		cout << "~Demo()" << endl;
	}
private:
	int _a1;
	int _a2;
};
void printIntArr(int* arr, int len)
{
	for (int i = 0; i < len; ++i)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
void printDemoArr(Demo* arr, int len)
{
	for (int i = 0; i < len; ++i)
	{
		arr[i].print();
	}
	cout << endl;
}
int main()
{
	//用 new 申请一个内置类型变量的空间
	int* pint1 = new int;
	cout << *pint1 << endl; //输出 -842150451
	//使用括号中的值初始化变量
	int* pint2 = new int(5);
	cout << *pint2 << endl;	//输出 5
	//用 delete 释放一个变量的空间
	delete pint1;
	delete pint2;
	//用 new 申请一个自定义类型对象的空间，申请后会自动调用构造函数
	Demo* pd1 = new Demo;	//输出 Demo()
	pd1->print();	//输出 10 20
	//自定义类型会根据括号中的参数调用对应的构造函数
	Demo* pd2 = new Demo(5, 5);	//输出 Demo()
	pd2->print();	//输出 5 5
	//用 delete 释放一个变量的空间，释放前会自动调用析构函数
	delete pd1;	//输出 ~Demo()
	delete pd2;	//输出 ~Demo()
	//对内置类型用 new[] 开辟一块连续的空间
	int* pint3 = new int[5];	//[]中表示开辟整形的个数
	printIntArr(pint3, 5);	//输出 -842150451 -842150451 -842150451 -842150451 -842150451
	//用花括号中的值初始化开辟的连续空间，未给值的为 0
	int* pint4 = new int[5]{ 1, 2, 3, 4 };	
	printIntArr(pint4, 5);	//输出 1 2 3 4 0
	//对内置类型用 delete[] 释放一块连续的空间
	delete[] pint3;
	delete[] pint4;
	//对自定义类型用 new[] 开辟一块连续的空间
	//申请后会对空间自动调用构造函数 5 次
	Demo* pd3 = new Demo[5];	//输出 5 行 Demo()
	printDemoArr(pd3, 5);	//输出 5 行 10 20
	//用花括号中的值初始化开辟的连续空间
	//花括号中如果用小括号会被认为是逗号表达式，会去调用单参的构造函数
	//调用多参构造函数应在花括号中使用花括号，未给的值根据构造函数决定
	Demo* pd4 = new Demo[5]{ (1, 2), {5}, {5, 10}};	//输出 5 行 Demo()
	printDemoArr(pd4, 5);	//输出 第一行 2 20，第二行 5 10 第三行 5 10，两行 10 20
	//对自定义类型用 delete[] 释放一块连续的空间
	//释放之前会对空间自动调用析构函数 5 次
	delete[] pd3;	//输出 5 行 ~Demo
	delete[] pd4;	//输出 5 行 ~Demo
	return 0;
}

#include <iostream>
using namespace std;
int main()
{
	//operator new 和 malloc 使用方法一样
	//operator new 申请空间失败时抛异常
	int* pi = (int*)operator new(sizeof(int) * 4);
	//operator delete 和 free 使用方法一样，都会调用 _free_dbg
	//operator delete 在释放空间时会做一些检查
	operator delete(pi);
	return 0;
}

#include <iostream>
using namespace std;
class Demo
{
public:
	Demo(int a1 = 10, int a2 = 20);
	~Demo();
private:
	int _a1;
	int _a2;
};
Demo::Demo(int a1, int a2)
	: _a1(a1)
	, _a2(a2)
{
	cout << "Demo()" << endl;
}
Demo::~Demo()
{
	cout << "~Demo()" << endl;
}
int main()
{
	Demo* pd1 = new Demo(5, 5);
	delete pd1;
	Demo* pd2 = new Demo[2]{ {1, 2}, {2, 3} };
	delete[] pd2;
	return 0;
}

#include <iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
		: _a(new int[capacity])
		, _top(0)
		, _capacity(capacity)
	{
	}
	~Stack()
	{
		if (_a)
		{
			delete[] _a;
			_top = _capacity = 0;
		}
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack* ps = new Stack;
	//free(ps);	//内存泄漏
	//delete 释放内存之前会调用析构函数
	delete ps;	//正确写法
	return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << endl;
	}
	~A()
	{
		cout << "~A():" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = new A[10];
	//free(p1); 	//崩溃
	delete[] p1;	//正确写法
	A* p2 = new A[10];
	//delete p2;	 //崩溃
	delete[] p2;	//正确写法
	return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
//定位 new 又叫 replacement new
int main()
{
	//p1 现在指向的只是与 A 对象相同大小的一段空间，并不是一个对象，因为没有调用构造函数
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;	//调用无参的构造函数 输出 A()
	//可以手动调用析构函数，然后释放空间
	p1->~A();	//输出 ~A()
	free(p1);
	//p2 现在指向的只是与 A 对象相同大小的一段空间，并不是一个对象，因为没有调用构造函数
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);	//10 是参数，可以根据参数调用对应的构造函数 输出 A()
	p2->~A();	//输出 ~A()
	operator delete(p2);
	return 0;
}