C++标准异常库

一 标准异常类的成员：

① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。

② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述

③ 所有的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。

1.1 标准异常类的具体描述：

 1.2 logic_error的子类：

1.3 runtime_error的子类：

示例代码：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>   
using namespace std;
#include <stdexcept>   // 标准异常
 
class num_1
{
    public:
        int age;
 
        num_1(int age)
        {
            if(age<0 || age>150)
            {
                throw length_error("年龄有错误");   
            } 
        }
};
 
int main(void)
{
    try
    {
        num_1 p1(1112);
    }
    catch(exception &p2)
    {
        cout << "类型异常，异常类为：" << p2.what() << endl;
    }
    return 0;
}

        在代码中，定义了一个类num_1，其中有一个构造函数，用于判断年龄是否符合要求，并抛出标准异常length_error。在主函数中，通过使用try-catch语句来捕获并处理异常。如果捕获到异常，会输出异常类的信息。通过这种方式可以处理并控制程序中的异常情况。

二 自己写一个异常类

2.1 为什么自己写异常类

① 标准库中的异常是有限的；

② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。

2.2 如何编写自己的异常类？

① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。

② 当继承标准异常类时，应该重载父类的what函数。

2.3 异常类的编写

2.3.1 多态

        因为我们自己编写的异常类要继承自 exception 这个标准异常类，所以我们应该有一种思路就是使用多态来扩展，多态的好处就是不影响原基类的情况下进行安全扩展。

         我们来到 exception 类的定义：

 virtual const char*
    what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;

        可以看到标准异常类也为多态做好了准备，做了一个virtual的虚函数。注意这里返回的是char* 类型的数组。

2.3.2 异常类的编写

        第一步先写一个继承类，继承自exception。

代码如下：

class num_1:public exception   //自己写的异常类
{
    private:
        string msg;
 
    public:
        num_1(string msg)
        {
            this->msg = msg;
        }
        virtual const char *what() // 记得这里的返回值是char*
        {
            return this->msg.c_str();   // .c_str()作用是类型转换，即string——>char*
        }
};

        第二步做了一个普通的类，并在异常处使用 throw 抛出异常类 num_1。

代码如下：

class num_2      //普通类，进行年龄判断
{
    public:
        int age;
 
        num_2(int age)
        {
            if(age<0 || age>160)
            {
                if(age<0)
                {
                    throw num_1("年龄小于0，异常");   //抛异常
                }
                else
                {
                    throw num_1("年龄大于160，异常");  //抛异常
                }
               
            }
            else
            {
                this->age = age;
            }
        }
};

        第三步，在 main 函数中进行。

代码如下：

try
    {
        num_2 p1(180);
    }
    catch (exception &e) // 相当于exception &e = num_1("年龄大于160，异常")  符合多态条件
    {
        cout << e.what() << endl;
    }

 总体代码：

#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <string>
#include<iomanip>
#include<fstream>  //头文件流
#include<vector>
using namespace std;
 
 
class num_1:public exception   //自己写的异常类
{
    private:
        string msg;
 
    public:
        num_1(string msg)
        {
            this->msg = msg;
        }
        virtual const char *what() // 记得这里的返回值是char*
        {
            return this->msg.c_str();   // .c_str()作用是类型转换，即string——>char*
        }
};
 
class num_2
{
    public:
        int age;
 
        num_2(int age)
        {
            if(age<0 || age>160)
            {
                if(age<0)
                {
                    throw num_1("年龄小于0，异常");
                }
                else
                {
                    throw num_1("年龄大于160，异常");
                }
               
            }
            else
            {
                this->age = age;
            }
        }
};
 
int main(void)
{
    try
    {
        num_2 p1(180);
    }
    catch (num_1 &e) // exception &e = num_1("年龄大于160，异常")
    {
        cout << e.what() << endl;
    }
    return 0；
}

总结

• 异常类可以通过继承exception类来自定义
• 异常类可以包含自定义的错误信息，方便在异常处理时输出错误原因
• 异常类的成员函数what()必须被重写，返回错误信息的char*类型
• 在异常类的构造函数中，可以通过条件判断来抛出异常，例如判断年龄是否小于0或大于160
• 在主函数中，可以使用try-catch块来捕获并处理抛出的异常
• 捕获到的异常对象可以通过引用传递给catch块，然后使用e.what()来输出错误信息