作用

简单说，异常处理机制主要作用是让程序能够继续执行，或者以一种可控的方式终止，而非让程序因为错误直接崩溃

一个简单的动态数组类，来看看有异常捕获和无异常捕获的区别

1. 无异常捕获

先注释掉 main 函数中的 try-catch
输入数组元素个数 5 ，然后设置下标为 5 的元素值为任意整数，这里假设为111

#include <iostream>
#include <cstddef>    // size_t
#include <stdexcept>  // out_of_range
#include <cstdlib>    // rand exit
using namespace std;

class DynamicArray
{
private:
    int* m_arr;     // 动态分配内存
    size_t m_size;  // 数组大小
public:
    DynamicArray(size_t n = 1) :m_size(n)// 默认数组有一个元素
    {
        try
        {
            m_arr = new int[m_size]();  // 初始化为零    
        }
        catch (const bad_alloc& e)
        {
            cerr << "动态数组内存申请失败: " << e.what() << endl;
            exit(1);   // 如果内存分配失败，退出程序
        }
    }
    // 内存分配异常捕获放在构造函数里
    // 如果内存分配失败，程序就没有足够的资源来正常工作
    // 此时退出程序,给出友好的错误信息

    ~DynamicArray()
    {
        delete[] m_arr;  // 释放内存
    }

    // 获取数组大小
    size_t getSize() const
    {
        return m_size;  // 获取数组大小
    }

    // 设置指定位置的元素值
    void set(size_t index, int value)
    {
        if (index >= m_size)
        {
            throw out_of_range("越界");
           
        }
        m_arr[index] = value;
    }

    // 输出数组所有元素
    void print()
    {
        int i;
        for (i = 0; i < m_size; i++)
        {
            cout << m_arr[i] << "\t";
        }
        cout << "\n\n";
    }
};

int main() 
{
    srand(unsigned(time(NULL)));
    while (1)
    {
        cout << "请输入数组元素个数：";
        int n;
        cin >> n;
        DynamicArray  array(n);   // 动态数组对象
        int i;
        int x;


        //try  //对于可恢复的错误，抛出异常并让外部调用者来处理
        //{
            cout << "输入x 设置下标为x的元素值为111" << endl;
            cin >> x;
            array.set(x, 111);
        //}
        //catch (const out_of_range& e)
        //{
        //    cerr << "ERROR: " << e.what() << endl;
        //    continue;
        //}
    }   
    return 0;
}

程序直接运行中崩溃，中止

2. 有异常捕获

将 main 函数中的 try-catch 注释行恢复
输入数组元素个数 5 ，然后设置下标为 5 的元素值为任意整数，这里假设为111
当发生异常时（比如数组越界），程序不退出， continue 跳过当前循环并提示用户重新输入

#include <iostream>
#include <cstddef>    // size_t
#include <stdexcept>  // out_of_range
#include <cstdlib>    // rand exit
using namespace std;

class DynamicArray
{
private:
    int* m_arr;     // 动态分配内存
    size_t m_size;  // 数组大小
public:
    DynamicArray(size_t n = 1) :m_size(n)// 默认数组有一个元素
    {
        try
        {
            m_arr = new int[m_size]();  // 初始化为零    
        }
        catch (const bad_alloc& e)
        {
            cerr << "动态数组内存申请失败: " << e.what() << endl;
            exit(1);   // 如果内存分配失败，退出程序
        }
    }
    // 内存分配异常捕获放在构造函数里
    // 如果内存分配失败，程序就没有足够的资源来正常工作
    // 此时退出程序,给出友好的错误信息

    ~DynamicArray()
    {
        delete[] m_arr;  // 释放内存
    }

    // 获取数组大小
    size_t getSize() const
    {
        return m_size;  // 获取数组大小
    }

    // 设置指定位置的元素值
    void set(size_t index, int value)
    {
        if (index >= m_size)
        {
            throw out_of_range("越界");   // 抛出越界异常
           
        }
        m_arr[index] = value;
    }

    // 输出数组所有元素
    void print()
    {
        int i;
        for (i = 0; i < m_size; i++)
        {
            cout << m_arr[i] << "\t";
        }
        cout << "\n\n";
    }
};

int main() 
{
    srand(unsigned(time(NULL)));
    while (1)
    {
        cout << "请输入数组元素个数：";
        int n;
        cin >> n;
        DynamicArray  array(n);   // 动态数组对象
        int i;
        int x;

        try  //对于可恢复的错误，应该抛出异常并让外部调用者来处理
        {
            cout << "输入x 设置下标为x的元素值为111" << endl;
            cin >> x;
            array.set(x, 111);
        }
        catch (const out_of_range& e)
        {
            cerr << "ERROR: " << e.what() << endl;
            cout << "\n\n";
            continue;
        }
        array.print();
    }   
    return 0;
}