当前位置： 首页 > news >正文

【C++11】异常

news 来源：原创 2025/6/20 2:57:47

异常

异常的概念

异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理。

异常使得我们能够将问题的检测与解决问题的过程分开，程序的一部分负责检测问题的出现，然后把解决问题的任务传递给程序的另一部分，检测环节无须知道问题的处理模块的所有细节。

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

  • throw:当问题出现时，程序会抛出一个异常，这是通过throw关键字完成的
  • catch：在您想要处理问题的地方，通过异常处理程序捕获异常，catch关键字用于捕获异常
  • try：try块中的代码标识将被激活特定异常，其后面通常跟着一个或多个catch块

异常的抛出和捕获

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

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

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

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

实际使用抛出和捕获的匹配原则有个例外，并不狗屎完全匹配，可以抛出派生类对象，使用基类捕获（这个在实际中非常好用）

使用try、catch语句语法如下：

try{
	//受保护的标识代码
}

catch(ExceptionName e1)
{
	//catch块
}

catch(ExceptionName e2)
{
	//catch块
}


...

栈展开

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

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

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

所以实际中我们最后都要加上一个catch（...）捕获任意类型的异常，否则当有异常没捕获，程序直接会终止。

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

有三个函数func1()、func2()、func3()，在func2()中调用func1()，func3()中调用func2()，main()中调用func3()，并在func1()抛出一个异常，在main()用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;
}

栈展开过程如下：首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则处理。没有则退出当前函数栈，继续在调用函数的栈中进行查找，不断重复上述过程，若到达main函数的栈，依旧没有匹配的，则终止程序。

查找匹配的处理代码

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

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

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

#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;
}

异常重新抛出

有时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; //而是通过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;
}

异常安全问题

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

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

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;
}

总结：

  • 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则容易导致对象不完整或没有完全初始化
  • 析构函数主要是完成对资源的清理释放，最好不要在析构函数内抛出异常，否则容易导致内存泄漏

异常规范

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

  • C++98中函数参数列表的后面接throw()，表示函数不抛异常，函数参数列表的后面接throw(类型1,类型2…)表示可能会抛出多种类型的异常，可能会抛出的类型用逗号分割。
  • C++98的方式这种方式过于复杂，实践中并不好用，C++11中进行了简化，函数参数列表后面加noexcept表示不会抛出异常，什么都不加表示可能会抛出异常。
  • 编译器并不会在编译时检查noexcept
    • 也就是说如果一个函数用noexcept修饰了，但是同时又包含了throw语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的（有些编译器可能会报个警告）。
    • 但是一个声明了noexcept的函数抛出了异常，程序会调用terminate终止程序。
  • noexcept(expression)还可以作为一个运算符去检测一个表达式是否会抛出异常，可能会则返回false，不会就返回true。
// 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++11
size_type size() const noexcept;
iterator begin() noexcept;
const_iterator begin() const noexcept;

double Divide(int a, int b) noexcept
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        throw "Division by zero condition!";
    }
    return (double)a / (double)b;
}

int main()
{
    try
    {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    catch (...)
    {
        cout << "Unkown Exception" << endl;
    }

    int i = 0;
    cout << noexcept(Divide(1,2)) << endl;
    cout << noexcept(Divide(1,0)) << endl;
    cout << noexcept(++i) << endl;

    return 0;
}

标准库的异常

C++标准库也定义了一套自己的一套异常继承体系库，基类是exception，所以我们日常写程序，需要在主函数捕获exception即可，要获取异常信息，调用what函数，what是一个虚函数，派生类可以重写。
在这里插入图片描述

C++异常的优缺点

缺点

  • 异常会导致程序的执行流乱跳，并且非常混乱，并且运行时出错抛异常就会乱跳，导致跟踪调试分析程序时比较困难
  • 会有一定的性能开销
  • C++无垃圾回收机制，有了异常就会导致内存泄漏，死锁等安全问题
  • C++标准库异常体系不好，导致各自定义，较为混乱

异常尽量规范使用

  • 抛出异常类型都继承与同一个基类
  • 函数是否会抛异常，抛什么异常，都会使用func() throw()方式规范化

优点

  • 相比于错误码的形式，可清晰准确展示出出错的各种详细信息，可帮助定位程序的bug（可以包含堆栈调用的信息）
  • 返回错误码的传统方式有一个很大的问题就是在函数调用链中深层的函数返回看错误，需要层层返回错误，到最外层才能拿到错误。（若是异常体系无论哪一层函数出错，都可以直接通过mian函数进行catch捕捉进行处理）

相关文章：

  • C语言学习笔记-9
  • Redis-x64-3.2.100.msi ： Windows 安装包（MSI 格式）安装步骤
  • MessageQueue --- RabbitMQ可靠传输
  • [项目总结] 在线OJ刷题系统项目技术应用(下)
  • 同花顺客户端公司财报抓取分析
  • 【AI Infra】【RLHF框架】四、VeRL中PPO、GRPO、REINFORCE++、RLOO实现源码解析
  • Spring 怎么解决循环依赖问题？
  • 室内指路机器人是否支持与第三方软件对接？
  • 2025年渗透测试面试题总结-某四字大厂面试复盘扩展 二面 （题目+回答）
  • JavaScript 中的 Reflect 详解
  • notepad++8.6.4安装及细节
  • 【Python Cookbook】数字日期和时间（一）
  • unity的dots中instantiate克隆对象后，对象会在原位置闪现的原因和解决
  • 吉卜力动画风格图像生成：Ghibli Diffusion
  • SDL中SDL_AudioSpec结构体参数
  • 23 MVC模式
  • Android学习总结之网络篇（HTTP请求流程）
  • Day82 | 灵神 | 快慢指针 重排链表
  • 科技赋能消防：无人机“挂弹灭火“构筑森林防火墙！
  • 生成式人工智能认证（GAI认证）如何推动就业市场的创新？
  • 网络营销与传统营销相比的优势/宁波网站优化公司推荐
  • 网站基础建设/如何让网站被百度收录
  • vi设计百度百科/百度seo关键词优化软件
  • 旅行社电商网站怎么做/seo超级外链发布
  • 网站制作换下面友情连接/媒体宣传推广方案
  • 电子商务网站的开发方式有哪三种/seo资源网站 排名