Ciallo～(∠・ω< )⌒☆ ~ 今天，我将和大家一起学习C++中的异常 ~
❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
澄岚主页：椎名澄嵐-CSDN博客
C++基础篇专栏：★ C++基础篇 ★_椎名澄嵐的博客-CSDN博客
C++进阶篇专栏：★ C++进阶篇 ★_椎名澄嵐的博客-CSDN博客
❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
目录
壹 异常的概念及使用
1.1 异常的概念
1.2 异常的抛出和捕获
1.3 栈展开
1.4 查找匹配的处理代码
1.5异常重新抛出
1.6 异常安全问题
1.7 异常规范
1.8 标准库的异常
壹 异常的概念及使用
1.1 异常的概念
异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理， 异常使得我们能够将问题的检测与解决问题的过程分开，程序的⼀部分负责检测问题的出现，然后 解决问题的任务传递给程序的另⼀部分，检测环节无须知道问题的处理模块的所有细节。
C语言主要通过错误码的形式处理错误，错误码本质就是对错误信息进行分类编号，拿到错误码以 后还要去查询错误信息，比较麻烦。异常时抛出⼀个对象，这个对象可以函数更全面的各种信息。
1.2 异常的抛出和捕获
程序出现问题时，我们通过抛出(throw)一个对象来引发一个异常，该对象的类型以及当前的调用链决定了应该由哪个catch的处理代码来处理该异常。
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的 类型和内容，程序的抛出异常部分告知异常处理部分到底发⽣了什么错误。
double Divide(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
string s("Divide by zero condition!");
throw s; // 会直接跳转到处理异常的地方
cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl; // 永远不执行
}
else
{
return ((double)a / (double)b);
}
return 0;
}
void Func()
{
int len, time;
cin >> len >> time;
try
{
cout << Divide(len, time) << endl;
}
catch (const char* errmsg) // 因为类型不匹配不会跳在这里~
{
cout << errmsg << endl;
}
cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}
int main()
{
while (1)
{
try
{
Func();
}
catch (const string& errmsg)
{
cout << errmsg << endl; // <--这里~
}
}
return 0;
}
当throw执行时，throw后面的语句将不再被执行。程序的执行从throw位置跳到与之匹配的catch模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调用链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置。这里还有两个重要的含义：
1、沿着调用链的函数可能提早退出。
2、⼀旦程序开始执行异常处理程序，沿着调用链创建的对象都将销毁。
抛出异常对象后，会生成⼀个异常对象的拷贝，因为抛出的异常对象可能是一个局部对象，所以会 ⽣成⼀个拷⻉对象，这个拷⻉的对象会在catch⼦句后销毁。
1.3 栈展开
抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch⼦句，首先检查throw本身是否 在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，栈会正常调用销毁，上述查找的catch过程被称为栈展开。
如果到达main函数，依旧没有找到匹配的catch子句，程序会调用标准库的terminate 函数终止程序。
1.4 查找匹配的处理代码
一般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的 那个。
但是也有⼀些例外，允许从非常量向常量的类型转换，也就是权限缩小；允许数组转换成指向数组 元素类型的指针，函数被转换成指向函数的指针；允许从派生类向基类类型的转换，这个点非常实 用，实际中继承体系基本都是用这个方式设计的。
如果到main函数，异常仍旧没有被匹配就会终止程序，不是发生严重错误的情况下，我们是不期望程序终⽌的，所以⼀般main函数中最后都会使用catch(...)，它可以捕获任意类型的异常，但是是 不知道异常错误是什么。
class Exception
{
public:
Exception(const string& errmsg, int id)
:_errmsg(errmsg)
, _id(id)
{}
virtual string what() const
{
return _errmsg;
}
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;
}1.5异常重新抛出
有时catch到⼀个异常对象后，需要对错误进行分类，其中的某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接 throw; 就可以把捕获的对象直接抛出。
void _SendMsg(const string& s)
{
if (rand() % 2 == 0)
{
throw HttpException("⽹络不稳定，发送失败", 102, "put");
}
else if (rand() % 7 == 0)
{
throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
}
else
{
cout << "发送成功" << endl;
}
}
void SendMsg(const string& s)
{ // 发送消息失败，则再重试3次
for (size_t i = 0; i < 4; i++)
{
try
{
_SendMsg(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;
}1.6 异常安全问题
异常抛出后，后面的代码就不再执行，前面申请了资源(内存、锁等)，后面进行释放，但是中间可 能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我 们需要捕获异常，释放资源后面再重新抛出，智能指针章节讲的RAII方式解决这种问题是更好的。
其次析构函数中，如果抛出异常也要谨慎处理，⽐如析构函数要释放10个资源，释放到第5个时抛 出异常，则也需要捕获处理，否则后⾯的5个资源就没释放，也资源泄漏了。《EffctiveC++》第8 个条款也专⻔讲了这个问题，别让异常逃离析构函数。
1.7 异常规范
对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异 常有助于简化调用函数的代码。
C++98中函数参数列表的后面接throw()，表示函数不抛异常，函数参数列表的后面接throw(类型1, 类型2...)表示可能会抛出多种类型的异常，可能会抛出的类型用逗号分割。
C++11中进行了简化，函数参数列表后面加 noexcept表示不会抛出异常，啥都不加表示可能会抛出异常。编译器并不会在编译时检查noexcept，也就是说如果⼀个函数⽤noexcept修饰了，但是同时又包含了throw语句或者调⽤的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调用 terminate 终止程序。
// 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;noexcept(expression)还可以作为⼀个运算符去检测⼀个表达式是否会抛出异常，可能会则返回 false，不会就返回true。
cout << noexcept(Divide(1, 2)) << endl;
cout << noexcept(Divide(1, 0)) << endl;
cout << noexcept(++i) << endl;1.8 标准库的异常
exception - C++ Reference
C++标准库也定义了一套自己的一套异常继承体系库，基类是exception，所以我们日常写程序，需要在主函数捕获exception即可，要获取异常信息，调用what函数，what是一个虚函数，派生类可以重写。
~ 完 ~
