C++相关概念和易错语法（30）（异常、智能指针）

1.异常

在C语言这样的面向过程编程的语言来说，处理错误一般有两种方式：终止程序，如assert；返回错误码，比如打开文件失败，errno就会改变，perror就会打印错误码对应的错误信息

在面向对象的语言中，异常是更常见的处理错误的方式，如连接服务器我们不会一次就成功，需要多尝试几次，不能一失败就终止程序。errno也过于局限，错误码的分配有限，不能自定义，同时错误码还必须及时手动处理，否则会被覆盖

（1）处理方式

先执行try内部语句，内部可能有throw抛异常，catch捕获异常并处理

我们可以看到，先执行try里面的语句，在fun()里遇到了throw语句抛出异常，抛出异常后终止后续所有代码的执行，之后catch捕获后进行处理。只有抛了异常才会走catch，如果不抛异常就不会走catch。抛异常是传值返回，返回的是拷贝的对象，返回右值会调用移动构造简化。

下面是一个更直观的例子，可以更好理解使用规则

（2）详细规则

在try语句内部（try中调用函数也算作在try代码块中，如上面的例子）抛出异常后，会直接跳转到catch语句，跳转规则是会沿着函数栈帧（调用函数的顺序）层层往回找，先看抛异常的语句在不在try代码块中，再看抛出的异常的类型有没有匹配当前catch，如果匹配了就会执行当前catch语句以及后面的语句，返回上层栈帧后如果本身还在try内部，那么不会进入任何catch语句，就算有匹配的，可以理解为抛出的异常用一次就销毁了。

#include <iostream>
using namespace std;

void fun2()
{
	throw "fun2()";
}

void fun1()
{
	try
	{
		fun2();
	}
	catch(const char* msg)
	{
		cout << "fun1()" << endl;
	}

	cout << "fun1()" << endl;
}

int main()
{
	try
	{
		fun1();
	}
	catch (const char* msg)
	{
		cout << "main()" << endl;
	}

	return 0;
}

结果是

我们可以看到fun2抛出异常后，会层层往上找，fun2是在fun1的try语句内，所以会被fun1的catch捕获，catch后的语句正常执行，再往上走发现fun1和fun2其实都是在main函数的try语句内，但是总共就抛出一次异常并被解决了，所以后面就不会执行catch语句

注意层层向上匹配时需要严格匹配，抛出的常量字符串不会被char*捕获，也不能用string捕获，如果抛出int异常自然也不会转为size_t。所以fun1中的catch语句及之后的代码不会执行，而会匹配main函数中的catch语句。抛异常后的下一句执行代码一定是向上找第一次完美匹配的catch语句的第一行代码

如果到了main函数还是找不到对应的catch，即抛出的异常没有被处理，就会直接终止程序，编译器认为异常没有被处理一定是存在问题的。

所以我们要保证所有的异常能得到处理，我们可以使用catch(...)兜底，catch(...)能在其它catch语句匹配不上时派上用场，至少不会让程序直接终止

有个小细节，即catch(...)只能放在最后作为兜底，不过也几乎没人这么做，这里提一下

（3）子类异常用父类捕获

先看看下面的代码，顺便复习复习继承和多态

#include <iostream>
using namespace std;

class B;

class A
{
public:
	virtual B& CreateMessage(int id = 1, const string& errmsg = "error") = 0
	{}

	int _id;
	string _errmsg;
};

class B : public A 
{
public:
	B& CreateMessage(int id, const string& errmsg)
	{
		_id = id;
		_errmsg = errmsg;
		return *this;
	}
};

int main()
{
	try
	{
		A* throwmsg = new B;

		throw throwmsg->CreateMessage();
	}
	catch (A& msg)
	{
		cout << msg._id << ":" << msg._errmsg << endl;
	}

	return 0;
}

结果是

首先使用父类指针指向子类空间构成多态，虚函数表存的CreateMessage()是B中的，当以A指针调用函数时匹配的是B的内容，但是多态中，都是以父类声明+子类定义调用函数，所以不需要传参，用纯虚函数的缺省值就可以了，实际走的代码还是B中的。

抛出的B可以被A&捕获，这其实也和赋值兼容转换结合起来了，同时也再次强调赋值兼容转换不是类型转换，因为catch是严格匹配的，不允许赋值兼容转换，因此这在逻辑上是合理的。

（4）异常规范

确定不会抛异常的在函数后面加noexcept，这样能很好规范异常的使用

写了noexcept后就算再抛异常也不会编译报错，但是noexcept会影响编译器逻辑，运行时不会捕获抛出的异常，就算看上去能匹配catch也会报错，这也相当于另一种规范

（5）标准库异常体系

当我们调用库中的函数出了问题时，就会抛出异常，我们可以用const exception& e接收异常，exception是一个类，我们可以用成员函数e.what()得到具体错误信息

下面是常见的用法

（6）C++异常缺点

异常使用频繁会导致代码执行位置乱跳，标准库的异常体系并不是太好用，一般来说都是自定义异常体系，同时noexcept也不是硬性规定。

但是最大的问题还是安全问题，即抛出异常后后续代码都会终止，这可能会导致已开辟的空间没有办法delete，出现内存泄漏，这极难控制，需要引入更复杂的解决办法，后续会讲到。

我为这个问题举个例子

如果arr1开辟失败要抛异常，如果arr2开辟失败也要开辟异常，arr3同理，而且还可能出现arr1和arr2都开辟好了，但arr3开辟失败，这个时候还要处理arr1和arr2的释放。我们发现要处理的异常极多，根本没有办法涵盖所有情况，所以我们用常规思维解决不了内存泄漏的问题。

2.智能指针（RAII思想）

RAII思想是实现智能指针的核心，它利用了C++局部对象自动销毁的特性（类的对象自动调用析构函数）来控制资源的生命周期，就能很好地防止内存泄漏，下面举个简单的例子

当调用函数时，创建了Ptr类的对象，资源获得立即初始化，这个对象掌管着堆区开辟的数组，当返回函数栈帧时，就会自动调用析构函数，把资源释放掉，因此我们堆区开辟的空间就不会泄露了

这本质上是借助对象的生命周期来控制程序资源，使用模板就可以管理任意类型的资源，智能指针就是按照这个思路来实现的，相当于在原本管理数据的int*外再包一层，这样就能解决异常乱跳导致的问题。

（1）unique_ptr

用法：unique_ptr<int> up(new int)

就和我们前面的使用一样，unique_ptr本质也是利用RAII思想实现的类，靠着类的生命周期来防止开辟的空间无法被delete，就算我们不知道unique_ptr具体实现，但是也能很快弄清具体的功能，直接用unique_ptr开辟空间也要安全得多。

智能指针还能模仿原生指针的相关操作，如operator*和operator->（和迭代器的实现一样）

因此，堆区动态开辟空间应尽量交给智能指针管理。

智能指针难度在于拷贝，我们所需的拷贝是浅拷贝，而不是深拷贝，因为它是要模仿指针的拷贝，不同的智能指针可以指向同一块空间，但问题在于析构多次会导致越界访问。unique_ptr的特点就是禁止任何拷贝和赋值，一片空间只能交给一个unique_ptr管理。

拷贝构造和赋值重载都被delete掉，或是使用了private修饰，不能显式调用，也就实现了禁止拷贝赋值的操作，进而也就不会出现同一块空间用多个unique_ptr管理的情况。

在不需要同一块空间用多个unique_ptr管理时，可以多使用unique_ptr。

unique_ptr还需要处理自定义类型，如数组的开辟

第一种解决办法就是在模板参数类型后面加[ ]

第二种办法就是手动实现仿函数（删除器）

先看一下下面的代码，想一想是怎样使用的。

#include <iostream>
#include <vector> 
using namespace std;

template<class T>
class DeleteArray
{
public:
	void operator()(T* t)
	{
		cout << "DeleteArray" << endl;
		delete[] t;
	}
};

class DeleteFile
{
public:
	void operator()(FILE* f)
	{
		cout << "DeleteFile" << endl;
		if (f)
			fclose(f);
	}
};

class A
{
public:
	~A()
	{
		cout << "~A()" << endl;
	}
	int _a = 10;
};

int main()
{

	unique_ptr<FILE, DeleteFile> up1(fopen("test.txt", "r"));
	unique_ptr<A, DeleteArray<A>> up2(new A[10]);

	return 0;
}

结果是

第二个模板参数删除器是一个仿函数，unique_ptr会将里面存放的指针以仿函数的形式传过去，以此来进行自定义处理。

unique_ptr删除器对象不能作为参数传递

通过删除器和类型 + [ ]的使用，我们能处理任何指针类型了，只不过这种使用形式要多记忆一下，容易混淆。

（2）shared_ptr基本使用

unique_ptr的功能几乎完美，唯独缺失了拷贝和赋值的操作。

shared_ptr支持拷贝，采用了引用计数，每当新增一个shared_ptr管理一块空间，就为它计数++，每析构一次就计数--，最后一个析构的释放空间。这类似于最后一个人关灯的操作。

我们可以看见，shared_ptr能够精准避免越界访问的情况。

下面看一看自定义类型如何处理，用法几乎一致，但有区别

#include <iostream>
#include <memory>
using namespace std;

template<class T>
class DeleteArray
{
public:
	void operator()(T* t)
	{
		cout << "DeleteArray" << endl;
		delete[] t;
	}
};

class DeleteFile
{
public:
	void operator()(FILE* f)
	{
		cout << "DeleteFile" << endl;
		if (f)
			fclose(f);
	}
};


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


int main()
{
	shared_ptr<A> sp1(new A[10], DeleteArray<A>());//开辟了一块新的空间
	shared_ptr<A> sp2(sp1);	
	
	shared_ptr<FILE> sp3(fopen("test.txt", "r"), DeleteFile());//开辟了一块新的空间
	shared_ptr<FILE> sp4(sp3);

	shared_ptr<A[]> sp5(new A[5]);//开辟了一块新的空间


	return 0;
}

结果是

shared_ptr删除器对象只能作为函数参数传递

（3）shared_ptr模拟实现

shared_ptr很重要，下面通过其具体实现来加深印象，并且找出shared_ptr的漏洞

这是模拟实现shared_ptr的成员变量，_ptr用于存储开辟的空间，_del用于接收删除器对象，_pcount是用于计数。

在这个模板类中，构造函数的第一个参数用于接收开辟空间的指针对象，如new int返回的int*；第二个参数利用了包装器，用lambda表达式做缺省值（匿名函数对象拷贝出临时对象，被包装器接收），默认以delete来释放空间，我们也可以手动传匹配的函数形式的对象（如仿函数，函数指针，仿函数），它们都能被包装器接收，这也体现包装器的优势。

通过构造和拷贝构造我们就能知道，shared_ptr再调用构造时（开辟新空间）就开辟一个存计数的空间，如果后续调用拷贝构造就会++计数，同理调用析构会--，如果为计数为0就delete开辟的空间。

这里需要理解为什么要用这种方式计数，为什么不用static？

static变量的特点就是一个类就只有一份，这就意味着当我们用同一个类实例化出多个对象时，计数就完全不可控了。假设同一个类有2个对象，4个指针管理，其中3个指针指向其一对象，另一个指针指向另一个对象。但static的计数始终为4，static完全没办法区分这两个对象，所以不可用。

最后还剩下赋值重载，需要注意两点，第一点即瞻前顾后，第二点则是处理自己给自己赋值

下面是所有代码实现，应该很快就能理解了

	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr, const function<void(T*)>& del = [](T* t)
			{
				cout << "默认删除器" << endl;
				delete t;
				return;
			})
			:_ptr(ptr)
			, _del(del)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr& sp)
		{
			(*(sp._pcount))++;
			_ptr = sp._ptr;
			_del = sp._del;
			_pcount = sp._pcount;
		}

		~shared_ptr()
		{
			release();
		}

		void release()
		{
			if (--*(_pcount) == 0)
			{
				_del(_ptr);
				delete _pcount;
			}
		}

		T& operator*() const
		{
			return *_ptr;
		}

		T* operator->() const
		{
			return _ptr;
		}

		shared_ptr& operator=(const shared_ptr& sp)
		{
			if (_ptr == sp._ptr)
				return *this;

			release();

			_ptr = sp._ptr;
			_del = sp._del;
			_pcount = sp._pcount;
			(*_pcount)++;

			return *this;
		}

		size_t use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		function<void(T*)> _del;
		int* _pcount;
	};

注意const修饰函数可以防止使用该函数时发生权限放大的情况

下面对拷贝操作进行讲解

一定要体会右值的处理，这样才能理解为什么不需要写移动构造。

移动构造的底层就是将有用的指针和无用的指针做交换，将无用的指针析构。如果实现移动构造当然也没问题，不实现是因为析构时有一个条件判断阻止了delete，总体上和值拷贝没任何区别。

（4）循环引用、weak_ptr

看一下下面这段代码，为什么会出现这种状况

class A类似于双向链表，A* _next和A* _prev指向后一个和前一个A。但是由于异常的处理麻烦，我们使用智能指针来包装指针，实现同样的功能并且能自动析构。像上述代码如果觉得难以理解的话，先将它们看作A*，再替换成智能指针，结合operator*和operator->仔细体会。

看懂代码后，我们就能明白sp1和sp2互指

我们可以很好理解sp2和sp1的计数都是2，当析构时，它们都只会计数--，不会delete。最后变成use_count() == 1，这个时候析构操作已经完成了，但空间没有释放，造成了内存泄漏。这就叫循环引用。

处理循环引用，我们需要使用另一种智能指针weak_ptr

下面是一个粗略的实现，帮我们简单看看weak_ptr的结构

weak_ptr不同于其它智能指针，它不支持直接管理资源，它配合解决shared_ptr的一个缺陷，即循环引用导致的泄漏。

weak_ptr不支持RAII，不支持管理资源，也不能用operator*和operator->访问。

在用法上，weak_ptr<int> wp(new int) 这种操作是不可行的（不支持RAII），但是weak_ptr可以用shared_ptr构造和赋值，而shared_ptr可以用weak_ptr构造

当在循环引用出现时使用weak_ptr避免时，使用sp1->_next = sp2就调用了weak_ptr<T>& operator=(const shared_ptr<T>& sp)这个赋值重载。

我们还可以借助make_shared<T>(new T)来让weak_ptr指向数据空间

wp只有在构造的那行才有用，过了之后shared_ptr就析构了（临时对象），这个时候wp就失效了，也叫悬空。这又如何处理？

weak_ptr中use_count()记录了管理的数据有多少次计数，当计数为0时就标记为已失效。expired()就是这个功能，为真时就表示失效

我们还可以在悬空前将数据进行转移，lock()就能实现这项功能

转移前后count计数会++（weak_ptr不会增加计数，转移到shared_ptr，shared_ptr会增加计数），只不过上面的代码是先++，后析构--，整体不变

下面的代码可以说明这一点

我们要把weak_ptr理解为一个单独存储数据的类，不会增加计数。存储的数据很完备，有_ptr、_pcount、_del，但是由于weak_ptr不会--计数，即不会析构，所以当原数据被释放后，就有可能出现悬空的情况。我们可以用expired()检查是否悬空，也可以在悬空前用lock()把数据转移出去。

（5）智能指针总结

C++98推出了auto_ptr（失败的设计，拷贝是管理权转移，拷贝后原来的自动指针为空，调用原来的指针会直接报错），在C++11又推出了unique_ptr、shared_ptr、weak_ptr，用于解决绝大多数内存泄露的场景。当不涉及拷贝时可用unique_ptr，涉及拷贝、传值返回用shared_ptr，weak_ptr用于解决循环引用。

（6）内存泄漏

智能指针要处理的就是内存泄漏问题，即占据着内存却不使用，内存不断被消耗，会导致最终程序被卡死。一般来说，短期快速出现的内存泄漏更容易被发现，而长期运行的慢速内存泄漏的程序影响很大，如服务器几乎不停服，就算每次内存泄漏一点，但时间一长，就会造成服务器崩溃。当今的windows、linux都有各自的内存泄漏检测工具。我们写代码时，如果管理好资源，就能防止内存泄漏。