C++异常详细介绍

Posted 2021-12-03 两片空白

目录

前言

一.C++异常概念

二.异常的抛出和匹配规则

三.异常的重新抛出

四.异常安全问题

五.异常规范说明

 六.自定义异常体系

 七.C++标准库的异常体系

 八.异常优缺点

---

前言

        在C语言中处理错误的方式和缺陷有：

• 返回错误码。

        缺陷：

        1.错误码不好设置，比如：除0操作，就不好返回错误码。如果返回一个数字，可能会有两层含义，是错误，还是结果呢。一般我们会在参数加一个输出型参数返回结果，再规定成功和失败返回的数字。

        2.需要程序员去查找错误码对应的含义。比如：很多系统接口函数都是把错误码放到全局变量errno中，表示错误。

• 终止程序。比如：发生越界，除0，内存错误等，会直接终止程序。

        缺陷：并不能明确知道是什么错误。用户难以接收。

C++针对上面的不足，引入了异常的概念，不会终止程序，并且会将错误信息详细介绍。

int test(){
	int a = 0;
	int b = 0;
	cin >> a >> b;
	if (b == 0){
		throw bad_exception("除0错误");//抛出异常
	}
	return a / b;
}

int main(){

	try{
		cout << test() << endl;//可能会出现异常代码
	}
	catch (const exception& e){
		cout << e.what() << endl;//捕获异常
	}

	system("pause");
	return 0;
}

一.C++异常概念

        异常是面向对象语言处理错误的一种方式。当一个函数出现自己无法处理的错误时，可以抛出异常，然后输的直接或者间接调用者处理这个错误。

        有三个关键字：

• throw：当问题出现，程序抛出一个异常。抛异常使用throw关键字完成。
• catch：用于捕捉异常。catch(...)可以捕获任意类型的异常，主要时用来捕获没有显示捕获类型的异常。相当于条件判断中的else。
• try：try中包含会出现异常的代码或者函数。后面通常会跟一个或者多个catch块。

        注意：可以抛出任意类型的对象。抛出的异常必须捕获。try要和catch匹配使用，catch里的内容抛出异常时才执行，没有异常，不执行。

int test(){
	int a = 0;
	int b = 0;
	cin >> a >> b;
	if (b == 0){
		throw "除0错误";//抛出异常,异常的描述
	}
	return a / b;
}

int main(){

	try{
		cout << test() << endl;//会出现异常的代码
	}
	//捕获异常
	catch (const char* a){
		cout << a << endl;
	}
	catch (...){
		cout << "unknow exception" << endl;
	}

	system("pause");
	return 0;
}

二.异常的抛出和匹配规则

1. 异常时通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

2. 被选中的处理代码的调用链是，找到于该类型匹配且离抛出异常位置最近的那一个catch。

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象。

4. catch(...)可以捕获任意类型的对象，主要是用来捕获没有显示捕获类型的异常，因为如果没有匹配的catch会终止程序。相当于条件判断中的else。问题是不知道异常错误是什么。

5. 实际中抛出和捕获的类型不一定类型完全匹配，可以抛出派生类对象，使用基类来捕获，这个在实际生活中很实用。主要原因是：派生类可以赋值给基类。

异常的匹配规则：

• 首先检查throw本身是否在try块内部，如果是，再在当前函数栈中查找匹配的catch语句。如果有匹配的直接跳到catch的地方执行。
• 如果没有匹配的catch块，则退出但钱函数栈，在调用函数的栈中查找匹配的catch。
• 如果到达main函数的栈，都没有匹配的catch，就会终止程序。
• 上述沿着调用链查找匹配的catch块的过程叫栈展开。所以实际要最后要加一个catch(...)来捕获任意类型的异常，防止程序终止。
• 找到匹配的catch会直接跳到catch语句执行，执行完后，会继续沿着catch语句后面执行。

如果在中间匹配的：

         结论：按照函数调用链，一层一层往外找，直到找到匹配的catch块，直接跳到匹配的catch块执行，执行完catch，会继续往catch块后面的语句执行。相当于没有找到匹配的函数栈帧被释放了。

三.异常的重新抛出

        有可能单个的catch不能完全处理一个异常，在进行一些矫正处理后，需要交给更外层的调用链函数来处理。catch可以做完矫正操作，再将异常重新抛出，交给更上层的函数进行处理。

四.异常安全问题

        由于抛异常只要找到匹配的catch就直接跳到catch块执行，没有找到对应catch的函数就不会继续执行。这样导致函数的执行流回很乱。可能会导致一些问题。

• 构造函数完成对象的构造和初始化，最好不要再构造函数中抛出异常，否则可能导致对象不完整或者没有完全初始化

• 析构函数主要完成资源的清理，最好不要在析构函数中抛异常，否则可能导致内存泄漏。

• C++异常经常会导致资源泄漏问题。比如：在new和delete中抛出异常，导致new出来的资源没有释放，导致内存泄漏。在lock和unlock中抛出异常，导致锁没有释放，导致死锁。

有两种解决办法：

1. 将异常捕获，释放资源后，将锁重新抛出。
2. 使用RAII的思想解决。定义一个类封装，管理资源。当要使用时实例化一个类对象，将资源传入，当退出函数，调用对象析构函数，释放资源。

五.异常规范说明

• 异常规格说明，是使函数调用者直到函数可能会抛出哪些异常。可以在函数后面接throw(异常类型)，列出这个函数可能抛出的所有异常类型。
• 在函数后面加throw()或者noexcept表示不抛异常。
• 若没有接口声明表示，此函数可能会抛出任意类型的异常。

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator new (std::size_t size, void* ptr) throw();
void* operator new (std::size_t size, void* ptr) noexcept;

 六.自定义异常体系

        在实际中，并不是我们想抛什么异常就抛什么异常，这样会导致捕捉的时候不好捕捉。而是，会建立一个继承体系，建立一个异常类，派生类继承这个类，来定义出不同的异常。

        到时候抛出异常，只需要用基类进行捕捉即可。

基类可以相当于是一个框架，派生类是具体的异常。然后去具体实现异常的内容，然后抛异常只需要抛派生类，捕捉异常只需要捕捉基类即可。 

下面是一个简单的实现：

//基类
//异常
class Exception{
public:
	
	Exception(const char* str = nullptr, int id = 0)
		:_errmsg(str)
		, _id(id)
	{}
	virtual void what()const = 0;
protected:
	string _errmsg;//错误信息
	int _id;//错误码
};
//派生类
//数据库异常
class SqlException :public Exception{
public:
	SqlException(const char *str = nullptr, int id = 1)
		:Exception(str, id)
	{}

	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout << "error id:" << _id << endl;
	}
};
//网络异常
class HttpException :public Exception{
public:
	HttpException(const char *str = nullptr, int id = 2)
		:Exception(str, id)
	{}

	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout << "error id:" << _id << endl;
	}
};
//缓存异常
class CacheException :public Exception{
public:
	CacheException(const char *str = nullptr, int id = 3)
		:Exception(str, id)
	{}

	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout<< "error id:" << _id << endl;
	}
};

void test(){
	//当网络连接失败，抛出这个异常即可
	//throw HttpException("Http fail", 2);
	//当缓存错误
	//throw CacheException("Cache error", 3);
	//当数据库错误
	throw SqlException("Sql error", 4);
}

int main(){
	try{
		test();
	}
    //用基类捕捉即可
	catch (const Exception& a){
		a.what();
	}
	catch (...){
		cout << "unknow exception" << endl;
	}
	system("pause");
	return 0;
}

 七.C++标准库的异常体系

        在C++库中也建立了一个异常体系。也给我们提供了一些异常类。我们可以在程序中使用这些标准异常，它们也是以父子类层次结构组织起来的。

 说明：

unsigned short test(){
	unsigned short a = 0;
	unsigned short b = 0;
	cin >> a >> b;
	if (a + b > 65535 ){
		//c++标准库中的异常类
		throw overflow_error("overflow");
	}
	return a + b;
}


int main(){
	try{
		printf("%d\\n", test());
	}
	//用基类捕捉
	catch (const exception& a){
		cout << a.what() << endl;
	}
	catch (...){
		cout << "unknow exception" << endl;
	}
	system("pause");
	return 0;
}

 八.异常优缺点

         异常优点：

• 异常对象定义好了，相比较于错误码，可以清晰准确的展示出错误的各种信息，甚至包含堆栈调用信息，可以帮我们很好的定位程序的bug。
• 在函数调用链中，深层函数返回错误，我们得层层返回，需要不断的判断是什么错误，再返回给最外层。异常直接会找到对应的catch执行，不需要判断是什么错误。
• 部分函数更好处理，比如没有返回值的函数或者返回值为自身的T& operator，不好返回错误码。并且pos越界了，内存错误等不需要终止程序。
• 更好的进行测试

        总而言之，跟好的返回和描述错误信息，更好定位。针对某些错误，不需要终止程序。

        异常缺点

• 异常导致执行流乱跳，运行混乱。导致我们调试和分析程序时，比较困难。
• C++没有垃圾回收机制，可能会导致异常安全问题。开辟的资源和打开的流，由于执行流乱跳，导致没有释放和关闭等。导致内存泄漏。打开的锁为关闭，导致死锁。
• C++标准库的异常体系定义不好，导致我们需要各自定义各自的体系，非常混乱。
• 随意抛异常，外层不好捕获，所以尽量按找异常规范使用。异常规范有两点：1.派生类继承基类。2.函数后面加thow()，表明要抛什么异常。

 总结：异常的使用利大于弊。异常时面向对象语言处理错误的方式，鼓励使用。