C++异常处理

你一身傲骨怎能输

于 2024-12-06 03:19:40 发布

阅读量804

点赞数 7

分类专栏： c++ 文章标签： c++ 开发语言 c++异常处理

本文链接：https://blog.youkuaiyun.com/qq_33060405/article/details/144279809

版权

c++ 专栏收录该内容

58 篇文章

订阅专栏

C++异常处理是一种用于处理程序运行时错误的机制。它允许程序在遇到错误时，能够优雅地处理这些错误，而不是直接崩溃。C++的异常处理机制主要由try、catch和throw三个关键字组成。以下是对C++异常处理的详细介绍，包括其基本概念、使用方法、示例代码以及一些最佳实践。

1. 基本概念

异常：异常是程序在运行过程中发生的错误或异常情况。它可以是任何类型的对象，通常是一个类的实例。
抛出异常：当程序检测到错误时，可以使用throw关键字抛出一个异常。
捕获异常：使用try块来包围可能抛出异常的代码，并使用catch块来捕获和处理这些异常。

2. 语法

2.1 抛出异常

使用throw关键字来抛出异常：

throw exception_object; // exception_object可以是任何类型

2.2 捕获异常

使用try和catch来捕获异常：

try {
    // 可能抛出异常的代码
} catch (const ExceptionType& e) {
    // 处理异常的代码
}

3. 示例代码

以下是一个简单的示例，展示了如何使用C++异常处理机制：

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

// 一个简单的函数，可能抛出异常
double divide(double numerator, double denominator) {
    if (denominator == 0) {
        throw std::invalid_argument("Denominator cannot be zero."); // 抛出异常
    }
    return numerator / denominator;
}

int main() {
    double a = 10.0;
    double b = 0.0;

    try {
        double result = divide(a, b); // 可能抛出异常
        std::cout << "Result: " << result << std::endl;
    } catch (const std::invalid_argument& e) { // 捕获特定类型的异常
        std::cerr << "Error: " << e.what() << std::endl; // 处理异常
    } catch (...) { // 捕获所有其他类型的异常
        std::cerr << "An unknown error occurred." << std::endl;
    }

    return 0;
}

4. 异常处理的工作原理

抛出异常：当程序执行到throw语句时，控制权会立即转移到最近的try块的catch部分。
查找匹配的catch：程序会查找与抛出的异常类型匹配的catch块。如果找到匹配的catch，则执行该块中的代码。
异常传播：如果没有找到匹配的catch，异常会继续向上层调用栈传播，直到找到匹配的catch或程序终止。

5. 最佳实践

使用标准异常：尽量使用标准库中的异常类（如std::runtime_error、std::invalid_argument等），以提高代码的可读性和可维护性。
捕获特定异常：尽量捕获特定类型的异常，而不是使用通用的catch(...)，这样可以更精确地处理不同类型的错误。
避免在catch中抛出异常：在catch块中抛出异常可能会导致程序的异常处理机制失效，应该谨慎使用。
清理资源：在异常发生时，确保释放已分配的资源（如动态内存、文件句柄等），可以使用RAII（资源获取即初始化）模式来管理资源。

6. 总结

C++的异常处理机制提供了一种优雅的方式来处理运行时错误。通过使用try、catch和throw，程序可以在遇到错误时进行适当的处理，而不是直接崩溃。合理使用异常处理可以提高程序的健壮性和可维护性。

异常传播

在C++中，当一个异常被抛出时，如果没有在当前的try块中找到匹配的catch块，异常会继续向上层调用栈传播，直到找到一个匹配的catch块或者程序终止。这个过程称为异常传播（exception propagation）。

异常传播的详细说明

抛出异常：当程序执行到throw语句时，控制权会立即转移到最近的try块的catch部分。
查找匹配的catch：
- 程序会从当前的try块开始查找与抛出的异常类型匹配的catch块。
- 如果找到匹配的catch，则执行该块中的代码，并且异常处理完成。
向上层传播：
- 如果当前的try块没有找到匹配的catch，异常会向上层调用栈传播。
- 这意味着程序会返回到调用当前函数的地方，查找该函数的try块。
- 如果在上层函数中找到匹配的catch，则执行该块中的代码。
- 如果没有找到，继续向上层传播，直到找到匹配的catch或到达main函数。
程序终止：
- 如果异常传播到main函数仍然没有找到匹配的catch，程序将终止，并且通常会输出一个未处理异常的错误信息。

示例代码

以下是一个示例，展示了异常传播的过程：

#include <iostream>
#include <stdexcept>

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

void functionB() {
    functionC(); // 调用C，抛出异常
}

void functionA() {
    functionB(); // 调用B，继续传播异常
}

int main() {
    try {
        functionA(); // 调用A，异常从C传播到A
    } catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl; // 捕获异常
    } catch (...) {
        std::cout << "Caught an unknown exception." << std::endl;
    }

    return 0;
}

输出结果

运行上述代码时，输出将是：

Caught exception: Error in function C

总结

异常传播是C++异常处理机制的一个重要特性，它允许异常在调用栈中向上移动，直到找到合适的处理程序。
这种机制使得程序能够在不同层次上处理异常，提供了灵活性和可维护性。
设计良好的异常处理可以帮助程序员更好地管理错误情况，提高程序的健壮性。

C++自定义异常处理

在C++中，您可以通过定义自己的异常类来实现自定义异常处理。这使得您能够创建特定于应用程序的异常类型，以便更好地描述和处理特定的错误情况。自定义异常类通常继承自标准异常类（如std::exception），并重写其成员函数以提供更具体的错误信息。

自定义异常类的步骤

定义异常类：创建一个类，继承自std::exception或其他标准异常类。
重写what()函数：重写what()函数以返回错误信息。
抛出自定义异常：在代码中使用throw关键字抛出自定义异常。
捕获自定义异常：在catch块中捕获自定义异常。

示例代码

以下是一个示例，展示了如何定义和使用自定义异常类：

#include <iostream>
#include <exception>
#include <string>

// 自定义异常类
class MyException : public std::exception {
public:
    MyException(const std::string& message) : msg_(message) {}

    // 重写what()函数
    virtual const char* what() const noexcept override {
        return msg_.c_str();
    }

private:
    std::string msg_;
};

// 一个可能抛出自定义异常的函数
void riskyFunction(int value) {
    if (value < 0) {
        throw MyException("Negative value error: " + std::to_string(value));
    }
    std::cout << "Value is: " << value << std::endl;
}

int main() {
    try {
        riskyFunction(-10); // 传入负值，抛出自定义异常
    } 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;
    } catch (...) { // 捕获所有其他异常
        std::cerr << "Caught an unknown exception." << std::endl;
    }

    return 0;
}

输出结果

运行上述代码时，输出将是：

Caught MyException: Negative value error: -10

解释

自定义异常类：
- MyException类继承自std::exception，并重写了what()函数，以返回自定义的错误信息。
- 构造函数接受一个字符串参数，用于初始化错误消息。
抛出异常：
- 在riskyFunction中，如果传入的值小于0，则抛出MyException。
捕获异常：
- 在main函数中，使用try块调用riskyFunction，并在catch块中捕获MyException。

总结

自定义异常类使得您能够创建特定于应用程序的异常类型，从而更好地描述和处理错误情况。
通过继承标准异常类并重写what()函数，您可以提供详细的错误信息。
使用自定义异常可以提高代码的可读性和可维护性，使得错误处理更加清晰。

c++的内置异常处理类

C++标准库提供了一组内置的异常处理类，主要位于<stdexcept>和<exception>头文件中。这些内置异常类可以帮助程序员处理常见的错误情况。以下是一些常用的内置异常类及其用途：

1. `std::exception`

描述：所有标准异常类的基类。
成员函数：
- const char* what() const noexcept: 返回一个描述异常的字符串。

2. `std::runtime_error`

描述：表示在程序运行期间发生的错误。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::runtime_error("Runtime error occurred");

3. `std::logic_error`

描述：表示程序逻辑错误，例如违反了程序的逻辑约束。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::logic_error("Logic error occurred");

4. `std::invalid_argument`

描述：表示传递给函数的参数无效。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::invalid_argument("Invalid argument provided");

5. `std::out_of_range`

描述：表示访问超出范围的错误，例如访问数组的非法索引。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::out_of_range("Index out of range");

6. `std::overflow_error`

描述：表示算术运算导致溢出。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::overflow_error("Overflow error occurred");

7. `std::underflow_error`

描述：表示算术运算导致下溢。
构造函数：接受一个字符串参数，用于描述错误。

示例：

throw std::underflow_error("Underflow error occurred");

8. `std::bad_alloc`

描述：表示内存分配失败。
构造函数：不接受参数，通常在内存分配失败时自动抛出。
示例：
```
throw std::bad_alloc();
```

示例代码

以下是一个示例，展示了如何使用这些内置异常类：

#include <iostream>
#include <stdexcept>

void riskyFunction(int value) {
    if (value < 0) {
        throw std::invalid_argument("Negative value error: " + std::to_string(value));
    } else if (value > 100) {
        throw std::out_of_range("Value exceeds the maximum limit: " + std::to_string(value));
    }
    std::cout << "Value is: " << value << std::endl;
}

int main() {
    try {
        riskyFunction(-10); // 传入负值，抛出invalid_argument异常
        riskyFunction(150); // 传入超出范围的值，抛出out_of_range异常
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught invalid_argument: " << e.what() << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "Caught out_of_range: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught std::exception: " << e.what() << std::endl;
    }

    return 0;
}

输出结果

运行上述代码时，输出将是：

Caught invalid_argument: Negative value error: -10
Caught out_of_range: Value exceeds the maximum limit: 150

总结

C++标准库提供的内置异常类可以帮助程序员处理常见的错误情况。通过使用这些异常类，您可以提高代码的可读性和可维护性，并且能够更好地管理错误处理。使用内置异常类时，建议捕获特定类型的异常，以便进行更精确的错误处理。

std::exception类的底层实现

std::exception 是 C++ 标准库中所有异常类的基类。它提供了一个基本的接口，用于描述异常的性质。虽然 C++ 标准库的具体实现可能因编译器和平台而异，但我们可以讨论 std::exception 的一般结构和常见实现方式。

`std::exception` 的基本结构

std::exception 类通常包含以下几个关键部分：

构造函数：用于创建异常对象。
虚析构函数：确保派生类的析构函数能够被正确调用。
what() 函数：返回一个 C 风格字符串，描述异常的性质。

示例实现

以下是一个简化的 std::exception 类的示例实现，展示了其基本结构：

#include <iostream>
#include <cstring>

class exception {
public:
    // 默认构造函数
    exception() noexcept {}

    // 虚析构函数
    virtual ~exception() noexcept {}

    // 返回异常描述
    virtual const char* what() const noexcept {
        return "std::exception";
    }
};

// 示例派生类
class runtime_error : public exception {
public:
    runtime_error(const char* msg) noexcept {
        std::strncpy(message, msg, sizeof(message) - 1);
        message[sizeof(message) - 1] = '\0'; // 确保字符串以 null 结尾
    }

    const char* what() const noexcept override {
        return message;
    }

private:
    char message[256]; // 存储错误消息
};

int main() {
    try {
        throw runtime_error("An error occurred");
    } catch (const exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    return 0;
}

关键点

虚函数：what() 函数是一个虚函数，允许派生类重写它以提供更具体的错误信息。这是多态的一个重要特性。
异常安全：std::exception 和其派生类的构造函数和析构函数都被声明为 noexcept，这意味着它们不会抛出异常。这是为了确保在异常处理过程中不会引发新的异常，从而导致程序崩溃。
字符串处理：在派生类中，通常会使用字符数组来存储错误消息，并确保字符串以 null 结尾。

实际实现

在实际的 C++ 标准库实现中，std::exception 及其派生类的实现可能会更加复杂，可能会使用更高级的字符串处理机制（如 std::string）来存储错误消息。此外，具体的实现可能会考虑到线程安全、内存管理等因素。

总结

std::exception 是 C++ 异常处理机制的核心，提供了一个基本的接口来描述异常。虽然具体的实现可能因编译器和平台而异，但其基本结构和功能在所有实现中都是相似的。通过使用 std::exception 及其派生类，程序员可以有效地管理和处理错误情况。

std::out_of_range类的底层实现

std::out_of_range 是 C++ 标准库中用于表示超出范围错误的异常类，属于 std::logic_error 的派生类。它通常用于指示访问容器或数组时索引超出有效范围的情况。

虽然 C++ 标准库的具体实现可能因编译器和平台而异，但我们可以讨论 std::out_of_range 的一般结构和常见实现方式。以下是一个简化的 std::out_of_range 类的示例实现，展示了其基本结构。

`std::out_of_range` 的基本结构

std::out_of_range 类通常包含以下几个关键部分：

构造函数：用于创建异常对象，并接受一个描述错误的字符串。
虚析构函数：确保派生类的析构函数能够被正确调用。
what() 函数：返回一个 C 风格字符串，描述异常的性质。

示例实现

以下是一个简化的 std::out_of_range 类的示例实现：

#include <iostream>
#include <cstring>
#include <stdexcept>

class logic_error : public std::exception {
public:
    logic_error(const char* msg) noexcept {
        std::strncpy(message, msg, sizeof(message) - 1);
        message[sizeof(message) - 1] = '\0'; // 确保字符串以 null 结尾
    }

    virtual const char* what() const noexcept override {
        return message;
    }

private:
    char message[256]; // 存储错误消息
};

class out_of_range : public logic_error {
public:
    out_of_range(const char* msg) noexcept : logic_error(msg) {}
};

int main() {
    try {
        throw out_of_range("Index out of range");
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    return 0;
}

关键点

继承：out_of_range 类继承自 logic_error，这意味着它可以使用 logic_error 的构造函数和 what() 方法。
构造函数：out_of_range 的构造函数接受一个字符串参数，用于描述错误，并将其传递给基类 logic_error 的构造函数。
what() 方法：what() 方法在基类中实现，返回错误消息。