【探寻C++之旅】第十二章：异常

code_monnkey_

发布于 2025-05-31 08:22:58

2980

文章被收录于专栏：知识分享知识分享

前言

今天，我们继续踏入追寻C++的冒险历程。今天我们让我们来讲讲C++中用来处理错误的一种方式——异常，下面让我们一起进入异常的学习。

1.异常的概念

异常是面向对象语言在处理错误的一种方式。在C语言中我们主要通过错误码的形式处理错误，例如我们可以通过perror函数去打印对应的错误码所指代的信息：

#include <stdio.h>

int main ()
{
  FILE * pFile;
  pFile=fopen ("unexist.ent","rb");
  if (pFile==NULL)
    perror ("The following error occurred");
  else
    fclose (pFile);
  return 0;
}

例如上述代码，如果文件 unexist.ent 不存在，则程序输出可能会有类似这样的内容：

The following error occurred: No such file or directory

这句话冒号前是我们给定的字符串，可以看作是错误提示，冒号后跟的便是由对应的错误码解释的错误消息。

错误码本质就是对错误信息进⾏分类编号，拿到错误码以后还要去查询错误信息，⽐较⿇烦。而异常则会抛出⼀个对象，这个对象可以函数更全⾯的各种信息。异常处理机制允许程序中独⽴开发的部分能够在运⾏时就出现的问题进⾏通信并做出相应的处理，异常使得我们能够将问题的检测与解决问题的过程分开，程序的⼀部分负责检测问题的出现，然后解决问题的任务传递给程序的另⼀部分，检测环节⽆须知道问题的处理模块的所有细节。

2.异常的使用

2.1 抛出与捕获

当程序出现问题时，我们通过抛出(throw)⼀个对象来引发⼀个异常，该对象的类型以及当前的调⽤链决定了应该由哪个catch的处理代码来处理该异常。

上面是我们对于异常的使用，下面让我们来具体的介绍一下我们该如何去使用异常：

C++异常机制通过try、catch和throw三个关键字来实现异常的抛出和捕获：
- **try：**可能导致异常的操作通过try关键字来执行。
- **throw：**当程序遇到无法处理的错误时，可以使用throw关键字抛出一个异常。抛出的异常可以是任何类型的表达式，其类型决定了异常的类型。
- catch：如果try块中的代码抛出了一个异常，程序会跳转到匹配的catch块中执行相应的处理代码。被选中的处理代码（也就是catch代码块）是调⽤链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的类型和内容，程序的抛出异常部分告知异常处理部分到底发⽣了什么错误。
当throw执⾏时，throw后⾯的语句将不再被执⾏。程序的执⾏从throw位置跳到与之匹配的catch模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调⽤链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置。这⾥还有两个重要的含义：
1. 沿着调⽤链的函数可能提早退出。
2. ⼀旦程序开始执⾏异常处理程序，沿着调⽤链创建的对象都将销毁。
抛出异常对象后，会⽣成⼀个异常对象的拷⻉，因为抛出的异常对象可能是⼀个局部对象，所以会⽣成⼀个拷⻉对象，这个拷⻉的对象会在catch代码块执行完后销毁。（这⾥的处理类似于函数的传值返回）

下面我们通过一个简单的例子来感受一下异常的抛出与捕获：

double Divide(int a, int b)
{
    try
    {
        // 当b == 0时抛出异常
        if (b == 0)
        {
            string s("Divide by zero condition!");
            throw s;
        } 
        else
        {
            return ((double)a / (double)b);
        }
    } 
    catch (int errid)
    {
        cout << errid << endl;
    } 
    return 0;
} 
void Func()
{
    int len, time;
    cin >> len >> time;
    try
    {
        cout << Divide(len, time) << endl;
    } 
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    } 
    cout <<__FUNCTION__<<":" << __LINE__ << "⾏执⾏" << endl;
} 
int main()
{
    while (1)
    {
        try
        {
            Func();
        } 
        catch (const string& errmsg)
        {
            cout << errmsg << endl;
        }
    } 
    return 0;
}

我们来分析一下上面的代码：

代码的整体逻辑很简单：我们可以不断输入两个数去计算它们相除的结果。
首先在主函数中进入while循环，对于try中的代码块是我们执行的代码块，只是在我们执行时可能会遇到异常情况然后进行抛出异常的操作。
然后在try的代码块中我们进入Func函数；在Func函数中我们输入len和time，然后在Func函数中的try代码块中进入Divide函数；Divide函数我们用来计算两个数相除，如果除数为0则抛出异常s，在这里s是一个string类型的字符串，代表发生的异常；除数不为0则正常返回结果并且在Func函数中将结果打印出来。
在Func函数中的最后一行代码cout <<__FUNCTION__<<":" << __LINE__ << "⾏执⾏" << endl; 中的__FUNCTION__和__LINE__是两个宏，它们的作用是在程序运行时获取当前函数的名称和获取当前程序行的行号。这是用来对捕获异常后代码运行顺序的测试。

我们输入两个示例来演示一下：

可以看到，当我们第一次正常输入时，并不会抛出异常，程序正常执行try代码块中的语句，并且在Func函数中最后一行代码也正常执行；但是，当我们输入的除数为0时，引发了异常，这时在Divide函数中我们抛出了异常s，并且在main函数中捕获了该异常。这是因为Divide函数和Func函数中的catch与我们抛出的异常不匹配，而main函数中的catch与我们抛出的异常是相匹配的。

那么我们抛出的异常是如何寻找与之匹配的catch代码块呢？调用栈又是什么呢？

2.2 栈展开

只从上面的程序运行结果我们很难看出抛出的异常s到底是被main函数中的catch捕获了还是被Func函数中的catch捕获。但是通过分析代码我们可以知道Func函数里最后一行代码没有被执行，因此我们可以判定抛出的异常s是被main函数中的catch捕获了，这是因为Func函数中catch能够捕获的异常类型是const char*，而我们抛出的异常的类型是string。

抛出的异常会沿着调用栈去寻找类型匹配的最近的catch代码块，这里的调用栈其实就是我们函数的一个调用顺序，例如我们上面的例子的调用栈是：main->Func->Divide，当程序中发生异常并抛出时，异常会沿着调用栈层层向上传播，去找能够捕获该异常的catch块。这期间，程序需要逐层销毁已经进入的函数调用所创建的局部对象，释放资源，恢复执行环境。这个沿栈调用方向逐层退出函数的过程，称为“栈展开”。

在栈展开的过程中如果在中途某一个函数的catch与我们的异常不匹配，那么这个函数的栈帧会被销毁，继续向上寻找调用栈的另一个函数，因此该函数catch代码块后的语句也不会执行，因为函数栈帧已经被销毁。我们继续以上面的代码为例：如果我们将main函数与Func函数的catch能捕获异常的类型进行交换，那么在Divide函数中抛出的异常被Func函数中的catch捕获后程序的后续执行是如何的呢？

double Divide(int a, int b)
{
    try
    {
        // 当b == 0时抛出异常
        if (b == 0)
        {
            string s("Divide by zero condition!");
            throw s;
        } 
        else
        {
            return ((double)a / (double)b);
        }
    } 
    catch (int errid)
    {
        cout << errid << endl;
    } 
    return 0;
} 
void Func()
{
    int len, time;
    cin >> len >> time;
    try
    {
        cout << Divide(len, time) << endl;
    } 
    //与main函数中的类型进行交换
    catch (const string& errmsg)
    {
        cout << errmsg << endl;
    } 
    cout <<__FUNCTION__<<":" << __LINE__ << "⾏执⾏" << endl;
} 
int main()
{
    while (1)
    {
        try
        {
            Func();
        } 
        //与Func函数中的类型进行交换
        catch (const char* errmsg)
        {
            cout << errmsg << endl;
        }
        //观察是否执行
    	cout <<__FUNCTION__<<":" << __LINE__ << "⾏执⾏" << endl;
    } 
    return 0;
}

可以看到，当异常被捕获后，后续代码以及调用栈都会正常执行。

栈展开的最大意义之一就是保证资源安全释放，防止内存泄漏或资源泄漏：局部变量对象的析构函数都会被调用，类似于自动完成了一层层清理。

2.3 查找匹配的处理代码

⼀般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。就如同我们上面的代码一样。

但是也有⼀些例外：

异常的捕获允许从⾮常量向常量的类型转换，也就是权限缩⼩；
允许数组转换成指向数组元素类型的指针，函数被转换成指向函数的指针；
允许从派⽣类向基类类型的转换，这个点⾮常实⽤，实际中继承体系基本都是⽤这个⽅式设计的。

我们上面的例子也证实了这一点：我们抛出的异常类型是string，而捕获的类型是const string，这就是权限的缩小，虽然类型没有完全匹配，但也可以被捕获。

如果到main函数，异常仍旧没有被匹配就会终⽌程序，不是发⽣严重错误的情况下，我们是不期望程序终⽌的，所以⼀般main函数中最后都会使⽤catch(...)，它可以捕获任意类型的异常，但是是不知道异常错误是什么。

int main()
{
    while (1)
    {
        try
        {
            Func();
        } 
        catch (const string& errmsg)
        {
            cout << errmsg << endl;
        }
        catch(...)
        {
			cout << "未知异常" << endl;
        }
    } 
    return 0;
}

可以看到，我们一个try代码块后可以跟若干个catch块，以便可以捕获不同的异常，不过我们不可能把每一种异常的情况都写一遍，这时我们就可以使用一个异常类Exception，我们在main函数的最后捕获基类Exception，这样无论是它本身还是它的派生类我们都可以捕获，这样就大大减少了我们的代码量，同时也避免了“屎山代码”。

因此在异常的捕获中允许派生类到基类的转换是我们在项目中使用异常时最常用的。

2.4 简单的异常使用

⼀般⼤型项⽬程序才会使⽤异常，下⾯我们模拟设计⼀个服务的⼏个模块，每个模块抛出的异常都是Exception的派⽣类，每个模块对应的异常可以添加⾃⼰的数据，最后捕获时，我们捕获基类就可以，下面让我们来模拟一下代码：

#include<thread>
class Exception
{ 
    public:
    Exception(const string& errmsg, int id)
        :_errmsg(errmsg)
            , _id(id)
        {}
    virtual string what() const
    {
        return _errmsg;
    } 
    int getid() const
    {
        return _id;
    }
    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 HttpException : public Exception
{ 
    public:
    HttpException(const string& errmsg, int id, const string& type)
        :Exception(errmsg, id)
            , _type(type)
        {}
    virtual string what() const
    {
        string str = "HttpException:";
        str += _type;
        str += ":";
        str += _errmsg;
        return str;
    }
    private:
    const string _type;
};
void SQLMgr()
{
    if (rand() % 7 == 0)
    {
        throw SqlException("权限不⾜", 100, "select * from name = '张三'");
    } 
    else
    {
        cout << "SQLMgr 调⽤成功" << endl;
    }
}
void CacheMgr()
{
    if (rand() % 5 == 0)
    {
        throw CacheException("权限不⾜", 100);
    } 
    else if (rand() % 6 == 0)
    {
        throw CacheException("数据不存在", 101);
    } 
    else
    {
        cout << "CacheMgr 调⽤成功" << endl;
    } 
    SQLMgr();
} 
void HttpServer()
{
    if (rand() % 3 == 0)
    {
        throw HttpException("请求资源不存在", 100, "get");
    } 
    else if (rand() % 4 == 0)
    {
        throw HttpException("权限不⾜", 101, "post");
    } 
    else
    {
        cout << "HttpServer调⽤成功" << endl;
    } 
    CacheMgr();
} 
int main()
{
    srand(time(0));
    while (1)
    {
        this_thread::sleep_for(chrono::seconds(1));
        try
        {
            HttpServer();
        } 
        catch (const Exception& e) // 这⾥捕获基类，基类对象和派⽣类对象都可以被捕获
        {
            cout << e.what() << endl;
        } 
        catch (...)
        {
            cout << "Unkown Exception" << endl;
        }
    } 
    return 0;
}

分析一下上面的代码：

我们可以看到一个基类Exception，它的成员函数有错误信息_errmsg和相应的id值_id：

_errmsg用来保存异常的错误信息文本（错误描述）
_id 通常用来表示异常的类型编号或错误代码（error code），方便程序通过这个编号判断具体是哪种异常，进行针对性的处理。

在大型项目中，每个人会负责不同的板块，那么最后测试人员要如何去捕获不同的人编写的代码抛出的异常呢，如果每个人都抛出自己设定的异常类型，那么最后捕获时给每个人抛出的异常都单独写一个catch去捕获显然是不可能的。所以这时我们的异常类Exception就可以派上用场了：每个人都自己继承该基类来定义一个自己所需要异常类，里面加入需要描述的错误信息，这样再抛出异常后便可以通过一个统一的基类Exception捕获，同时也可以明显的找出是哪里抛出的异常。

例如上面代码中的示例：每一个派生类通过重写虚函数what就可以显示特定的错误信息，这得益于多态以及异常捕获共同作用的结果：

基类的指针和引用去调用对象的虚函数时，跟指针和引用的类型没关系，⽽是由指针和引用指向的对象决定的。
异常的捕获中允许派生类到基类的转换。

运行上述代码，我们可以看到：

可以发现，虽然我们在捕获时只执行了打印e.what这一行指令，可是我们却可以得到不同的错误指令，由此可见多态再异常中的作用。

2.5 异常重新抛出

有时catch到⼀个异常对象后，需要对错误进⾏分类，其中的某种异常错误需要进⾏特殊的处理，其他错误则重新抛出异常给外层调⽤栈处理。捕获异常后需要重新抛出，直接 throw 就可以把捕获的对象直接抛出。

重新抛出异常的更多作用：

局部处理异常后，通知调用者：有时候内部函数想做点日志、资源收尾等操作，但异常真正的处理应由调用者完成。
不同层级处理不同逻辑：底层捕获后做简要处理，上层捕获做最终处理。
保持异常信息不丢失：异常重新抛出可以保证异常类型和信息不变。

下⾯程序模拟展⽰了聊天时发送消息，发送失败补货异常，但是可能在电梯地下室等场景⼿机信号不好，则需要多次尝试，如果多次尝试都发送不出去，则就需要捕获异常再重新抛出，其次如果不是⽹络差导致的错误，捕获后也要重新抛出：

void _SeedMsg(const string& s)
{
    if (rand() % 2 == 0)
    {
        throw HttpException("⽹络不稳定，发送失败", 102, "put");
    } 
    else if (rand() % 7 == 0)
    {
        throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
    } 
    else
    {
        cout << "发送成功" << endl;
    }
} 
void SendMsg(const string& s)
{
    // 发送消息失败，则再重试3次
    for (size_t i = 0; i < 4; i++)
    {
        try
        {
            _SeedMsg(s);
            break;
        } 
        catch (const Exception& e)
        {
            // 捕获异常，if中是102号错误，⽹络不稳定，则重新发送
            // 捕获异常，else中不是102号错误，则将异常重新抛出
            if (e.getid() == 102)
            {
                // 重试三次以后否失败了，则说明⽹络太差了，重新抛出异常
                if (i == 3)
                    throw;
                cout << "开始第" << i + 1 << "重试" << endl;
            } 
            else
            {
                throw;
            }
        }
    }
} 
int main()
{
    srand(time(0));
    string str;
    while (cin >> str)
    {
        try
        {
            SendMsg(str);
        } 
        catch (const Exception& e)
        {
            cout << e.what() << endl << endl;
        } 
        catch (...)
        {
            cout << "Unkown Exception" << endl;
        }
    } 
    return 0;
}

关于重新抛出异常的一些注意事项：

只有在catch块里面的throw;才有效，离开catch使用throw;会导致编译错误。
重新抛出异常不会改变异常的类型和信息。
如果使用throw e;（带参数抛出），则会拷贝异常对象，可能改变异常类型（切割异常），一般不建议这样做。

2. 异常的安全问题

异常抛出后，后⾯的代码就不再执⾏，前⾯申请了资源(内存、锁等)，后⾯进⾏释放，但是中间可能会抛异常就会导致资源没有释放，这⾥由于异常就引发了资源泄漏，产⽣安全性的问题。所以中间我们需要捕获异常，释放资源后⾯再重新抛出。如下面代码所示：

double Divide(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        throw "Division by zero condition!";
    } 
    return (double)a / (double)b;
} 
void Func()
{
    // 这⾥可以看到如果发⽣除0错误抛出异常，另外下⾯的array没有得到释放。
    // 所以这⾥捕获异常后并不处理异常，异常还是交给外层处理，这⾥捕获了再
    // 重新抛出去。
    int* array = new int[10];
    try
    {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    } 
    catch (...)
    {
        // 捕获异常释放内存
        cout << "delete []" << array << endl;
        delete[] array;
        throw; // 异常重新抛出，捕获到什么抛出什么
    } 
    cout << "delete []" << array << endl;
    delete[] array;
} 
int main()
{
    try
    {
        Func();
    } 
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    } 
    catch (const exception& e)
    {
        cout << e.what() << endl;
    } 
    catch (...)
    {
        cout << "Unkown Exception" << endl;
    } 
    return 0;
}

其次析构函数中，如果抛出异常也要谨慎处理，⽐如析构函数要释放10个资源，释放到第5个时抛出了异常，则也需要捕获处理，否则后⾯的5个资源就没办法释放，就会造成资源泄漏了。

异常安全的层次（四种典型保证）

不抛异常保证（No-throw guarantee）
- 函数保证无论如何都不会抛异常。
- 程序稳定，不会因为异常而中断。
- 典型例子：std::swap、std::vector::swap等。
强异常安全保证（Strong exception safety guarantee）
- 要么函数成功执行，要么完全不改变程序状态。
- 如果函数抛出异常，程序的状态回滚到调用前，保证无副作用。
- 典型例子：std::vector::push_back在某些实现中提供强异常安全保证。
基本异常安全保证（Basic exception safety guarantee）
- 即使抛出异常，程序状态依然是有效的，但可能已部分更改。
- 数据结构不会崩溃或者泄漏资源，但数据可能已修改成某种不确定状态。
- 这是大多数函数至少应该做到的。
无异常安全保证（No exception safety guarantee）
- 函数抛出异常后程序状态可能不正确，资源可能泄漏，程序可能崩溃。

那么我们该如何保证异常安全呢？

资源管理对象化（RAII）
- 使用对象的构造和析构管理资源，确保资源自动释放。
使用标准库容器
- std::vector、std::string等已经提供异常安全。
复制-交换（Copy-and-swap）惯用法
- 操作时先修改副本，再交换，保证强异常安全。
尽量避免在析构函数中抛异常
- 析构函数应保证不抛异常，否则可能导致程序终止。

3. 异常的规范

对于⽤⼾和编译器⽽⾔，预先知道某个程序会不会抛出异常⼤有裨益，知道某个函数是否会抛出异常有助于简化调⽤函数的代码。

在C++98中函数参数列表的后⾯接throw()，表⽰函数不抛异常，函数参数列表的后⾯接throw(类型1,类型2...)表⽰可能会抛出多种类型的异常，可能会抛出的类型⽤逗号分割。

// C++98
// 这⾥表⽰这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这⾥表⽰这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();

不过C++98的⽅式这种⽅式过于复杂，实践中并不好⽤，C++11中进⾏了简化，函数参数列表后⾯加noexcept表⽰不会抛出异常，不加表⽰可能会抛出异常。

// C++11
//表示都不会抛出异常
size_type size() const noexcept;
iterator begin() noexcept;
const_iterator begin() const noexcept;

编译器并不会在编译时检查noexcept，也就是说如果⼀个函数⽤noexcept修饰了，但是同时⼜包含了throw语句或者调⽤的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调⽤ terminate 终⽌程序。

noexcept(expression)还可以作为⼀个运算符去检测⼀个表达式是否会抛出异常，可能会则返回false，不会就返回true。

4. 标准库的异常

C++标准库也定义了⼀套⾃⼰的⼀套异常继承体系库，基类是exception，所以我们⽇常写程序，需要时在主函数捕获exception即可，要获取异常信息，调⽤what函数，what是⼀个虚函数，派⽣类可以重写。

下面是标准库中exception的一些派生类：

异常类	说明
std::logic_error	逻辑错误，程序内部错误，不应该发生的错误，通常由程序错误导致
std::invalid_argument	函数参数不合法
std::domain_error	数学领域错误，如对无效域求函数值
std::length_error	超过长度限制
std::out_of_range	超出容器或字符串有效范围
std::runtime_error	运行时错误，程序外部条件引起的错误
std::range_error	数值超出合法范围
std::overflow_error	算术溢出
std::underflow_error	算术下溢
std::bad_alloc	内存分配失败（new操作符抛出）
std::bad_cast	无效的dynamic_cast失败
std::bad_typeid	typeid操作非法
std::ios_base::failure	IO流操作失败