C++ 中的异常处理：深入理解 throw

基础概念

在 C++ 中，throw 是用于抛出异常的关键字。异常是一种机制，用于处理程序运行过程中出现的错误或异常情况。当程序执行到 throw 语句时，它会中断当前的执行路径，并开始在调用栈中查找能够处理该异常的 catch 块。如果没有找到合适的 catch 块，程序将终止并输出错误信息。

使用方法

抛出基本类型异常

可以抛出基本数据类型的异常，如 int、double、char 或 std::string 等。下面是一个简单的示例：

#include <iostream>

void divide(int a, int b) {
    if (b == 0) {
        throw std::string("Division by zero error");
    }
    std::cout << "Result: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0);
    } catch (const std::string& e) {
        std::cerr << "Exception caught: " << e << std::endl;
    }
    return 0;
}

在这个例子中，divide 函数在 b 为 0 时抛出一个 std::string 类型的异常。main 函数通过 try-catch 块捕获并处理这个异常。

抛出自定义类型异常

除了基本类型，也可以抛出自定义类型的异常。这有助于提供更详细的错误信息，并组织异常处理逻辑。

#include <iostream>

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

void someFunction() {
    throw MyException();
}

int main() {
    try {
        someFunction();
    } catch (const MyException& e) {
        std::cerr << "Caught MyException: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught std::exception: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，定义了一个继承自 std::exception 的自定义异常类 MyException。someFunction 函数抛出这个自定义异常，main 函数通过多个 catch 块捕获并处理不同类型的异常。

常见实践

函数内部的异常抛出

在函数内部，当检测到错误条件时，应及时抛出异常。这有助于保持函数的单一职责，并使调用者能够处理错误。

#include <iostream>
#include <vector>

double average(const std::vector<int>& numbers) {
    if (numbers.empty()) {
        throw std::runtime_error("Vector is empty");
    }
    int sum = 0;
    for (int num : numbers) {
        sum += num;
    }
    return static_cast<double>(sum) / numbers.size();
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    try {
        double avg = average(numbers);
        std::cout << "Average: " << avg << std::endl;

        std::vector<int> emptyVector;
        avg = average(emptyVector);
    } catch (const std::runtime_error& e) {
        std::cerr << "Runtime error: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，average 函数在输入的 std::vector 为空时抛出 std::runtime_error 异常。main 函数捕获并处理这个异常。

多层调用中的异常传递

异常可以在函数调用栈中向上传递，直到被捕获。这使得高层函数能够处理底层函数抛出的异常。

#include <iostream>

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

void functionB() {
    functionC();
}

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

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

在这个例子中，functionC 抛出一个 std::logic_error 异常，functionB 没有捕获它，异常继续向上传递到 functionA，在 functionA 中被捕获并处理。

最佳实践

遵循异常安全准则

异常安全准则确保在异常发生时，程序的资源得到正确管理，对象状态保持一致。常见的异常安全级别有：

基本保证：如果异常发生，对象状态保持有效，没有资源泄漏。
强保证：如果异常发生，操作要么完全成功，要么对象状态保持不变，没有资源泄漏。
不抛出保证：函数承诺不会抛出任何异常。

例如，使用智能指针（如 std::unique_ptr 和 std::shared_ptr）可以帮助实现基本的异常安全，因为它们会自动管理资源的释放。

合理使用异常层次结构

定义自定义异常类时，应建立合理的层次结构。继承自 std::exception 或其派生类（如 std::runtime_error、std::logic_error）可以让异常处理代码根据异常类型进行分类处理。

#include <iostream>

class DatabaseError : public std::runtime_error {
public:
    DatabaseError(const std::string& message) : std::runtime_error(message) {}
};

class ConnectionError : public DatabaseError {
public:
    ConnectionError(const std::string& message) : DatabaseError(message) {}
};

class QueryError : public DatabaseError {
public:
    QueryError(const std::string& message) : DatabaseError(message) {}
};

void connectToDatabase() {
    throw ConnectionError("Failed to connect to database");
}

int main() {
    try {
        connectToDatabase();
    } catch (const ConnectionError& e) {
        std::cerr << "Connection error: " << e.what() << std::endl;
    } catch (const DatabaseError& e) {
        std::cerr << "Database error: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "General exception: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，DatabaseError 是基类，ConnectionError 和 QueryError 是派生类。通过这种层次结构，可以更精确地捕获和处理不同类型的数据库相关异常。

小结

throw 是 C++ 中异常处理的核心机制之一，它允许在程序中抛出异常以处理错误和异常情况。通过合理使用 throw、try-catch 块以及遵循最佳实践，可以编写更健壮、易于维护的代码。理解异常处理的概念和技术，能够帮助开发者在面对复杂的程序逻辑和潜在的错误时，确保程序的稳定性和可靠性。

希望这篇博客能够帮助你深入理解 C++ 中的 throw 以及相关的异常处理机制。在实际编程中，不断练习和应用这些知识，将有助于提升你的编程技能和代码质量。