C++异常抛出与捕获不匹配问题详解与解决方案

C++异常抛出与捕获不匹配问题详解与解决方案

一、问题概述

异常抛出与捕获不匹配是C++异常处理中常见的错误，主要表现形式包括：

1. 类型不匹配：抛出的异常类型与捕获的类型不一致
2. 继承关系处理不当：基类异常覆盖了派生类异常
3. 异常修饰符问题：const、引用修饰符不匹配
4. 多态异常丢失：按值捕获导致对象切片
5. 异常说明符（exception specification）问题：C++11前的throw()声明

二、常见问题场景

2.1 类型不匹配问题

// ❌ 错误示例：抛出的类型与捕获的类型完全不匹配
#include <iostream>
#include <stdexcept>
#include <string>

void risky_operation() {
    int error_code = 42;
    if (error_code != 0) {
        throw error_code;  // 抛出int类型
    }
}

int main() {
    try {
        risky_operation();
    } catch (const std::string& e) {  // 捕获std::string，但抛出的是int
        std::cout << "Caught string: " << e << std::endl;
    } catch (const char* e) {         // 捕获const char*，也不是int
        std::cout << "Caught C-string: " << e << std::endl;
    }
    // 程序终止！int异常没有被捕获
    return 0;
}

2.2 继承层次中的捕获顺序问题

// ❌ 错误示例：基类异常在派生类之前捕获
#include <iostream>
#include <exception>

class BaseException : public std::exception {
public:
    const char* what() const noexcept override {
        return "BaseException";
    }
};

class DerivedException : public BaseException {
public:
    const char* what() const noexcept override {
        return "DerivedException";
    }
};

void function_that_throws() {
    throw DerivedException();  // 抛出派生类异常
}

int main() {
    try {
        function_that_throws();
    } catch (const BaseException& e) {      // 先捕获基类
        std::cout << "Caught BaseException: " << e.what() << std::endl;
    } catch (const DerivedException& e) {   // 永远执行不到这里！
        std::cout << "Caught DerivedException: " << e.what() << std::endl;
    }
    // 输出：Caught BaseException: DerivedException
    // 虽然能捕获，但丢失了具体的异常类型信息
    return 0;
}

2.3 对象切片问题

// ❌ 错误示例：按值捕获导致对象切片
#include <iostream>
#include <memory>

class Base {
public:
    virtual void print() const {
        std::cout << "Base" << std::endl;
    }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void print() const override {
        std::cout << "Derived" << std::endl;
    }
    
    void special_method() const {
        std::cout << "Special method in Derived" << std::endl;
    }
};

void throw_derived() {
    throw Derived();  // 抛出Derived对象
}

int main() {
    try {
        throw_derived();
    } catch (Base e) {  // ❌ 按值捕获，发生对象切片！
        e.print();  // 输出：Base（不是Derived！）
        // e.special_method();  // 编译错误：Base没有这个方法
    }
    
    try {
        throw_derived();
    } catch (Base& e) {  // ✅ 按引用捕获，保持多态
        e.print();  // 输出：Derived
        // 但仍然不能调用Derived特有的方法
    }
    
    return 0;
}

2.4 异常说明符问题（C++11之前）

// ❌ 错误示例：违反异常说明符
#include <iostream>

// C++11之前的异常说明符（已废弃）
void func() throw(int, std::runtime_error) {  // 只能抛出int或std::runtime_error
    // ...
    throw "Unexpected error";  // ❌ 抛出const char*，违反异常说明符
    // 这会导致std::unexpected()被调用，默认终止程序
}

int main() {
    try {
        func();
    } catch (...) {
        std::cout << "Caught something" << std::endl;
    }
    return 0;
}

三、解决方案

3.1 解决方案一：使用标准异常层次结构

// ✅ 正确示例：使用标准异常层次结构
#include <iostream>
#include <stdexcept>
#include <memory>
#include <string>

// 自定义异常类，继承自标准异常
class MyException : public std::runtime_error {
public:
    explicit MyException(const std::string& msg)
        : std::runtime_error(msg), error_code_(0) {}
    
    MyException(const std::string& msg, int error_code)
        : std::runtime_error(msg), error_code_(error_code) {}
    
    int get_error_code() const noexcept { return error_code_; }
    
private:
    int error_code_;
};

class NetworkException : public MyException {
public:
    NetworkException(const std::string& msg, int error_code)
        : MyException("Network: " + msg, error_code) {}
};

class FileException : public MyException {
public:
    FileException(const std::string& msg, int error_code)
        : MyException("File: " + msg, error_code) {}
};

// 正确的捕获顺序：从最具体到最一般
void handle_exception() {
    try {
        // 模拟不同异常
        bool network_error = true;
        bool file_error = false;
        
        if (network_error) {
            throw NetworkException("Connection failed", 1001);
        } else if (file_error) {
            throw FileException("Cannot open file", 2001);
        } else {
            throw MyException("Unknown error", 0);
        }
        
    } catch (const NetworkException& e) {
        std::cout << "Network exception: " << e.what() 
                  << " (code: " << e.get_error_code() << ")" << std::endl;
    } catch (const FileException& e) {
        std::cout << "File exception: " << e.what() 
                  << " (code: " << e.get_error_code() << ")" << std::endl;
    } catch (const MyException& e) {
        std::cout << "MyException: " << e.what() 
                  << " (code: " << e.get_error_code() << ")" << std::endl;
    } catch (const std::runtime_error& e) {
        std::cout << "Runtime error: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Standard exception: " << e.what() << std::endl;
    } catch (...) {
        std::cout << "Unknown exception" << std::endl;
    }
}

int main() {
    handle_exception();
    return 0;
}

3.2 解决方案二：使用异常包装器（Exception Wrapper）

// ✅ 正确示例：异常包装器模式
#include <iostream>
#include <variant>
#include <memory>
#include <string>
#include <typeinfo>

// 异常包装器基类
class ExceptionWrapper {
public:
    virtual ~ExceptionWrapper() = default;
    virtual const std::type_info& type() const noexcept = 0;
    virtual std::string what() const noexcept = 0;
    virtual std::unique_ptr<ExceptionWrapper> clone() const = 0;
};

// 具体异常包装器
template<typename E>
class TypedExceptionWrapper : public ExceptionWrapper {
public:
    explicit TypedExceptionWrapper(E exception)
        : exception_(std::move(exception)) {}
    
    const std::type_info& type() const noexcept override {
        return typeid(E);
    }
    
    std::string what() const noexcept override {
        try {
            if constexpr (std::is_base_of_v<std::exception, E>) {
                return exception_.what();
            } else {
                // 对于非std::exception类型，使用typeid
                return "Exception of type: " + std::string(typeid(E).name());
            }
        } catch (...) {
            return "Exception what() failed";
        }
    }
    
    std::unique_ptr<ExceptionWrapper> clone() const override {
        return std::make_unique<TypedExceptionWrapper<E>>(*this);
    }
    
    E& get() noexcept { return exception_; }
    const E& get() const noexcept { return exception_; }
    
private:
    E exception_;
};

// 统一的异常容器
class AnyException {
public:
    template<typename E>
    AnyException(E&& exception) 
        : wrapper_(std::make_unique<TypedExceptionWrapper<std::decay_t<E>>>(
            std::forward<E>(exception))) {}
    
    const std::type_info& type() const noexcept {
        return wrapper_ ? wrapper_->type() : typeid(void);
    }
    
    std::string what() const noexcept {
        return wrapper_ ? wrapper_->what() : "Empty exception";
    }
    
    template<typename E>
    bool is() const noexcept {
        return wrapper_ && wrapper_->type() == typeid(E);
    }
    
    template<typename E>
    E* get_if() noexcept {
        if (is<E>()) {
            return &static_cast<TypedExceptionWrapper<E>*>(wrapper_.get())->get();
        }
        return nullptr;
    }
    
    template<typename E>
    const E* get_if() const noexcept {
        return const_cast<AnyException*>(this)->get_if<E>();
    }
    
private:
    std::unique_ptr<ExceptionWrapper> wrapper_;
};

// 使用示例
void test_exception_wrapper() {
    try {
        throw AnyException(std::runtime_error("Test error"));
    } catch (const AnyException& e) {
        if (e.is<std::runtime_error>()) {
            if (auto* ex = e.get_if<std::runtime_error>()) {
                std::cout << "Runtime error: " << ex->what() << std::endl;
            }
        }
        std::cout << "Exception what: " << e.what() << std::endl;
    }
    
    try {
        throw AnyException(42);  // 甚至可以包装int
    } catch (const AnyException& e) {
        if (e.is<int>()) {
            if (auto* value = e.get_if<int>()) {
                std::cout << "Integer exception: " << *value << std::endl;
            }
        }
    }
}

int main() {
    test_exception_wrapper();
    return 0;
}

3.3 解决方案三：使用std::exception_ptr和std::rethrow_exception

// ✅ 正确示例：使用std::exception_ptr传递异常
#include <iostream>
#include <exception>
#include <functional>
#include <future>
#include <stdexcept>

// 异步异常处理
class AsyncExceptionHandler {
public:
    // 在异步操作中捕获并存储异常
    std::exception_ptr capture_exception(std::function<void()> operation) {
        try {
            operation();
            return {};
        } catch (...) {
            return std::current_exception();
        }
    }
    
    // 在合适的地方重新抛出并处理异常
    void handle_exception(std::exception_ptr eptr) {
        if (eptr) {
            try {
                std::rethrow_exception(eptr);
            } catch (const std::runtime_error& e) {
                std::cout << "Runtime error in async operation: " 
                          << e.what() << std::endl;
            } catch (const std::logic_error& e) {
                std::cout << "Logic error in async operation: " 
                          << e.what() << std::endl;
            } catch (const std::exception& e) {
                std::cout << "Standard exception in async operation: " 
                          << e.what() << std::endl;
            } catch (...) {
                std::cout << "Unknown exception in async operation" << std::endl;
            }
        }
    }
    
    // 使用future传递异常
    std::future<void> async_operation() {
        return std::async(std::launch::async, []() {
            // 模拟可能抛出异常的操作
            throw std::runtime_error("Async operation failed");
        });
    }
};

// 嵌套异常处理
class ExceptionRecorder {
public:
    void record_and_rethrow(std::function<void()> operation, 
                            const std::string& context) {
        try {
            operation();
        } catch (...) {
            std::throw_with_nested(
                std::runtime_error("Failed in context: " + context)
            );
        }
    }
    
    void print_nested_exceptions(const std::exception& e, int level = 0) {
        std::cerr << std::string(level, ' ') << "level " << level 
                  << ": " << e.what() << std::endl;
        
        try {
            std::rethrow_if_nested(e);
        } catch (const std::exception& nested) {
            print_nested_exceptions(nested, level + 1);
        } catch (...) {
            std::cerr << std::string(level + 1, ' ') << "level " << level + 1
                      << ": unknown exception" << std::endl;
        }
    }
};

int main() {
    // 测试std::exception_ptr
    AsyncExceptionHandler handler;
    
    auto eptr = handler.capture_exception([]() {
        throw std::runtime_error("Test exception");
    });
    
    handler.handle_exception(eptr);
    
    // 测试嵌套异常
    ExceptionRecorder recorder;
    
    try {
        recorder.record_and_rethrow([]() {
            try {
                throw std::logic_error("Inner logic error");
            } catch (...) {
                std::throw_with_nested(
                    std::runtime_error("Middle layer error")
                );
            }
        }, "outer operation");
    } catch (const std::exception& e) {
        recorder.print_nested_exceptions(e);
    }
    
    return 0;
}

3.4 解决方案四：使用异常匹配器（Exception Matcher）

// ✅ 正确示例：异常匹配器模式
#include <iostream>
#include <functional>
#include <type_traits>
#include <string>
#include <vector>
#include <memory>

// 异常匹配器基类
class ExceptionMatcher {
public:
    virtual ~ExceptionMatcher() = default;
    virtual bool matches(const std::exception& e) const noexcept = 0;
    virtual std::string description() const = 0;
    virtual void handle(const std::exception& e) const = 0;
};

// 具体匹配器
template<typename ExceptionType>
class TypeMatcher : public ExceptionMatcher {
public:
    using Handler = std::function<void(const ExceptionType&)>;
    
    TypeMatcher(Handler handler, std::string desc = "")
        : handler_(std::move(handler)), desc_(std::move(desc)) {
        if (desc_.empty()) {
            desc_ = "Exception of type: " + std::string(typeid(ExceptionType).name());
        }
    }
    
    bool matches(const std::exception& e) const noexcept override {
        try {
            dynamic_cast<const ExceptionType&>(e);
            return true;
        } catch (const std::bad_cast&) {
            return false;
        }
    }
    
    std::string description() const override {
        return desc_;
    }
    
    void handle(const std::exception& e) const override {
        handler_(dynamic_cast<const ExceptionType&>(e));
    }
    
private:
    Handler handler_;
    std::string desc_;
};

// 谓词匹配器
class PredicateMatcher : public ExceptionMatcher {
public:
    using Predicate = std::function<bool(const std::exception&)>;
    using Handler = std::function<void(const std::exception&)>;
    
    PredicateMatcher(Predicate pred, Handler handler, std::string desc)
        : pred_(std::move(pred)), handler_(std::move(handler)), desc_(std::move(desc)) {}
    
    bool matches(const std::exception& e) const noexcept override {
        try {
            return pred_(e);
        } catch (...) {
            return false;
        }
    }
    
    std::string description() const override {
        return desc_;
    }
    
    void handle(const std::exception& e) const override {
        handler_(e);
    }
    
private:
    Predicate pred_;
    Handler handler_;
    std::string desc_;
};

// 异常处理器
class ExceptionHandler {
public:
    void add_matcher(std::unique_ptr<ExceptionMatcher> matcher) {
        matchers_.push_back(std::move(matcher));
    }
    
    bool handle(const std::exception& e) const {
        for (const auto& matcher : matchers_) {
            if (matcher->matches(e)) {
                std::cout << "Matched: " << matcher->description() << std::endl;
                matcher->handle(e);
                return true;
            }
        }
        return false;
    }
    
    template<typename ExceptionType, typename Handler>
    void add_type_matcher(Handler&& handler, const std::string& desc = "") {
        add_matcher(std::make_unique<TypeMatcher<ExceptionType>>(
            std::forward<Handler>(handler), desc
        ));
    }
    
    template<typename Predicate, typename Handler>
    void add_predicate_matcher(Predicate&& pred, Handler&& handler, 
                               const std::string& desc) {
        add_matcher(std::make_unique<PredicateMatcher>(
            std::forward<Predicate>(pred),
            std::forward<Handler>(handler),
            desc
        ));
    }
    
private:
    std::vector<std::unique_ptr<ExceptionMatcher>> matchers_;
};

// 使用示例
#include <stdexcept>
#include <system_error>

int main() {
    ExceptionHandler handler;
    
    // 添加类型匹配器
    handler.add_type_matcher<std::runtime_error>(
        [](const std::runtime_error& e) {
            std::cout << "Handling runtime_error: " << e.what() << std::endl;
        },
        "Runtime Error Handler"
    );
    
    handler.add_type_matcher<std::logic_error>(
        [](const std::logic_error& e) {
            std::cout << "Handling logic_error: " << e.what() << std::endl;
        },
        "Logic Error Handler"
    );
    
    // 添加谓词匹配器
    handler.add_predicate_matcher(
        [](const std::exception& e) {
            std::string what = e.what();
            return what.find("network") != std::string::npos ||
                   what.find("connection") != std::string::npos;
        },
        [](const std::exception& e) {
            std::cout << "Network-related error: " << e.what() << std::endl;
        },
        "Network Error Detector"
    );
    
    // 默认处理器
    handler.add_predicate_matcher(
        [](const std::exception&) { return true; },
        [](const std::exception& e) {
            std::cout << "Default handler: " << e.what() << std::endl;
        },
        "Default Exception Handler"
    );
    
    // 测试不同的异常
    std::vector<std::exception_ptr> exceptions;
    exceptions.push_back(std::make_exception_ptr(
        std::runtime_error("Network connection failed")
    ));
    exceptions.push_back(std::make_exception_ptr(
        std::logic_error("Invalid argument")
    ));
    exceptions.push_back(std::make_exception_ptr(
        std::out_of_range("Index out of range")
    ));
    
    for (const auto& eptr : exceptions) {
        try {
            std::rethrow_exception(eptr);
        } catch (const std::exception& e) {
            if (!handler.handle(e)) {
                std::cout << "No handler matched for: " << e.what() << std::endl;
            }
        }
    }
    
    return 0;
}

3.5 解决方案五：使用现代C++特性（C++17/C++20）

// ✅ 正确示例：使用现代C++特性
#include <iostream>
#include <variant>
#include <optional>
#include <expected>  // C++23，这里用模拟实现
#include <string>
#include <system_error>

// C++17：使用std::variant和std::visit处理多种可能的结果
template<typename SuccessType, typename... ErrorTypes>
class Result {
private:
    std::variant<SuccessType, ErrorTypes...> value_;
    
public:
    Result(SuccessType success) : value_(std::move(success)) {}
    Result(ErrorTypes... errors) : value_(errors...) {}
    
    template<typename ErrorType>
    Result(ErrorType error) : value_(std::move(error)) {}
    
    bool is_success() const {
        return std::holds_alternative<SuccessType>(value_);
    }
    
    template<typename ErrorType>
    bool is_error() const {
        return std::holds_alternative<ErrorType>(value_);
    }
    
    SuccessType& get_success() & {
        return std::get<SuccessType>(value_);
    }
    
    const SuccessType& get_success() const & {
        return std::get<SuccessType>(value_);
    }
    
    template<typename ErrorType>
    ErrorType& get_error() & {
        return std::get<ErrorType>(value_);
    }
    
    template<typename Visitor>
    decltype(auto) visit(Visitor&& visitor) {
        return std::visit(std::forward<Visitor>(visitor), value_);
    }
};

// C++23风格：std::expected模拟（使用C++17实现）
template<typename T, typename E>
class Expected {
private:
    union {
        T value_;
        E error_;
    };
    bool has_value_;
    
public:
    Expected(T value) : value_(std::move(value)), has_value_(true) {}
    Expected(E error) : error_(std::move(error)), has_value_(false) {}
    
    ~Expected() {
        if (has_value_) {
            value_.~T();
        } else {
            error_.~E();
        }
    }
    
    explicit operator bool() const { return has_value_; }
    
    T& operator*() & {
        if (!has_value_) {
            throw std::bad_variant_access();
        }
        return value_;
    }
    
    const T& operator*() const & {
        if (!has_value_) {
            throw std::bad_variant_access();
        }
        return value_;
    }
    
    E& error() & {
        if (has_value_) {
            throw std::bad_variant_access();
        }
        return error_;
    }
    
    const E& error() const & {
        if (has_value_) {
            throw std::bad_variant_access();
        }
        return error_;
    }
    
    template<typename U>
    T value_or(U&& default_value) const {
        return has_value_ ? value_ : static_cast<T>(std::forward<U>(default_value));
    }
};

// 使用示例
#include <filesystem>
#include <fstream>

class FileError {
public:
    enum class Code {
        NotFound,
        AccessDenied,
        IOError,
        Unknown
    };
    
    FileError(Code code, std::string message)
        : code_(code), message_(std::move(message)) {}
    
    Code code() const { return code_; }
    const std::string& message() const { return message_; }
    
private:
    Code code_;
    std::string message_;
};

Expected<std::string, FileError> read_file(const std::filesystem::path& path) {
    std::ifstream file(path);
    
    if (!file.is_open()) {
        if (!std::filesystem::exists(path)) {
            return FileError(FileError::Code::NotFound, 
                           "File not found: " + path.string());
        }
        return FileError(FileError::Code::AccessDenied,
                       "Cannot access file: " + path.string());
    }
    
    try {
        std::string content((std::istreambuf_iterator<char>(file)),
                           std::istreambuf_iterator<char>());
        return content;
    } catch (const std::exception& e) {
        return FileError(FileError::Code::IOError,
                       "IO error: " + std::string(e.what()));
    }
}

void modern_exception_handling() {
    // 方法1：使用Expected（类似Rust的Result）
    auto result = read_file("example.txt");
    
    if (result) {
        std::cout << "File content: " << *result << std::endl;
    } else {
        const auto& error = result.error();
        std::cout << "Error reading file: " << error.message() 
                  << " (code: " << static_cast<int>(error.code()) << ")" << std::endl;
    }
    
    // 方法2：使用Result和std::visit
    Result<std::string, FileError, std::runtime_error> result2 = 
        read_file("another.txt").visit([](auto&& arg) {
            using T = std::decay_t<decltype(arg)>;
            if constexpr (std::is_same_v<T, std::string>) {
                return Result<std::string, FileError, std::runtime_error>(arg);
            } else {
                return Result<std::string, FileError, std::runtime_error>(arg);
            }
        });
    
    result2.visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "Success: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, FileError>) {
            std::cout << "FileError: " << arg.message() << std::endl;
        } else {
            std::cout << "Runtime error: " << arg.what() << std::endl;
        }
    });
}

int main() {
    modern_exception_handling();
    return 0;
}

四、最佳实践总结

4.1 异常设计原则

// 1. 从std::exception或适当的标准异常派生
class MyException : public std::runtime_error {
public:
    explicit MyException(const std::string& what)
        : std::runtime_error(what) {}
};

// 2. 按引用捕获异常
try {
    // ...
} catch (const std::exception& e) {  // ✅ 按const引用
    // ...
} catch (MyException& e) {           // ✅ 按引用（如果要修改）
    // ...
}

// 3. 捕获顺序：从最具体到最一般
try {
    // ...
} catch (const DerivedException& e) {
    // 处理派生类
} catch (const BaseException& e) {
    // 处理基类
} catch (const std::exception& e) {
    // 处理所有标准异常
} catch (...) {
    // 处理所有其他异常
}

// 4. 使用noexcept正确标记函数
void safe_function() noexcept {  // 保证不抛出异常
    // 绝对不能抛出异常
}

void maybe_throws() {  // 可能抛出异常
    // 可能抛出
}

// 5. 避免异常说明符（C++11前）
// 使用noexcept替代throw()

4.2 异常安全保证

1. 基本保证：操作失败时，程序保持有效状态
2. 强保证：操作要么成功，要么程序状态不变（事务性）
3. 无异常保证：操作保证不抛出异常

class Transaction {
public:
    // 强保证：要么全部成功，要么全部回滚
    void perform_transaction() {
        auto old_state = save_state();  // 保存当前状态
        
        try {
            step1();
            step2();
            step3();
            commit();
        } catch (...) {
            restore_state(old_state);  // 失败时恢复状态
            throw;                     // 重新抛出异常
        }
    }
    
private:
    State save_state() { /* ... */ }
    void restore_state(const State&) { /* ... */ }
    void step1() { /* ... */ }
    void step2() { /* ... */ }
    void step3() { /* ... */ }
    void commit() { /* ... */ }
};

4.3 调试和测试策略

// 自定义terminate_handler
#include <iostream>
#include <exception>
#include <cstdlib>

void my_terminate_handler() {
    std::cerr << "Terminate called due to uncaught exception" << std::endl;
    
    // 尝试获取当前异常信息
    if (std::current_exception()) {
        try {
            std::rethrow_exception(std::current_exception());
        } catch (const std::exception& e) {
            std::cerr << "Uncaught exception: " << e.what() << std::endl;
        } catch (...) {
            std::cerr << "Uncaught unknown exception" << std::endl;
        }
    }
    
    // 调试信息
    std::cerr << "Stack trace or additional debug info here" << std::endl;
    
    std::abort();
}

// 在main函数开始处设置
int main() {
    std::set_terminate(my_terminate_handler);
    
    // 启用异常调试
    #ifdef _MSC_VER
        _set_se_translator([](unsigned int, EXCEPTION_POINTERS*) {
            throw std::runtime_error("Structured exception");
        });
    #endif
    
    // ...
    return 0;
}

五、总结

1. 始终按引用捕获异常，避免对象切片
2. 正确排序catch块，从最具体到最一般
3. 使用标准异常层次结构或适当继承
4. 考虑使用异常包装器或匹配器处理复杂场景
5. 利用现代C++特性（variant、optional、expected）
6. 实现适当的异常安全保证
7. 设置合适的terminate_handler用于调试

通过遵循这些最佳实践，可以有效避免异常抛出与捕获不匹配的问题，编写出更健壮、更易维护的C++代码。