C++面向对象（OOP）编程-异常机制

发狂的小花

已于 2023-12-28 15:48:13 修改

阅读量830

点赞数 20

分类专栏： # C/C++精进之路 C/C++编程集合文章标签： c++ 异常开发语言面向对象

于 2023-12-19 00:19:02 首次发布

本文链接：https://blog.csdn.net/m0_47324800/article/details/135072367

版权

C/C++编程集合同时被 2 个专栏收录

36 篇文章 0 订阅

订阅专栏

C/C++精进之路

19 篇文章 5 订阅

订阅专栏

本文主要介绍C++异常的处理，异常的种类，以及如何自己实现异常，以及异常常见的面试题。

🎬个人简介：一个全栈工程师的升级之路！
📋个人专栏：C/C++精进之路
🎀CSDN主页发狂的小花
🌄人生秘诀：学习的本质就是极致重复!

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

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

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

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

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

6.6 什么是异常安全性？如何保证程序具有异常安全性？

6.7 如果一个函数可能抛出多种类型的异常，应该如何进行捕获？

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

1 异常介绍

异常是指在程序运行过程中，由于系统条件、操作不当等原因而引起的运行错误。

常见的异常包括：除零错误、指针访问受保护空间、数据越界、分配空间失败、要打开的文件不存在等。

C++异常处理使用关键字try、catch和throw来实现。

try块：用于包含可能会抛出异常的代码。当异常被抛出时，程序会立即停止执行try块中的剩余代码，并将控制权转移到与该异常匹配的catch块。
catch块：用于捕获并处理异常。每个catch块都指定了要捕获的异常类型。当异常与某个catch块匹配时，程序将执行该块中的代码来处理异常。
throw语句：用于显式地抛出一个异常对象。可以使用throw语句手动触发异常，或者在程序中遇到错误时自动抛出异常。

2 异常处理

2.1 抛出异常

使用throw来主动抛出异常，程序运行错误也会主动抛出异常。

一个例子：

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

当输入的值小于0时，抛出一个异常对象，然后可以利用try{}catch{}来捕获。

2.2 捕获异常

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

一个例子：

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

上述例子使用try来检测异常，看func函数是否会抛出异常，如果抛出std::exception异常，就会跳转到catch语句块中进行处理。

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

2.3 自定义异常

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

一个例子：

#include <iostream>
#include <exception>

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

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

    private:
        const char* msg_;
};

int main() {
    try {
        throw MyException("这是一个自定义异常");
    } catch (const MyException& e) {
        std::cerr << "捕获到自定义异常： " << e.what() << std::endl;
    }

    return 0;
}

运行结果：

上述代码描述了一个继承自标准库中的exception类，重写what方法的自定义异常类。

3 异常使用原则

（1）异常处理只是一种容错机制，不能用来代替正常的程序代码逻辑。

（2）不要滥用异常处理，应该只在必要的情况下使用。

（3）应该尽可能提供详细的异常信息，以方便调试和定位问题。

（4）在捕获异常时，应该考虑到可能发生的所有异常情况，并分别进行处理。

（5）对于一个检测会有多种异常，我们可以使用多个catch来捕获。

一个例子：

try{        //异常检测
        throw  异常类型1对应的异常值；  //抛出异常：异常值或异常对象

}
catch (异常类型1)                     //捕获异常
{

    // 进行异常处理的语句

}
catch (异常类型2)
{

    //进行异常处理的语句

}

上述形式可以抛出多个类型的异常。

4 异常处理模式

异常处理模式——指处理完异常后，程序的执行流程。默认的异常处理模式为终止模式。

终止模式——指异常抛出后，将退出导致异常的子程序或结构，转而去执行捕捉异常的catch块，catch块执行完毕后也不会再返回到抛出异常的位置，也就是说throw 后的数据不会再执行。

一个例子：

#include <iostream>
#include <exception>

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

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

    private:
        const char* msg_;
};

void test_exp()
{
    std::cout << "throw before!" << std::endl;
    throw MyException("这是一个自定义的测试异常!");
    std::cout << " throw after!" << std::endl; 
}

int main() {
    try {
        std::cout << "异常的检测!" << std::endl;
        test_exp();
    } catch (const MyException& e) {
        std::cerr << "捕获到自定义异常： " << e.what() << std::endl;
    }

    return 0;
}

运行结果：

由上述得知，main函数执行后，首先执行try中程序，调用throw抛出异常，此时不会执行抛出异常后的代码，会直接跳转到执行catch程序块，执行后续的代码。

因此throw后面不能放有效的代码。

5 stdexcept 中的异常类

`stdexcept` 是 C++ 标准库中的一个头文件，它定义了一些用于表示异常情况的类。以下是 `stdexcept` 中的主要异常类：

（1） `logic_error`：逻辑错误，通常是由于程序中的逻辑错误导致的异常。
（2）`invalid_argument`：无效参数，当函数接收到无效参数时抛出。
（3）`runtime_error`：运行时错误，通常是由于程序中的运行时错误导致的异常。
（4）`domain_error`：域错误，当函数接收到超出有效范围的值时抛出。
（5）`length_error`：长度错误，当请求的长度超出了有效范围时抛出。
（6）`out_of_range`：范围错误，当操作数超出有效范围时抛出。
（7）`overflow_error`：溢出错误，当算术运算导致溢出时抛出。
（8）`underflow_error`：下溢错误，当算术运算导致下溢时抛出。
（9）`system_error`：系统错误，当发生操作系统相关的错误时抛出。
（10）`ios_base::failure`：I/O 失败，当 I/O 操作失败时抛出。
（11）`bad_alloc`：内存分配失败，当无法分配所需内存时抛出。

异常类层次：

6 异常机制面试问题

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

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

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

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

#include <iostream>
#include <exception>

int main(int argc, char *argv[])
{

    try{
        throw std::runtime_error(" 这是一个异常的检测!");

    }
    catch(std::exception & e)
    {
        std::cout << e.what() << std::endl;
    }



    return 0;
}

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

继承标准库中的expection类，重写其中的what方法。

一个例子：

#include <iostream>
#include <exception>
#include <stdexcept>

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

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

    private:
        const char* msg_;
};

void test_exp()
{
    std::cout << "throw before!" << std::endl;
    throw MyException("这是一个自定义的测试异常!");
    std::cout << " throw after!" << std::endl; 
}

int main() {
    try {
        std::cout << "异常的检测!" << std::endl;
        test_exp();
    } catch (const MyException& e) {
        std::cerr << "捕获到自定义异常： " << e.what() << std::endl;
    }

    return 0;
}

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

        td::exception：所有标准异常类的基类，包含了一些通用的异常信息。
        std::bad_alloc：内存分配错误时抛出的异常。
        std::logic_error：内部逻辑错误时抛出的异常，例如无效参数或操作。
        std::runtime_error：运行时错误时抛出的异常，例如文件打开失败等。
这些异常类都包含了一个what()方法，返回一个描述异常信息的字符串。我们可以通过继承这些异常类来实现自己的异常。

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

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

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

6.6 什么是异常安全性？如何保证程序具有异常安全性？

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

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

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

try：用于包含可能抛出异常的代码块。
catch：用于捕获并处理异常的代码块。
throw：用于抛出一个异常，并跳转到最近的catch语句块。
noexcept：指示一个函数不会抛出任何异常。

6.7 如果一个函数可能抛出多种类型的异常，应该如何进行捕获？

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

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

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

一个例子：

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

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

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

🌈我的分享也就到此结束啦🌈
如果我的分享也能对你有帮助，那就太好了！
若有不足，还请大家多多指正，我们一起学习交流！
📢未来的富豪们：点赞👍→收藏⭐→关注🔍
感谢大家的观看和支持！最后，☺祝愿大家每天有钱赚！！！

发狂的小花

关注

20
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++面向对象（OOP）编程-异常机制

异常是指在程序运行过程中，由于系统条件、操作不当等原因而引起的运行错误。除零错误、指针访问受保护空间、数据越界、分配空间失败、要打开的文件不存在等。C++异常处理使用关键字trycatch和throw来实现。try块：用于包含可能会抛出异常的代码。当异常被抛出时，程序会立即停止执行try块中的剩余代码，并将控制权转移到与该异常匹配的catch块。catch块：用于捕获并处理异常。每个catch块都指定了要捕获的异常类型。当异常与某个catch块匹配时，程序将执行该块中的代码来处理异常。throw。
复制链接

扫一扫