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

[C++] 异常

article 2024/11/18 18:58:28

文章目录

  • 异常的概念
  • 异常的抛出与捕获
  • 栈展开（Stack Unwinding）
        • 四、总结
  • 查找匹配的处理代码
  • 异常的重新抛出
        • 三、模拟示例：服务模块中的异常处理
        • 四、总结
  • C++ 异常规范详解
        • 一、C++98异常规范
        • 二、C++11及其后的异常规范 (`noexcept`)
        • 三、使用`noexcept`的场景与注意事项
        • 四、综合示例
        • 五、总结

异常的概念

异常机制是一种重要的错误处理方法，可以帮助程序在运行时检测并处理问题，从而提高程序的可靠性和可维护性。C++异常机制的核心思想是：将错误检测和错误处理分离，从而让程序结构更清晰。

  1. 异常的作用
    • 检测环节只需发现问题，而不需要关注问题的处理细节。
    • 异常机制允许程序的某个部分通过抛出（throw）信号，将错误信息传递给能够处理它的另一个部分。
    • 异常对象比传统的错误码更灵活，因为它可以包含更丰富的上下文信息。
  2. C语言 vs. C++异常机制
    • C语言通过返回错误码的方式处理错误，开发者需要检查返回值或查询对应的错误信息表，操作繁琐且易遗漏。
    • C++通过异常对象，可以直接携带错误信息，程序员无需额外查找错误码。

异常的抛出与捕获

在C++中，异常的抛出和捕获分为以下几个步骤：

  1. 抛出异常 (throw)
    当程序遇到错误或特殊情况时，使用throw关键字抛出异常对象：
if (b == 0) {
    string s("Divide by zero condition!");
    throw s;
}
  • 抛出的对象可以是内置类型、标准库类型（如std::string）或用户自定义类型。
  • 注意：throw之后的代码不会被执行。
  1. 捕获异常 (catch)
    捕获异常通过try-catch块完成：
try {
    cout << Divide(len, time) << endl;
} catch (const string& errmsg) {
    cout << errmsg << endl;
}
  • try块包裹可能发生异常的代码。
  • catch子句处理捕获的异常，参数类型必须匹配抛出异常的类型。
  • 捕获顺序：越具体的异常类型越靠前。例如，catch (const std::exception& e)放在通用的catch (...)之前。
  1. 重要规则
  • 如果try块中没有匹配的catch子句，异常会沿调用链向上传递。
  • 如果最终仍未找到匹配的catch，程序会调用std::terminate()终止。

栈展开（Stack Unwinding）

栈展开是C++异常机制的核心，它描述了异常从抛出到被捕获的整个传播过程。

  1. 栈展开的流程
  • 当异常被抛出时，程序会暂停当前函数的执行，并沿调用链查找匹配的catch块。
  • 首先检查throw语句所在函数是否有try-catch，如果没有或类型不匹配，退出当前函数。
  • 依次回退到调用函数，重复上述过程，直到找到匹配的catch块或到达main函数。
  1. 对象销毁
  • 栈展开过程中，函数局部对象会按逆序调用析构函数，释放资源。
  • 这使得RAII（Resource Acquisition Is Initialization）在异常处理期间依然可靠。
  1. 未捕获异常
  • 如果到达main函数仍未找到匹配的catch块，程序会终止。

  1. 示例代码
double Divide(int a, int b) {
    if (b == 0) {
        string s("Divide by zero condition!");
        throw s;
    }
    return (double)a / (double)b;
}

void Func() {
    int len, time;
    cin >> len >> time;
    try {
        cout << Divide(len, time) << endl;
    } catch (const string& errmsg) {
        cout << "Caught exception: " << errmsg << endl;
    }
}

int main() {
    try {
        Func();
    } catch (const string& errmsg) {
        cout << "Unhandled exception: " << errmsg << endl;
    }
    return 0;
}
四、总结
  • 异常机制的优势
    • 提高代码的可读性和可维护性。
    • 将错误检测与处理解耦，增强模块化设计。
    • 支持复杂对象的生命周期管理（如RAII）。
  • 开发建议
    • 只在异常场景中使用异常，避免过度使用。
    • 异常处理应尽量精准，不要捕获所有异常（如catch (...)）。
    • 保证栈展开期间资源正确释放，推荐使用智能指针（如std::shared_ptr、std::unique_ptr）。

查找匹配的处理代码

在C++的异常处理机制中，当程序抛出一个异常对象时，系统会按照一定规则查找与该对象类型匹配的catch代码块，并执行相应的异常处理逻辑。

  1. 完全匹配的优先规则
    一般情况下，抛出的异常对象的类型与catch的形参类型完全匹配时，会优先选中该catch子句。例如：
try {
    throw std::string("Error occurred");
} catch (const std::string& err) {
    std::cout << "String exception: " << err << std::endl;
}
  1. 特殊匹配规则
    如果没有完全匹配的catch块，C++允许以下类型转换来匹配：
    • 非常量向常量转换：允许从非const类型转换为const类型。
    • 数组与指针转换：允许数组转换为指向其元素类型的指针。
    • 函数与指针转换：允许函数转换为指向函数的指针。
    • 派生类向基类转换：这是面向对象编程中最常用的设计方式。在捕获派生类对象时，可以通过基类类型进行匹配。
  2. 继承体系下的匹配示例
    继承体系允许捕获基类类型的异常，从而简化代码编写。例如：
class Exception {
public:
    Exception(const std::string& errmsg) : _errmsg(errmsg) {}
    virtual std::string what() const { return _errmsg; }
private:
    std::string _errmsg;
};

class SqlException : public Exception {
public:
    SqlException(const std::string& errmsg) : Exception(errmsg) {}
};

try {
    throw SqlException("SQL Error");
} catch (const Exception& e) { // 基类捕获派生类异常
    std::cout << e.what() << std::endl;
}
  1. 捕获通配符异常
    如果异常没有与任何具体类型匹配，可以使用通配符catch (...)捕获所有类型的异常。这种方式一般用于处理未知异常：
try {
    throw 42;
} catch (...) {
    std::cout << "Unknown exception caught!" << std::endl;
}
  1. 未捕获异常的处理
    如果异常传播到main函数仍未被捕获，程序会调用std::terminate()函数终止程序。为了避免程序非预期终止，可以在main中使用catch (...)捕获所有未匹配的异常。

异常的重新抛出

在某些情况下，捕获到一个异常后，需要将其重新抛出，供调用链上的其他部分继续处理。

  1. 重新抛出异常 (throw;)
    在catch块中，使用不带参数的throw关键字可以重新抛出当前捕获的异常。例如：
try 
{
    throw std::runtime_error("Error occurred");
} 
catch (const std::exception& e) {
    std::cout << "Caught: " << e.what() << ", rethrowing..." << std::endl;
    throw; // 重新抛出异常
}
  1. 传递异常的场景
    • 局部处理与传递：在捕获异常后执行部分处理操作，再重新抛出异常让更高层次代码进行处理。
    • 日志记录：记录异常日志，然后将异常重新抛出。
  2. 重新抛出后的异常处理
    重新抛出的异常会沿调用链继续传播，直至找到匹配的catch块。例如：
void InnerFunc() {
    throw std::runtime_error("Inner exception");
}

void OuterFunc() {
    try {
        InnerFunc();
    } catch (...) {
        std::cout << "Logging exception in OuterFunc" << std::endl;
        throw; // 重新抛出异常
    }
}

int main() {
    try {
        OuterFunc();
    } catch (const std::exception& e) {
        std::cout << "Caught in main: " << e.what() << std::endl;
    }
}

输出结果：

Logging exception in OuterFunc
Caught in main: Inner exception
  1. 带参数的重新抛出
    可以在catch块中捕获异常后，抛出另一个异常对象：
try {
    throw std::runtime_error("Original Error");
} catch (const std::exception& e) {
    throw std::logic_error("New Error"); // 抛出新的异常
}
  1. 注意事项
    • 在重新抛出异常时，资源的释放需要特别注意，建议使用智能指针或RAII管理资源。
    • 捕获基类对象重新抛出时，避免丢失原始的派生类信息。
三、模拟示例：服务模块中的异常处理

以下示例展示了如何在复杂项目中使用异常处理、基类匹配以及重新抛出异常。

class Exception {
public:
    Exception(const std::string& errmsg) : _errmsg(errmsg) {}
    virtual std::string what() const { return _errmsg; }
private:
    std::string _errmsg;
};

class SqlException : public Exception {
public:
    SqlException(const std::string& errmsg) : Exception(errmsg) {}
};

void SQLMgr() {
    throw SqlException("SQL Error");
}

void CacheMgr() {
    try {
        SQLMgr();
    } catch (const Exception& e) {
        std::cout << "Caught in CacheMgr: " << e.what() << std::endl;
        throw; // 重新抛出
    }
}

int main() {
    try {
        CacheMgr();
    } catch (const Exception& e) {
        std::cout << "Caught in main: " << e.what() << std::endl;
    }
    return 0;
}

运行结果：

Caught in CacheMgr: SQL Error
Caught in main: SQL Error
四、总结
  • 查找匹配代码的关键点
    • 完全匹配优先。
    • 支持类型转换，如派生类向基类的转换。
    • 提供通配符捕获（catch (...)）以处理未知异常。
  • 异常重新抛出
    • 使用throw;重新抛出当前异常。
    • 可以抛出不同的异常对象，向上传递更多的上下文信息。
    • 重新抛出时要注意资源管理，避免内存泄漏。

通过合理运用异常匹配与重新抛出，能够让程序在复杂情况下保持健壮性和可维护性。

C++ 异常规范详解

在C++中，异常规范是描述函数是否可能抛出异常，以及可能抛出哪些类型的异常。随着C++标准的演变，异常规范的用法发生了一些变化，从C++98的throw()到C++11及之后的noexcept，逐步变得简化和实用。

一、C++98异常规范
  1. 语法
    在C++98中，函数的参数列表后面可以添加throw()或throw(类型列表)，用于说明函数可能抛出异常的情况：
void func1() throw();              // 表示函数不会抛出任何异常
void func2() throw(std::bad_alloc); // 表示函数可能抛出std::bad_alloc异常
void func3() throw(int, char);     // 表示函数可能抛出int或char类型的异常
  1. 问题
    • C++98异常规范不会被强制执行。即便一个函数声明为throw()（不会抛出异常），但实际抛出了异常，程序仍可能崩溃。
    • 限制过于繁琐，在实践中难以使用。例如，声明多个可能抛出的类型时，类型检查复杂。
  2. 缺点
    • 性能影响：编译器需要生成额外代码进行类型检查。
    • 实际不可靠：标准库函数通常不使用throw(类型)，在现代开发中也很少被使用。
二、C++11及其后的异常规范 (noexcept)

为解决C++98中异常规范的不足，C++11引入了noexcept，替代throw()，并提供更强大的功能和简单的语法。

  1. noexcept基本语法
    • noexcept表示函数不会抛出任何异常：
void func1() noexcept;  // 保证函数不会抛出异常
void func2();           // 未声明noexcept，可能抛出异常

- 如果`noexcept`函数实际抛出了异常，程序会调用`std::terminate()`终止执行，而不会进行异常传播。
  1. noexcept(expression)

示例：

int i = 0;
std::cout << noexcept(++i) << std::endl;        // 输出1（不会抛异常）
std::cout << noexcept(throw "Error!");         // 输出0（会抛异常）

- `noexcept`还可以作为**运算符**，用于判断表达式是否可能抛出异常：

noexcept(expression)

    * 如果`expression`在编译期确定不会抛出异常，`noexcept(expression)`返回`true`。
    * 如果可能抛出异常，返回`false`。
  1. 与C++98的区别
    • 兼容性：noexcept取代了throw()，现代C++中几乎不再使用throw()。
    • 强制性：noexcept是更强的约束，声明为noexcept的函数如果抛出异常，程序直接终止。
    • 简单性：noexcept比C++98的throw(类型)更简洁，无需列出具体类型。
  2. 编译器行为
    • 不会强制检查：编译器不会在编译时检查noexcept修饰的函数是否实际可能抛出异常。
    • 运行时行为：如果noexcept函数实际抛出了异常，直接调用std::terminate()。
三、使用noexcept的场景与注意事项
  1. 标准库中的noexcept
    标准库中的许多函数使用了noexcept修饰。例如：
size_t size() const noexcept;  // 容器的size()函数不会抛出异常
iterator begin() noexcept;     // begin()函数也不会抛出异常
  1. 用户定义函数
    • 如果可以明确保证函数不会抛出异常，建议使用noexcept，这可以帮助编译器优化代码。
    • 例如：
double Divide(int a, int b) noexcept {
    if (b == 0) {
        throw "Division by zero condition!"; // 会导致std::terminate()
    }
    return (double)a / (double)b;
}
  1. 异常的影响
    • 如果noexcept函数抛出异常，程序终止执行，且不会传播异常。
    • 因此，在设计API时，应当慎重决定是否使用noexcept，只有在可以完全保证不抛出异常时才使用。
  2. 优化潜力
    • 编译器可以针对noexcept函数进行优化，因为可以假设它们不会抛出异常。
    • 对于容器操作（如std::vector的移动构造），如果被移动的对象的移动操作声明为noexcept，容器可以更高效地移动对象。
四、综合示例

以下代码展示了noexcept的使用，以及noexcept(expression)运算符的行为：

#include <iostream>
#include <stdexcept>

int SafeDivide(int a, int b) noexcept {
    if (b == 0) {
        throw "Division by zero!"; // noexcept函数抛异常会终止程序
    }
    return a / b;
}

int PotentialThrow(int x) {
    if (x < 0) throw std::runtime_error("Negative value!");
    return x;
}

int main() {
    try {
        std::cout << "SafeDivide: " << SafeDivide(10, 0) << std::endl;
    } catch (...) {
        std::cout << "Caught exception in SafeDivide!" << std::endl;
    }

    std::cout << "noexcept(SafeDivide(10, 2)): "
              << noexcept(SafeDivide(10, 2)) << std::endl; // 输出1（静态分析）

    std::cout << "noexcept(PotentialThrow(10)): "
              << noexcept(PotentialThrow(10)) << std::endl; // 输出0（可能抛异常）

    return 0;
}

运行结果：

Caught exception in SafeDivide!
noexcept(SafeDivide(10, 2)): 1
noexcept(PotentialThrow(10)): 0
五、总结
  1. C++98中的异常规范（throw()）：
    • 提供对可能抛出的异常类型的声明，但在实践中不常用，现代C++中已基本弃用。
  2. C++11及之后的异常规范（noexcept）：
    • 简洁高效，标记函数不会抛出异常。
    • 编译器可利用noexcept进行优化，增强程序的性能。
  3. 实践建议：
    • 对于不会抛出异常的函数，明确声明为noexcept。
    • 避免滥用noexcept，因为一旦函数抛出异常，程序会直接终止。
    • 使用noexcept(expression)进行静态分析，确保表达式的安全性。

通过合理使用异常规范，可以提高代码的可读性和可靠性，同时优化程序性能。


http://www.kler.cn/a/399073.html

相关文章：

  • Spring Boot 接口防重复提交解决方案
  • 华东师范大学数学分析第五版PDF习题答案上册及下册
  • 基于Python深度学习的【垃圾识别系统】实现~TensorFlow+人工智能+算法网络
  • Linux从0——1之shell编程4
  • Web导出Excel表格
  • 每行数据个数在变的二维数组的输出
  • Upload-Labs-Linux1学习笔迹 （图文介绍）
  • 力扣周赛：第424场周赛
  • 【机器学习】朴素贝叶斯算法
  • 基于K8S1.28.2实验rook部署ceph
  • FPGA开发-逻辑分析仪的应用-数字频率计的设计
  • 关于做完 C# 项目的问题总结
  • STM32设计智能翻译手势识别加算法系统
  • 基于OpenCV的自制Python访客识别程序
  • Java基础-内部类与异常处理
  • Intern大模型训练营（八）：Llamaindex RAG 实践
  • python核心语法
  • 树莓派（Raspberry Pi）picotool
  • RHCSA学习超详细知识点2命令篇
  • 开源vs闭源：你更看好哪一方？
  • 徒步中补给问题——贪心算法
  • 畜牧定位器
  • Linux 硬链接和软链接的使用场景有哪些？
  • [C/C++] 定位新表达式 placement new
  • Android 中的 Zygote 和 Copy-on-Write 机制详解
  • React 中如何解析字符串中的 html 结构