C/C++｜关于C++的异常处理机制

已于 2024-06-02 15:10:18 修改
阅读量1.1k 收藏 23
点赞数 31
分类专栏： # C/C++ 文章标签： c语言 c++ java
于 2024-06-02 15:09:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caiziming_001/article/details/139388718
版权

来自C++入门选手的理解，希望有大佬看到可以指导补充

首先我们需要先讨论一下assert宏，它仅用来捕捉不应该发生的逻辑错误，而且他也不能对错误进行处理，而是直接终止程序执行。

随后我们来介绍C++的异常处理机制。它允许程序中独立开发的部分能够在运行时就出现的问题进行处理。

整个行文的逻辑我想先说明 try … catch…块，也就是我们如何抛出异常和捕获异常，然后我们再细致讨论这两个概念。

文章目录

assert宏

在 C++ 中，assert 是用于在调试时检查程序中某些条件是否为真的宏。当条件为假（即断言失败）时，程序会输出错误信息并终止执行。assert 通常用于捕捉不应该发生的逻辑错误，在发布版本中可以禁用这些检查以提高性能。

使用方法

  1. 包含头文件：
  2. 编写断言
  3. 实际示例

禁用断言

在发布版本中，可以通过定义 NDEBUG 来禁用 assert 检查。可以在编译时使用 -DNDEBUG 选项：

g++ -DNDEBUG -o myprogram myprogram.cpp

在 CMake文件中禁用断言，通常是在 CMakeLists.txt 文件中使用 add_definitions 或 target_compile_definitions 指令来设置编译选项。

cmake_minimum_required(VERSION 3.10)
project(MyProject)

set(CMAKE_CXX_STANDARD 14)

# 添加源文件
add_executable(MyProject main.cpp)

# 禁用所有目标的断言
add_definitions(-DNDEBUG)
# 为特定目标禁用断言
# target_compile_definitions(MyProject PRIVATE NDEBUG)

# 链接库
target_link_libraries(MyProject PRIVATE moduo_base)

异常处理机制

前面我们提到assert仅用于在调试期间的错误检测和诊断，如果断言为假，程序会直接终止执行。

而我们的 try...catch 块用于处理程序运行期间可能发生的异常，能够应对运行时的错误。它允许程序捕获并处理异常，从而防止程序崩溃并提供有意义的错误处理和恢复机制。

这里是一个简单的例子：

#include <iostream>
#include <stdexcept>

double divide(double numerator, double denominator) {
	if (denominator == 0) {
		throw std::invalid_argument("Denominator cannot be zero");
	}
	return numerator / denominator;
}

int main () {
	double num = 10.0;
	double den = 0.0;

	try {
		double result = divide(num, den);
		std::cout << "Result: " << result << std::endl;
	} catch (const std::invalid_argument &e) }
		std::cerr << "Error: " << e.what() << std::endl; 
	}
	return 0;
}

在这个例子中，如果分母为零，函数 divide 将抛出一个 std::invalid_argument 异常。try…catch 块捕获这个异常并输出错误信息，而不是让程序崩溃。
也就是说即使我们的被除数为设置为了0，程序也只会捕获这个异常信息，并且为我们提供了处理异常的机会，它并不会让程序崩溃。

那么，我们现在来了解一下它的整个运行机制吧！

throw、try、catch

作用

  1. throw

    • 用于抛出异常。可以在函数中通过 throw 关键字抛出一个异常，异常可以是基本类型或任何类型的对象。
    • 例如：throw 42; 或 throw std::runtime_error(“An error occurred”);

  2. try

    • 用于包围可能抛出异常的代码块。当异常被抛出时，控制权转移到与之关联的 catch 块。
    • 例如：
    try {
// 可能抛出异常的代码
}

  3. catch

    • 用于捕获异常。catch 块会捕获由 try 块抛出的异常，并对其进行处理。
    • 例如：
    catch (const std::exception& e) {
// 处理异常
}
    • 值得关注的是，我们的 catch 也能够使用 throw ，这叫重新抛出，也就是说有时候一个单独的 catch 语句不能完整地处理某个异常，在执行了某些矫正操作之后，当前的 catch 可能会决定由调用链更上一层的函数接着处理异常。一条 catch 语句通过重新抛出的操作将一场传递给另外一个 catch 语句。这里的重新抛出仍然是一条 throw 语句，只不过不包含任何表达式。

关系

当一个异常被抛出时，程序会跳转到最近的匹配的 catch 块进行处理。如果找不到匹配的 catch 块，程序会调用 std::terminate 并终止。

也就是说，如果一个异常没有被捕获，则它将终止当前的程序

那么这个异常是如何被捕获的呢 ？这里就不得不提到一个名词“栈展开”

当抛出一个异常后，程序暂停当前函数的执行过程并立即开始寻找与异常匹配的 catch 子句。当 throw 出现在一个 try 语句块內时，检查与该 try 块关联的 catch 子句。如果找到了匹配的 catch，就使用该 catch 处理异常。如果这一步没找到匹配的 catch 且该 try 语句嵌套在其他 try 块中，则继续检查与外层 try 匹配的 catch 子句。如果还是找不到匹配的 catch ，则退出当前这个主调函数，继续在调用了刚刚推出的这个函数的外层函数中寻找，以此类推。
这个过程就叫做栈展开，栈展开过程沿着嵌套函数的调用链不断寻找，直到找到与之匹配的 catch 子句为止，如果找不到匹配的 catch 子句，程序就会调用标准库函数 terminate，他负责终止程序的执行过程。

好了，我们已经能够基本使用C++的异常处理机制了，但是我们还需要弄明白以下内容：

⭐️栈展开过程中对象会被自动销毁

在栈展开的过程中，位于调用链上的语句块可能会提前退出。通常情况下，程序在这些块中可能已经创建了一些局部对象。我们已经知道，块退出后它的局部对象也将随之销毁，这条规则对于栈展开过程同样适用。

如果在栈展开过程中推出某个块，编译器将负责确保这个块中创建的对象能被正确地销毁。如果某个局部对象的类型是类类型，则该对象的析构函数将被自动调用。与往常一样，编译器在销毁内置类型的对象时不需要做任何事情。

⭐️异常可能会发生在构造函数中，我们应该怎么处理

如果异常发生在构造函数总，则当前的对象可能只构造了一部分。

有的成员已经初始化了，而另外一些成员在异常发生前也许还没有初始化。即使某个对象只构造了一部分，我们也要确保已经构造的成员能够被正确销毁。

如果成员是栈上的变量，那么这里的“我们”指的就是编译器，根本不需要操心。

如果成员是堆上的动态资源，那么这里的“我们”指的就是程序员了，程序员应该确保已构造的成员能够被正常销毁，这里是一个例子：展示如何在堆上分配成员变量以及在构造函数抛出异常时正确释放它们。

#include <iostream>
#include <stdexcept>

class Member {
public:
    Member(const std::string& name) : name(name) {
        std::cout << "Constructing Member: " << name << std::endl;
        if (name == "bad") {
            throw std::runtime_error("Failed to construct Member: " + name);
        }
    }
    ~Member() {
        std::cout << "Destructing Member: " << name << std::endl;
    }
private:
    std::string name;
};

class MyClass {
public:
    MyClass(const std::string& name1, const std::string& name2, const std::string& name3) 
        : member1(nullptr), member2(nullptr), member3(nullptr) {
        try {
            member1 = new Member(name1);
            member2 = new Member(name2);
            member3 = new Member(name3);
            std::cout << "Constructing MyClass" << std::endl;
        } catch (...) {
            // 释放已成功分配的资源
            delete member1;
            delete member2;
            delete member3;
            std::cout << "Exception caught in MyClass constructor" << std::endl;
            throw; // 重新抛出异常
        }
    }

    ~MyClass() {
        delete member1;
        delete member2;
        delete member3;
        std::cout << "Destructing MyClass" << std::endl;
    }
private:
    Member* member1;
    Member* member2;
    Member* member3;
};

int main() {
    try {
        MyClass myObject("good1", "bad", "good3");
    } catch (const std::exception& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
    return 0;
}

输出分析
运行上述代码，输出结果如下：

Constructing Member: good1
Constructing Member: bad
Exception caught in MyClass constructor
Destructing Member: good1
Exception: Failed to construct Member: bad

  1. 构造对象：

    • Member member1 被成功构造，输出 “Constructing Member: good1”。
    • Member member2 的构造函数抛出异常，输出 “Constructing Member: bad” 并抛出异常 std::runtime_error(“Failed to construct Member: bad”)。

  2. 捕获异常：

    • MyClass 的构造函数捕获到异常，进入 catch 块。
    • 在 catch 块中，删除已分配的成员变量 member1，防止内存泄漏。

  3. 栈展开：

在栈展开过程中，编译器不会自动处理堆上分配的成员变量的清理，因此需要程序员在 catch 块中手动释放这些资源。

  1. 异常处理：

    • 异常被传播到 main 函数的 catch 块，输出 “Exception: Failed to construct Member: bad”。

更好的办法是使用智能指针

为了简化内存管理并防止内存泄漏，可以使用智能指针（如 std::unique_ptr）。智能指针可以自动管理资源的生命周期，即使在异常情况下也能确保资源被正确释放。

#include <iostream>
#include <stdexcept>
#include <memory>

class Member {
public:
    Member(const std::string& name) : name(name) {
        std::cout << "Constructing Member: " << name << std::endl;
        if (name == "bad") {
            throw std::runtime_error("Failed to construct Member: " + name);
        }
    }
    ~Member() {
        std::cout << "Destructing Member: " << name << std::endl;
    }
private:
    std::string name;
};

class MyClass {
public:
    MyClass(const std::string& name1, const std::string& name2, const std::string& name3) {
        member1 = std::make_unique<Member>(name1);
        member2 = std::make_unique<Member>(name2);
        member3 = std::make_unique<Member>(name3);
        std::cout << "Constructing MyClass" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructing MyClass" << std::endl;
    }
private:
    std::unique_ptr<Member> member1;
    std::unique_ptr<Member> member2;
    std::unique_ptr<Member> member3;
};

int main() {
    try {
        MyClass myObject("good1", "bad", "good3");
    } catch (const std::exception& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
    return 0;
}

输出分析：

Constructing Member: good1
Constructing Member: bad
Exception: Failed to construct Member: bad
Destructing Member: good1

解释:

  1. 构造对象：

    • Member member1 被成功构造，输出 “Constructing Member: good1”。
    • Member member2 的构造函数抛出异常，输出 “Constructing Member: bad” 并抛出异常 std::runtime_error(“Failed to construct Member: bad”)。

  2. 智能指针管理资源：

    • 当异常抛出时，智能指针 member1 和 member2 会自动销毁已经构造的对象，防止内存泄漏。

  3. 异常处理：

    • 异常被传播到 main 函数的 catch 块，输出 “Exception: Failed to construct Member: bad”。

⭐️析构函数与异常

C++在语法层面上保证了，在栈展开的过程中，运行类类型的局部对象的析构函数时，由于这些析构函数是自动执行的，所以他们不应该抛出异常。一旦在栈展开的过程中析构函数抛出了异常，并且析构函数自身没能捕获到该异常，则程序直接终止。

Che3rry
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
《C/C++实战专栏》介绍
热门推荐
dvlinker的技术专栏
07-31 6万+
本文详细介绍《C/C++实战专栏》的主体内容构成。
C++之异常处理
一名还在努力学习技术的程序员的博客
11-16 257
本篇主要讲解了C++异常相关知识
通过设置gcc的flags来捕获异常
哦，原来你也在这里。
07-18 153
然后，就可以不使用gdb来调试即可打印堆栈等详细信息了。即可实现运行程序时捕获异常的目的。
try catch 异常处理
HateCode的胡言乱语
11-11 1954
学习code：int main(int argc, char * argv[])...{  try ...{... ...  }  catch(std::exception& e) ...{    std::cerr  "Exception caughted:"  std::endl       e.what ()       std::endl;  }  catch(...) ...{ 
C++assert和捕获异常
zhouguangfei0717的博客
10-27 1503
#include "stdafx.h" #include #include #include//异常处理 //#include int main() { int i = 20; assert(i == 20);//满足条件什么都不显示，不满足报错 return 0; } //捕获异常
C++ assert和异常捕获的对比
回头太难
08-02 1791
异常捕获（exception）和断言（assertion）的使用场景： 异常捕获：内存不足，运行时异常，用户输入错误（JSON格式不正确），数据库连接错误，IO错误 断言：写该代码的人造成的错误，例如指针为空（assert(nullptr!=p);） 一般生产环境不使用assert，因为会造成崩溃。 而异常捕获可用于给用户反馈，例如在HTTP服务中，用户发送的消息格式不正确（JSON格式非...
「C/C++」C/C++异常处理
何曾参静谧的博客
04-23 1173
一、C语言中的异常处理 1.返回值来传递错误信息 2.使用标准库函数对异常进行处理（不推荐） 3.使用全局变量来记录错误信息(不推荐) 二、C++中的异常处理 1.try{}catch(){}异常处理 2.C++标准的异常 3.异常的重新解析（工程开发中比较实用） 4.自定义异常类
C、C++、Java语言中异常处理机制浅析
01-31
异常处理又称异常错误处理，它提供了处理程序运行时出现任何意外或异常情况的方法。异常处理通常是防止未知错误的发生所采取的处理措施，对于某一类型的错误，异常处理应该提供相应的处理方法。例如，在设计程序时，...
C/C++ API 帮助文档大全（中文，chm格式）
10-15
3. **异常处理**：C++中的异常处理机制允许程序在运行时检测和处理错误。try、catch和throw关键字用于捕获和处理异常，确保程序的健壮性。 4. **模板**：模板是C++的泛型编程工具，可以创建类型无关的函数和类，...
C语言/C++实现图书管理系统
05-27
使用C++的异常处理机制可以优雅地处理这类情况。同时，使用标准输入/输出（cin/cout）与用户交互，或通过命令行参数接收输入，都是常见的实现方式。 总的来说，"C语言/C++实现图书管理系统"项目涵盖了C语言和C++的...
C++快速入门---assert函数和捕获异常（22）
Tim的嵌入式之旅
11-06 1576
C++快速入门---assert函数和捕获异常（22）   assert()函数，专为调试而准备的工具函数。 assert()函数需要有一个参数，它将测试这个输入参数的真 or 假状态。 #include &lt;iostream&gt; #include &lt;cassert&gt; int main() { int i = 20; assert (i == 65); re...
C++ assert函数与捕获异常
Chroniccandy的博客
10-09 3891
assert()函数 C语言和C++都有一个专门为程序调试准备的工具函数,这就是assert()函数。这个函数在C语言的assert.h库文件里定义的,所以包含到C++的程序里我们用以下语句对此头文件进行包含: #include <cassert> assert()函数需要有一个输入参数，他将测试这个输入参数的真or假状态: 如果这个输入参数的状态为真,程序什么都不做 如果这个输入参数的状态为假,程序按照要求进行动作 例如以下代码: int main() { int i = 20; as
(蓝桥杯C/C++）——基础算法(下)
最新发布
2402_82385099的博客
11-07 1172
概念:递归是指函数直接或间接调用自身的过程。基本情况(递归终止条件):递归函数中的一个条件，当满足该条件时，递归终止，避免无限递归。可以理解为直接解决极小规模问题的方法。递归表达式(递归调用):递归函数中的语句，用于解决规模更小的子问题，再将子问题的答案合井成为当前问题的答案。枚举算法是一种基本的算法思想，它通过穷举所有可能的情况来解决问题。它的基本思想是将问题的解空间中的每个可能的解都枚举出来，并进行验证和比较，找到满足问题条件的最优解或者所有解。枚举算法适用于问题规模较小、解空间可穷举的情况。
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 629
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 315
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
ChoSeitaku的博客
11-04 1108
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 101
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 372
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值