【C++】C++异常

Ne0inhk

— 13 min read
【C++】C++异常



🎬 个人主页：MSTcheng · ZEEKLOG
🌱 代码仓库 ：MSTcheng · Gitee
🔥 精选专栏: 《C语言》
《数据结构》
《算法学习》
《C++由浅入深》

💬座右铭：路虽远行则将至，事虽难做则必成！

在前面的文章中，我们已经介绍了C++11的一些新特性。本文将和下一篇一起为大家讲解C++的最后两个重要主题：异常处理和智能指针。

文章目录

一、异常的概念及使用

1.1异常的概念

异常（Exception）是指在程序执行过程中发生的意外或错误情况，这些情况可能导致程序无法继续正常执行。异常处理是编程中用于管理这些意外情况的机制，旨在提高程序的健壮性和用户体验。
相比于C语言，C语言主要通过错误码的方式处理错误，而错误码的本质就是对错误的信息进行分类编写。拿到错误码以后还要去查询错误信息，是比较麻烦的。而异常时直接抛出一个对象，这个对象可以涵盖更全面的错误信息。

1.2异常的分类

1、编译时异常（Checked Exception）

  • 这类异常在编译阶段就会被检查，必须显式处理（捕获或声明抛出）。
    常见于外部资源操作，如文件不存在（FileNotFoundException）、数据库连接 失败等。

2、运行时异常（Runtime Exception）

  • 编译时不会被强制检查，通常由逻辑错误引发，如空指针访问（NullPointerException）、数组越界（ArrayIndexOutOfBoundsException）等。

3、错误（Error）

  • 指严重问题（如内存耗尽OutOfMemoryError），通常无法通过程序处理，需从系统层面解决。

1.3异常的抛出与捕获

异常的抛出：

  • 当程序出现问题的时候，首先通过抛出(throw)一个对象来引发一个异常，该对象的类型以及当前调用链来决定匹配哪个catch，然后再被这个catch接收并处理异常。

异常的捕获：

  • 异常的捕获首先通过一个try/catch语句来捕获，并且该catch要与throw对象的类型匹配且为距离抛出异常位置最近的那一个catch，然后根据抛出的对象的类型和内容告知异常部分到底发生了什么错误。

下面我们就来看看C++的异常抛出与捕获机制：

#include<iostream>#include<string>usingnamespace std;//=================================//Divide这个函数是用来计算两个数相除的函数//对于一个除数来说被除数是不能为0的 也就是分子可以为0 但分母不能//所以我们针对被除数是否为0设计了一个异常机制//假设a为除数b为被除数 如果检测到b为0那么就抛出异常//=================================doubleDivide(int a,int b){try{// 当b == 0时抛出异常 引发除零错误if(b ==0){//===============================//抛出异常对象后，会⽣成⼀个异常对象的拷⻉，//因为抛出的异常对象可能是⼀个局部对象，//所以会⽣成⼀个拷⻉对象，//这个拷⻉的对象会在catch⼦句后销毁。//（这⾥的处理类似于函数的传值返回）//=============================== string s("Divide by zero condition!");throw s;//抛出的是一个string对象 catch的时候要用string类型接收}else{return((double)a /(double)b);}//... fxx()}catch(constint& s){ cout << s << endl;}//第一个catch 这个catch的类型与抛出异常的string对象类型匹配 且离抛出位置最近/*catch (const string& errmsg) { cout << errmsg << endl; }*/ cout << __FUNCTION__ <<":"<<__LINE__<<"行执行"<< endl;return0;}voidFunc(){int len, time; cin >> len >> time; cout <<Divide(len, time)<< endl; cout << __FUNCTION__ <<":"<<__LINE__<<"行执行"<< endl;}intmain(){try{Func();}//第二个catch 虽然也是string类型 与抛出异常的string对象类型配但是离抛出位置较远//所以第一个catch存在的情况下程序优先会跳到第一个catch中catch(const string& errmsg){ cout << errmsg << endl;}catch(int errid){ cout << errid << endl;}}
1、当被第一个catch捕获时

2、注释掉第一个catch，当被第二个catch捕获时

注意事项：

  1. 当throw执行时，throw后面的语句将不再执行，直接跳转到对应的catch中去执行，catch可能是同一个函数中的局部catch，也可能是调用链中另一个函数中的catch，制空权从throw位置转移到了catch位置之后还有两个重要含义：
    1、沿着调用链的函数可能提早退出
    2、一旦程序开始执行异常处理程序，沿着调用链创建的对象都将销毁。
对于第一点含义我们对比两次catch执行的结果就会发现，当第一个catch捕获时，由于第一个catch与抛出异常的对象位于同一个域，所以当异常对象s被第一个catch捕获时并没有跳过func函数所以程序运行时会执行func函数中的内容，而第二次catch就不同了，第二个catch在main函数中，throw之后直接跳过func函数，到main函数中执行catch之后的内容，跳过了func函数所以func函数中的内容不被执行。

对于第二点，我们就要来看看栈的展开了

1.4栈展开

如果一直到main函数都没有找到了与之类型匹配的catch子句，则程序会调用标准库的terminate函数终止程序，如下图：

在这里插入图片描述

当抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本⾝是否在try块内部，如果在则查找匹配的catch语句：如果有匹配的，则跳到catch的地方进行处理；如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。 下面来看看栈展开图

在这里插入图片描述

1.5 查找匹配的处理代码

⼀般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。
但是也有⼀些例外，允许从非常量向常量的类型转换，也就是权限缩小；允许数组转换成指向数组元素类型的指针，函数被转换成指向函数的指针；允许从派⽣类向基类类型的转换，这个点非常实⽤，实际中继承体系基本都是用这个方式式设计的。下面来看一些例子：
//=============第一种==============//精确匹配try{throw42;// 抛出int类型}catch(int e){// 精确匹配int std::cout <<"Caught int: "<< e;}//=============第二种===============//权限缩小转换(非常量->常量)try{char* ptr =newchar[10];throw ptr;// 抛出char*}catch(constchar* e){// 允许非常量转常量 std::cout <<"Caught const pointer";delete[] e;}//=============第三种==============//派生类->基类转换classBase{virtualvoidfoo(){}};classDerived:publicBase{};try{throwDerived();// 抛出派生类对象}catch(Base& e){// 捕获基类引用（多态处理） std::cout <<"Caught Base reference";}//==============第四种=============//数组->指针转换try{int arr[5]{1,2,3};throw arr;// 抛出int[5]}catch(int* e){// 自动转为指针 std::cout <<"Caught pointer to first element: "<< e[0];}//==============第五种=============//就近原则匹配catchtry{throw std::string("error");}catch(const std::string& e){// 优先匹配更近的 std::cout <<"Caught by string ref";}catch(const std::exception& e){ std::cout <<"Caught by exception ref";}

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

#include<iostream>#include<stdexcept>intmain(){try{// 可能抛出异常的代码throw std::runtime_error("An error occurred");}catch(const std::exception& e){ std::cerr <<"Caught exception: "<< e.what()<<std::endl;}catch(...)//使用三个点来接收异常{ std::cerr <<"Caught an unknown exception"<< std::endl;}return0;}

1.6异常重新抛出

有时catch到⼀个异常对象后，需要对错误进行分类，其中的某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接 throw; 就可以把捕获的对象直接抛出
try{// 可能抛出异常的代码someRiskyOperation();}catch(const std::exception& e){if(isSpecialError(e)){// 特殊错误处理handleSpecialCase();}else{// 其他错误重新抛出throw;// 注意没有参数}}

注意throw与throw e的区别：

  1. throw重新抛出当前异常对象，不进行拷贝构造。
  2. throw e会通过拷贝构造函数创建一个新的异常对象。

1.7异常的安全问题

由于异常抛出后，后面的代码就不再执行，前面申请了资源(内存、锁等)，后面进行释放，但是中间可能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我们需要捕获异常，释放资源后⾯再重新抛出。当然后面智能指针章节讲的RAII方式解决这种问题是更好的。
doubleDivide(int a,int b){// 当b == 0时抛出异常if(b ==0){throw"Division by zero condition!";}return(double)a /(double)b;}voidFunc(){// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。// 所以这里捕获异常后并不处理异常，异常还是交给外层处理，这里捕获了再// 重新抛出去。int* array =newint[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;}intmain(){try{Func();}catch(constchar* errmsg){ cout << errmsg << endl;}catch(const exception & e){ cout << e.what()<< endl;}catch(...){ cout <<"Unkown Exception"<< endl;}return0;}

1.8异常规范

相比于传统C++98时的异常规范C++11中进行了简化：函数参数列表后面加
noexcept表示不会抛出异常，什么都不加表示可能会抛出异常。
  • 编译器并不会在编译时检查noexcept，也就是说如果⼀个函数用noexcept修饰了，但是同时又包含了throw语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调用terminate函数来终止程序。
  • 另外noexcept还可以作为一个运算符去检测一个表达式是否会抛出异常，如果会抛出异常就返回false，如果不会就返回true。
doubleDivide(int a,int b)noexcept{// 当b == 0时抛出异常if(b ==0){throw"Division by zero condition!";}return(double)a /(double)b;}intmain(){try{int len, time; cin >> len >> time; cout <<Divide(len, time)<< endl;}catch(constchar* 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;return0;}
在这里插入图片描述

二、总结

C++的异常处理机制是管理运行时错误的重要工具，它通过try、catch和throw三个关键字的配合使用，能够有效应对程序执行中的意外情况。这套机制不仅确保了程序的健壮性，还能实现错误的优雅处理。因此，在代码编写时应当重视异常处理的应用。

MSTcheng 始终坚持用直观图解 + 实战代码，把复杂技术拆解得明明白白！ 👁️ 【关注】 看普通程序员如何用实用派思路搞定复杂需求 👍 【点赞】 给 “不搞虚的” 技术分享多份认可 🔖 【收藏】 把这些 “好用又好懂” 的干货技巧存进你的知识库 💬 【评论】 来唠唠 —— 你踩过最 “离谱” 的技术坑是啥？ 🔄 【转发】把实用技术干货分享给身边有需要的程序员伙伴 技术从无唯一解，让我们一起用最接地气的方式，写出最扎实的代码！ 🚀💻
感谢能够看到这里的小伙伴，如果这篇文章有帮到您，还请给个三连！你们的持续支持是我更新最大的动力！谢谢！

Read more

【C++深学日志】C++“类”的完全指南--从基础到实践（一）

【C++深学日志】C++“类”的完全指南--从基础到实践（一）

假想一下，你是一个顶级汽车设计师，你的任务不是亲自拧紧每一个螺丝，而是要设计出一幅“汽车蓝图”，你在图纸上设计了一辆汽车所需的一切：车轮、车灯、V8发动机、方向盘等，你手上这份设计好的蓝图就相当于我们今天要讲的C++中的“类”，它规定了汽车的属性（例如：离合器）和方法（功能：换挡），它本身并不是一辆真正的汽车，只是你的一份设计规划，后续你交付给工厂，工厂按照你的设计蓝图，生产出了一辆汽车，这就是实例化，后续工厂有根据你的蓝图设计了一条流水线，每一辆从流水线上生产下来的车辆，都是里这个蓝图（类）的一个对象，他们都有蓝图定义的属性和功能。在C++中类就充当着蓝图的作用，它定义了对象拥有哪些属性，那么就和我一起来揭开这份“蓝图”的面纱吧。 1.类 1.1.类的定义 类的基本思想是数据抽象和封装，数据抽象是一种依赖于接口和实现的分离式编程技术，类的接口包括用户所能执行的操作，类的实现则是包括类的数据成员、负责接口实现的函数以及定义类所需的各种私有函数。封装实现了类的接口和实现的分离，封装后的类隐藏了他的视线细节，也就是说，

By Ne0inhk
Rust赋能Android蓝牙协议栈：从C++到安全高效的重构之路

Rust赋能Android蓝牙协议栈：从C++到安全高效的重构之路

在移动设备生态中，蓝牙协议栈是连接物理世界与数字世界的关键桥梁，从无线耳机、智能手环到车载系统，其稳定性、安全性与效率直接决定用户体验。长期以来，Android蓝牙协议栈核心模块基于C++开发，凭借接近硬件的性能优势支撑了数十亿设备的运行。但随着物联网设备爆发式增长、蓝牙5.3/5.4等新协议落地，C++固有的内存安全缺陷与并发管理难题愈发凸显。2021年起，Google开始在Android蓝牙协议栈中引入Rust重构核心模块，这一技术选型并非偶然，而是工程实践中安全与效率平衡的必然结果。 目录 一、Android蓝牙协议栈的C++之困 1.1 内存安全漏洞：蓝牙模块的阿喀琉斯之踵 1.2 并发管理复杂：多设备连接下的稳定性难题 1.3 代码可维护性下降：遗产代码的演进瓶颈 二、Rust：破解困局的关键特性赋能 2.1 所有权模型 2.2 并发安全：无数据竞争的天生优势 2.3 零成本抽象与可维护性：

By Ne0inhk
C++ - 基于多设计模式下的同步&异步日志系统（11w字）

C++ - 基于多设计模式下的同步&异步日志系统（11w字）

1.前言 日志：程序运行过程中所记录的程序运行状态信息 作用：记录程序运行状态信息，以便于程序员能够随时根据状态信息，对系统的运行状态，进行分析 功能：能够让用户非常简便的进行日志的输出，以及控制 2.项目介绍 本项目主要实现一个日志系统，其主要支持以下功能： * 支持多级别日志消息 * 支持同步日志和异步日志 * 支持可靠写入日志到控制台、文件以及滚动文件中 * 支持多线程程序并发写文件 * 支持拓展不同的日志落地目标地 3.开发环境 * CentOS 7 * vscode/vim * g++/gdb * Makefile 4.核心技术 * 类层次设计（继承和多态的应用） * C++11(多线程、auto、智能指针、右值引用) * 双缓冲区 * 生产消费模型 * 设计模式（单例、工厂、代理、建造者） 5.日志系统介绍

By Ne0inhk