【C++】异常机制

目录

异常的概念

异常的基本语法

栈解旋（unwinding）

异常接口声明

异常类型

异常对象生命周期

C++标准异常exception处理类

编写自己的异常类

继承在异常中的应用

---

异常的概念

        在 C++ 中，异常处理的过程是：某个库软件或者代码提供的机制，能在异常处理情况时发出信号，这称为抛出异常（throwing the exception）。在程序的另一个地方，需要添加合适的代码处理异常情况，这称为处理异常（handing the exception）。这种编程方式可生成更有条理的代码

• C 语言处理异常的方式

int test(int x, int y) {
    if (!y) return -1; // 用 -1 表示失败
    else return x / y;
}

用 -1 表示失败，但是如果传入的 x 和 y 为 10 和 -10 时，是允许的，但返回的 -1 却也可以是失败的意思

• C++异常优点

1. 函数返回值可以忽略，异常不可以忽略。如果程序出现异常，但没有被获取，程序就会终止，使程序更具有健壮性，而如果使用 C语言 的 error 宏或者函数返回值，调用者可能会忘记检查，从而没有对错误进行处理，产生错误结果
2. 整形返回值没有任何语义信息，异常包含语义信息
3. 整形返回值缺乏相关的上下文信息，异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息
4. 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在多个函数的调用栈中出现了某个错误，使用整形返回码要求你在每一级函数中都要进行处理，而使用异常处理的栈展开机制，只需要在一处进行处理就可以，需要每级函数都处理

---

异常的基本语法

抛出异常：可以使用 throw 语句在代码块中的任何地方抛出异常，throw 语句的操作数可以是任意的表达式（常量或者变量表达式），表达式的结果的类型决定抛出异常的类型

int divide(int x, int y) {
    if (!y) {
        throw y; // 抛异常
    }
    return x / y;
}

捕获异常：catch 块跟在 try 块后面，用于捕获异常，可以指定想要捕获的异常类型，类型由 catch 关键字后面的括号内的异常声明决定的。

try
{
   // 保护代码
}catch( ExceptionName e )
{
  // 能处理任何异常的代码
}

捕获任意异常：如果想让 catch 块能处理 try 块抛出的任何类型异常，则可以在异常声明的括号里使用 ...

try
{
   // 保护代码
}catch(...)
{
  // 能处理任何异常的代码
}

小示例

代码示例：

#include
using namespace std;
 
int divide(int x, int y) {
    if (y == 0) {
        throw y; // 抛异常
    }
    return x / y;
}
 
// 异常基本语法
void test01() {
    // 试着捕获异常
    try {
        divide(10, 0);
    }
 
    // 异常根据类型进行匹配
    catch(int e) {      
        cout << "除数为 " << e <<  endl;
    }
}
 
int main() {
    test01();
    system("pause");
    return 0;
}

运行结果：

C++异常是必须处理的，一场会随着函数不断往上走，直到捕获异常，且可以跨函数

测试代码：

#include
using namespace std;
 
int divide(int x, int y) {
    if (y == 0) {
        throw y; // 抛异常
    }
    return x / y;
}
 
void CallDivide(int x, int y) {
    divide(x, y);
}
 
void test02() {
    try {
        CallDivide(10, 0);
    } catch (int e) {
        cout << "除数为 " << e << endl;
    }
}
 
int main() {
    test02();
    system("pause");
    return 0;
}

运行结果：

---

栈解旋（unwinding）

        异常被抛出后，从进入 try 块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序和构造的顺序相反，这一过程称为栈的解旋（unwinding）

#include
using namespace std;
 
class Person {
public:
    Person() {
        cout << "Person 构建" << endl;
    }
    ~Person() {
        cout << "Person 析构" << endl;
    }
};
 
int divide2(int x, int y) {
    Person p1, p2;
 
    if (!y) throw y; // 抛出异常，可以理解为函数退出
 
    // 下面的都不执行，Person类的对象也就析构了
    cout << "不会打印" << endl;
 
    return x / y;
}
 
int main() {
    try {
        divide2(10, 0);
    }
    catch (int) {
        cout << "异常捕获" << endl;
    }
    system("pause");
    return 0;
}

运行结果：

---

异常接口声明

• 为加强程序的可读性，可以在函数声明中列出抛出异常的所有类型，例如 void func() throw(A, B, C);，就只能抛出 A，B，C及其子类型的异常
• 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如：void func()
• 一个不抛任何类型异常的函数可以声明为：void func() throw()
• 如果一个函数抛出了它的异常接口声明锁不允许抛出异常，unexcepted 函数会被调用，该函数默认行为调用 terminate 函数中断程序

• 函数 func01() 只能抛出 int，float，char 三种类型异常，抛出其他类型就会报错 

void func01()throw(int, float, char) {
 
}

•  函数 func02() 不能抛出任何异常

void finc02()throw() {
 
}

• 函数 func03() 可以抛出任何异常

void func03() {
 
}

---

异常类型

• throw 的异常是有类型的，可以是数字，字符串，类对象
• throw 的异常有类型，catch 需严格匹配异常类型

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
 
void func01() {
    throw 1; // 抛出 int 类型异常
}
 
void func02() {
    throw "exception"; // 抛出 const char* 类型异常
}
 
// 自定义的异常类
class MyException {
public:
    // 有参构造
    MyException(const char* str) {
        error = new char[strlen(str) + 1];
        strcpy(error, str);
    }
    // 拷贝构造
    MyException(const MyException& me) {
        this->error = new char[strlen(me.error) + 1];
        strcpy(this->error, me.error);
    }
    // 重载 = ，深拷贝
    MyException& operator=(const MyException& me) {
        if (this->error != NULL) {
            delete[] error;
            error = NULL;
        }
        this->error = new char[strlen(me.error) + 1];
        strcpy(this->error, me.error);
        return *this;
    }
    void what() {
        cout << error << endl;
    }
    // 析构
    ~MyException() {
        if (error != NULL) {
            delete[] error;
            error = NULL;
        }
    }
public:
    char* error;
};
 
void func03() {
    throw MyException("<异常信息>"); // 抛出匿名对象异常
}
 
void test01() {
    try {
        func01();
    }
    catch (int) {
        cout << "异常捕获" << endl;
    }
//-----------------------------------
    try {
        func02();
    }
    catch (const char*) {
        cout << "异常捕获" << endl;
    }
//-----------------------------------
    try {
        func03();
    }
    catch (MyException e) {
        e.what(); // 调用异常对象
    }
//-----------------------------------
}
 
int main() {
    test01();
    system("pause");
    return 0;
}

---

异常对象生命周期

catch 捕获完后生命周期结束

普通的 = 方式取捕获

// 自定义异常类
class MyException {
public:
    // 构造
    MyException() {
        cout << "构造函数" << endl;
    }
    // 拷贝构造
    MyException(const MyException& me) {
        cout << "拷贝构造" << endl;
    }
    // 析构
    ~MyException() {
        cout << "析构函数" << endl;
    }
};
 
void func() {
    throw MyException(); // 创建匿名对象，调用构造
}
 
void test01() {
 
    // 普通元素，异常对象 catch 处理完后就析构
    try {
        func();
    }
    catch (MyException ex) // 调用拷贝构造
    {
        cout << "异常捕获" << endl;
    }
}

运行结果：

 先在抛出异常匿名对象时调用构造函数，然后捕获异常匿名对象调用拷贝构造函数，最后在处理完异常匿名对象调用析构函数。

引用 & 的方式捕获

// 自定义异常类
class MyException {
public:
    // 构造
    MyException() {
        cout << "构造函数" << endl;
    }
    // 拷贝构造
    MyException(const MyException& me) {
        cout << "拷贝构造" << endl;
    }
    // 析构
    ~MyException() {
        cout << "析构函数" << endl;
    }
};
 
void func() {
    throw MyException(); // 创建匿名对象，调用构造
}
 
void test02() {
 
    // 引用 不用调用拷贝构造，异常对象 catch 处理完析构
    try {
        func();
    }
    catch (MyException& ex) // 不调用拷贝构造
    {
        cout << "异常捕获" << endl;
    }
}

运行结果：

 在抛出异常匿名对象时调用构造函数，引用是给匿名对象其的别名，没有调用拷贝构造函数，最后在异常处理结束后匿名对象调用析构函数。

指针 * 的方式捕获

// 自定义异常类
class MyException {
public:
    // 构造
    MyException() {
        cout << "构造函数" << endl;
    }
    // 拷贝构造
    MyException(const MyException& me) {
        cout << "拷贝构造" << endl;
    }
    // 析构
    ~MyException() {
        cout << "析构函数" << endl;
    }
};
 
void func() {
    throw new MyException();
}
 
void test03() {
    
    // 指针，抛异常的时候就要抛出地址
    try {
        func();
    }
    catch (MyException* ex) // 不调用拷贝构造
    {
        cout << "异常捕获" << endl;
        delete ex; // 手动释放
    }
}

运行结果：

 指针的方式去接受匿名对象，就要在抛出异常的时候抛出地址，但要使用 new 出来的对象，因为不适用new，只是单纯的对匿名对象取地址，在函数 func3() 结束完，就被析构了，通过 new 出来的对象需要手动去释放（析构）。

---

C++标准异常exception处理类

C++给我们提供了标准的异常处理类，它用来抛出C++标准库中函数执行时的异常

使用C++自带的标准异常类，需要包含对应的头文件

C++提供的标准异常类的层次结构如图：

所有的异常类都继承自exception基类，exception类下的logic_error和runtime_error又是两个比较大类，包含有多个子类，它们分表代表逻辑类错误和运行时错误。

•  使用new开辟内存时，如果遇到空间不足，则会抛出bad_alloc异常。
• 使用dynamic_cast（）进行动态类型转化失败时，则抛出bad_typeid异常。
• 计算数值超过该类型表示的最大范围时，则抛出overflow_error异常。
• 使用string类下标但越界时，则抛出out_of_range异常。

---

编写自己的异常类

• 建议自己写的异常类要继承标准异常类，因为C++可以抛出任何异常类型，所以我们的异常类可以不继承标准异常类，但是这样可能会导致程序混乱，尤其协同开发。
• 当继承标准异常类时，应该重载父类的 what 函数和虚析构函数。
• 因为栈展开的过程中，需要复制异常类型，所以就要根据类中添加的成员考虑是否提供自己的复制构造函数。

代码示例：

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
#include
 
// 自定义异常类
class MyOutOfRange :public exception { // 继承标准异常类
public:
 
    // 有参构造
    MyOutOfRange(const char* error) {
        this->pError = new char[strlen(error) + 1];
        strcpy(this->pError, error);
    }
 
    // 析构
    ~MyOutOfRange() {
        if (pError != NULL) {
            delete[] pError;
            pError = NULL;
        }
    }
 
    // what 方法
    virtual char const* what() const {
        return pError;
    }
 
public:
    char* pError;
};
 
void func01() {
    throw MyOutOfRange("<自定义异常>");
}
 
void test01() {
    try {
        func01();
    }
    catch (exception& e) { 
        cout << e.what() << endl;
    }
}
 
int main() {
    test01();
    system("pause");
    return 0;
}

运行结果：

用基类去接受异常可以省去多个catch去捕获 

---

继承在异常中的应用

代码示例：

#include
using namespace std;
 
// 异常基类
class BaseMyException {
public:
 
    virtual void what() = 0; // 纯虚函数
 
    virtual ~BaseMyException() {} // 虚析构
};
 
// 目标文件异常类
class TargetSapceNullException :public BaseMyException {
public:
    // 重写父类纯虚函数
    virtual void what() {
        cout << "目标空间为空" << endl;
    }
    ~TargetSapceNullException() {}
};
 
// 源文件异常类
class SourceSpaceNullException :public BaseMyException {
public:
    // 重写父类纯虚函数
    virtual void what() {
        cout << "源空间为空" << endl;
    }
    ~SourceSpaceNullException() {}
};
 
void copy_str(char* target, const char* source) {
    if (target == NULL) {
        throw TargetSapceNullException();
    }
 
    if (source == NULL) {
        throw SourceSpaceNullException();
    }
 
    while (*source != '\0') {
        *target = *source;
        target++;
        source++;
    }
}
 
int main() {
 
    const char* source = "hello";
 
    char buf[1024] = { 0 };
 
    try {
        copy_str(buf, source);
    }
    catch (BaseMyException& e) {
        e.what();
    }
 
    cout << buf << endl;
 
    system("pause");
    return 0;
}

当buf位置传入空指针，source位置不为空

运行结果：

当buf位置不为空，source 位置为空指针

运行结果：