异常的抛出 与 捕获 的匹配原则#

1. 异常是通过 抛出对象而引发的, 该对象的类型决定了应该激活哪个catch的处理代码

   即, catch的异常类型 必须与throw的异常类型相同, 否则无法捕获目标异常

2. 被选中的处理代码是调用链中 与该对象类型匹配 且离抛出异常位置最近 的那一个

   这句话是什么意思呢?

   来分析这一段代码:

   1
   #include <iostream>
   2
   
   3
   using std::cout;
   4
   using std::endl;
   5
   using std::cin;
   6
   
   7
   double division(int a, int b) {
   8
       // 当b == 0时抛出异常
   9
       if (b == 0) {
   10
           try {
   11
               throw "Division by zero condition!";
   12
           }
   13
           catch (const char* errmsg) {
   14
               cout << "Division 捕获了 const char* 异常: " << errmsg << endl;
   15
               return 1;
   16
           }
   17
       }
   18
       else
   19
           return ((double)a / (double)b);
   20
   }
   21
   
   22
   void func() {
   23
       int len, time;
   24
       cin >> len >> time;
   25
       try {
   26
           cout << division(len, time) << endl;
   27
       }
   28
       catch (const int errI) {
   29
           cout << "func 捕获了 const int 异常: " << errI << endl;
   30
       }
   31
       catch (const char* errS) {
   32
           cout << "func 捕获了 const char* 异常: " << errS << endl;
   33
       }
   34
   }
   35
   
   36
   int main() {
   37
       try {
   38
           func();
   39
       }
   40
       catch (const char* errmsg) {
   41
           cout << "main 捕获了 const char* 异常: " << errmsg << endl;
   42
       }
   43
   
   44
       return 0;
   45
   }
   

   这段代码, main()中catch(const char*), func()中catch(const cahr*), division()中也catch(const char*)

   如果发生除零错误, 会触发哪个catch捕获异常呢?

   

   很明显, division()内部的catch (const char* errmsg)会捕捉到

   因为, 捕捉异常类型与抛出异常类型匹配 且离抛出异常位置最近

   如果,将division()内部的catch (const char* errmsg)改为catch (const int errI), 则会被func()中的catch捕捉到呢?

   

   没错, 就是func()内部的catch (const char* errS)

3. throw抛出异常时, 编译器会生成一个 异常对象的临时拷贝, 类似函数返回, 所以可以正常的被更外层的函数栈捕捉到

4. 使用catch(...)可以 捕获任意类型的异常

   也就是说, 使用catch(...)之后, 只要 有异常在此之前没有被捕获, 就会捕获此异常

   比如可以用这段代码来实验一下:

   1
   #include <iostream>
   2
   
   3
   using std::cout;
   4
   using std::endl;
   5
   using std::cin;
   6
   
   7
   class Exc1 {
   8
   private:
   9
       int _excID;
   10
   };
   11
   
   12
   class Exc2 {
   13
   private:
   14
       int _excID;
   15
   };
   16
   
   17
   double division(int a, int b) {
   18
       // 当b == 0时抛出异常
   19
       if (b == 0) {
   20
           throw "Division by zero condition!";
   21
       }
   22
       else if (b == 1) {
   23
           throw 1024;
   24
       }
   25
       else if (b == 2) {
   26
           throw 'b';
   27
       }
   28
       else if (b == 3) {
   29
           throw Exc1();
   30
       }
   31
       else if (b < 0) {
   32
           throw Exc2();
   33
       }
   34
       else
   35
           return ((double)a / (double)b);
   36
   }
   37
   
   38
   void func() {
   39
       int len, time;
   40
       cin >> len >> time;
   41
       try {
   42
           cout << division(len, time) << endl;
   43
       }
   44
       catch (const int errI) {                                    // 捕获const整型异常
   45
           cout << "func 捕获了 const int 异常: " << errI << endl;
   46
       }
   47
       catch (const char errC) {                                   // 捕获const字符异常
   48
           cout << "func 捕获了 const char 异常: " << errC << endl;
   49
       }
   50
   }
   51
   
   52
   int main() {
   53
       while(true) {
   54
           try {
   55
               func();
   56
           }
   57
           catch (const char* errmsg) {                            // 捕获const字符串异常
   58
               cout << "main 捕获了 const char* 异常: " << errmsg << endl;
   59
           }
   60
           catch (...) {
   61
               cout << "main 捕获了 未知异常" << endl;
   62
           }
   63
       }
   64
   
   65
       return 0;
   66
   }
   

   

   const char*、const int、const char这三种类型的异常, 分别在main()和func()中指定捕获了

   在传入的b == 3和b < 0时, 抛出的Exc1对象和Exc2对象异常 并没有指定捕获

   但是, 他们却执行了cout << "main 捕获了 未知异常" << endl;这个语句

   即, 执行了catch(...)内的处理

   这可以说明, catch(...)可以捕获任意类型的异常

   但, 由于catch(...)没有指定类型, 所以 无法了解捕捉到的究竟是什么类型的异常

5. 虽说 catch的异常类型 必须与throw的异常类型相同, 否则无法捕获目标异常

   但实际上, 那只是一般情况下

   除此之外, 还存在一个特例:

   如果catch捕捉基类异常, 那么 除了可以捕捉到throw抛出的 此基类异常外, 还可以捕捉到throw抛出的 此基类的派生类异常

   即, catch可以捕获目标类型的子类型异常

   比如这段代码:

   1
   #include <iostream>
   2
   
   3
   using std::cin;
   4
   using std::cout;
   5
   using std::endl;
   6
   
   7
   class faClass {
   8
   private:
   9
       size_t _faExcID;
   10
   };
   11
   
   12
   class sonClass: public faClass {
   13
   private:
   14
       size_t _sonExcID;
   15
   };
   16
   
   17
   double division(int a, int b) {
   18
       // 当b == 0时抛出异常
   19
       if (b == 0) {
   20
           throw "Division by zero condition!";
   21
       }
   22
       else if (b == 1) {
   23
           throw faClass();
   24
       }
   25
       else if (b < 0) {
   26
           throw sonClass();
   27
       }
   28
       else
   29
           return ((double)a / (double)b);
   30
   }
   31
   
   32
   void func() {
   33
       int len, time;
   34
       cin >> len >> time;
   35
       cout << division(len, time) << endl;
   36
   }
   37
   
   38
   int main() {
   39
       while (true) {
   40
           try {
   41
               func();
   42
           }
   43
           catch (const char* errmsg) {
   44
               cout << errmsg << endl;
   45
           }
   46
           catch (const faClass& e) {
   47
               cout << "main 捕获到faClass类异常 或 以faClass为基类的派生类异常" << endl;
   48
           }
   49
       }
   50
   
   51
       return 0;
   52
   }
   

   这段代码:

   1. b传入0,throw "Division by zero condition!"

   2. b传入1,throw faClass()

   3. b传入负数,throw sonClass()

      sonClass是faClass的派生类

   而除了catch(const char* errmsg)之外, 只catch(const faClass& e)

   那么, 这段代码发生各种异常的结果是什么?

   

   可以看到, 当b传入负数或1时, 都会执行catch (const faClass& e)内的处理动作

   这其实就证明了, 如果catch捕捉基类异常, 那么 除了可以捕捉到throw抛出的 此基类异常外, 还可以捕捉到throw抛出的 此基类的派生类异常

在函数调用链中 异常栈展开匹配原则#

1. 首先检查throw本身是否在try块内部

   如果是, 则在当前函数栈帧 查找匹配的catch语句

   如果当前函数栈帧有匹配的, 则 跳到catch的地方进行处理

2. 如果当前函数栈帧内没有匹配的, 则 退出当前函数栈, 继续在外层调用函数的栈中进行查找匹配的catch

   此操作, 会一直退出到main()函数栈帧中

3. 如果到达main函数的栈, 依旧没有匹配的catch, 则 终止进程

4. 整个沿着调用链 向更外层调用函数的栈帧中查找匹配的catch的行为, 被称为 栈展开

5. 为了避免 由于异常没有匹配的catch导致进程终止, 所以 一般使用异常时 都会在最后 使用catch(...)捕获未知异常

6. 找到匹配的catch子句并处理以后, 会继续沿着catch子句后面继续执行

此原则中, 前三条原则 即为栈展开的过程.

假如存在func1()、func2()、func3():

1
void func3() {
2
    throw "Throw an exception directly!";
3
    cout << "hello func3" << endl;
4
}
5

6
void func2() {
7
    func3();
8
    cout << "hello func2" << endl;
9
}
10

11
void func1() {
12
    func2();
13
    cout << "hello func1" << endl;
14
}

且,main()函数呢存在以下内容:

1
int main() {
2
    try {
3
        func1();
4
    }
5
    catch (const char* errmsg) {
6
        cout << errmsg << endl;
7
    }
8
    cout << "hello main" << endl;
9

10
    return 0;
11
}

那么,throw异常之后, 栈展开的过程大概为这样的:

C++异常处理有一个非常麻烦的点, 但不是异常麻烦, 本身麻烦, 而是需要特别注意内存管理

throw之后, 如果找到对应类型的catch, 会直接跳转到对应函数栈帧内执行catch子句, 执行完之后 会留在catch到异常的函数内继续向下执行, 而不是回到throw的位置继续执行

func1()、func2()、func3()中, 都有一句cout语句, 但是, 只执行了main()中的cout语句

这是很正常的逻辑, 但 很可能会造成什么后果呢? 可以看一看这段代码:

1
#include <iostream>
2

3
using std::cout;
4
using std::endl;
5

6
void func1() {
7
    // new一块空间
8
    int* arr = new int[20480];
9

10
    throw "Throw an exception directly!";
11
    cout << "hello func1" << endl;
12

13
    delete[] arr;
14
}
15

16
int main() {
17
    while (true) {
18
        try {
19
            func1();
20
        }
21
        catch (const char* errmsg) {
22
            cout << errmsg << endl;
23
        }
24
        cout << "hello main" << endl;
25
    }
26

27
    return 0;
28
}

这段代码执行之后, 会发生什么后果?

没错, 内存泄漏! 非常严重的内存泄漏!

可以看到, 名为exception_test.exe的内存占用, 在疯狂的上涨

这是什么原因呢?

其实是因为, new int[20480]出来的空间, 没有被delete[]掉

但是func1()函数中, new[]之后 函数结束前 明明delete[]了, 为什么没有delete[]掉呢?

就是因为func1()函数内throw之后, 直接跳到了main()中catch的位置, 并且留在了main()中没有回到throw那里

所以 在throw之后的 delete[]语句根本就没有执行

当前阶段, 如何正确的解决这个问题呢?

如果存在new之后会throw的可能, 就需要直接在func1()内 将throw放在try块内, 就地catch处理并返回:

1
void func1() {
2
    // new一块空间
3
    int* arr = new int[20480];
4

5
    try {
6
        throw "Throw an exception directly!";
7
    }
8
    catch (const char* errmsg) {
9
        cout << errmsg << endl;
10
        delete[] arr;
11
        return;
12
    }
13

14
    // 这里也要delete[]
15
    // 因为在其他场景中, 可能并不一定会throw
16
    delete[] arr;
17
}

这样, 就不会发生内存泄漏了:

这是当前阶段最简单的处理方式, 也比较安全

异常的重新抛出#

观察这段代码:

1
double division(int a, int b) {
2
    // 当b == 0时抛出异常
3
    if (b == 0) {
4
        throw "Division by zero condition!";
5
    }
6
    return (double)a / (double)b;
7
}
8

9
void func() {
10
    int* array = new int[10];
11

12
    try {
13
        int len, time;
14
        cin >> len >> time;
15
        cout << division(len, time) << endl;
16
    }
17
    catch (...) {
18
        cout << "delete []" << array << endl;
19
        delete[] array;
20
        throw;
21
    }
22

23
    cout << "delete []" << array << endl;
24
    delete[] array;
25
}
26

27
int main() {
28
    try {
29
        func();
30
    }
31
    catch (const char* errmsg) {
32
        cout << errmsg << endl;
33
    }
34

35
    return 0;
36
}

func()中new了一个数组. 但是在delete[]之前又有可能throw异常

此异常的处理动作, 已经在main()函数中实现了

但是, 由于还有new出来的空间未delete, 又不得不在func()函数内添加一个try{...}catch{...}

不过, 这里的捕获异常 可以使用catch(...)捕获任意异常, 并且不处理异常, 只将未释放的空间delete掉, 然后 使用throw;再将异常重新抛出

抛出之后, 会再沿着调用链进行栈展开寻找对应的catch, 找到真正处理此异常的catch再处理掉异常

上面例子中, func()的catch(...)子句中的throw;即为重新抛出异常

C++重新抛出异常的语法是throw 目标异常

由于这里使用的是 catch(...) 没有指定类型捕获, 所以throw; 就可以重新抛出

如果指定了类型 catch(const char* errmsg), 就需要throw errmsg; 来实现重新抛出

异常安全#

关于异常的使用, 有一些情况下需要非常的小心:

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

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

3. 还有就是, 在new和delete中抛出了异常, 导致 内存泄漏

   在lock和unlock之间抛出了异常 导致死锁

   这些问题的更好解决方法其实是智能指针

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

上面介绍过: 如果catch捕捉基类异常, 那么 除了可以捕捉到此基类异常外, 还可以捕捉到此基类的派生类异常

所以, C++标准就根据此原则, 实现了一个 异常类体系

即 C++标准中 实现了许多的类 来对应C++可能发生的所有错误, 被称为 异常类

这些异常类, 都派生于一个基类std::exception

文档中对此类的描述是:

标准库中所有组件抛出的异常对象都派生于此类, 因此, 通过捕获此类, 就可以捕获所有标准异常

此类中, 除了构造、析构等成员函数之外, 还实现了一个共其派生类重写的成员函数what()

自定义异常体系#

实际的项目开发中, 许多的公司都会自己定义一套异常体系 来进行规范的异常管理

这里有一个 自定义异常体系的例子:

1
#include <iostream>
2
#include <string>
3
#include <unistd.h>
4

5
using std::string;
6
using std::cout;
7
using std::endl;
8

9
class Exception {
10
public:
11
    Exception(const string& errmsg, int id)
12
        : _errmsg(errmsg)
13
        , _id(id)
14
    {}
15

16
    virtual string what() const {
17
        return _errmsg;
18
    }
19

20
protected:
21
    string _errmsg;
22
    int _id;
23
};
24

25
class SqlException : public Exception {
26
public:
27
    SqlException(const string& errmsg, int id, const string& sql)
28
        : Exception(errmsg, id)
29
        , _sql(sql)
30
    {}
31

32
    virtual string what() const {
33
        string str = "SqlException:";
34
        str += _errmsg;
35
        str += "->";
36
        str += _sql;
37

38
        return str;
39
    }
40

41
private:
42
    const string _sql;
43
};
44

45
class CacheException : public Exception {
46
public:
47
    CacheException(const string& errmsg, int id)
48
        : Exception(errmsg, id)
49
    {}
50

51
    virtual string what() const {
52
        string str = "CacheException:";
53
        str += _errmsg;
54

55
        return str;
56
    }
57
};
58

59
class HttpServerException : public Exception {
60
public:
61
    HttpServerException(const string& errmsg, int id, const string& type)
62
        : Exception(errmsg, id)
63
        , _type(type)
64
    {}
65

66
    virtual string what() const {
67
        string str = "HttpServerException:";
68
        str += _type;
69
        str += ":";
70
        str += _errmsg;
71

72
        return str;
73
    }
74

75
private:
76
    const string _type;
77
};
78

79
void SQLMgr() {
80
    if (rand() % 7 == 0) {
81
        throw SqlException("权限不足", 100, "select * from name = '张三'");
82
    }
83
    else {
84
        cout << "Sql Success" << endl;
85
    }
86
}
87

88
void CacheMgr() {
89
    if (rand() % 5 == 0) {
90
        throw CacheException("权限不足", 101);
91
    }
92
    else if (rand() % 6 == 0) {
93
        throw CacheException("数据不存在", 102);
94
    }
95
    else {
96
        cout << "Cache Success" << endl;
97
    }
98

99
    SQLMgr();
100
}
101

102
void HttpServer() {
103
    if (rand() % 3 == 0) {
104
        throw HttpServerException("资源请求错误", 103, "get");
105
    }
106
    else if (rand() % 4 == 0) {
107
        throw HttpServerException("权限不足", 104, "post");
108
    }
109
    else {
110
        cout << "Http Success" << endl;
111
    }
112

113
    CacheMgr();
114
}
115

116
int main() {
117
    srand(time(0));
118
    while (true) {
119
        // 此代码中 唯一一个不能跨平台的函数sleep(), 这里用的是 Linux环境
120
        // Windows 平台 需要将其换为 Sleep(1000);
121
          // 并将 头文件 unistd.h 换为 Windows.h
122
        sleep(1);
123
        try {
124
            HttpServer();
125
        }
126
        catch (const Exception& e) {
127
            // 多态
128
            cout << e.what() << endl;
129
        }
130
        catch (...) {
131
            cout << "Unkown Exception" << endl;
132
        }
133
    }
134

135
    return 0;
136
}

我们先分析一下这段代码:

1. 首先, 代码实现了 4 个类: 1个基类, 3个派生类

   1. 基类 Exception

      成员变量: _errmsg, string类型 用于存储异常信息; _id, int类型 用于存储异常代码

      成员函数: what(), 返回异常信息, 用于获取当前异常类

   2. 派生类1 SqlException

      成员变量: 除继承于基类的 _errmsg 和 _id 之外; _sql, const string类型 用于存储 异常sql指令

      成员函数: 重写what(), 返回异常信息, 包括 所属类、_errmsg和_sql

   3. 派生类2 CacheException

      成员变量: 除继承于基类的 _errmsg 和 _id 之外, 无其他成员变量

      成员函数: 重写what(), 返回异常信息, 包括 所属类和_errmsg

   4. 派生类3 HttpServerException

      成员变量: 除继承于基类的 _errmsg 和 _id 之外; _type, const string类型 用于存储 发生异常的服务类型

      成员函数: 重写what(), 返回异常信息, 包括 所属类、type和_errmsg

2. 其次, 实现了三个函数 用来模拟不同的服务的异常场景

   1. SqlMgr():

      模拟数据库管理时的异常场景:

      随机数 % 7 == 0 执行 throw SqlException, 模拟数据库管理时权限不足的场景

      异常信息: 权限不足, 异常代码: 100, 异常Sql语句: select * from name = '张三'

   2. CacheMgr():

      模拟缓存管理时的异常场景:

      随机数 % 5 == 0执行throw CacheException("权限不足", 100)

      异常信息: 权限不足, 异常代码: 101

      随机数 % 6 == 0执行throw CacheException("数据不存在", 101)

      异常信息: 数据不存在, 异常代码: 102

      最后, 调用SqlMgr()

   3. HttpServer():

      模拟HTTP服务可能发生的异常场景:

      随机数 % 3 == 0执行HttpServerException("请求资源不存在", 200, "get")

      异常信息: 资源请求错误, 异常代码: 103, 异常服务类型: get

      随机数 % 4 == 0执行HttpServerException("权限不足", 100, "post")

      异常信息: 权限不足, 异常代码: 104, 异常服务类型: post

      最后, 调用CacheMgr()

3. 最后, 主函数内 死循环模拟服务器运行

   try块内调用HttpServer(), 而HttpServer()内调用CacheMgr(), CacheMgr()内调用SqlMgr(), 模拟服务运行的流程

   catch (const Exception& e)及代码块实际作用是 捕获三种异常类, 并多态调用不同异常类对象的what() 接受打印相关异常信息

   catch (...)及代码块捕获其他异常, 输出未知异常

至此, 整个代码分析结束, 从HttpServer() 层层调用到 SqlMgr(), 每个函数内都有概率抛出不同的异常, 抛出之后会在 main内被捕获并处理

查看执行结果:

从结果可以看到, 每次循环 每层调用都有一定的概率抛异常

并且都会在main函数内被捕捉到并处理

图中, 光标可能在某行停顿1-2s, 说明此时并没有异常抛出

在添加一个SeedMsg()函数, 模拟发送信息异常

1
void SeedMsg(const string& str) {
2
    if (rand() % 2 == 0) {
3
        throw HttpServerException("SeedMsg::网络错误", 105, "put");
4
    }
5
    else if (rand() % 4 == 0) {
6
        throw HttpServerException("SeedMsg::你已经不是对方好友", 106, "post");
7
    }
8
    else {
9
        cout << "消息发送成功！->" << str << endl;
10
    }
11
}

将main()函数try块中执行的函数 换为此函数, 查看执行:

并尝试, 将 网络错误异常的处理方式 改为 发生异常之后 直接重试再发送10次

其实很简单, 只需要改动main函数内容就可以(不过要先在 Exception类中添加一个成员函数getid()):

1
int main() {
2
    srand(time(0));
3
    while (true) {
4
        // 此代码中 唯一一个不能跨平台的函数sleep(), 这里用的是 Linux环境
5
        // Windows 平台 需要将其换为 Sleep(1000);
6
          // 并将 头文件 unistd.h 换为 Windows.h
7
        sleep(1);
8
        try {
9
            for(int i = 1; i <= 10; i++) {
10
                try {
11
                    SeedMsg("你好啊?");
12
                    // 能走到这里 一定发送成功
13
                    // 直接break跳出 for循环
14
                    break;
15
                }
16
                catch (const Exception& e) {
17
                    if (e.getid() == 105) {
18
                        // 针对 103 异常处理
19
                        cout << "网络错误, 重发送, 第 " << i << " 次" << endl;
20
                        continue;
21
                    }
22
                    else {
23
                        // 不是此异常, 重新抛出
24
                        throw e;
25
                    }
26
                }
27
            }
28
        }
29
        catch (const Exception& e) {
30
            // 多态
31
            cout << e.what() << endl;
32
        }
33
        catch (...) {
34
            cout << "Unkown Exception" << endl;
35
        }
36
    }
37

38
    return 0;
39
}

执行结果:

这里的关键点就是, 异常的重新抛出, 还有 SeedMsg()之后的break

由于需要特定的处理_id为105的异常, 所以需要先 就近catch 一下, 然后判断异常代码, 进行处理

而, 由于只处理105异常, 其他异常就需要再次抛出, 让其他地方处理

然后, SeedMsg()之后的break:

SeedMsg()正常返回, 就一定会顺着向下走, 也表示这发送成功, 就不需要继续for循环, 所以直接break

如果抛异常, 则会跳过break, 然后异常被下面的catch子句捕获