前言

1. 在程序运行时经常碰到一些错误，例如年龄、身高不能为负，除数为0等，这些错误放到程序中如果不加以管制，程序就会崩溃。C++提供了异常机制，让我们能跟捕获运行时错误，给程序一次机会，给用户一个反馈。

2. C++异常处理机制可以让我们捕获并进行处理错误，然后我们可以通过捕获后的判断，重新给程序指一条明路，或者在程序结束之前，做一些必要的工作，例如将错误写到日志等。

说到C++，C语言的处理错误方式也简单提一下:
assert宏

1. 生产环境可能被禁用（会带来性能开销，并且不能对用户提供任何实际好处）编译器会优化掉。
2. 开发环境可以用来检查条件，但是不提供详细的错误信息，并且终止程序。
3. 只能用来检查布尔表达式，无法用于更复杂的逻辑和错误处理。

返回错误码

1. 程序员要自己查找对应的错误，系统很多库函数也都是通过错误码（errno）表示错误

一、程序的错误分类

程序的错误大致可以分为三种，分别时语法错误、逻辑错误和运行时错误。

1. 语法错误：在编译和链接阶段就能发现，必须全符合语法规则才能生成可执行代码。这种错误最简单。
2. 逻辑错误：编码思路问题，执行的结果不是预定的，也可以通过调试解决。
3. 运行时错误：程序运行期间发生的错误，如同除0，越界等。C++异常（Exception）机制就是为了解决这种错误。

二、异常

1. 概念

异常：异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛异常，让函数的直接或间接调用者处理这个错误。

2. 捕获异常的关键字和格式

C++异常处理涉及三个关键字

• throw：出现问题，程序使用throw抛出异常
• catch：有抛出也得有捕获，catch关键字就是用来捕获异常。捕获的地方就是处理问题的地方。
• try：try块中的代码为保护代码，如果出错会激活特定的异常，后面跟着一个或多个catch块。

eg:语法

try{//保护区，就是可能会出错的代码
}
catch(ExceptionName e1){//出错后，通过异常处理程序捕获异常，在这里处理问题或者 再抛出
}
catch(ExceptionName e2){//因为异常对象类型的多样，所以可以多个catch块捕获匹配的异常
}
catch(...){//如果try块中出现异常，而前面的catch块也没有捕获，这是最后一道防线，所有类型都会在这里捕获，但不知道异常的错误原因。
}

注意： 可能有些不好理解，后面内容我会逐步介绍

3. 异常的使用

异常的原则

简单的例子：

double Division(int a, int b)
{if (b == 0)throw "Division by zero condition!";elsereturn (double)a / (double)b;
}void Func()
{int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}int main()
{try {Func();}catch (const char* errmsg){cout << errmsg << endl;}catch (...){cout << "unknow exception" << endl;}return 0;
}

上例的函数调用链中栈的细节：

1. 检查被throw是否在try块中，如果在并触发异常。
2. 被throw抛出对象的类型和最近的catch块的参数进行匹配，匹配成功，则调到catch块中处理。没有匹配成功，则退出当前函数栈，在调用该函数的栈中继续匹配。
3. 如果到main函数的栈依旧没有匹配，则终止程序（非正常结束）。但一般有catch(…)兜底。
4. 如果匹配到catch子句处理完块中内容后，会沿着try,catch语句后继续执行

匹配原则

1. throw抛出的对象类型与调用链中位置最近并且参数类型一样的catch匹配。
2. throw抛出异常会生成一个异常对象的拷贝（因为抛出的对象可能是一个临时对象），这个拷贝的对象会被catch以后销毁。（类似函数传值返回）
3. catch(…)可以捕获任意类型异常，但是不知道异常错误是什么。
4. 匹配原则的例外：可以抛出派生类对象，使用基类捕获。（后面讲）

异常再抛出

一个单独的catch语句不能完整的处理某个异常，再执行一些校正操作之后，可能会抛给调用链更上一层的函数接着处理异常。
这个简单的校正工作可能就是改变参数内容，但是这里又要注意是不是引用
eg:

//简单的校正操作
catch (my_error& eObj){                     //引用类型 eObj.status = errCodes::severeErr;      //修改了异常对象throw;
}
catch (other_error eObj) {                     //非引用类型 eObj.status = errCodes::severeErr;         //只修改了异常对象的局部副本throw;
}

异常再抛出：

try
{//保护代码//...
}
catch (const char* errmsg)
{cout << errmsg << endl;
}
catch (...)
{throw;//异常再抛出，不含任何表达式//注意异常进行抛出后，是直接跳过这个函数栈的后面部分，例如下面的打印语句就  不会在进行执行cout << "unknow Exception" << endl;
}

异常说明

目的是为了让使用者知道该函数抛出的异常类型。

异常说明：

//这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void func()  throw(A, B, C, D);//这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);//这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw ();//若无异常接口声明：表示这个函数可以抛出任何类型的异常
void func1()

C++11新增的noexcept，表示不会抛出异常

void recoup(int) noexcept; //不会抛出异常
void alloc(int)            //可能抛出异常

注意： noexcept的位置也很特殊，因为const，final，override或者虚函数=0，都可以跟在函数后面，所以noexcept要在const及引用限定符之后，在final，override或者虚函数=0之前。

注意事项

建议

1. 不要在构造函数中抛出异常（可能导致对象未完成初始化）
2. 不要在析构函数中抛出异常（可能导致资源泄漏）
3. 不要在lock和unlock之间抛异常（死锁）（后面的博客讲）

4. 自定义异常体系

实际很多公司会自己定义异常体系，规范管理。大家抛出的都是继承的派生类对象，捕获一个基类即可。

eg:服务器开发中使用的异常继承体系（例子）

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
{
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:SqlException(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;
};

调用捕获：

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 (true){Sleep(500);      //引用系统头文件<Windows.h>try {HttpServer();}catch (const Exception& e) // 这里捕获父类对象就可以{// 多态cout << e.what() << endl;}catch (...){cout << "Unkown Exception" << endl;}}return 0;
}

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

注意： C++标准库的异常体系设计的不好用，所以一般都是定义自己的异常体系

三、总结

异常总体而言利大于弊

异常的优缺点

优点：

1. 异常对象定义好了，可以更加清晰准确的展示出错误的各种信息，更好的定位bug。
2. 不需要层层返回检查并错误码，异常体系直接跳到catch捕获的位置
3. 很多第三方库都包含异常，想要使用这些库也需要使用异常
4. 部分函数使用异常更好处理，例如没有返回值的或者不便于返回的。

缺点：

1. 执行流乱跳，导致跟踪调试时以及分析程序困难，很混乱
2. 性能的开销
3. C++标准库的异常体系定义的不好，大家各自定义异常体系，不统一