C++11之异常
C语言传统的处理错误的方式
传统的错误处理机制：
终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序
返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通 过把错误码放到errno中，表示错误
实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的 错误。
异常概念
异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的 直接或间接的调用者处理这个错误
try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块
- throw: 当问题出现时，程序会抛出一个异常**(是一个对象！)**。这是通过使用 throw 关键字来完成的。
catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异 常，可以有多个catch进行捕获
异常的使用
例子
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; cout << "异常被抛出后，这里的代码不会被执行！" << endl; } int main() { try { cout << Dvision(10, 10) << endl; } catch(const char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } return 0; }==如果异常不发生==
那么catch的这个代码就不会执行！——只有通过异常才能进入catch里面！
==如果发生了异常==
cout << Dvision(10, 0) << endl;
==后续的代码都不会执行！直接跳到catch里面！==
相比以前的c语言！——c语言只能返回错误码！（然后通过错误码表去寻找错误！）
但是异常可以抛出更丰富的报错！
异常的抛出和捕获
当存在多个catch的时候——异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码——==必须要求类型匹配！==
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; } int test(int x,int y) { if(x == 1) throw 1; else return y; } int main() { test(1,2);//无法捕抓！ try { //只能在try里面进行捕抓！try外面是捕抓不到的！ cout << Dvision(10, 1) << endl; test(1,2); } catch(const char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } catch(int errid) { cout << "Error id: " << errid << endl; } return 0; }
那么如果在同一个try下面有捕抓相同类型的catch呢？——有的编译器可能会报错！有的编译器可能会警告！
==如果没有匹配的catch！==
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; } int main() { test(1,2); try { cout << Dvision(10, 1) << endl; test(1,2); } catch(char* msg)//此时此时会报错！因为没有匹配的类型！ { cerr << msg << endl; } return 0; }
==此时会直接终止进程！==
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
什么是调用链呢？
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; cout << "异常被抛出后，这里的代码不会被执行！" << endl; } void func() { try { cout << Dvision(10, 0) << endl; } catch(const char* msg)//与要捕获的异常相匹配！ { cerr << msg << endl; }//在中间进行异常捕获！ cout << "------------------------------" << endl; } int main() { try { func(); } catch(char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } return 0; }这个代码有三个函数！
==我们还能发现一点！抛出异常后，它是会继续执行catch后面的执行流的！（如果后面有catch的代码是不会执行的！非catch的代码会执行！）==
为什么要怎么做呢？
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0) throw "Division by zero condition!"; else return a / b; } void func() { int* p = new int[100]; cout << Dvision(10, 0) << endl; delete []p;//如果我们不在func里面进行捕获！ cout << "释放内存成功！！" << endl; } int main() { try { func(); } catch(const char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } return 0; }
==我们发现我们new出来的内存没有被释放！==
==异常的出现导致了可能会出现这种情况的内存泄漏！——这种又叫做异常安全问题！==
我们加回来就可以看到正确的释放了！
void func() { int * p = new int[100]; try { cout << Dvision(10, 0) << endl; } catch(const char* msg) { cerr << msg << endl; }//在中间进行异常平捕获！ delete []p; cout << "释放内存成功！！" << endl; }
那么如果我们想要都集中到main函数统一的捕抓异常！那么我们应该怎么办？
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; cout << "异常被抛出后，这里的代码不会被执行！" << endl; } void func() { int * p = new int[100]; try { cout << Dvision(10, 0) << endl; } catch(const char* msg) { delete []p; cout << "释放内存成功！！" << endl; throw msg;//重新抛出异常！ } delete []p; cout << "释放内存成功！！" << endl; } int main() { try { func(); } catch(const char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } return 0; }但是这样的写法很挫！为了更加简洁好看！要使用只能指针来解决！
如果有很多抛异常的函数要怎么办？
#include <iostream> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 throw "Division by zero condition!";//throw后面是抛出一个对象！(可以是任意类型的对象！) else return a / b; cout << "异常被抛出后，这里的代码不会被执行！" << endl; } void func() { int * p = new int[100]; try { cout << Dvision(10, 0) << endl; //假如这里的函数也要抛异常！那么我们下面就要写好多的catch语句！ // func2(); // func3(); //...... } catch(...)// ... 这个表示可以捕获任意类型的异常！ { delete []p; cout << "释放内存成功！！" << endl; throw;//这样写就是捕获到什么就抛出什么！ } delete []p; cout << "释放内存成功！！" << endl; } int main() { try { func(); } catch(const char* msg)//捕获一个const char*类型的对象 { cerr << msg << endl; } return 0; }这种我们一般称之为==异常的重新抛出==
单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用 链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。
抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象， 所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁（生命周期被延长到catch里面）。（这里的处理类似于函数的传值返回）
#include <iostream> #include <string> using namespace std; double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 { string s("Division by zero condition!"); throw s;//当要抛出异常对象的时候！就可能要构造出来一个对象！ //而这个对象可能是一个临时对象！——出了作用域就 //所以这个s这里就是一个右值（将亡值！） //传值返回编译器一般都会被识别成右值！ } else return a / b; } void func() { cout << Dvision(10, 0) << endl; } int main() { try { func(); } catch(const string& msg)//捕获的时候最好加上引用防止拷贝！ //所以我们捕获的时候不是上面的那个s！我们捕获的是s的拷贝（一个临时变量）！ //这个临时对象！会在catch之后会被销毁！ //这个临时对象比较特殊不具有const属性！——所以我们也可以使用string& 进行接收！ //因为编译器会将这个异常对象的生命周延长至catch下面的代码块！（所以是可以被string& 接收的！） { cerr << msg << endl; } return 0; }catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。
catch还有一种使用场景！——防止因为未知异常导致程序崩溃！（或者终止！）
==因为程序终止是一件很严重的问题！==
double Dvision(double a, double b) { if(b == 0)//如果被除数为0，抛出异常 { string s("Division by zero condition!"); throw s;// } else return a / b; } void func() { cout << Dvision(10, 0) << endl; } int main() { try { func(); } catch(string& msg) { cout << msg << endl; } catch(...)//放在这里是为了防止程序因为未知异常而导致终止！ { //因为未知异常可能不会匹配类型！！ cout << "未知异常！" <<endl; } return 0; }所以一般情况！我们都会写一个任意异常！
因为一般的程序都是一个死循环！所以捕抓到这个未知异常后还是可以继续运行！
如果遇到了抛出多个不同类型异常情况应该怎么办？
例如：有一个项目组，里面有30个人——每一个人抛出了一个异常！而且，异常都是属于不同的类型异常！（例如数据库的异常，内存的异常......）那么该怎么办？
==那么我们是不是应该写很多很多的不同的情况？——我们还不能使用 ... 来捕抓！ ...主要是用来捕抓未知或者中间转发一下(重新抛出)（因为... 并不能知道它捕抓的是什么类型的异常！）==
所以异常有一个最终的解决方案
实际中抛出和捕获的匹配原则有个例外，==并不都是类型完全匹配，可以抛出的派生类对象， 使用基类捕获==——而且是支持多态的！
class Exception//基类 { public: Exception(const string& errmsg, int id) :_errmsg(errmsg) ,_id(id) {} virtual string what() const { return _errmsg; } protected: string _errmsg; int _id; };class SqlException : public Exception//派生类！ //这是关于sql的异常的报错！ { 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 HttpServerException : public Exception { public: HttpServerException(const string& errmsg, int id, const string& type) :Exception(errmsg, id) , _type(type) {} virtual string what() const { string str = "HttpServerException:"; str += _type; str += ":"; str += _errmsg; return str; } private: const string _type; };==接下来我们写一个模拟的情况！==
#include <iostream> #include <string> #include <cstring> #include <ctime> #include <windows.h> //使用随机值来模拟出现错误！ void SQLMgr() { srand(time(0)); if (rand() % 7 == 0) { throw SqlException("权限不足", 100, "select * from name = '张三'"); } //throw "xxxxxx"; } void CacheMgr() { srand(time(0)); if (rand() % 5 == 0) { throw CacheException("权限不足", 100); } else if (rand() % 6 == 0) { throw CacheException("数据不存在", 101); } SQLMgr(); } void HttpServer() { // ... srand(time(0)); if (rand() % 3 == 0) { throw HttpServerException("请求资源不存在", 100, "get"); } else if (rand() % 4 == 0) { throw HttpServerException("权限不足", 101, "post"); } CacheMgr(); } int main() { while (1) { this_thread::sleep_for(chrono::seconds(1)); try{ HttpServer(); } catch (const Exception& e) // 这里捕获父类对象就可以 { // 多态 cout << e.what() << endl; } catch (const CacheException& e)//虽然语法是支持的 { //但是因为异常上面的就可以适配所以是不会走到这里的！ //但是如果想要对这种类型的异常进行特殊处理可以将其放在 //catch (const Exception& e) 的上面！ cout << "11111111" <<endl; } catch (...)//这里是为了防止出现未知异常导致程序崩溃！ { //可以修改上面的异常抛出一个未知的来进行测试！ cout << "Unkown Exception" << endl; } } return 0; }
==我们可以很简单的看出来是什么错误！发生错误的原因是什么！==
在函数调用链中异常栈展开匹配原则
- 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。(就是检测一下这个函数里面本身有没有try catch语言！有且有匹配那么就是直接进入这个匹配的!）
- 没有匹配的catch则退出当前函数栈，继续在调用函数的栈(上一个栈帧)中进行查找匹配的catch。
- ==如果到达main函数的栈，依旧没有匹配的，则终止程序==。上述这个沿着调用链查找匹配的 catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异 常，否则当有异常没捕获，程序就会直接终止
- 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行
异常安全
除了上面的我们说的会导致内存泄漏异常安全还分一下几类
- 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
- 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内 存泄漏、句柄未关闭等)
和上面的构造函数的道理是差不多的！
==虽然上面的情况！看起来不怎么可能发生！但是这种情况的发生往往不是我们主动的抛出异常！而是我们在中间的调用了什么容器，或者什么函数，或者new（new失败就会抛异常！）导致了被动的抛出异常！——这种隐藏行为导致的异常抛出往往是最难找到的==
- C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄 漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题
异常规范
- 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的 后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
- 函数的后面接throw()，表示函数不抛异常。
- 若无异常接口声明，则此函数可以抛掷任何类型的异常。
// 这里表示这个函数会‘可能’抛出A/B/C/D中的某种类型的异常 void fun() throw(A，B，C，D); // 这里表示这个函数只会抛出bad_alloc的异常 void* operator new (std::size_t size) throw (std::bad_alloc); //new会抛出异常！ // 这里表示这个函数不会抛出异常 void* operator delete (std::size_t size, void* ptr) throw(); //说明delete是不会抛出异常的！ // C++11 中新增的noexcept，表示不会抛异常 thread() noexcept; thread (thread&& x) noexcept;
C++标准库的异常体系
int main() { catch (const exception& e) //这是C++标准库里面的异常 { } catch (...) { cout << "Unkown Exception" << endl; return 0; } }==这是这个异常的派生类！==
例如：bad_alloc这个我们一般调用new的出现错误的时候就会抛出这个异常！
==这些是间接使用上面这些派生类的异常！==
像是out_of_rang就是在vector中使用的at接口就是使用这个类型进行抛异常！
==但是其实一般情况很少会使用到C++标准库里面的异常！一般的公司都会自己写一个异常体系！——因为这套异常体系复杂，没有强制所以很难让所有人遵守==
异常的优缺点
优点：
异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包 含堆栈调用的信息，这样可以帮助更好的定位程序的bug
返回错误码的传统方式有个很大的问题就是，在函数调用链中**，深层的函数返回了错误，那 么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。**
很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们 也需要使用异常
部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如 T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回 值表示错误。
T& operator[](size_t pos) { assert(pos < _size);//要么使用断言！ if(pos >= _size)//要么抛出异常！ { throw out_of_rang("越界访问！"); } return _start[pos];//这种就没有办法用错误码处理！ }缺点：
- 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会 导致我们跟踪调试时以及分析程序时，比较困难
异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常 安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常 规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都 使用 func(), noexcept的方式规范化。
像是比较大型的项目！——一般是依靠异常的日志来进行查错的！
