C++：渴望力量吗，少年？

---

一、C++内存管理方式

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

1. new/delete操作内置类型

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

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

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

	delete ptr4;
	delete ptr5; 
	delete[] ptr6;

	// 额外支持开空间+初始化
	int* p6 = new int(10);//注意这里是赋值为10
	int* p7 = new int[10]{1,2,3};//和C语言一样，这种情况下没有初始化到的部分默认为0
	int* p8 = new int[10]{};

	return 0;
}

2. new和delete操作自定义类型

  在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。而他们对内置类型是几乎是一样的。

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

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

private:
	int _a;
};
int main()
{
	// malloc没有办法很好支持动态申请的自定义对象初始化
	A* p1 = (A*)malloc(sizeof(A));
	//p1->_a = 0;
	//p1->A(1);

	// 自定义类型，开空间的同时调用构造函数初始化
	A* p2 = new A;
	A* p3 = new A(3);

	// 自定义类型，调用析构函数+释放空间
	delete p2;
	delete p3;

	A* p4 = new A[10];
	delete[] p4;

/*下面三种写法都是一样的
	A aa1(1);
	A aa2(2);
	A* p5 = new A[10]{ aa1, aa2 };
	delete[] p5;

	A* p6 = new A[10]{ A(1), A(2) };
	delete[] p6;

	A* p7 = new A[10]{ 1, 2 };
	delete[] p7;
*/
	return 0;
}

二、operator new与operator delete函数

  new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
  operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

typedef char DataType;
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		cout << "Stack()" << endl;

		_array = new DataType[capacity];//析构函数对应也得用delete释放空间
		//_array = new char[0x7ffffffffff];//如果取消注释，那么对应的第二段代码会抛出异常

		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		delete[] _array;
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};
class A
{
public:
	A(int a = 0)
		:_a1(a)
	{}

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

private:
	int _a1;
};
int main()
{
	Stack* pst1 = (Stack*)operator new(sizeof(Stack));//相当于malloc，创造它是为了符合抛出异常的方式
	operator delete(pst1);//相当于free
	//其实上面两个函数主要都不是让我们直接使用，而是分别封装在new和delete中，new就相当于operator new和调用构造函数

	Stack* pst2 = new Stack;
	delete pst2;
	//free(pst2);

	A* p2 = new A[10];
	delete[] p2;
	return 0;
}

  new和delete一定要匹配使用，否则后果可能是未定义的！！！

三、new和delete的实现原理

1. 内置类型

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

2. 自定义类型

（1）new的原理
    a.调用operator new函数申请空间
    b.在申请的空间上执行构造函数，完成对象的构造
（2）delete的原理
    a.在空间上执行析构函数，完成对象中资源的清理工作
    b.调用operator delete函数释放对象的空间
（3）new T[N]的原理
    a.调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
    b.在申请的空间上执行N次构造函数
（4）delete[]的原理
    a.在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
    b.调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

四、内存泄漏

1. 什么是内存泄漏

  内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

2. 内存泄漏的危害

  长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int)); 
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); 
	// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放. 
	delete[] p3;
}

3. 堆内存泄漏(Heap leak)

  作为初学者，我们更加关注的是这方面的泄露。堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

4. 解决方案

内存泄漏非常常见，一般解决方案分为两种：
（1）事前预防型。如智能指针等；
（2）事后查错型。如泄漏检测工具。

---