【C++】异常：概念及使用

[一异常的概念及使用](#一异常的概念及使用)

[1 异常的概念](#1 异常的概念)

[2 异常的抛出和捕获](#2 异常的抛出和捕获)

[3 栈展开](#3 栈展开)

[4 查找匹配的处理代码](#4 查找匹配的处理代码)

[5 异常重新抛出问题](#5 异常重新抛出问题)

[6 异常安全问题](#6 异常安全问题)

[7 异常规范](#7 异常规范)

[二标准库的异常](#二标准库的异常)

一异常的概念及使用

1 异常的概念

• 异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理，异常使得我们能够将问题的检测与解决问题的过程分开 ，程序的⼀部分负责检测问题的出现，然后解决问题的任务传递给程序的另⼀部分，检测环节无须知道问题的处理模块的所有细节。

• C语⾔主要通过错误码的形式处理错误，错误码本质就是对错误信息进行分类编号，拿到错误码以后还要去查询错误信息，比较麻烦。异常时抛出一个对象，这个对象可以函数更全面的各种信息

2 异常的抛出和捕获

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

• 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的类型和内容，程序的抛出异常部分告知异常处理部分到底发⽣了什么错误。

• 当throw执行时，throw后面的语句将不再被执行。程序的执行从throw位置跳到与之匹配的catch 模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调用链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置。这里还有两个重要的含义：1、沿着调用链的函数可能提早退出。2、⼀旦程序开始执行异常处理程序，沿着调⽤链创建的对象都将销毁。

• 抛出异常对象后，会生成⼀个异常对象的拷贝，因为抛出的异常对象可能是⼀个局部对象，所以会省成⼀个拷贝对象，这个拷贝的对象会在catch子句后销毁。（这里的处理类似于函数的传值返回）

如果没有发生异常，catch会被跳过

3 栈展开

• 抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句 ，⾸先检查throw本⾝是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。

• 如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。

• 如果到达main函数，依旧没有找到匹配的catch子句，程序会调用标准库的 terminate 函数终止
程序。

• 如果找到匹配的catch子句处理后，catch子句后面的代码会继续执行。

抛出的异常类型与 catch 块期望的类型不匹配，这会导致异常在调用链中向上传播，直到找到匹配的 catch 块，如果始终没有匹配的，程序会崩溃：

cpp 复制代码

double Divide(int a, int b)
{
    try
    {
        // 当b == 0时抛出异常 
        if (b == 0)
        {
            string s("Divide by zero condition!");
            throw s; 
        }
        else
        {
            // 使用 static_cast 进行显式类型转换，避免整数除法
            return static_cast<double>(a) / static_cast<double>(b);
        }
    }
    catch (int errid) // 这个 catch 块尝试捕获 int 类型的异常
    {
        // 由于上面抛出的是 string 类型，这里永远不会被执行
        cout << "Divide 函数内部捕获到 int 类型异常，错误ID: " << errid << endl;
    }
    // 如果 try 块中没有异常，或者异常被捕获并处理了（虽然这里没有），函数会执行到这里
    // 但在有返回值的函数中，所有可能的代码路径都应该有返回值
    return 0; 
}

/**
 * @brief 一个功能函数，用于获取用户输入并调用 Divide 函数
 */
void Func()
{
    int len, time;
    cin >> len >> time;

    try
    {
        // 如果 Divide 函数内部抛出异常，异常会在此处被抛出
        cout << Divide(len, time) << endl;
    }
    catch (const char* errmsg) // 这个 catch 块尝试捕获 const char* 类型的异常
    {
        // 由于 Divide 函数抛出的是 string 对象，而不是字符指针，这里也永远不会被执行
        cout << "Func 函数内部捕获到 const char* 类型异常，错误信息: " << errmsg << endl;
    }
    
    // 无论 try 块中是否发生异常（以及异常是否被当前函数捕获），
    // 只要程序没有终止，这行代码都会被执行，用于显示函数执行到了这里
    cout << __FUNCTION__ << ":" << __LINE__ << " 行执行" << endl;
}

int main()
{
    while (1)
    {
        try
        {
            Func();
        }
        catch (const string& errmsg) // 这个 catch 块尝试捕获 const string& 类型的异常
        {
            // Divide 函数抛出了一个 string 对象，
            // 这个异常在 Divide 和 Func 函数中都没有被匹配的 catch 块捕获，
            // 最终会传播到这里，并被这个 catch 块成功捕获。
            cout << "Main 函数内部捕获到 string& 类型异常，错误信息: " << errmsg << endl;
        }
    }
    return 0;
}

4 查找匹配的处理代码

• ⼀般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。

• 但是也有⼀些例外，允许从非常量向常量的类型转换，也就是权限缩小；允许数组转换成指向数组元素类型的指针，函数被转换成指向函数的指针；允许从派生类向基类类型的转换，这个点非常实用，实际中继承体系基本都是用这个方式设计的。

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

cpp 复制代码

#include<thread>// ⼀般⼤型项⽬程序才会使⽤异常，下⾯我们模拟设计⼀个服务的⼏个模块 
// 每个模块的继承都是Exception的派⽣类，每个模块可以添加⾃⼰的数据 
// 最后捕获时，我们捕获基类就可以 
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;
}

5 异常重新抛出问题

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

6 异常安全问题

•异常抛出后，后面的代码就不再执行，前面申请了资源(内存、锁等)，后面进行释放，但是中间可能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我们需要捕获异常，释放资源后面再重新抛出，当然后⾯智能指针章节讲的RAII方式解决这种问题是更好的。

• 其次析构函数中，如果抛出异常也要谨慎处理，比如析构函数要释放10个资源，释放到第5个时抛出异常，则也需要捕获处理，否则后面的5个资源就没释放，也资源泄漏了。《Effctive C++》第8个条款也专门讲了这个问题，别让异常逃离析构函数。

7 异常规范

• 对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。

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

• C++98的方式这种方式过于复杂，实践中并不好用，C++11中进行了简化，函数参数列表后面加noexcept表示不会抛出异常，啥都不加表示可能会抛出异常。

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

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

二标准库的异常

https://legacy.cplusplus.com/reference/exception/exception/日·C++标准库也定义了⼀套自己的⼀套异常继承体系库，基类是exception，所以我们⽇常写程序，需要在主函数捕获exception即可，要获取异常信息，调用what函数，what是⼀个虚函数，派生类可以重写。