C++ 异常机制详解-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++ 异常机制详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

对C++学习感兴趣的可以看看这篇文章哦：C/C++教程

1. 异常处理机制介绍

C++中的异常处理机制可以帮助我们处理程序在运行时可能会遇到的异常情况，比如内存分配错误、文件打开失败等。当程序运行到某一处出现异常时，程序会立即跳转到相应的异常处理代码。

C++中的异常处理使用try-catch语句实现，try语句块中包含可能抛出异常的代码，catch语句块用来捕获并处理异常。当程序执行到throw语句时，就会抛出一个异常，并跳转到最近的catch语句块处理异常。

以下是一个简单的示例：

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

2. 如何抛出异常和捕获异常

2.1 抛出异常

在C++中，我们可以通过throw语句来抛出一个异常。throw后面跟着一个表达式，它的类型可以是任意类型，通常我们使用标准库中的异常类，比如std::runtime_error、std::invalid_argument等。

比如如果你抛出的int，那后面你就需要在catch块中使用int类型来接收这个抛出的值

以下是一个抛出异常的示例：

void foo(int x) {
    if (x < 0) {
        throw std::invalid_argument("x不能为负数");
    }
}

在上面的示例中，如果参数x小于0，就会抛出一个std::invalid_argument异常，异常信息为"x不能为负数"。

2.2 捕获异常

当程序执行到throw语句时，会跳转到最近的catch语句块处理异常。catch语句块中包含了捕获异常后要执行的代码。

以下是一个捕获异常的示例：

try {
    foo(x);
} catch (std::exception& e) {
    // 处理异常
}

在上面的示例中，如果foo函数抛出了一个std::exception异常，就会跳转到catch语句块中进行处理。

如果内部抛出的double，则这里的std::exception&就要写为double

3. 如何实现自己的异常

一般我们可以通过继承标准库中的异常类，来实现自己的异常。

通常情况下，我们需要重写exception类中的what()方法，以提供更详细的异常信息。

以下是一个自定义异常的示例：

class MyException : public std::exception {
public:
    MyException(const char* msg) : _msg(msg) {}

    virtual const char* what() const noexcept override {
        return _msg.c_str();
    }

private:
    std::string _msg;
};

void foo(int x) {
    if (x < 0) {
        throw MyException("x不能为负数");
    }
}

在上面的示例中，我们继承了std::exception类，并重写了它的what()方法。然后在foo函数中，如果参数x小于0，就会抛出一个MyException异常，异常信息为"x不能为负数"。

4. 注意事项

在使用异常处理时，我们需要注意以下几点：

异常处理只是一种容错机制，不能用来代替正常的程序代码逻辑。
不要滥用异常处理，应该只在必要的情况下使用。
应该尽可能提供详细的异常信息，以方便调试和定位问题。
在捕获异常时，应该考虑到可能发生的所有异常情况，并分别进行处理。

5. 面试常问的题目

以下是一些常见的关于C++异常处理的面试题目：

什么是C++中的异常处理机制？它的作用是什么？
如何抛出异常和捕获异常？请给出一个示例。
如果需要实现自己的异常，应该怎么做
请简述C++中的异常类层次结构，并说明它们的作用。
在使用异常处理时，有哪些需要注意的事项？
什么是异常安全性？如何保证程序具有异常安全性？
请解释以下关键字的含义：try、catch、throw、noexcept。
如果一个函数可能抛出多种类型的异常，应该如何进行捕获？
在C++11中新增了一种异常处理机制，即std::exception_ptr。请简述它的作用和使用方法。
请介绍一下RAII技术在异常处理中的应用。

以上是一些常见的面试题目，希望能够对大家有所帮助。

6. 答案

什么是C++中的异常处理机制？它的作用是什么？

C++中的异常处理机制是一种错误处理机制，可以帮助我们处理程序在运行时可能会遇到的异常情况，比如内存分配错误、文件打开失败等。当程序运行到某一处出现异常时，程序会立即跳转到相应的异常处理代码。

其主要作用在于：在程序运行时，发生异常后能够快速地定位并处理问题，从而保证程序的稳定性和正确性。

如何抛出异常和捕获异常？请给出一个示例。

我们可以通过throw语句来抛出一个异常，catch语句块用来捕获并处理异常。以下是一个示例：

void foo(int x) {
    if (x < 0) {
        throw std::out_of_range("x不能为负数");
    }
}

int main() {
    try {
        foo(-1);
    } catch (std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

在上面的示例中，如果参数x小于0，就会抛出一个std::out_of_range异常，异常信息为"x不能为负数"。在main函数中，我们使用try-catch语句块来捕获异常，并输出异常信息。

如果需要实现自己的异常，应该怎么做？

我们可以通过继承标准库中的exception类，来实现自己的异常。通常情况下，我们需要重写exception类中的what()方法，以提供更详细的异常信息。

以下是一个自定义异常的示例：

class MyException : public std::exception {
public:
    MyException(const char* msg) : _msg(msg) {}

    virtual const char* what() const noexcept override {
        return _msg.c_str();
    }

private:
    std::string _msg;
};

void foo(int x) {
    if (x < 0) {
        throw MyException("x不能为负数");
    }
}

请简述C++中的异常类层次结构，并说明它们的作用。

C++中的异常类层次结构如下所示：

std::exception：所有标准异常类的基类，包含了一些通用的异常信息。
std::bad_alloc：内存分配错误时抛出的异常。
std::logic_error：内部逻辑错误时抛出的异常，例如无效参数或操作。
std::runtime_error：运行时错误时抛出的异常，例如文件打开失败等。

这些异常类都包含了一个what()方法，返回一个描述异常信息的字符串。我们可以通过继承这些异常类来实现自己的异常。

在使用异常处理时，有哪些需要注意的事项？

在使用异常处理时，我们需要注意以下几点：

异常处理只是一种容错机制，不能用来代替正常的程序代码逻辑。
不要滥用异常处理，应该只在必要的情况下使用。
应该尽可能提供详细的异常信息，以方便调试和定位问题。
在捕获异常时，应该考虑到可能发生的所有异常情况，并分别进行处理。
什么是异常安全性？如何保证程序具有异常安全性？

异常安全性是指程序在发生异常后能够正确地进行资源回收。保证程序具有异常安全性可以避免内存泄漏等问题。

通常情况下，我们可以通过RAII（Resource Acquisition Is Initialization）技术来保证程序具有异常安全性。RAII技术利用对象的生命周期来管理资源的分配和释放，将资源的分配和释放过程封装在类的构造函数和析构函数中。

例如，我们可以使用std::vector来动态分配内存：

std::vector<int> v;
for (int i = 0; i < 10; ++i) {
    v.push_back(i);
}

当std::vector对象被销毁时，它会自动调用析构函数来释放内存，即使在循环中发生了异常也不会影响资源的释放。

请解释以下关键字的含义：try、catch、throw、noexcept。

try：用于包含可能抛出异常的代码块。
catch：用于捕获并处理异常的代码块。
throw：用于抛出一个异常，并跳转到最近的catch语句块。
noexcept：指示一个函数不会抛出任何异常。
如果一个函数可能抛出多种类型的异常，应该如何进行捕获？

如果一个函数可能抛出多种类型的异常，我们可以使用多个catch语句块来分别捕获这些异常。catch语句块的顺序应该从具体到一般，以确保所有异常都能够被正确地捕获。

以下是一个示例：

void foo(int x) {
    if (x == 0) {
        throw std::invalid_argument("x不能为0");
    } else if (x < 0) {
        throw std::out_of_range("x不能为负数");
    }
}

int main() {
    try {
        foo(-1);
    } catch (std::invalid_argument& e) {
        std::cout << "invalid argument: " << e.what() << std::endl;
    } catch (std::out_of_range& e) {
        std::cout << "out of range: " << e.what() << std::endl;
    } catch (std::exception& e) {
        std::cout << "exception: " << e.what() << std::endl;
    }
    return 0;
}

在上面的示例中，如果foo函数抛出了一个std::invalid_argument异常，就会跳转到第一个catch语句块进行处理；

如果抛出了一个std::out_of_range异常，就会跳转到第二个catch语句块进行处理；

如果抛出了其他类型的异常，就会跳转到最后一个catch语句块进行处理。

在C++11中新增了一种异常处理机制，即std::exception_ptr。请简述它的作用和使用方法。

std::exception_ptr是C++11中新增的一种异常处理机制，可以用来保存当前正在处理的异常，并在稍后的时间点重新抛出该异常。

以下是一个使用std::exception_ptr的示例：

void foo() {
    try {
        // 可能会抛出异常的代码
    } catch (...) {
        std::exception_ptr p = std::current_exception();
        // 处理异常
        std::rethrow_exception(p);
    }
}

int main() {
    try {
        foo();
    } catch (std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

在上面的示例中，如果foo函数抛出了异常，就会跳转到catch语句块中处理异常，并使用std::current_exception()函数获取当前正在处理的异常，然后使用std::rethrow_exception()函数重新抛出该异常。在main函数中，我们再次捕获这个异常并进行处理。

请介绍一下RAII技术在异常处理中的应用。

RAII技术在异常处理中的应用非常广泛。通过将资源的分配和释放过程封装在类的构造函数和析构函数中，可以保证程序具有异常安全性。

例如，在操作文件时，我们可以使用std::ofstream来打开文件，并将其封装在一个类中：

class File {
public:
    File(const std::string& filename) : _file(filename) {
        if (!_file.is_open()) {
            throw std::runtime_error("failed to open file");
        }
    }

    ~File() {
        if (_file.is_open()) {
            _file.close();
        }
    }

    void write(const std::string& s) {
        _file << s;
    }

private:
    std::ofstream _file;
};

void foo() {
    File f("test.txt");
    f.write("hello, world");
}

int main() {
    try {
        foo();
    } catch (std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}