C++：异常

Hello大家好！ 很高兴与大家见面！ 给生活添点快乐，开始今天的编程之路。

我的博客: <但愿.

我的专栏: C语言、题目精讲、算法与数据结构、C++

欢迎点赞，关注

目录

前言

二 异常的使用

2.1 异常的抛出和捕获

2.2 栈展开

2.3 异常的抛出和捕获的示例

2.4 查找匹配的处理代码

2.4.1 查找匹配的处理代码的规则

2.4.2 现在处理异常的方法：定义一个基类在生成派⽣类

2.5 异常重新抛出

2.6 异常安全问题

2.7 异常规范(伪规范不是强制的)

三 标准库的异常

四 异常的优缺点

4.1异常的优点

4.2异常的缺点

前言

在C中，传统的异常处理机制有两种：

第一种：
通过assert断言。

第二种：程序异常返回错误码。本质：给错误码遍个号，出错后就告诉你是几号错误，在根据错误码去查(比较麻烦）。

传统处理异常的方法不好，在C++面向对象处理错误而引入异常机制这一处理方式(别的语言也有，只要有面向对象就有)。在C++中异常机制的处理过程是：如果在一个地方出现异常(错误)，就把我想要给你的错误信息弄成一个对象，在把这个对象直接抛出给你(抛异常)，如果此时你想在这个地方处理这个异常就通过throw catch捕获异常(但是必须在throw catch内部抛异常【可能是这个函数，有可能是这个函数的调用链】。

一 异常的概念

• 异常处理机制允许程序中独⽴开发的部分能够在运⾏时就出现的问题进⾏通信并做出相应的处理， 异常使得我们能够将问题的检测与解决问题的过程分开，程序的⼀部分负责检测问题的出现，然后 解决问题的任务传递给程序的另⼀部分，检测环节⽆须知道问题的处理模块的所有细节。
• C语⾔主要通过错误码的形式处理错误，错误码本质就是对错误信息进⾏分类编号，拿到错误码以 后还要去查询错误信息，⽐较⿇烦。异常时 抛出⼀个对象 ，这个对象可以函数更全⾯的各种信息。

二 异常的使用

2.1 异常的抛出和捕获

• 程序出现问题时，我们通过抛出(throw)⼀个对象来引发⼀个异常，该对象的类型以及当前的调⽤ 链决定了应该由哪个catch的处理代码来处理该异常。
• 被选中的处理代码是调⽤链中与该对象类型匹配且离抛出异常位置最近的那⼀个(因为调用链中可能但出的catch的类型和throw的类型都相同）。根据抛出对象的 类型和内容，程序的抛出异常部分告知异常处理部分到底发⽣了什么错误。
• 当throw执⾏时，throw后⾯的语句将不再被执⾏。程序的执⾏从throw位置跳到与之匹配的catch 模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调⽤链中另⼀个函数中的catch，控 制权从throw位置转移到了catch位置。这⾥还有两个重要的含义：
1、沿着调⽤链的函数可能提早 退出(跳到catch中但是没有匹配的类型，此时就会跳到调用链的上一层，此时该层catch后面的一些逻辑可能不好执行，但是栈帧该销毁的销毁)。
2、⼀旦程序开始执⾏异常处理程序，沿着调⽤链创建的对象都将销毁。
• 抛出异常对象后，会 ⽣成⼀个异常对象的拷⻉ ，因为 抛出的异常对象可能是⼀个局部对象，所以会⽣成⼀个拷⻉对象，这个拷⻉的对象会在catch⼦句后销毁。（这⾥的处理类似于函数的传值返回）

【其中走的过程】

函数调用链走的过程

1）无异常：

如果正常无异常时，会像之前一样正常走，不好进入catch（只要出现异常进行匹配处理时才会进入。即无异常处理catch，其余代码正常运行。

2）有异常(抛异常）：

出现异常(无返回值...的概念)位置的后续代码不会执行(即当前函数的后面代码不会执行【对于前面函数的执行时向下执行，只有遇到return才会结束，结束后回到上一个调用它的函数。而这里抛异常，抛出一个对象来引发异常就是为了终止程序因为此时程序已经出问题了】）,后续会和调用链中的catch中的类型进行匹配(即throw抛出的类型和catch中的类型进行匹配，走栈展开的过程【此过程中编译时进行】）

2.2 栈展开

• 抛出异常后，程序暂停当前函数的执⾏，开始寻找与之匹配的catch⼦句，⾸先检查throw本⾝是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地⽅进⾏处理。
• 如果当前函数中没有try/catch⼦句，或者有try/catch⼦句但是类型不匹配，则退出当前函数，继续在外层调⽤函数链中查找(注意异的捕获catch可以有多个，因为可能抛异常时抛出不同类型的异常出来，而捕获的要求只是类型匹配即可，没有匹配的catch会不断向调用链中的上一层匹配，在到main函数)， 上述查找的catch过程被称为栈展开 。 如果异常被捕获catch此时该层catch的代码就会进行执行(即捕获后其他代码正常运行)，直到在调用链中匹配匹配到main函数时还是没有捕获到此时程序就会终止(此时退出码不为0，所以异常必须捕获）。
• 如果到达main函数，依旧没有找到匹配的catch⼦句，程序会调⽤标准库的 terminate 函数终⽌ 程序。
• 如果找到匹配的catch⼦句处理后，catch⼦句代码会继续执⾏。
• 从抛异常和 捕获的过程就知道catch的代码不是顺序运行下去的(如果没有抛异常就直接会跳过)，所以catch的代码一定是通过抛异常跳过去运行的(即抛出异常后跳到对应的捕获去就结束了，其他catch都不会进入不断在调用层中匹配)。

2.3 异常的抛出和捕获的示例

【图解】

【示例】

double Divide(int a, int b)
{
	try
	{
		if (b == 0)
		{
			string s("Divide by zero condition!");
			throw s;//如果出现异常就抛异常，这里抛出一个string类型对象
			//这里先判断throw是否在同一个try catch中，在就在这个中进行类型匹配
			//不在就在其调用层中进行类型匹配
		}
		else//如果没有异常就执行下面代码，但是不会进入catch中，直接到调用的上一层。
		{
			return ((double)a / (double)b);
		}

	}
	catch (int errid)//这里的类型是int和抛异常抛出的类型string不一样，所以不会在继续向下执行；而是继续到调用层的傻瓜一层进行类型匹配
	{
		cout << errid << endl;
	}

	return 0;
}

void func()
{
	int len, time;
	cin >> len >> time;
	try
	{
		cout << Divide(len, time) << endl;
	}
	catch (const char* errmsg)//这里的类型是char*和抛异常抛出的类型string不一样，所以不会在继续向下执行；而是继续到调用层的傻瓜一层进行类型匹配
	{
		cout << errmsg << endl;
	}
	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;//如果没有异常就不会进入到catch中所以直接执行这一行。
}

int main()
{
	while (1)
	{
		try
		{
			func();
		}
		catch (const string& errmsg)////这里的类型是string和抛异常抛出的类型string一样，所以会在继续向下执行,不会在进行异常捕获了，后续代码正常执行
		{
			cout << errmsg << endl;
		}
	}
	return 0;
}

【运行结果】

【无异常抛出】

【有异常抛出】

2.4 查找匹配的处理代码

2.4.1 查找匹配的处理代码的规则

• 为什么要有这个规则：
由于异常可以抛出任意的类型，而类型是无数的(可以是自定义类型，而自定义类型的成员变量等等不同类型也就不同)，那如果此时任由大家随便抛出就很麻烦，所以异常要制定规则，但是也不能规定抛出的类型，因为每个类型所带的东西不一样。
• ⼀般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的 那个。
• 但是也有⼀些例外，允许从⾮常量向常量的类型转换，也就是权限缩⼩；允许数组转换成指向数组 元素类型的指针，函数被转换成指向函数的指针(这里和传参一样，抛异常(拷贝返回拷贝的对象)，如果返回对应的数组和函数代价就太大了；允许从派⽣类向基类类型的转换，这个点⾮常实 ⽤，实际中继承体系基本都是⽤这个⽅式设计的。
• 如果到main函数，异常仍旧没有被匹配就会终⽌程序，不是发⽣严重错误的情况下，我们是不期望 程序终⽌的，所以⼀般main函数中最后都会使⽤catch(...)，它可以捕获任意类型的异常，但是是 不知道异常错误是什么。
(因为在程序中一个功能的出错是不影响其他功能的所以一般不会使用catch(...)，但是异常是抛不完的，如果抛出新类型，而未进行捕获，引发程序终止，此时就麻烦大了，所以这是做出的最坏打算，可以保证因异常未捕获而导致程序终止的最后一道防线。进入catch中只有两种情况要么是未规范抛异常。要么未捕获异常。
所以catch(...),可能新人进入公司刚刚接手项目就会未捕获异常此时作用就体现了。

2.4.2 现在处理异常的方法：定义一个基类在生成派⽣类

在实现中处理异常一般是通过设计出一个异常的基类(一般成员变量有一个记录错误编号的变量和一个记录错误信息的变量，因为每个类型抛出的异常信息可能不一样，所以这里一定要将其弄成抽象类【不可实例化出对象，将一个函数弄成虚函数即可】)；如果没其他类型的错误就抛这个类型，如果有其他的(例如自己还像加一些自己的信息进去即想加一些单独的东西，此时可以加自己的类型中但是必须通过继承异常的基类。也就意味着正常我们只会捕两个异常：捕异常的基类；捕异常的派生类。这样既保证了捕获的地方不用捕获很多类型，又给了各个模块(自己想带的信息)，其次外层捕获到异常，在日志中查到了也要找一下是哪个模块出问题的此时这种设计法案的好处就体现了(每个模块把自己的信息带好即可)。

【示例】

#include<thread>

// 一般大型项目程序才会使用异常，下面我们模拟设计一个服务的几个模块
// 每个模块的继承都是Exception的派生类，每个模块可以添加自己的数据
// 最后捕获时，我们捕获基类就可以
//定义异常的基类
class Exception
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)//输出错误信息的对象
		, _id(id)//编号方便观察错误模块
	{
	}

	// 输出错误信息这里纯虚函数将基类变成抽象类方便后续生成派生类
	virtual string what() const = 0;
	
	//得到错误编号
	int getid() const
	{
		return _id;
	}

protected:
	string _errmsg;
	int _id;
};

//第一个模块-数据库
class SqlException : public Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{
	}

	//输出自己想要的信息
	virtual string what() const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}

private:
	const string _sql;
};

//第一个模块-
class CacheException : public Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{
	}

	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};

//第三个模块
class HttpException : public Exception
{
public:
	HttpException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{
	}

	virtual string what() const
	{
		string str = "HttpException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};

void SQLMgr()
{
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}
	else
	{
		cout << "SQLMgr 调用成功" << endl;
	}
}

void CacheMgr()
{
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}
	else
	{
		cout << "CacheMgr 调用成功" << endl;
	}

	SQLMgr();
}

void HttpServer()
{
	if (rand() % 3 == 0)
	{
		throw HttpException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpException("权限不足", 101, "post");
	}
	else
	{
		cout << "HttpServer调用成功" << endl;
	}

	CacheMgr();
}

int main()
{

	srand(time(0));
	while (1)
	{
		this_thread::sleep_for(chrono::seconds(1));

		try
		{
			HttpServer();
		}
		catch (const Exception& e) // 这里捕获基类，基类对象和派生类对象都可以被
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...) // 最后一道防线
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

2.5 异常重新抛出

概念：
有时catch到⼀个异常对象后，需要对错误进⾏分类，其中的某种异常错误需要进⾏特殊的处理，其他 错误则重新抛出异常给外层调⽤链处理。捕获异常后需要重新抛出，直接 throw; 就可以把捕获的对 象直接抛出。
例如：
在一个程序中的发信息模块，可能因为在地下室等等原因导致信息发不出去，此时要设置每隔一定时间重新发送，重复发送几次未成功就抛异常(这不就要对某种错误进行特殊处理)，这时候我们类中的编号的作用就出来了(我们一般是在外层捕获异常，但是一些特殊场景要在中间捕获异常，这里的中间捕获异常不是处理异常，而是这个异常的某些场景的特殊处理，特殊处理后要把这个异常抛出，异常最终还是要留给外面，当然中间的特殊处理可能处理成功了就不用抛异常(例如发信息，第一次错误，可能在规定次数内发送成功就不用抛异常了。

【示例这里与发信息为例】

class Exception
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)//输出错误信息的对象
		, _id(id)//编号方便观察错误模块
	{
	}

	// 输出错误信息这里纯虚函数将基类变成抽象类方便后续生成派生类
	virtual string what() const = 0;
	
	//得到错误编号
	int getid() const
	{
		return _id;
	}

protected:
	string _errmsg;
	int _id;
};

//第一个模块-数据库
class SqlException : public Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{
	}

	//输出自己想要的信息
	virtual string what() const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}

private:
	const string _sql;
};

//第一个模块-
class CacheException : public Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{
	}

	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};

//第三个模块
class HttpException : public Exception
{
public:
	HttpException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{
	}

	virtual string what() const
	{
		string str = "HttpException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};

void SQLMgr()
{
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}
	else
	{
		cout << "SQLMgr 调用成功" << endl;
	}
}

void CacheMgr()
{
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}
	else
	{
		cout << "CacheMgr 调用成功" << endl;
	}

	SQLMgr();
}

void HttpServer()
{
	if (rand() % 3 == 0)
	{
		throw HttpException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpException("权限不足", 101, "post");
	}
	else
	{
		cout << "HttpServer调用成功" << endl;
	}

	CacheMgr();
}
// 下面程序模拟展示了聊天时发送消息，发送失败补货异常，但是可能在
// 电梯地下室等场景手机信号不好，则需要多次尝试，如果多次尝试都发
// 送不出去，则就需要捕获异常再重新抛出，其次如果不是网络差导致的
// 错误，捕获后也要重新抛出。
void _SeedMsg(const string& s)
{
	if (rand() % 2 == 0)
	{
		throw HttpException("网络超时，发送失败", 102, "put");
	}
	else if (rand() % 7 == 0)
	{
		throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
	}
	else
	{
		cout << "发送成功:" << s << endl;
	}
}

void SendMsg(const string& s)
{
	// 发送消息失败，则再重试3次-中间要做特殊处理
	for (size_t i = 0; i < 4; i++)
	{
		try
		{
			_SeedMsg(s);
			break;
		}
		catch (const Exception& e)
		{
			// 捕获异常，if中是102号错误，网络不稳定，则重新发送
			// 捕获异常，else中不是102号错误，则将异常重新抛出
			if (e.getid() == 102)
			{
				// 重试三次以后否失败了，则说明网络太差了，重新抛出异常
				if (i == 3)
					throw;//异常重新抛出

				cout << "开始第" << i + 1 << "重试" << endl;
			}
			else
			{
				throw;//异常重新抛出
			}
		}
	}
	//...
}


int main()
{
	srand(time(0));
	string str;
	while (cin >> str)
	{
		try
		{
			SendMsg(str);
		}
		catch (const Exception& e)
		{
			cout << e.what() << endl << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

【运行结果】

2.6 异常安全问题

• 异常引起安全问题的原因：
因为异常会影响代码执行的逻辑(异常抛出后，后⾯的代码就不再执⾏），所以可能会引起一些安全问题。
• 第一种：异常抛出后，后⾯的代码就不再执⾏，前⾯申请了资源(内存、锁等)，后⾯进⾏释放，但是中间可 能会抛异常就会导致资源没有释放，这⾥由于异常就引发了资源泄漏，产⽣安全性的问题。中间我 们需要捕获异常，释放资源后⾯再重新抛出。(后⾯智能指针章节讲的RAII⽅式解决这种问题是 更好的)。
• 第二种：析构函数中，如果抛出异常也要谨慎处理，⽐如析构函数要释放10个资源，释放到第5个时抛出异常，则也需要捕获处理，否则后⾯的5个资源就没释放，也资源泄漏了。这时候如果还一个一个try catch中delete就很麻烦了，这时候就要使用智能指针(后一个博客会讲)《Effctive C++》第8个条款也专⻔讲了这个问题，别让异常逃离析构函数。

【示例】

double Divide(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	return (double)a / (double)b;
}

void Func()
{
	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
	// 所以这里捕获异常后并不处理异常，异常还是交给外层处理，这里捕获了再
	// 重新抛出去。
	int* array = new int[10];
	//int* array1 = new int[10];
	//int* array2 = new int[10];
	//int* array3 = new int[10];
	//int* array4 = new int[10];
	//int* array5 = new int[10];
	//int* array6 = new int[10];
	//这里还有一个致命的问题，如果异常不是上面这个 Divide函数引起的，而是int* array = new int[10];
	//中new引起的怎么办，如果是array1引起的，则array要特殊处理，在array1之前写一个try catch特殊处理
	//那个如果是array2引起的呢？在写一个try catch特殊处理吗
	//那又很多个new呢？这种方法就很麻烦了，此时就要使用智能指针。

	try
	{
		int len, time;
		cin >> len >> time;
		cout << Divide(len, time) << endl;
	}
	catch (...)
	{
		// 捕获异常释放内存
		cout << "delete []1:" << array << endl;
		delete[] array;//因为异常未释放内存-这里特殊处理

		throw; // 异常重新抛出，捕获到什么抛出什么
	}

	cout << "delete []2:" << array << endl;
	delete[] array;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "Unkown Exception" << endl;
	}


	return 0;
}

2.7 异常规范(伪规范不是强制的)

• C++98中函数参数列表的后⾯接throw()，表⽰函数不抛异常，函数参数列表的后⾯接throw(类型1, 类型2...)表⽰可能会抛出多种类型的异常，可能会抛出的类型⽤逗号分割。这种⽅式过于复杂，实践中并不好⽤,并且会出乌龙(例如可能会抛三种类型，但是只写了两种类型的异常，规范的不纯粹，并且这种方法不抛异常也要处理)，所以很麻烦，一般不用。
• C++98的⽅式这种⽅式过于复杂，实践中并不好⽤，C++11中进⾏了简化，函数参数列表后⾯加 noexcept表⽰不会抛出异常，啥都不加表⽰可能会抛出异常。
• 编译器并不会在编译时检查noexcept，也就是说如果⼀个函数⽤noexcept修饰了，但是同时⼜包 含了throw语句或者调⽤的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会 报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调⽤ terminate 终⽌程序(即声明了noexcept的函数就不会抛异常，但是你又抛了异常，此时会认为你捕获了异常)。
• noexcept(expression)还可以作为⼀个运算符去检测⼀个表达式是否会抛出异常，可能会则返回 false，不会就返回true。

【示例】

// C++98
// 这⾥表⽰这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这⾥表⽰这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11
size_type size() const noexcept;
iterator begin() noexcept;
const_iterator begin() const noexcept;
double Divide(int a, int b) noexcept
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
return (double)a / (double)b;
}
int main()
{
try
{
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
int i = 0;
cout << noexcept(Divide(1,2)) << endl;
cout << noexcept(Divide(1,0)) << endl;
cout << noexcept(++i) << endl;
return 0;
}

三 标准库的异常

【参考文档】

标准库中异常文档

四 异常的优缺点

4.1异常的优点

异常的处理机制相比于错误码的处理方式，可以清晰准确的展示错误的信息，甚至可以包含栈调用的信息，帮助单位bug。特别是在函数调用链比较深中，错误码要层层往上返回，而异常直接跳到对应的地方！并且在很多第三方库都有自己的异常处理机制。

4.2异常的缺点

在运行时，异常会导致代码执行顺序乱跳，并且非常混乱，导致调试的难度增加。

C++中没有垃圾回收机制，资源要增加管理，异常的产生，可能会导致资源泄漏等异常安全问题，一般是通过智能指针处理。

由于C++标准库中异常体系的不足，导致大家第三方有自己的异常处理体系，非常混乱。

异常尽量规范使用，随意抛异常，外层捕获的用户苦不堪言。所以异常一般：一、抛出的异常类型都继承于异常的基类。而函数是否抛异常，抛什么异常，都使用throw()的方式规范。

本篇文章就到此结束，欢迎大家订阅我的专栏，欢迎大家指正，希望有所能帮到读者更好了解C++相关知识 ，后面我将继续更新解决异常引起的安全问题的智能指针相关知识。觉得有帮助的还请三联支持一下~后续会不断更新算法与数据结构相关知识，我们下期再见。