【C++11】异常 {try/catch语句语法；异常抛出和捕获的匹配原则，异常的栈展开，异常的重新抛出；异常继承体系，异常声明；异常的优缺点，异常安全问题}

一、C++异常的基本概念

C语言传统的错误处理机制：

1. 终止程序，如assert，缺陷：一旦触发assert就会终止程序，用户难以接受。在发生内存错误，除0错误时，也会终止程序。
2. 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库函数都是通过把错误码放到errno中来表示错误的。

实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

C++异常处理机制：

C++异常是在程序执行过程中出现错误或异常情况时，用于进行错误处理和异常处理的机制。它允许程序员捕获和处理这些异常，以避免程序崩溃或发生不可预测的行为。

异常可以分为两种类型：系统异常和用户自定义异常。系统异常是由编译器或系统库引发的异常，例如访问越界、除以零等。用户自定义异常是程序员根据业务需求自己定义的异常，例如文件未找到、输入值非法等。

C++中的异常处理机制主要包括三个关键词：try、catch和throw：

1. throw：用于手动抛出异常。在代码中，当遇到某种特定的情况时，程序员可以使用throw关键字抛出一个异常，然后由上层调用函数的try块进行处理。
2. try：用于包含可能引发异常的代码。当程序执行到try块时，如果发生异常，会立即跳到catch块，并根据异常类型匹配相应的catch块进行处理。catch块可以是多个，用于处理不同类型的异常。如果没有匹配的catch块，异常将会传递给上层调用函数的try块进行处理，直到找到匹配的catch块或程序终止。
3. catch：用于捕获并处理异常。在catch块中，程序员可以根据具体情况进行异常处理，例如输出错误信息、修复错误或重新抛出异常等。

所谓的抛异常是指throw抛出异常对象，让catch语句捕获（类似于函数传参）。异常对象可以是任意类型的，包括内置类型和自定义类型。如果是自定义类型，当中可以包含错误码、错误描述等更丰富的错误信息，还可以包含相应的异常处理方法。

使用 try/catch 语句的语法如下所示：

try
{
    // 受保护的标识代码
}
catch (ExceptionType1 e1)
{
    // catch块，捕获ExceptionType1类型的异常
}
catch (ExceptionType2 e2)
{
    // catch块，捕获ExceptionType2类型的异常
}
catch (...)
{
    // catch块，捕获任意类型的异常，防止程序直接终止。
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

二、异常的抛出和捕获

2.1 抛出和捕获的匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
2. 抛出异常后异常对象必须被捕获，否则进程会因为错误而导致终止。
3. 被选中的处理代码是调用链中与该异常对象类型匹配且离抛出异常位置最近的那一个。
4. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象。这个拷贝对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）不能抛出和捕获局部异常对象的指针，其数据会在出作用域之前销毁。但是可以捕获异常对象的引用，实际上捕获的是拷贝对象的引用。
5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配。可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

2.2 异常的栈展开

被选中的处理代码是调用链中与该异常对象类型匹配且离抛出异常位置最近的那一个。程序是如果实现这一点的？

沿着调用链查找类型匹配的catch语句的过程称为异常的栈展开，栈展开过程如下：

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的catch语句，则跳到对应的catch进行处理。
2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中查找匹配的catch。
3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
4. 找到匹配的catch语句并进行处理以后，会继续执行catch语句后面的代码。

提示：如上图中的例子，如果在main函数中catch异常，func1抛出异常后会直接跳转执行main函数中的异常处理逻辑。并将调用链中上层函数的栈帧释放（func1, func2, func3）。

测试程序：

double Division(int x, int y)
{
    if (y == 0)
        throw "Division by zero exception!";
    if (y == 4)
        throw 1;
    return (double)x / (double)y;
}

void Func()
{
    int x, y;
    while (true)
    {
        cin >> x >> y;
        cout << Division(x, y) << endl;
    }
}

int main()
{
    while (true)
    {
        try
        {
            Func();
        }
        catch (const char *errstr)
        {
            cout << errstr << endl;
        }
        catch (...)
        {
            cout << "unkown exception" << endl;
        }

        cout << "catch之后的代码继续执行" << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

运行结果：

---

2.3 异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

通常，总是在最外层函数捕获并处理异常。但是由于异常的栈展开，会将调用链中间层的函数直接跳过（中断执行）从而导致这些函数的某些收尾工作不能正常执行，如释放堆空间，释放锁资源等（异常安全问题）。所以我们要在这些中间层函数中捕获异常，执行收尾工作后重新抛出，交给最外层函数执行最后的异常处理工作。

在上面代码的基础上进行修改：

void Func()
{
    int *arr = new int[10]; // 申请堆空间
    int x, y;
    try
    {
        while (true)
        {
            cin >> x >> y;
            cout << Division(x, y) << endl;
        }
    }
    catch (...) // 捕获任意类型的异常对象
    {
        cout << "delete[] arr" << endl;
        delete[] arr; // 释放堆空间
        throw;      // 重新抛出，捕到什么类型就抛出什么类型
    }
    // 如果不在中途捕获异常，就会跳过执行delete语句
    delete arr; // 释放堆空间   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

---

三、异常规范

3.1 异常继承体系

3.1.1 自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了。所以实际中都会定义一套异常继承体系。这样大家抛出的都是派生类对象，捕获基类的引用就可以进行多态调用异常处理函数了。

测试程序：

// 基类异常
class Exception
{
protected:
    string _errmsg; // 错误描述
    int _errid;     // 错误码

public:
    Exception(const string &errmsg, int errid)
        : _errmsg(errmsg),
          _errid(errid)
    {
    }
    virtual string what() const // 基类的虚函数
    {
        return _errmsg;
    }
    int geterrid() const
    {
        return _errid;
    }
};

// 数据库派生类异常
class SqlException : public Exception
{
    string _sql;

public:
    SqlException(const string &errmsg, int errid, const string &sql)
        : Exception(errmsg, errid),
          _sql(sql)
    {
    }

    virtual string what() const // 重写虚函数
    {
        string msg = "SqlException: ";
        msg += _errmsg;
        msg += " | ";
        msg += _sql;
        return msg;
    }
};

// 缓存派生类异常
class CacheException : public Exception
{
public:
    CacheException(const string &errmsg, int errid)
        : Exception(errmsg, errid)
    {
    }

    virtual string what() const // 重写虚函数
    {
        string msg = "CacheException: ";
        msg += _errmsg;
        return msg;
    }
};

// 网络服务派生类异常
class HttpException : public Exception
{
    string _type;

public:
    HttpException(const string &errmsg, int errid, const string &type)
        : Exception(errmsg, errid),
          _type(type)
    {
    }

    virtual string what() const // 重写虚函数
    {
        string msg = "HttpException: ";
        msg += _errmsg;
        msg += " | ";
        msg += _type;
        return msg;
    }
};

void SqlMgr()
{
    // 模拟出错场景，抛异常处理
    if (rand() % 5 == 0)
    {
        throw SqlException("权限不足", 104, "select * from name = '张三'");
    }
    if (rand() % 4 == 0)
    {
        throw 1; // 不遵循异常规范体系抛异常
    }

    cout << "调用成功" << endl;
}

void CacheMgr()
{
    // 模拟出错场景，抛异常处理
    if (rand() % 7 == 0)
    {
        throw CacheException("权限不足", 102);
    }
    if (rand() % 6 == 0)
    {
        throw CacheException("数据不存在", 103);
    }

    SqlMgr();
}

void HttpServer()
{
    // 模拟出错场景，抛异常处理
    if (rand() % 9 == 0)
    {
        throw HttpException("请求资源不存在", 100, "get");
    }
    if (rand() % 8 == 0)
    {
        throw HttpException("权限不足", 101, "post");
    }

    CacheMgr();
}

int main()
{
    srand((unsigned int)time(nullptr));
    while (true)
    {
        this_thread::sleep_for(chrono::seconds(1));
        try
        {
            HttpServer();
        }
        catch (const Exception &e) // 捕获基类的引用
        {
            cout << e.what() << endl; // 多态调用what函数
        }
        catch (...)
        {
            cout << "unknown exception!" << endl;
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

运行结果：

---

3.1.2 C++标准库的异常体系

C++ 提供了一系列标准的异常，他们都是std::exception的派生类，我们可以在程序中使用这些标准的异常。如下所示：

说明：实际中我们可以去继承exception类实现自己的异常类。但是实际中很多公司会自己定义一套异常继承体系。因为C++标准库设计的不够好用。

测试程序：

int main()
{
    try
    {
        vector<int> v(10, 5);
        // 这里如果系统内存不够会抛异常
        v.reserve(100000000000); //bad_alloc
        // 这里越界访问会抛异常
        v.at(10) = 100; //out_of_range
    }
    catch (const exception &e) // 捕获基类引用
    {
        cout << e.what() << endl;
        // cout << typeid(e).name() << endl; //可以打印看一下类型
    }
    catch (...)
    {
        cout << "Unkown Exception" << endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

---

3.2 异常声明

C++98中的异常规范

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() 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();
1
2
3
4
5
6

1. 异常声明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
2. 函数的后面接throw()，表示函数不抛异常。
3. 在加了throw()声明的函数中抛出的异常不会被捕获，程序会直接终止。
4. 函数异常声明并不是必须要写的。若无异常接口声明，则此函数可以抛掷任何类型的异常。

C++11中的异常规范（简化了C++98）

// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;
1
2
3

1. 如果一个函数明确不抛异常的话，加noexcept声明。
2. 在加了noexcept声明的函数中抛出的异常不会被捕获，程序会直接终止。
3. 如果一个函数可能会抛异常，什么都不加。

---

四、异常的优缺点

4.1 C++异常的优点

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误。而异常可以直接跳出多层函数被最外层函数捕获。

3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator[]这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

4.2 C++异常的缺点

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。

2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。

4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

4.3 异常安全问题

• 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化

• 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)

• C++中异常经常会导致资源泄漏的问题，比如：

  • 在new和delete之间抛出了异常，导致内存泄漏问题；
  • 在lock和unlock之间抛出了异常，导致程序阻塞，死锁问题；
  • 在fopen和fclose之间抛出了异常，导致文件指针丢失，文件资源泄露问题。

  C++经常使用RAII来解决以上问题，关于RAII我们智能指针这节进行讲解。

4.4 总结

• 异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误，这也可以看出这是大势所趋。
• 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：
  1. 使用异常继承体系，抛出的异常类型都继承自同一个基类。
  2. 函数是否抛异常、抛什么异常，都使用noexcept或throw()的异常声明规范化。