1. 基本概念
异常，即 exception，是C++中的基本概念之一，在某段程序发生无法继续正常执行的情况时，C++允许程序进行所谓抛出异常（有时也被称为吐出异常）的行为，这些被抛出的异常，会自动地从触发点开始向外传播，直到被捕获（有时也被称为吞下异常）或者程序终止。
2. 语法
2.1 抛出异常
下面用一个简单的例子，说明异常是如何发生的：
// 一个简易除法器，返回 a ÷ b 的结果
float divider(float a, float b)
{
// 当除数b为0时，抛出异常！
if(b == 0)
throw "除数不可为零";
return a/b;
}
int main(void)
{
float a,b;
// 从键盘获取被除数a和除数b，并输出结果
while(1)
{
cin >> a >> b;
cout << divider(a, b) << endl;
}
return 0;
}
在上述代码中，除法器函数 divider() 中出现了一个新的关键字：throw，它代表抛出异常操作，所谓的抛出异常，就是在程序中触发一个必须处理的情况，如果不处理，程序将会被强行终止。像上述代码，main() 函数没有对除法器 divider() 潜在会抛出的异常进行任何处理，因此当输入的除数 b 为0时，触发的异常将直接关闭程序。
注意
上述代码的流程是：
如果异常发生在更里层的函数调用中，那么异常会一直向外传播，直到遇到main函数，如果一直没有任何函数捕获异常，那么异常就会终结程序，这是异常的第一个特征：强制性。
假设有如下代码：
void f3()
{
throw "抛出异常";
}
void f2()
{
f3();
}
void f1()
{
f2();
}
int main()
{
f1();
cout << "此语句不会被执行" << endl;
}
此时，异常发生在函数 f3() 处，然后一路传播到最终的调用者 main() 函数，这就是异常第二个特性：传播性。
2.2 捕获异常
如果程序不想被异常终止，那么就应该在异常的传播链上的某一环对其进行处理，即所谓的捕获异常，或吞下异常等操作，即 catch，例如上述调除法器的程序，可以让main函数捕获除数为0的异常：
/ 一个简易除法器，返回 a ÷ b 的结果
float divider(float a, float b)
{
// 当除数b为0时，抛出一个字符串异常
if(b == 0)
throw "除数不可为零";
return a/b;
}
int main(void)
{
float a,b;
float ans; // ans = a ÷ b
// 从键盘获取被除数a和除数b，并输出结果
while(1)
{
cin >> a >> b;
// 试图执行 a÷b
try{
ans = divider(a, b);
}
catch(const char * &e)
{
// 发生了异常
cout << e << endl;
break;
}
// 输出运算结果
cout << ans << endl;
}
return 0;
}
以下是执行效果：
gec@ubuntu:~$ ./a.out
88 0
除数不可为零
gec@ubuntu:~$
关键代码：
try{
有潜在抛出异常可能的代码块
}
catch(类型1 e)
{
处理异常类型1
}
catch(类型2 e)
{
处理异常类型2
}
catch(...)
{
处理其他异常类型
}
语法要点:
将有可能出现异常且需要捕获这些异常的代码，放入 try{} 代码块中。
try{} 代码块至少带一个 catch(){} 代码块，也可以带多个。
当异常发生时，多个 catch(){} 代码块中最多执行一个，用类型来区分它们。
当没有任何 catch(){} 的类型能匹配异常时，异常会被继续向main函数传播，如果没有任何函数捕获异常，程序将被异常终止。
可以用 catch(...){} 来匹配任意类型的异常。
2.3 异常的类型
捕获异常时，如果有多个 catch(){} 代码块，它们是以异常的类型来彼此区分的，也就是说如果被调函数有触发异常的多种不同的可能，且每种不同的异常情况需要不同的处理方式，那么要抛出不同的异常类型来区分它们，示例代码如下：
void f3(int n)
{
// 当遇到三种不同的异常需要区别以待时
// 抛出三种不同类型的异常
if(n == 1)
throw 666;
if(n == 2)
throw 1.23;
if(n == 3)
throw "abc";
cout << "程序正常执行" << endl;
}
void f2(int n)
{
try{
f3(n);
}
catch(const int &e)
{
cout << "遇到了异常情况1:" << e << endl;
cout << "处理完毕" << endl;
}
}
void f1(int n)
{
try{
f2(n);
}
catch(const double &e)
{
cout << "遇到了异常情况2:" << e << endl;
cout << "处理完毕" << endl;
}
}
int main()
{
int n;
cin >> n;
f1(n);
cout << "遇到异常情况3时，程序无法处理，将被终止" << endl;
}
上面的程序展示了如何为不同的异常安排一个类型来加以区分，它们分别是：
返回一个 int 型数据时，代表发生了异常情况1
返回一个 double 型数据时，代表发生了异常情况2
返回一个 const char * 型数据时，代表发生了异常情况3
乍一看这设计有问题，因为如果异常情况较多（比如有10种不同的异常情况），那么就很难找到这么多不同的数据类型来对它们进行彼此区分了，而在原来C语言的框架下，不同的错误情况只需要对应不同的错误值即可，比如返回-1、-2、-3来区分不同的错误。
问题的奥秘在于，抛出的异常一般是以类对象的方式出现的，而类是可以继承的，这样一来，不仅可以让每一种不同的类型异常对应灵活定义的类对象，还能利用类的层次关系在顶层的异常父类中定义通用的报错渠道，极大地扩展了对错误信息处理的灵活性。事实上，C++已经提供了标准的异常类，来作为各种不同异常情况的顶层父类，供我们扩展使用，它们被定义在如下头文件之中：
#include <exception>
C++为每种不同的异常定义了标准异常类，既可以直接使用这些异常类，也可以根据实际所需扩展这些类：
一个使用上述标准异常类的简单例子：
#include <iostream>
#include <exception>
using namespace std;
float divider(float a, float b)
{
// 抛出标准异常对象
if(b == 0)
throw invalid_argument("除数不可为零");
return a/b;
}
int main(void)
{
float a,b;
float ans; // ans = a ÷ b
while(1)
{
cin >> a >> b;
try{
ans = divider(a, b);
cout << ans << endl;
}
// 捕获参数非法异常
catch(invalid_argument &e)
{
cout << e.what() << endl;
}
}
return 0;
}
关于运用类的继承机制，基于标准异常类扩展自定义异常类，可以等到学习了类与继承之后，再自行进行练习，目前可以简单将标准异常类看做就是一种数据类型即可。
3. 异常与返回错误值的区别
在刚接触C++异常机制的时候，很容易会跟C语言的函数出错返回相对比，掌握异常机制的语法规范很简单，但关键还要理解这么设计的初衷和用意。
首先要理解，当一个函数发生异常时，类似于在某个组织中的一个基层人员遇到了某个无法处理的问题，这个问题可能是基层人员能力、权限、格局所致，正确的做法是将该问题逐级上报，每一级有每一级的解决问题的层次，基层解决不了的，上一级有可能可以解决，或者基层不知道该怎么处理的，上一级有可能知道怎么处理，这种层层上报的工作须是自动发生的，如果某一个层级不对基层上报上来的异常做任何处理，那么该异常会自动地传播给上上级，且如果组织中没有任何对已出现的异常负责，也无人进行处理，那么为了避免埋雷，避免留下隐患，整个组织将会因为这个无人认领的异常而被强制终止运转。基于这样的逻辑设定，C++发明了异常机制，来更好地、更方便地维护程序的健壮和安全。
在函数内抛出异常，跟返回错误值，有如下区别：
(1)传播性
返回错误值，不具备自动传播性，某层级的代码无法处理基层传来的错误，依然需要做判定和处理，非常麻烦。
异常具备自动传播性，遇到与本层级无关、或不属于本层级管理的异常，不管它即可，它会自动向主函数传播。
(2)强制性
返回错误值，不具备强制性，容易给程序埋下难以察觉的隐患。异常具备强制性，不处理程序就会自动终止，将隐患尽早暴露出来。
(3)灵活性
返回错误值时，用不同的值来区分不同的错误，类型是固定的，即无法使用类与继承的方式代码重用。触发异常时，用不同的类型来区分不同的错误，天生就支持类与继承方式来代码重用，并且可以通过设定标准异常类来规范各种形式的错误信息，灵活性大大提高。
4. 异常与析构函数
5. 异常安全性问题
#include <iostream>
#include <string>
#include <exception>
#include <stdexcept>
using namespace std;
class err
{
public:
err(string const &s){_msg = s;}
string &msg(){return _msg;}
private:
string _msg;
};
void f1(int a)
{
// 抛出的异常，可以是普通变量，也可以是类对象
// 抛出的异常对象与函数传参类似，被传送至catch语句
// 但有以下两点不同:
// ① 异常对象能持续追踪try...catch语句，直到遇到匹
// 配的类型，或者程序退出
// ② 异常对象在匹配的catch语句之后仍然存在不会释放
if(a == 1)
throw "abcd";
else if(a == 2)
throw 3.14;
else if(a == 3)
{
throw (runtime_error("运行时错误"));
}
else if(a == 4)
{
throw (err("自定义错误"));
}
else
{
throw ('a');
}
return;
}
void f2(int n)
{
try
{
f1(n);
}
catch(const char *e)
{
cerr << "错误:" << e << endl;
}
catch(double e)
{
cerr << "错误:" << e << endl;
}
}
int main(void)
{
int n;
while(1)
{
cin >> n;
try
{
f2(n);
}
catch(runtime_error &e)
{
string errstr;
errstr.append(__FUNCTION__).append(":").append(e.what());
cerr << errstr << endl;
}
catch(err &e)
{
string errstr;
errstr.append(__FUNCTION__).append(":").append(e.msg());
cerr << errstr << endl;
}
catch(...)
{
cerr << "其他未知情况" << endl;
}
}
return 0;
}
#include <iostream>
using namespace std;
bool DBEnable = false;
void close()
{
if(!DBEnable)
throw 100;
else
cout << "数据库正常关闭了" << endl;
}
// 类对象用来管理一个数据库的连接
// 当对象被释放时，析构函数将自动断开数据库的连接
class A
{
bool closed;
public:
A(){closed = false;}
void dbclose();
~A();
};
void A::dbclose()
{
close();
closed = true;
}
// 当对象被释放时，析构函数将自动断开数据库的连接
// 而析构过程中的 close() 可能会触发异常
A::~A()
{
if(!closed)
{
// close会触发异常，不处理的话
// 该异常将外溢到析构函数之外的其他代码，造成程序终止或者不明确行为
// 因此使用try...catch捕获异常是类对象职责所在
// 但如果仅提供此项功能，就意味着类对象的使用者无法干预close所带来的问题
try
{
close();
}
catch(...)
{
cout << "close触发了异常" << endl;
}
}
}
int main()
{
// 对象 a 出了代码块将被释放，届时触发析构函数
// 由于 a 的使用者（即本main函数）不对数据库关闭可能触发的异常感兴趣
// 因此以下代码可能会错失处理该异常的第一时机
{
A a;
}
A b;
// 作为类对象的使用者，可以显式地使用 try...catch 来捕获异常
// 一旦发现确有问题，便可酌情作出处理
// 相反，如果将可能触发异常的 close 只封装在类析构函数中，由于析构函数
// 被调用的时机的特殊性，将会使得类对象使用者则很难或无法针对异常做出反应
try
{
b.dbclose();
}
catch(...)
{
cout << "数据库关闭异常，接下来做出某些操作... ..." << endl;
DBEnable = true;
}
return 0;
}