c++如何进行异常处理_c++异常处理try-catch机制详解

try-catch

try-catch

try

throw

catch

try

try

#include <iostream>
#include <string>
#include <stdexcept> // 包含标准异常类

double divide(double numerator, double denominator) {
    if (denominator == 0) {
        // 当分母为0时，这是一个异常情况，我们选择抛出异常
        throw std::runtime_error("Error: Division by zero is not allowed.");
    }
    return numerator / denominator;
}

int main() {
    try {
        // 尝试执行可能抛出异常的代码
        double result1 = divide(10.0, 2.0);
        std::cout << "10 / 2 = " << result1 << std::endl;

        double result2 = divide(5.0, 0.0); // 这行代码会抛出异常
        std::cout << "5 / 0 = " << result2 << std::endl; // 这行将不会被执行
    }
    catch (const std::runtime_error& e) {
        // 捕获特定类型的异常
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    catch (const std::exception& e) {
        // 捕获所有标准异常的基类，更通用
        std::cerr << "Caught a general standard exception: " << e.what() << std::endl;
    }
    catch (...) {
        // 捕获任何类型的异常（包括非标准异常），通常作为最后的防线
        std::cerr << "Caught an unknown exception!" << std::endl;
    }

    std::cout << "Program continues after exception handling." << std::endl;
    return 0;
}

divide(5.0, 0.0)

denominator == 0

throw std::runtime_error(...)

std::runtime_error

catch

catch

try

catch

catch

std::terminate

catch

std::exception

...

throw

if (error_code != SUCCESS)

try

catch

catch

#include <iostream>
#include <fstream>
#include <memory> // for std::unique_ptr
#include <mutex>  // for std::lock_guard

// 示例1: 传统的资源管理（容易泄露）
void process_file_old(const std::string& filename) {
    std::FILE* file = std::fopen(filename.c_str(), "r");
    if (!file) {
        throw std::runtime_error("Could not open file.");
    }
    // 假设这里有一段代码可能会抛出异常
    // 如果抛出异常，fclose(file) 将不会被执行，导致文件句柄泄露
    // ...
    std::fclose(file); // 如果前面有异常，这行代码可能永远不会执行
}

// 示例2: 使用RAII管理文件句柄
class FileHandle {
public:
    FileHandle(const std::string& filename, const char* mode) {
        file_ptr_ = std::fopen(filename.c_str(), mode);
        if (!file_ptr_) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
        std::cout << "File '" << filename << "' opened." << std::endl;
    }

    ~FileHandle() {
        if (file_ptr_) {
            std::fclose(file_ptr_);
            std::cout << "File closed." << std::endl;
        }
    }

    // 禁止拷贝，避免双重释放
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    std::FILE* get() const { return file_ptr_; }

private:
    std::FILE* file_ptr_;
};

void process_file_raii(const std::string& filename) {
    FileHandle file(filename, "r"); // 资源在构造时获取
    // 假设这里有一段代码可能会抛出异常
    // 无论是否抛出异常，当file对象离开作用域时，其析构函数都会被调用
    // 从而保证文件句柄被正确关闭。
    std::cout << "Processing file content..." << std::endl;
    // ...
    // file对象离开作用域，析构函数自动调用，文件关闭
}

// 示例3: 使用标准库的RAII工具，如std::lock_guard
std::mutex my_mutex;
void guarded_operation() {
    std::lock_guard<std::mutex> lock(my_mutex); // 构造时加锁
    // 临界区代码，可能抛出异常
    std::cout << "Critical section entered." << std::endl;
    // ...
    // 无论如何，lock对象离开作用域时，析构函数会自动解锁
    std::cout << "Critical section exited." << std::endl;
}

int main() {
    try {
        // process_file_old("non_existent.txt"); // 演示传统方式的风险
        process_file_raii("example.txt"); // 假设example.txt存在
        guarded_operation();
    } catch (const std::exception& e) {
        std::cerr << "Main caught exception: " << e.what() << std::endl;
    }
    return 0;
}

process_file_raii

FileHandle file(filename, "r");

file

std::fclose

std::unique_ptr

std::shared_ptr

std::lock_guard

std::unique_lock