《C++进阶之C++11》【异常】

if (divisor == 0) 
{
    throw "除数不能为0";  // 抛出字符串类型的异常
}

try 
{
    // 可能抛出异常的代码
}

catch (异常类型 变量名) 
{
    // 异常处理逻辑
}

/*-------------------------异常处理的基本语法-------------------------*/

/* 说明：
*   1. error_condition：错误条件
*	2. exception_type：异常类型
*/

try 
{
    // 可能抛出异常的代码
    if (error_condition) 
    {
        throw exception_type("Error message");
    }
} 

catch (const exception_type& e) 
{
    // 处理异常
    std::cerr << "Caught exception: " << e.what() << std::endl;
} 
catch (...) 
{
    // 捕获所有其他类型的异常
    std::cerr << "Unknown exception caught" << std::endl;
}

#include <iostream>
using namespace std;


/*------------------------ 除法函数 ------------------------*/
double divide(int num, int divisor)
{
    if (divisor == 0)   // 当除数为0时抛出异常
    {
        throw "错误：除数不能为0"; //注：抛出异常（此处为字符串类型）
    }
    
    return (double)num / divisor;
}


/*------------------------ 主函数 ------------------------*/
int main()
{
    //1.定义三个变量用于计算和保存结果
    int a = 10, b = 0;
    double result;

    //2.监控可能抛出异常的代码
    try
    {
        //2.1：
        result = divide(a, b);

        //2.2：
        cout << "结果：" << result << endl; //注意：若divide抛出异常，这行代码不会执行
    }
    //3.捕获字符串类型的异常
    catch (const char* errorMsg)
    {
        cout << "捕获到异常：" << errorMsg << endl;
    }

    //4.异常处理后，程序继续执行
    cout << "程序继续运行..." << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;


/*---------------------------自定义异常类---------------------------*/
class DivideError : public exception  //注：继承自标准库的exception类，可以兼容标准异常处理机制
{
private:
    string msg; // 用于存储异常的详细信息

public: 
    //1.实现：“构造函数”
    DivideError(string message) 
        : msg(message)
    { }
    /* 说明：
    *    1. 接收异常信息字符串并初始化成员变量
    *    2. 参数message：描述异常原因的字符串
    */

    //2. 重写exception类的what()方法
    const char* what() const noexcept override
    {
        return msg.c_str(); // 将string转换为C风格字符串返回
    }
    /* 说明：
    *    1. 该方法返回异常的描述信息，是异常处理的标准接口
    *    2. const noexcept：保证该方法不会修改对象状态，也不会抛出异常
    */
};

/*---------------------------除法函数---------------------------*/
double divide(int num, int divisor)
{
    //1.检查除数是否为0，如果是则抛出异常
    if (divisor == 0) 
    {
        //1.1：抛出自定义异常对象，包含具体的错误信息
        throw DivideError("除数不能为0（自定义异常）");
    }

    //2.执行正常的除法运算并返回结果
    return (double)num / divisor;
}

int main()
{
    //1.try块：包含可能抛出异常的代码
    try
    {
        //1.1：调用divide函数
        cout << divide(10, 0) << endl;   //注：此处传入除数0，会触发异常

        //1.2：输出提示信息
        cout << "除法运算完成" << endl;  //注：如果上面的函数调用抛出异常，下面的代码不会执行
    } 
    //2.catch块：捕获并处理特定类型的异常
    catch (const DivideError& e) //这里捕获DivideError类型的异常，使用const引用接收以避免对象拷贝
    {
        //2.1：调用异常对象的what()方法获取错误信息并输出
        cout << "捕获到异常：" << e.what() << endl;
    }
    //3.程序执行到这里，无论是否发生异常都会继续运行
    cout << "程序继续执行..." << endl;
    return 0;
}

try 
{
    // 可能抛出异常的代码
}

catch (const DivideError& e) 
{
    // 处理特定异常
}
catch (...) 
{
    // 处理所有其他未捕获的异常
    cout << "发生未知异常" << endl;
}

#include <iostream>
#include <string>
using namespace std;

void func()
{
    throw string("异常测试");
}
int main()
{
    //1.
    try
    {
        func();
    }

    //2.需特殊转换，才会匹配 const char*（）
    catch (const char* e)
    {
        cout << "捕获 C 字符串异常" << endl;
    }
    //3.完全匹配 string 类型
    catch (string& e)
    {
        cout << "捕获 string 异常" << endl;
    }
}

#include <iostream>
#include <string>
using namespace std;

/*-------------------------------自定义异常类-------------------------------*/
class DivideError
{
public:
    //存储异常的具体描述信息
    string msg;  

    //构造函数：初始化异常信息
    DivideError(string m)
        : msg(m)  
    { }
};
/* 说明：
*    1. 自定义异常类：用于表示除法运算中的错误
*    2. 推荐使用类对象传递异常信息，可包含更丰富的错误详情
*/

/*-------------------------------函数A-------------------------------*/
void funcA()
{
    //1.此处模拟检测到除数为0的错误，直接抛出自定义异常
    throw DivideError("除数不能为 0"); //异常对象包含具体的错误信息："除数不能为 0"
}
/* 说明：
*   1. 函数A：负责抛出异常的函数
*   2. 当检测到除法错误时，抛出自定义的DivideError异常对象
*/

/*-------------------------------函数B-------------------------------*/
void funcB()
{
    //1.调用可能抛出异常的函数
    funcA();  

    //2.打印提示内容
    cout << "funcB：这条语句不会执行" << endl;
}
/* 说明：
*    1. 函数B：中间调用层，不处理异常
*    2. 调用funcA()，但不捕获其抛出的异常，异常会向上传播
*/

/*-------------------------------主函数-------------------------------*/
int main()
{
    //1.try块：包裹可能抛出异常的代码
    try
    {
        funcB();  // 调用funcB()，该函数间接调用可能抛出异常的funcA()
    }

    //2.第一个catch块：专门捕获DivideError类型的异常
    catch (DivideError& e) //注：使用引用接收异常对象，避免对象拷贝，提高效率
    {
        //2.1：输出异常信息
        cout << "捕获异常：" << e.msg << endl; //通过异常对象的msg成员获取错误描述
    }

    //3.第二个catch块：捕获所有其他未被处理的异常（通配符）
    catch (...)  //注：作为兜底处理，确保所有异常都能被捕获，避免程序崩溃
    {
        cout << "捕获未知异常" << endl;
    }

    //4.异常处理完成后，程序继续执行后续代码
    cout << "程序正常结束" << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

/*----------------------------除法函数----------------------------*/
double Divide(int a, int b) 
{
    //1.包裹可能出现异常的代码
    try
    {
        //1.1：当除数 b 为 0 时抛出异常
        if (b == 0)
        {
            //第一步：定义一个局部字符串对象，存储异常信息
            string s("Divide by zero condition!");

            //第二步：抛出异常类型为 string（实际是抛出局部对象的拷贝）
            throw s;
        }

        //1.2：正常除法运算返回结果
        else
        {
            return ((double)a / (double)b);
        }
    }
    //2.捕获int类型的异常
    catch (int errid) //注意：仅处理 int 类型的异常
    {
        cout << errid << endl; // 若捕获到 int 类型异常，输出错误码
    }
    return 0;
}


/*----------------------------功能函数----------------------------*/
void Func() 
{
    //1.定义两个变量并输出并进行赋值
    int len, time;
    cin >> len >> time;

    //2.包裹可能出现异常的代码
    try
    {
        cout << Divide(len, time) << endl;  //调用 Divide 函数，输出结果
    }
    //3.捕获 const char* 类型的异常
    catch (const char* errmsg) 
    {
        cout << errmsg << endl; //输出 C 风格字符串的异常信息
    }

    //4.输出函数名和行号，标记函数执行到此处
    cout << __FUNCTION__ << ":" << __LINE__ << " 执行" << endl;
    /* 说明：
    *    1. __FUNCTION__：当前函数名
    *    2. __LINE__：当前行号
    */ 
}

//：
/*----------------------------主函数----------------------------*/
int main()
{
    while (1) //循环调用 Func，持续测试异常
    {
        //1.定义两个变量并输出并进行赋值
        try
        {
            // 调用 Func 函数
            Func();
        }
        //2. 捕获string 类型的异常（与 Divide 中抛出的类型匹配）
        catch (const string& errmsg)
        {
            cout << errmsg << endl; //输出 string 类型的异常信息 
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <stdexcept>  // 包含标准异常类的头文件，提供std::exception及其派生类
using namespace std;

int main()
{
    //1.创建一个vector容器并初始化
    vector<int> v = { 1, 2, 3 };

    //2.try块：包含可能抛出异常的代码
    try
    {
        //1.使用vector的at()方法会进行边界检查
        cout << v.at(10) << endl; 
        /* 说明：
        *    1. 尝试访问索引为10的元素，而容器只有3个元素（索引0,1,2）
        *    2. 此时会抛出out_of_range类型的异常
        */

        //2.打印输出信息
        cout << "元素访问成功" << endl; //注：如果上面的代码抛出异常，下面的语句不会执行
    }
    //3.第一个catch块：专门捕获out_of_range类型的异常
    catch (const out_of_range& e)  //注：out_of_range是std::exception的派生类，用于表示范围越界错误
    { 
        //3.1：调用异常对象的what()方法，获取异常的描述信息
        cout << "异常：" << e.what() << endl;
    }
    //4.第二个catch块：捕获所有其他标准异常（std::exception及其派生类）
    catch (const exception& e)  //注：作为兜底处理，确保所有标准异常都能被捕获
    {
        cout << "标准异常：" << e.what() << endl;
    }

    //5.异常处理完成后，程序继续执行
    cout << "程序继续运行..." << endl;
    return 0;
}

#include<iostream>
#include<string>
#include<thread>

#include<cstdlib>    // rand、srand所需头文件
#include<ctime>      // time函数所需头文件
#include<chrono>     // 时间相关工具（this_thread::sleep_for）
using namespace std;

// ===================== 异常类体系 =====================

/*------------------------------【异常基类设计】------------------------------*/
class Exception  //定义通用异常接口，派生出各模块异常
{ 

protected:
    string _errmsg; // 错误描述信息
    int _id;        // 错误码（可用于分类处理）

public:
    //1.构造函数：初始化错误信息和错误ID
    Exception(const string& errmsg, int id)
        :_errmsg(errmsg)
        , _id(id)
    { }

    //2.虚函数：返回异常描述（多态关键，子类需重写）
    virtual string what() const
    {
        return _errmsg;
    }

    //3.获取错误ID
    int getid() const
    {
        return _id;
    }
};


/*------------------------------【SQL模块异常】------------------------------*/
class SqlException : public Exception  //继承Exception，补充SQL语句信息
{
private:
    const string _sql; // 存储触发异常的SQL语句

public:
    //1.构造函数：传递基类参数 + SQL语句
    SqlException(const string& errmsg, int id, const string& sql)
        :Exception(errmsg, id)
        , _sql(sql)
    { }

    //2.重写what：拼接SQL异常信息
    virtual string what() const override
    {
        string str = "SqlException:";

        str += _errmsg;
        str += "->";
        str += _sql;

        return str;
    }
};


/*------------------------------【缓存模块异常】------------------------------*/
class CacheException : public Exception  //继承Exception，基础错误场景
{
public:
    //1.构造函数：传递基类参数
    CacheException(const string& errmsg, int id)
        :Exception(errmsg, id)
    { }

    //2.重写what：标识缓存异常
    virtual string what() const override
    {
        string str = "CacheException:";
        str += _errmsg;

        return str;
    }
};


/*------------------------------【HTTP模块异常】------------------------------*/
class HttpException : public Exception  //继承Exception，补充请求类型
{
private:
    const string _type; // 请求类型（如get/post）

public:
    //1.构造函数：传递基类参数 + HTTP请求类型
    HttpException(const string& errmsg, int id, const string& type)
        :Exception(errmsg, id)
        , _type(type)
    { }

    //2.重写what：拼接HTTP请求类型 + 错误
    virtual string what() const override
    {
        string str = "HttpException:";

        str += _type;
        str += ":";
        str += _errmsg;

        return str;
    }
};


// ===================== 模块功能函数 =====================

/*------------------------------【SQL管理模块】------------------------------*/
void SQLMgr() //随机触发“SQL异常”
{
    //情况一：1/7概率触发异常 ----> 这里以及下面的异常触发条件都是只是为了帮助理解，无实际意义
    if (rand() % 7 == 0)
    {
        // 抛SQL异常：带错误信息+SQL语句
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    }
    //情况二：正常调用
    else
    {
        cout << "SQLMgr 调用成功" << endl;
    }
}


/*------------------------------【缓存管理模块】------------------------------*/
void CacheMgr()  //随机触发“缓存异常”
{
    //1.
    //情况一：1/5概率触发“权限不足”
    if (rand() % 5 == 0)
    {
        throw CacheException("权限不足", 100);
    }
    //情况二：1/6概率触发“数据不存在”
    else if (rand() % 6 == 0)
    {
        throw CacheException("数据不存在", 101);
    }
    //情况三：正常调用
    else
    {
        cout << "CacheMgr 调用成功" << endl;
    }

    //2.调用SQL模块（模拟多层依赖）
    SQLMgr();
}

// ：
/*------------------------------【HTTP服务模块】------------------------------*/
void HttpServer()  //随机触发“HTTP异常”
{    
    //1.
    //情况一： 1/3概率触发“资源不存在”（get请求）
    if (rand() % 3 == 0)
    {
        throw HttpException("请求资源不存在", 100, "get");
    }
    //情况二：1/4概率触发“权限不足”（post请求）
    else if (rand() % 4 == 0)
    {
        throw HttpException("权限不足", 101, "post");
    }
    //情况三：正常调用
    else
    {
        cout << "HttpServer调用成功" << endl;
    }


    //2.调用缓存模块（模拟多层依赖）
    CacheMgr();
}


// ===================== 主逻辑 =====================
int main()
{
    //1.初始化随机数种子（按时间）
    srand(time(0));

    //2.持续模拟服务调用
    while (1)
    {
        //2.1：线程休眠1秒（避免高频输出）
        this_thread::sleep_for(chrono::seconds(1));

        //2.2：包含可能抛出异常的代码
        try
        {
            HttpServer(); // 启动HTTP服务（触发多层调用）
        }
  
        //2.3：专门：捕获基类Exception类型的异常
        catch (const Exception& e) //注意：利用多态，派生类异常会匹配到基类引用
        {
            cout << "捕获异常：" << e.what() << endl;
            cout << "错误码：" << e.getid() << endl;
        }
        //2.4：兜底：捕获所有未处理异常
        catch (...)
        {
            cout << "Unkown Exception" << endl;
        }
    }
    return 0;
}

HttpServer() → CacheMgr() → SQLMgr()  

void processRequest()
{
   //1.包含可能抛出异常的代码
   try
   {
       callService();  // 可能抛出多种异常的逻辑
   }

   //2.捕获基类异常（多态场景）
   catch (const Exception& e) 
   {
       //2.1：特殊处理特定异常
       if (typeid(e) == typeid(SqlException)) 
       {
           // 假设是数据库异常，执行回滚
           rollbackTransaction();
           cout << "已回滚事务：" << e.what() << endl;
       }
       //2.2：其他异常重新抛出
       else 
       {
           throw; // 不改变异常，继续向上传播
       }
   }
}

int main() 
{
   //1.包含可能抛出异常的代码
   try 
   {
       processRequest();
   }
   //2.最终捕获并处理所有异常
   catch (const Exception& e) 
   {
       cout << "外层处理异常：" << e.what() << endl;
   }
}

#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;


/*-------------------------基类异常-------------------------*/
class Exception
{
public:
    //1.纯虚函数what：返回异常的“描述信息”
    // 作用：多态调用时，能返回具体异常的详细说明（如 "网络不稳定"）
    virtual string what() const = 0;

    //2.纯虚函数getid：返回异常的“错误码”
    // 作用：用于分类处理异常（如：102 代表网络错误、103 代表业务错误）
    virtual int getid() const = 0;

    //3.虚析构函数~Exception：
    //  1）确保派生类对象销毁时，先调用派生类析构，再调用基类析构
    //  2）使用 =default 让编译器生成默认实现，简洁且符合规范
    virtual ~Exception() = default;
};


/*-------------------------HTTP 异常-------------------------*/
class HttpException : public Exception
{
private:
    string _msg;    // 异常的具体描述信息（如："网络不稳定，发送失败"）
    int _id;        // 异常对应的错误码（如：102 代表网络错误）
    string _type;   // HTTP 请求类型（如："put"/"get"，区分不同场景的 HTTP 操作）

public:
    //1.构造函数：初始化私有成员
    HttpException(const string& msg, int id, const string& type)
        : _msg(msg),    // 初始化异常描述
        _id(id),        // 初始化错误码
        _type(type)     // 初始化 HTTP 请求类型
    { }

    //2.重写基类的纯虚函数 what()
    string what() const override
    {
        return "HttpException: " + _type + " -> " + _msg; //返回包含 HTTP 场景信息的异常描述
    }

    //3.重写基类的纯虚函数 getid()
    int getid() const override  //返回异常对应的错误码（让外层代码通过错误码分类处理）
    {
        return _id;
    }
};



/*-------------------------模拟发送消息的底层函数-------------------------*/

void _SeedMsg(const string& s)  //可能抛出异常
{
    if (rand() % 2 == 0)  // 随机数模拟异常概率
    {
        // 抛出网络不稳定异常（102 号错误）
        throw HttpException("网络不稳定，发送失败", 102, "put");
    }
    else if (rand() % 7 == 0) 
    {
        // 抛出好友关系异常（103 号错误）
        throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
    }
    else 
    {
        // 模拟发送成功
        cout << "发送成功: " << s << endl;
    }
}

/*-------------------------封装重试逻辑的发送函数-------------------------*/

void SendMsg(const string& s)  //核心异常处理
{
    for (size_t i = 0; i < 4; ++i)  //最多重试 3 次
    {
        //1.1：包含可能抛出异常的代码
        try 
        {
            //第一步：尝试发送消息
            _SeedMsg(s);

            //第二步：发送成功则跳出循环
            break;
        }
        //1.2：捕获Exception类型的异常
        catch (const Exception& e) 
        {
            //情况一：错误码是102
            if (e.getid() == 102) 
            {
                // 重试 3 次后仍失败，重新抛出异常
                if (i == 3) 
                {
                    cout << "重试 3 次均失败，网络太差！" << endl;
                    throw;
                }

                //输出重试提示
                cout << "开始第 " << (i + 1) << " 重试" << endl;
            }

            //情况二：错误码不是102
            else 
            {
                throw; //直接重新抛出
            }
        }
    }
}


/*-------------------------主函数-------------------------*/
int main() 
{
    //1.初始化随机数种子（按当前时间）
    srand(time(0));
    //2.定义字符串来接受用户输入的消息
    string str;

    //3.持续接收用户输入
    while (cin >> str)  
    { 
        try 
        {
            //发送消息并处理可能的异常
            SendMsg(str);
        }
        catch (const Exception& e) 
        {
            //精准：输出异常详细信息
            cout << "捕获异常: " << e.what() << endl << endl;
        }
        catch (...) 
        {
            //兜底：捕获未知异常
            cout << "Unknown Exception" << endl;
        }
    }

    return 0;
}

void func()
{
    //1.申请内存资源
    int* p = new int[100]; 

    //2.中间逻辑可能抛出异常
    if (/* 某种错误条件 */)
    {
        throw "内存操作异常";
    }

    //3.正常流程下的资源释放
    delete[] p;  //注意异常安全：若异常被抛出，delete[] p 不会执行，内存无法释放，造成泄漏
}

void func()
{
    //1.申请内存资源
    int* p = new int[100];

    //2.包含可能抛出异常的代码
    try
    {
        if (/* 错误条件 */)
        {
            throw "内存操作异常";
        }
    }

    //3.捕获所有其他未被处理的异常
    catch (...)
    {
        //3.1：异常时释放资源
        delete[] p; 

        //3.2：重新抛出，让上层感知错误
        throw; 
    }

    //4.正常流程释放
    delete[] p; 
}

// 函数功能：演示使用智能指针unique_ptr实现异常安全的内存管理
void func()
{
    // 1. 使用unique_ptr智能指针管理动态数组内存
    unique_ptr<int[]> p(new int[100]);
    /* 说明：
    *    1. unique_ptr是C++11引入的智能指针，遵循RAII（资源获取即初始化）原则
    *    2. 这里分配了一个包含100个int元素的动态数组
    *    3. 模板参数<int[]>表示管理的是int类型的数组
    */

    // 2. 模拟可能抛出异常的错误检查
    if (/* 错误条件 */)  // 假设这里是某种错误条件判断，实际使用时会替换为具体的判断逻辑
    {
        //2.1：当错误条件满足时，抛出异常
        throw "内存操作异常"; //异常类型为const char*（C风格字符串），描述错误信息
    }

    // 3. 后续正常业务逻辑（此处省略）
    // ...

    // 4. 无需手动释放内存
    /* 说明：
    *    1. 无论函数是正常执行结束，还是因抛出异常而提前退出
    *    2. unique_ptr会在离开其作用域（即func()函数结束）时自动调用delete[]
    *    3. 释放所管理的动态数组内存，彻底避免内存泄漏
    */
}

class Resource
{
public:
    ~Resource()
    {
        releaseResource1(); // 释放第1个资源
        releaseResource2(); // 释放第2个资源（假设此处抛异常）
        releaseResource3(); // 若上面抛异常，这里不会执行
        // ... 后续7个资源释放逻辑
    }
private:
    void releaseResource2() 
    {
        throw "释放资源2失败";
    }
};

~Resource() 
{
    try 
    {
        releaseResource2();
    }

    catch (...) 
    {
        logError("释放资源2失败");
    }

    releaseResource3(); // 继续执行后续资源释放逻辑
}

#include <iostream>
#include <string>
using namespace std;


/*------------------------除法函数------------------------*/
double Divide(int a, int b)
{
    //1.当除数 b 为 0 时抛出异常
    if (b == 0)
    {
        //抛出 C 风格字符串异常，表示“除以 0”的错误
        throw "Division by zero condition!";
    }

    //2.正常计算除法并返回结果
    return static_cast<double>(a) / b;
}


/*------------------------功能函数------------------------*/
void Func()
{
    //1.动态分配一个大小为 10 的 int 数组（需要手动释放内存）
    int* array = new int[10];

    //2.包含可能抛出异常的代码
    try
    {
        //2.1：从控制台输入两个整数
        int len, time;
        cin >> len >> time;


        //2.2：调用 Divide 函数，可能抛出异常
        cout << Divide(len, time) << endl;
    }
    //3.捕获所有类型的异常（通配符捕获）
    catch (...)
    {
        //3.1：释放动态分配的数组内存
        cout << "delete [] " << array << endl;
        delete[] array;

        //3.2：重新抛出异常，让上层调用者继续处理
        throw; //这里不会改变异常的类型，只是将异常传递给更外层的 catch
    }

    //4.释放动态分配的数组内存
    cout << "delete [] " << array << endl; //注意：如果上面的 try 块中没有抛出异常，会执行到这里
    delete[] array;
}


/*------------------------主函数------------------------*/
int main()
{
    //1.包含可能抛出异常的代码
    try
    {
        Func(); // 调用 Func 函数，可能抛出异常
    }

    //2.捕获 const char* 类型的异常（与 Divide 中抛出的类型匹配）
    catch (const char* errmsg)
    {
        cout << errmsg << endl;  // 输出异常信息
    }
    //3.捕获 std::exception 类型的异常（C++ 标准库异常）
    catch (const exception& e)
    {
        cout << e.what() << endl; //输出异常的详细描述（通过 what() 方法）
    }
    //4.捕获所有其他类型的异常（兜底处理）
    catch (...)
    {
        cout << "Unknown Exception" << endl; // 输出未知异常的提示
    }

    return 0;
}

// 明确承诺：不会抛异常 → 调用者无需 try/catch
void sendRequest() noexcept 
{ ... }

// 明确声明：可能抛 NetworkError 或 TimeoutError → 调用者针对性捕获
void sendRequest() throw(NetworkError, TimeoutError) 
{ ... }

void func() noexcept 
{
    // 函数体中不应有 throw 语句，也不应调用可能抛异常的函数
}

// 检测 add 函数是否抛异常，决定当前函数是否声明为 noexcept
void wrapper() noexcept(noexcept(add(1, 2))) 
{
    add(1, 2); 
}

// 标准异常类的层次结构

std::exception
├── std::logic_error
│   ├── std::invalid_argument
│   ├── std::domain_error
│   ├── std::length_error
│   └── std::out_of_range
├── std::runtime_error
│   ├── std::range_error
│   ├── std::overflow_error
│   ├── std::underflow_error
│   └── std::system_error (C++11)
├── std::bad_alloc
├── std::bad_cast
└── std::bad_typeid

#include <iostream>
#include <string>
#include <stdexcept>

int main() 
{
    try 
    {
        //1.模拟容器越界访问，会抛出std::out_of_range异常
        std::string str = "hello";
        char c = str.at(10);

        //2.模拟无效参数，会抛出std::invalid_argument异常
        int num = std::stoi("abc");

        //3.模拟算术溢出，会抛出std::overflow_error异常
        int a = 2147483647;
        int b = 1;
        int result = a + b;
    }
    catch (const std::out_of_range& e) 
    {
        std::cout << "捕获到out_of_range异常: " << e.what() << std::endl;
    }
    catch (const std::invalid_argument& e) 
    {
        std::cout << "捕获到invalid_argument异常: " << e.what() << std::endl;
    }
    catch (const std::overflow_error& e)
    {
        std::cout << "捕获到overflow_error异常: " << e.what() << std::endl;
    }
    catch (const std::exception& e) 
    {
        std::cout << "捕获到其他异常: " << e.what() << std::endl;
    }
    return 0;
}

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

// 自定义异常类，继承自std::runtime_error
class MyCustomException : public std::runtime_error 
{
public:
    MyCustomException(const std::string& msg) 
        : std::runtime_error(msg) 
    {}
};

int main() 
{
    try 
    {
        // 抛出自定义异常
        throw MyCustomException("这是一个自定义的运行时异常");
    }
    catch (const MyCustomException& e) 
    {
        std::cout << "捕获到自定义异常: " << e.what() << std::endl;
    }
    catch (const std::exception& e) 
    {
        std::cout << "捕获到其他异常: " << e.what() << std::endl;
    }
    return 0;
}