注：原创不易，转载请务必注明原作者和出处，感谢支持！
注：内容来自某培训课程，不一定完全正确！
一 C++异常机制概述
什么是异常处理?一句话，异常处理就是处理程序中的错误。
为什么需要异常处理以及异常处理的基本思想？
C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以在用户的代码里处理了，不用留给库去发现）。
Bjane Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或间接）调用者能够处理这个问题。也就是说，C++将问题的检测与问题的处理相分离。
在异常处理机制出现之前的错误处理方式？在C语言中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单理解为一个全局整型变量）去记录错误。当然C++中仍然可以使用这两种方法。但是这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。还有一个缺点是一个函数的返回值只有一个，你通过函数的返回值标识错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但这可能会令你的程序略微晦涩难懂。
异常的优点在哪里？
（1）函数的返回值可以忽略，但异常不可以忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少回促使程序员开发出来的程序更健壮一点。而如果使用C语言的errno宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其妙地终止或者出现错误的结果。
（2）整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。
（3）整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
（4）异常处理可以在调用时跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需在一处进行处理就可以了，不需要每级函数都处理。
下面是一个异常的基本语法实例。如果除数y为0，则抛出y的值。在Test1()中尝试捕获异常。
// 异常的基本语法
int Divide(int x, int y)
{
if (y == 0)
{
// 抛出异常
throw y;
}
return x / y;
}
void Test1(void)
{
// 试着捕获异常
try
{
Divide(10, 0);
}
// 异常是根据类型进行匹配的
catch (int e)
{
cout << "Error : 除数为" << e << endl;
}
}
异常可以跳级处理。比如在下面的这个例子中，函数的调用顺序为Test2() --> CallDivide() --> Divide()。异常在Divide()函数中被抛出，但异常的捕获却没有在CallDivide()中进行，而是放到了Test2()中进行。
int Divide(int x, int y)
{
if (y == 0)
{
// 抛出异常
throw y;
}
return x / y;
}
// CallDivide()并未对异常进行处理
void CallDivide(int x, int y)
{
Divide(x, y);
}
// Divide()所抛出的异常在函数调用顶层Test2()中被捕获
// 如果Test2()中仍然没有捕获到Divide()所抛出的异常，则
// 异常会被抛到函数调用的最顶层main()函数中，如果在main()
// 中异常还没有被捕获并处理，则程序会终止执行！
void Test2(void)
{
try
{
CallDivide(10, 0);
}
catch (int e)
{
cout << "错误：除数为" << e << endl;
}
}
二 栈解旋（unwinding）
栈解旋是指当异常被抛出后，从进入try块起，到异常被抛出前，这期间在栈上构造的所有对象，都会被自动析构，析构的顺序与构造的顺序相反。这一过程被称为栈的解旋（unwinding）。
比如下面的例子，进入try语句块之后，先调用的是CallDivide()，在CallDivide()当中先是构建了Person对象p3，然后调用Divide()，在Divide()当中构建了对象p1和p2，直到异常的发生。
class Person
{
public:
Person(string nm)
{
name = nm;
cout << "Person对象" << name << "构建" << endl;
}
~Person()
{
cout << "Person对象" << name << "析构" << endl;
}
private:
string name;
};
int Divide(int x, int y)
{
Person p1("p1");
Person p2("p2");
if (y == 0)
throw y;
return x / y;
}
void CallDivide()
{
Person p3("p3");
Divide(10, 0);
}
void Test01()
{
try
{
CallDivide();
}
catch (int e)
{
cout << "有异常发生！" << endl;
}
}
上面程序的输出如下，可以看到构建的顺序和析构的顺序刚好相反。
Person对象p3构建
Person对象p1构建
Person对象p2构建
Person对象p2析构
Person对象p1析构
Person对象p3析构
有异常发生！
三 异常接口的声明
（1）为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw (A, B, C)，这个函数func能够且只能抛出类型A，B，C及其子类型的异常。
（2）如果在函数声明中没有包含异常接口声明，则此函数可以抛出任何类型的异常
（3）一个不抛出任何异常的函数可以声明为：void func() throw ()
（4）如果一个函数抛出了它的异常接口声明所不允许抛出的异常，则unexcepted函数会被调用，该函数默认行为调用terminate()函数中断程序。
下面是一个异常接口声明的实例。
// 这个函数只能抛出int float char三种类型的异常，抛出其他异常就报错
void func1() throw (int, float, char)
{
// 抛出char *会导致程序异常退出
throw string("abc");
}
// 这个函数不能抛出任何异常
void func2() throw ()
{
// 抛出异常会导致程序异常退出
throw 1;
}
// 这个函数可以抛出任何类型异常
void func3()
{
;
}
四 异常类型和异常变量的生命周期
throw的异常是有类型的，可以是数字、字符串、和类对象等。catch需要严格地匹配异常类型。
void fun1()
{
throw 1;
}
void fun2()
{
throw "exception";
}
class MyException
{
public:
MyException(string msg)
{
error = msg;
}
void what()
{
cout << error << endl;
}
private:
string error;
};
void fun3()
{
// 抛出匿名对象
throw MyException("我刚写的异常！");
}
void Test1()
{
try
{
fun1();
}
catch (int e)
{
cout << "int型异常！" << endl;
}
try
{
fun2();
}
catch (char *e)
{
cout << "char *型异常！" << endl;
}
try
{
fun3();
}
catch (MyException e)
{
// 对象MyException里封装了异常的相关信息
e.what();
}
}
下面进行异常变量生命周期分析。首先是使用普通的匿名对象去接抛出异常的情况。
class MyException
{
public:
MyException()
{
cout << "MyException构造函数被调用" << endl;
}
MyException(const MyException & ex)
{
cout << "MyException拷贝构造函数被调用" << endl;
}
~MyException()
{
cout << "MyException析构函数被调用" << endl;
}
};
void fun()
{
// 抛出匿名异常对象
throw MyException();
}
void Test()
{
try
{
fun();
}
// 使用普通对象去接抛出的异常
catch (MyException e)
{
cout << "异常捕获！" << endl;
}
}
此时，程序输出结果如下。程序首先是在fun()中调用了MyException的构造函数创建了一个匿名对象，然后将该匿名对象抛出。然后在使用普通元素e接收抛出的异常对象时，调用了拷贝构造函数将匿名对象拷贝至e当中。然后是捕获异常，捕获之后，在catch语句中进行处理。当catch中处理完了异常之后再将对象e和匿名对象析构，所以输出两次“MyException析构函数被调用”。
MyException构造函数被调用
MyException拷贝构造函数被调用
异常捕获！
MyException析构函数被调用
MyException析构函数被调用
接下来是使用引用去接抛出的异常对象的情况。
void Test()
{
try
{
fun();
}
// 使用引用去接抛出的异常
catch (const MyException &e)
{
cout << "异常捕获！" << endl;
}
}
此时程序输出如下。和使用普通元素e接收抛出异常对象相比，使用引用去接收抛出对象少了调用拷贝构造函数的步骤。因为，在catch时直接引用了匿名对象，所以从始至终，只要匿名对象被创建和析构。
我比较菜，我有疑问：参考下面的用指针去接收抛出的异常部分，为什么这里可以在catch语句块里去引用匿名对象？这个匿名对象不是在fun()里创建的吗？随着fun()调用完毕，退栈之后，匿名对象还存在吗？如果不存在，那你还怎么能够引用呢？如果存在，那说明这个匿名异常对象肯定不在栈内存中，不在栈内存中，那它在哪里？在堆区吗？
MyException构造函数被调用
异常捕获！
MyException析构函数被调用
下面是使用指针去接收抛出异常对象的错误示范。
void fun()
{
// 抛出匿名对象的地址
throw &(MyException());
}
void Test()
{
try
{
fun();
}
// 使用指针去接抛出的异常
catch (const MyException *e)
{
cout << "异常捕获！" << endl;
}
}
此时，程序输出结果如下。可以看到，在catch块中进行异常处理之前，匿名对象就已经被析构了！此时指针e成了一个野指针，你再也无法通过e来获取e中封装的异常信息了！
MyException构造函数被调用
MyException析构函数被调用
异常捕获！
下面是使用指针去接收抛出异常对象的正确示范。为了防止匿名对象在进行异常处理之前被析构，你需要在堆中创建匿名对象，这也就意味着你需要手动地管理内存！
void fun()
{
// 抛出匿名对象的地址，匿名对象在堆中创建
throw new MyException();
}
void Test()
{
try
{
fun();
}
// 使用指针去接抛出的异常
catch (const MyException *e)
{
cout << "异常捕获！" << endl;
// 千万别忘记手动释放匿名对象的内存！
delete e;
}
}
此时，程序终于输出正确了！
MyException构造函数被调用
异常捕获！
MyException析构函数被调用
五 C++标准异常库
C++标准异常库的成员
（1）在上述的继承体系中，每个类都提供了构造函数、拷贝构造函数和赋值操作符重载
（2）logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述
（3）所有的异常类都有一个what()方法，返回const char *类型（C风格字符串）的值，描述异常信息。
标准异常类的具体描述
| 异常名称 | 描述 |
|---|---|
| exception | 所有标准异常类的父类 |
| bad_alloc | 当operator new and operator new[]请求分配失败时 |
| bad_exception | 这是个特殊的异常类，如果函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常列表中没有的异常，这时调用的unexcepted函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型 |
| bad_type | 使用typeid操作符，操作一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常 |
| bad_cast | 使用dynamic_cast转换引用失败时 |
| ios_base::failure | io操作过程中出现错误 |
| logic_error | 逻辑错误，可以在运行前检测的错误 |
| runtime_error | 运行时错误，仅在运行时才可以检测的错误 |
logic_error的子类：
| 异常名称 | 描述 |
|---|---|
| length_error | 试图生成一个超出该类型最大长度的对象时，例如vector的resize操作 |
| domain_error | 参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操作非负值的函数 |
| out_of_range | 超出有效范围 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是'0'或者'1'的时候，抛出该异常 |
runtime_error的子类：
| 异常名称 | 描述 |
|---|---|
| range_error | 计算结果超出了有意义的值域范围 |
| overflow_error | 算数计算上溢 |
| underflow_error | 算数计算下溢 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是'0'或者'1'的时候，抛出该异常 |
编写自己的异常类
为什么要编写自己的异常类？
（1）标准库中的异常类是有限的
（2）在自己的异常类中，可以添加自己的信息（标准库中的异常类值允许设置一个用来描述异常的字符串）
如何编写自己的异常类？
（1）建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时
（2）当继承标准异常类时，应该重载父类的what()函数和虚析构函数
（3）因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。
下面是一个C++标准异常库的应用实例
class Person
{
public:
Person()
{
mAge = 0;
}
void setAge(int age)
{
if (age < 0 || age > 100)
throw out_of_range("年龄应该在0到100之间");
this->mAge = age;
}
private:
int mAge;
};
void Test()
{
Person p;
try
{
p.setAge(1000);
}
catch (const exception &e)
{
cout << e.what() << endl;
}
}
下面是自己手写的异常类的应用实例。
class MyOutOfRangeException : public exception
{
public:
MyOutOfRangeException(char *error)
{
pError = new char[strlen(error) + 1];
strcpy_s(pError, strlen(error) + 1, error);
}
~MyOutOfRangeException()
{
if (pError != nullptr)
{
delete[] pError;
}
}
virtual const char *what() const
{
return pError;
}
private:
char *pError;
};
void Call(void)
{
throw MyOutOfRangeException("我自己的异常类！");
}
void Test()
{
try
{
Call();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
}
六 异常的继承
下面是一个自己手写异常继承的应用案例。
// 异常基类
class BaseMyException
{
public:
virtual void what() = 0;
virtual ~BaseMyException() {}
};
// 继承
class TargetSpaceNullException : public BaseMyException
{
public:
virtual void what()
{
cout << "目标空间为空！" << endl;
}
~TargetSpaceNullException() {}
};
// 继承
class SourceSpaceNullException : public BaseMyException
{
public:
virtual void what()
{
cout << "源空间为空！" << endl;
}
~SourceSpaceNullException() {}
};
void copy_str(char *target, char *source)
{
if (target == nullptr)
{
throw TargetSpaceNullException();
}
if (source == nullptr)
{
throw SourceSpaceNullException();
}
while (*source != ' ')
{
*target = *source;
target++;
source++;
}
*target = ' ';
}
int main(int argc, char **argv)
{
char *source = "abcdefg";
char buf[1024] = { 0 };
try
{
copy_str(nullptr, source);
}
catch (BaseMyException &e)
{
e.what();
}
cout << buf << endl;
getchar();
return 0;
}