搜索文档
登录/投稿 会员注册

位置： 文档库 > C/C++ > 文档下载预览

《C++异常处理机制及代码示例.doc》

1. 下载的文档为doc格式,下载后可用word或者wps进行编辑;

2. 将本文以doc文档格式下载到电脑，方便收藏和打印;

3. 下载后的文档,内容与下面显示的完全一致,下载之前请确认下面内容是否您想要的,是否完整.

点击下载文档

C++异常处理机制及代码示例.doc

《C++异常处理机制及代码示例》

在C++程序设计中，异常处理（Exception Handling）是构建健壮系统的核心机制之一。它通过将错误处理逻辑与正常业务逻辑分离，提高了代码的可读性和可维护性。与传统的错误码返回方式相比，异常处理能够更清晰地表达程序执行过程中遇到的意外情况，并通过栈展开（Stack Unwinding）机制自动释放资源，避免内存泄漏。本文将系统阐述C++异常处理的核心概念、语法结构、实际应用场景及最佳实践，辅以完整代码示例。

一、异常处理的基本原理

C++异常处理机制基于三个核心操作：throw（抛出异常）、try（捕获异常）和catch（处理异常）。当程序遇到无法继续执行的错误时，通过throw语句抛出一个异常对象；该对象会沿着函数调用栈向上传递，直到被某个try块捕获；若未被捕获，程序将调用std::terminate终止执行。

异常对象的类型可以是内置类型（如int、char*）、标准库异常类（如std::runtime_error）或用户自定义类。标准库在头文件中定义了异常类层次结构，其中std::exception是所有标准异常的基类。

二、异常处理语法结构

1. try-catch块

try块包含可能抛出异常的代码，catch块用于捕获并处理特定类型的异常。多个catch块可以并列存在，按顺序匹配异常类型。

#include 
#include 

void riskyOperation() {
    throw std::runtime_error("Something went wrong!");
}

int main() {
    try {
        riskyOperation();
    } catch (const std::runtime_error& e) {
        std::cerr

2. 函数异常声明

C++允许通过异常规范（Exception Specification）声明函数可能抛出的异常类型，但C++11起推荐使用noexcept关键字替代动态异常规范。

// C++11前（已不推荐）
void oldFunction() throw(std::logic_error);

// C++11后推荐方式
void newFunction() noexcept;  // 不抛出异常
void anotherFunction() noexcept(false);  // 可能抛出异常

3. 标准异常类

标准库提供了丰富的异常类，涵盖常见错误场景：

  • std::logic_error：逻辑错误（如无效参数）
  • std::runtime_error：运行时错误（如文件打开失败）
  • std::bad_alloc：内存分配失败
  • std::out_of_range：越界访问
#include 
#include 
#include 

void accessVector(const std::vector& vec, size_t index) {
    if (index >= vec.size()) {
        throw std::out_of_range("Index out of range");
    }
    std::cout  data = {1, 2, 3};
    try {
        accessVector(data, 5);
    } catch (const std::out_of_range& e) {
        std::cerr

三、异常安全与资源管理

异常安全（Exception Safety）指程序在抛出异常后仍能保持一致状态。RAII（Resource Acquisition Is Initialization）技术通过将资源管理封装在对象生命周期中，确保异常发生时资源自动释放。

1. 智能指针应用

#include 
#include 
#include 

class Resource {
public:
    Resource() { std::cout ();
    res->use();  // 若抛出异常，res会自动释放
}

int main() {
    try {
        safeOperation();
    } catch (...) {
        std::cerr

2. 异常安全的函数设计

实现异常安全需满足以下保证之一：

  • 基本保证：不泄漏资源，对象处于有效状态
  • 强保证：操作要么完全成功，要么保持原状
  • 不抛出异常保证（noexcept）：绝对不抛出异常
#include 
#include 

// 强保证的插入操作
template
void safeInsert(std::vector& vec, const T& value) {
    size_t oldSize = vec.size();
    try {
        vec.push_back(value);
    } catch (...) {
        vec.resize(oldSize);  // 回滚到原始状态
        throw;  // 重新抛出异常
    }
}

四、自定义异常类

当标准异常类无法满足需求时，可通过继承std::exception创建自定义异常。

#include 
#include 
#include 

class DatabaseError : public std::exception {
    std::string msg;
public:
    DatabaseError(const std::string& s) : msg("Database error: " + s) {}
    const char* what() const noexcept override {
        return msg.c_str();
    }
};

void connectToDatabase() {
    throw DatabaseError("Connection timeout");
}

int main() {
    try {
        connectToDatabase();
    } catch (const DatabaseError& e) {
        std::cerr

五、异常处理最佳实践

1. 异常类型选择

  • 使用标准异常类处理常见错误
  • 自定义异常类应包含有意义的错误信息
  • 避免抛出指针或基本类型（如int），优先使用类对象

2. 性能考虑

异常处理会带来一定性能开销，主要体现在：

  • try块入口处的隐式检查
  • 栈展开时的对象析构

建议在性能敏感场景中：

  • 将可能抛出异常的代码隔离到独立函数
  • 对高频调用函数使用noexcept声明
  • 用错误码处理可预期的错误

3. 异常规范演进

C++17起，动态异常规范（throw(...)）已被弃用，推荐使用noexcept替代：

// C++17推荐方式
void processData() noexcept(std::is_move_constructible_v);

// 替代旧式写法
void oldWay() throw(std::bad_alloc, std::logic_error);

六、实际应用案例分析

案例1：文件解析器

#include 
#include 
#include 
#include 
#include 

class ParseError : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};

struct DataRecord {
    int id;
    std::string name;
};

std::vector parseFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file) throw std::runtime_error("File open failed");

    std::vector records;
    std::string line;

    while (std::getline(file, line)) {
        std::istringstream iss(line);
        DataRecord rec;
        if (!(iss >> rec.id >> rec.name)) {
            throw ParseError("Invalid record format: " + line);
        }
        records.push_back(rec);
    }

    return records;
}

int main() {
    try {
        auto data = parseFile("data.txt");
        for (const auto& rec : data) {
            std::cout

案例2：银行账户系统

#include 
#include 
#include 

class InsufficientFunds : public std::runtime_error {
public:
    InsufficientFunds(double balance, double amount)
        : std::runtime_error("Insufficient funds: required " + 
          std::to_string(amount) + ", available " + std::to_string(balance)) {}
};

class Account {
    double balance;
public:
    Account(double initial) : balance(initial) {}
    
    void withdraw(double amount) {
        if (amount > balance) {
            throw InsufficientFunds(balance, amount);
        }
        balance -= amount;
    }
    
    double getBalance() const { return balance; }
};

int main() {
    Account acc(100.0);
    try {
        acc.withdraw(150.0);
    } catch (const InsufficientFunds& e) {
        std::cerr

七、异常处理与错误码的权衡

虽然异常处理具有诸多优势，但在某些场景下错误码可能更合适：

  • 需要高频检查的简单错误
  • 跨模块边界的C兼容接口
  • 性能极度敏感的代码路径

现代C++实践中，常采用混合策略：

#include 
#include 

enum class FileError {
    NotFound,
    PermissionDenied,
    DiskFull
};

std::error_code openFile(const std::string& path) {
    // 模拟检查
    if (path == "nonexistent.txt") {
        return {static_cast(FileError::NotFound), std::generic_category()};
    }
    return {};  // 成功
}

void processWithException(const std::string& path) {
    auto ec = openFile(path);
    if (ec) {
        throw std::system_error(ec, "File operation failed");
    }
    std::cout

八、异常处理在多线程环境中的注意事项

多线程程序中，异常处理需要特别注意：

  • 线程函数应捕获所有异常，避免未捕获异常导致程序终止
  • 跨线程传递异常需使用std::exception_ptr
  • 避免在析构函数中抛出异常（可能导致std::terminate）
#include 
#include 
#include 
#include 

void threadFunction() {
    try {
        throw std::runtime_error("Thread error");
    } catch (...) {
        std::exception_ptr eptr = std::current_exception();
        // 实际项目中可通过队列传递eptr到主线程
        throw;  // 重新抛出以便观察
    }
}

int main() {
    try {
        std::thread t(threadFunction);
        t.join();  // 实际会因未捕获异常而终止
    } catch (const std::exception& e) {
        std::cerr

九、C++异常处理的未来演进

C++23引入了std::expected和std::unexpected，提供更灵活的错误处理方式：

#include 
#include 
#include 

std::expected divide(int a, int b) {
    if (b == 0) {
        return std::unexpected("Division by zero");
    }
    return a / b;
}

int main() {
    auto result = divide(10, 0);
    if (result) {
        std::cout

这种模式结合了异常的安全性和错误码的性能优势，可能成为未来C++错误处理的主流方案之一。

十、总结与建议

C++异常处理机制为构建健壮系统提供了强大工具，但需遵循以下原则：

  1. 优先使用标准异常类，必要时创建自定义异常
  2. 确保异常安全，采用RAII管理资源
  3. 合理使用noexcept声明，避免不必要的性能开销
  4. 在多线程环境中谨慎处理异常传播
  5. 根据场景选择异常或错误码，避免过度使用异常

通过系统掌握异常处理机制，开发者能够编写出更健壮、更易维护的C++程序，有效应对各种运行时错误场景。

关键词：C++异常处理、try-catch块、标准异常类、RAII、异常安全、noexcept、自定义异常、多线程异常、std::expected

简介：本文全面解析C++异常处理机制，涵盖基本语法、标准异常类、资源管理、自定义异常、多线程处理及最佳实践，通过完整代码示例展示异常处理在真实项目中的应用，帮助开发者构建健壮的C++程序。

《C++异常处理机制及代码示例.doc》
将本文以doc文档格式下载到电脑，方便收藏和打印
推荐度：
点击下载文档

Copyright © 2006-2025 文档知识库版权所有 联系我们 侵权投诉 网络辟谣

浙ICP备2025195263号-1

内容侵权、违法和不良信息举报邮箱：邮箱