C++异常处理完全指南：原理、用法与避坑实践

引言

异常处理是C++中处理错误情况的重要机制。与传统的错误码返回相比，异常处理提供了更加结构化和灵活的错误处理方式。本文将深入探讨C++异常处理的原理、用法、注意事项以及常见陷阱。

异常处理的基本概念

为什么需要异常处理？

在传统的错误处理中，我们通常使用返回值来表示函数执行的成功或失败。但这种方式存在几个问题：

错误信息可能被忽略
错误处理代码与正常逻辑代码混杂
多层调用中错误传递繁琐

异常处理机制解决了这些问题，将正常逻辑与错误处理分离。

C++异常处理的三要素

C++异常处理基于三个关键字：try、catch 和 throw。

try {
    // 可能抛出异常的代码
    if (error_condition) {
        throw some_exception;
    }
} catch (const SomeException& e) {
    // 处理异常
} catch (...) {
    // 处理所有其他异常
}

异常处理的工作原理

栈展开（Stack Unwinding）

当异常被抛出时，程序控制流会立即离开当前函数，沿着调用栈向上查找匹配的catch块。这个过程称为栈展开：

搜索当前函数的catch块
如果没有找到匹配的catch块，当前函数终止，局部对象被销毁
在调用者中继续搜索
重复这个过程直到找到匹配的catch块或程序终止

void functionC() {
    throw std::runtime_error("Error in C");
}

void functionB() {
    std::string resource = "B's resource";
    functionC(); // 异常从这里抛出
    // resource会被正确销毁
}

void functionA() {
    try {
        functionB();
    } catch (const std::exception& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
}

异常对象的生命周期

抛出的异常对象会被复制到一个特殊的内存区域（异常对象存储），确保在栈展开过程中仍然有效：

class MyException {
public:
    MyException(const char* msg) : message(msg) {
        std::cout << "MyException constructed" << std::endl;
    }
    
    MyException(const MyException& other) : message(other.message) {
        std::cout << "MyException copied" << std::endl;
    }
    
    ~MyException() {
        std::cout << "MyException destroyed" << std::endl;
    }
    
    const char* what() const { return message.c_str(); }
    
private:
    std::string message;
};

void testException() {
    try {
        throw MyException("Test exception"); // 构造并可能复制
    } catch (const MyException& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
    // 异常对象在这里被销毁
}

异常处理的具体用法

标准异常类

C++标准库提供了一系列异常类，都继承自std::exception：

#include <stdexcept>
#include <exception>

try {
    // 各种标准异常
    throw std::runtime_error("运行时错误");
    throw std::logic_error("逻辑错误");
    throw std::out_of_range("越界访问");
    throw std::bad_alloc(); // 内存分配失败
} catch (const std::exception& e) {
    std::cerr << "Standard exception: " << e.what() << std::endl;
}

自定义异常类

可以创建自己的异常类来提供更具体的错误信息：

class DatabaseException : public std::exception {
public:
    DatabaseException(const std::string& msg, int errorCode) 
        : message(msg), code(errorCode) {}
        
    const char* what() const noexcept override {
        return message.c_str();
    }
    
    int getErrorCode() const { return code; }
    
private:
    std::string message;
    int code;
};

class ConnectionFailedException : public DatabaseException {
public:
    ConnectionFailedException(const std::string& server, int port)
        : DatabaseException("Connection failed to " + server + ":" + 
                           std::to_string(port), 1001) {}
};

异常规格说明（C++11之后）

C++11引入了noexcept说明符来替代旧的异常规格：

// 该函数承诺不抛出异常
void safeFunction() noexcept {
    // 如果这里抛出异常，程序会调用std::terminate()
}

// 条件性的noexcept
template<typename T>
void swap(T& a, T& b) noexcept(noexcept(T(std::move(a))) && 
                               noexcept(a.operator=(std::move(b)))) {
    // 实现...
}

异常安全保证

编写异常安全的代码是C++编程中的重要课题。异常安全通常分为三个级别：

1. 基本保证（Basic Guarantee）

发生异常时，程序保持有效状态
无资源泄漏，所有对象处于可析构状态

2. 强保证（Strong Guarantee）

操作要么完全成功，要么完全失败（事务语义）
发生异常时，程序状态回滚到操作前的状态

3. 不抛出保证（Nothrow Guarantee）

操作保证不会抛出异常

实现强异常安全的技巧

RAII（Resource Acquisition Is Initialization） 是C++中管理资源的核心理念：

class FileHandle {
public:
    FileHandle(const std::string& filename) : file(fopen(filename.c_str(), "r")) {
        if (!file) {
            throw std::runtime_error("Failed to open file");
        }
    }
    
    ~FileHandle() {
        if (file) fclose(file);
    }
    
    // 禁用拷贝（或实现拷贝语义）
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 支持移动语义
    FileHandle(FileHandle&& other) noexcept : file(other.file) {
        other.file = nullptr;
    }
    
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file) fclose(file);
            file = other.file;
            other.file = nullptr;
        }
        return *this;
    }
    
private:
    FILE* file;
};

拷贝并交换（Copy-and-Swap）惯用法：

class String {
public:
    // 强异常安全的赋值运算符
    String& operator=(const String& other) {
        if (this != &other) {
            String temp(other); // 可能抛出异常，但不影响当前对象
            swap(temp);         // 不抛出的交换操作
        }
        return *this;
    }
    
    void swap(String& other) noexcept {
        std::swap(data, other.data);
        std::swap(size, other.size);
        std::swap(capacity, other.capacity);
    }
    
private:
    char* data;
    size_t size;
    size_t capacity;
};

常见陷阱与最佳实践

陷阱1：在析构函数中抛出异常

class Problematic {
public:
    ~Problematic() {
        throw std::runtime_error("Exception in destructor"); // 危险！
    }
};

// 如果同时有两个异常（栈展开时析构函数抛出），程序会终止

解决方案：

class SafeDestructor {
public:
    ~SafeDestructor() noexcept {
        try {
            // 清理代码
            cleanup();
        } catch (...) {
            // 记录日志，但不要抛出新异常
            std::cerr << "Error during cleanup" << std::endl;
        }
    }
};

陷阱2：切片问题（Slicing）

try {
    Derived d;
    Base& b = d;
    throw b; // 切片！只抛出Base部分
} catch (const Derived& e) {
    // 不会捕获到
} catch (const Base& e) {
    // 这里捕获，但丢失了Derived的信息
}

解决方案：总是抛出和捕获指针或引用，或者使用智能指针：

try {
    throw std::make_unique<Derived>();
} catch (const std::unique_ptr<Base>& e) {
    // 正确处理，无切片
}

陷阱3：异常屏蔽重要错误信息

void processFile(const std::string& filename) {
    try {
        FileHandle file(filename);
        // 处理文件
    } catch (...) {
        throw std::runtime_error("Failed to process file"); // 原始异常信息丢失！
    }
}

解决方案：使用std::throw_with_nested或自定义异常链：

void processFile(const std::string& filename) {
    try {
        FileHandle file(filename);
        // 处理文件
    } catch (...) {
        std::throw_with_nested(
            std::runtime_error("Failed to process file: " + filename)
        );
    }
}

// 提取嵌套异常
void printException(const std::exception& e, int level = 0) {
    std::cerr << std::string(level, ' ') << "exception: " << e.what() << '\n';
    try {
        std::rethrow_if_nested(e);
    } catch (const std::exception& nested) {
        printException(nested, level + 1);
    }
}

最佳实践总结

按引用捕获异常：避免切片和不必要的拷贝

1 2	`catch (const std::exception& e) // 正确 catch (std::exception e) // 避免这样`

从最具体到最一般排序catch块

1
2
3

catch (const Derived& e)
catch (const Base& e)
catch (...)

使用RAII管理资源
析构函数声明为noexcept
不要忽略异常：至少记录日志
在性能关键路径谨慎使用异常

性能考虑

异常处理确实有性能开销，主要体现在：

正常执行路径：现代编译器优化后开销很小
抛出异常时：有较大开销（栈展开、异常对象构造）
代码大小：异常处理信息会增加二进制文件大小

建议：

在错误不常见但严重时使用异常
在性能关键的紧密循环中，考虑使用错误码
不要将异常用于正常的控制流

C++17和C++20的改进

C++17: `std::terminate_handler`改进

std::terminate_handler previous = std::set_terminate([](){
    std::cout << "Terminate called" << std::endl;
    std::abort();
});

C++20: 契约编程（未来可能特性）

虽然契约在C++20中被移除，但了解其设计思想：

void process(int* data) 
    [[pre: data != nullptr]]  // 前置条件
    [[post: data[0] == 42]]   // 后置条件
{
    // 实现
}

结论

C++异常处理是一个强大的工具，但需要正确使用。关键要点：

理解栈展开和RAII是编写异常安全代码的基础
遵循最佳实践避免常见陷阱
在适当的地方使用异常，不要滥用
考虑性能影响，在关键代码路径谨慎使用

异常处理是C++错误处理策略的重要组成部分，与错误码、断言等机制结合使用，可以构建健壮可靠的软件系统。

希望这篇博客能帮助您深入理解C++异常处理。如有疑问或发现错误，欢迎在评论区讨论！

技术分享

C++异常处理完全指南：原理、用法与避坑实践

https://www.psnow.sbs/2025/09/25/C-异常处理完全指南：原理、用法与避坑实践/

作者

Psnow

发布于

2025年9月25日

许可协议

C++ PIMPL模式详解：实现编译防火墙的利器上一篇

Clang、CMake与Ninja详解：现代C++开发工具链完全指南下一篇

C++异常处理完全指南：原理、用法与避坑实践

C++异常处理完全指南：原理、用法与避坑实践

引言

异常处理的基本概念

为什么需要异常处理？

C++异常处理的三要素

异常处理的工作原理

栈展开（Stack Unwinding）

异常对象的生命周期

异常处理的具体用法

标准异常类

自定义异常类

异常规格说明（C++11之后）

异常安全保证

1. 基本保证（Basic Guarantee）

2. 强保证（Strong Guarantee）

3. 不抛出保证（Nothrow Guarantee）

实现强异常安全的技巧

常见陷阱与最佳实践

陷阱1：在析构函数中抛出异常

陷阱2：切片问题（Slicing）

陷阱3：异常屏蔽重要错误信息

最佳实践总结

性能考虑

C++17和C++20的改进

C++17: std::terminate_handler改进

C++20: 契约编程（未来可能特性）

结论

C++17: `std::terminate_handler`改进