cpp_12_异常处理

发布时间:2024年01月21日

1? 异常理论

1.1? 何为异常?

? ? ? ? 在实际运行环境中发生,却在设计、编码、测试阶段无法预料的,各种潜在的问题。

1.2? 报告异常的2种机制

? ? ? ? 1)通过 return?返回值报告异常信息:

? ? ? ? ? ? ? ? 所有局部对象都能正确地被析构、被释放

? ? ? ? ? ? ? ? 定位错误点,需要逐层判断,流程繁琐

? ? ? ? 2)抛出--捕获异常对象:

? ? ? ? ? ? ? ? 所有局部对象都能正确地被析构、被释放

? ? ? ? ? ? ? ? 定位错误点,可一步到位,流程简单

// return.cpp  1)通过return报告异常信息
#include <iostream>
#include <cstdio>
using namespace std;

class A {
public:
    A() {   cout << "A() is invoked" << endl;   }
    ~A() {  cout << "~A() is invoked" << endl;  }
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int foo() {
    cout << "foo出错前的几百行代码" << endl;
    A a;
    FILE* pfile = fopen("./cfg", "r");
    if( !pfile ) 
        return -1; // (1)将数据返回给调用者 (2)跳转至右花括号
    cout << "foo出错后的几百行代码" << endl;
    return 0;
} // a.~A()  释放a本身所占内存空间

int bar() {
    cout << "bar出错前的几百行代码" << endl;
    A b;
    if( foo()==-1 )
        return -1;
    cout << "bar出错后的几百行代码" << endl;
    return 0;
} // b.~A()  释放b本身所占内存空间

int hum( ) {
    cout << "hum出错前的几百行代码" << endl;
    A c;
    if( bar()==-1 )
        return -1;
    cout << "hum出错后的几百行代码" << endl;
    return 0;
} // c.~A()  释放c本身所占内存空间

int main( void ) {
    cout << "main出错前的几百行代码" << endl;
    A d;
    if( hum()==-1 )
        return -1;
    cout << "main出错后的几百行代码" << endl;
    return 0;
} // d.~A()  释放d本身所占内存空间

2? 抛出异常(throw异常对象)

? ? ? ? 1)可以抛出基本类型的对象,如:

? ? ? ? ? ? ? ? throw? -1;

? ? ? ? ? ? ? ? throw? "内存分配失败";

? ? ? ? 2)可以抛出类类型的对象,如:

? ? ? ? ? ? ? ? MemoryException? ex;

? ? ? ? ? ? ? ? throw? ex;? // 栈对象

? ? ? ? ? ? ? ? throw? MemoryException();? // 匿名堆对象

? ? ? ? 3)但不要抛出局部对象的指针,如:

? ? ? ? ? ? ? ? MemoryException? ex;

? ? ? ? ? ? ? ? throw? &ex;? // 错误!(同C中,不要返回局部变量的地址)

3? 捕获异常(try? catch)

? ? ? ? try { 可能引发异常的语句; }

? ? ? ? catch ( 异常类型1&? ex?) { 针对异常类型1的异常处理;?}

? ? ? ? catch ( 异常类型2&? ex?) { 针对异常类型2的异常处理;?}

? ? ? ? ...

????????catch ( 异常类型n&? ex?) { 针对异常类型n的异常处理;?}

? ?

// throwPre.cpp 利用throw报告异常信息
//              对于能解决的异常,尽早捕获;
//              对于不能解决的异常,远点捕获,使程序尽早结束。
#include <iostream>
#include <cstdio>
using namespace std;

class A {
public:
    A() {   cout << "A() is invoked" << endl;   }
    ~A() {  cout << "~A() is invoked" << endl;  }
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo() {
    cout << "foo出错前的几百行代码" << endl;
    A a;
    FILE* pfile = fopen("./cfg", "r");
    if( !pfile ) 
        throw -1; 
    cout << "foo出错后的几百行代码" << endl;
} // a.~A()  释放a本身所占内存空间

void bar() {
    cout << "bar出错前的几百行代码" << endl;
    A b;
//    try {
        foo();
//    }
//    catch( int e ) {
//        cout << "bar函数中捕获异常信息: " << e << endl;
//    }
    cout << "bar出错后的几百行代码" << endl;
} // b.~A()  释放b本身所占内存空间

void hum( ) {
    cout << "hum出错前的几百行代码" << endl;
    A c;
//    try {
        bar();
//    }
//    catch( int e ) {
//        cout << "hum函数中捕获异常信息: " << e << endl;
//    }
    cout << "hum出错后的几百行代码" << endl;
} // c.~A()  释放c本身所占内存空间

int main( void ) {
    cout << "main出错前的几百行代码" << endl;
    A d;
    try {
        hum();
    }
    catch( int e ) {
        cout << "main函数中捕获异常信息: " << e << endl;
    }
    cout << "main出错后的几百行代码" << endl;
    return 0;
} // d.~A()  释放d本身所占内存空间

?

4? 建议、要求、总结

? ? ? ? 1)建议:在catch子句中使用引用接收异常对象,减少一次克隆。

? ? ? ? ? ? ?建议:以匿名临时对象的形式抛出异常,编译器优化会减少一次克隆。

? ? ? ? 2)对于能解决的异常,尽早捕获;对于不能解决的异常,远点捕获,使程序尽早结束。

? ? ? ? 3)要求:异常对象必须允许被拷贝构造和析构

? ? ? ? 4)匹配顺序:根据异常对象的类型,自上至下顺序匹配,而非最优匹配?

? ? ? ? ? ? ? 因此对子类类型异常的捕获,要放在对基类类型异常的捕获之前。

? ? ? ? 5)可以抛出基本类型类类型的异常,建议抛类类型的异常,携带更多诊断信息,以便查错

? ? ? ? 6)可在catch中继续抛出所捕获的异常,或其他异常

? ? ? ? 7)任何未被捕获的异常,默认的处理方式就是中止进程?

? ? ? ? 8)忽略异常:捕获异常,但不做处理:? catch (...){}? ?//三个点

// 关于 异常处理的 几点建议
#include <iostream>
#include <cstdio>
using namespace std;

class A {
public:
    A() {}
    A( const A& that ) { cout << "A类的拷贝构造函数被调用" << endl; }
    ~A() {}
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {
    A a;
    throw A(); //建议抛出的为 匿名临时对象(编译器将优化,减少1次克隆)
}
int main( void ) {
    try {
        foo();
    }
    catch( A& e ) { // 建议利用引用 接收异常对象,减少1次克隆
        // ...
    }
    return 0;
}
// throw2.cpp 建议将 子类类型异常捕获 放在 基类类型异常捕获 之前
//                  (顺序匹配,而非最优匹配)
#include <iostream>
#include <cstdio>
using namespace std;

class A {};
class B : public A {};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {
    throw B();
}
int main( void ) {
    try {
        foo();
    }
    catch( B& e ) { // 对子类类型异常的捕获
        cout << "B类型的catch捕获" << endl;
    }
    catch( A& e ) { // 对基类类型异常的捕获
        cout << "A类型的catch捕获" << endl;
    }
    return 0;
}

5? "异常说明"

? ? ? ? 1)异常说明是函数原型的一部分,旨在说明函数可能抛出的异常类型:

? ? ? ? ? ? ? ? 返回类型? 函数名 (形参表) throw (异常类型1,异常类型2,...) { 函数体;?}

? ? ? ? 2)异常说明是一种承诺,承诺函数不会抛出 异常说明以外的异常类型:

? ? ? ? ? ? ? ? 如果抛出了异常说明以外的异常类型,该异常无法被捕获,(而被编译器捕获),进程

????????????????中止

? ? ? ? 3)隐式抛出异常的函数,也可以列出它的异常说明。

// except.cpp
// 异常说明 - 给 调用者 说明, 函数内部可能会抛出 哪些类型的异常
//         - 给 调用者 承诺, 函数内部绝对不会抛出异常说明以外异常类型
#include <iostream>
#include <cstdio>
using namespace std;

void foo() throw(int,double, const char*) { // 显式抛出异常的函数
    throw "hello world"; // 3.14; // -1;
}

void bar() throw(int,double, const char*) { // 隐式抛出异常的函数
    foo();
    // 调用几十个不同函数,而且每个函数都可能抛出异常,并且抛出的异常类型都不相同
}

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    try {
        bar();
//        foo();    
    }
    catch(int& e) {
        cout << "1. 捕获异常信息:" << e << endl;
    }
    catch(double& e) {
        cout << "2. 捕获异常信息:" << e << endl;
    }
    catch(const char* e) {
        cout << "3. 捕获异常信息:" << e << endl;
    }
    return 0;
}

? ? ? ? 4)异常说明可以没有,也可以为空

? ? ? ? ? ? ? ? 没有,表示可能抛出任何类型的异常? ?void foo (void)? ? ? ? ? ? ?{ ... }

? ? ? ? ? ? ? ? 为空,表示不会抛出任何类型的异常? ?void foo (void) throw() { ... }

? ? ? ? 5)异常说明在函数的声明定义中必须保持严格一致,否则编译报错。

// except2.cpp
// 没有异常说明 - 给 调用者 承诺,函数内部可能抛出任何类型的异常
// 异常说明为空 - 给 调用者 承诺,函数内部不抛出任何类型的异常
#include <iostream>
#include <cstdio>
using namespace std;

void foo() {
    throw "hello world"; // 3.14; // -1;
}

void bar() throw() {
    throw -1;
}

void hum() throw(int,double); // 声明

void hum() throw(int,double) { // 定义

}

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    try {
//        bar();
        foo();    
    }
    catch(...) { // 捕获异常,但不处理
        
    }
    /*
    catch(int& e) {
        cout << "1. 捕获异常信息:" << e << endl;
    }
    catch(double& e) {
        cout << "2. 捕获异常信息:" << e << endl;
    }
    catch(const char* e) {
        cout << "3. 捕获异常信息:" << e << endl;
    }
    */
    return 0;
}

6? 构造函数中的异常

? ? ? ? 1)构造函数可以抛出异常,某些时候还必须抛出异常

? ? ? ? ? ? - 构造过程中可能遇到各种错误,比如内存分配失败

? ? ? ? ? ? - 构造函数没有返回值,无法通过返回值通知调用者

? ? ? ? 2)构造函数抛出异常,对象将被不完整构造,这个对象的析构函数永不执行

? ? ? ? ? ? - 所有对象形式的成员变量,在抛出异常的瞬间,能得到正确地析构(构造函数的回滚机制)

? ? ? ? ? ? - 所有动态分配的资源,必须在抛出异常之前,自己手动释放,否则形成资源的泄露

// consExcept.cpp 构造函数中的异常
#include <iostream>
#include <cstdio>
using namespace std;

class A {
public:
    A() { cout << "A() is invoked" << endl; }
    ~A() { cout << "~A() is invoked" << endl; }
};
class C {
public:
    C() : m_p(new int) {
        //【A m_a;】定义m_a,利用m_a.A()
        //【int* m_p=new int;】定义m_p,初值为指向一块堆内存(动态资源)
        cout << "C() is invoked" << endl;
        FILE* pfile = fopen("./file", "r");
        if( !pfile ) {
            delete m_p; // 动态资源需要自己手动释放
            // 对于m_a,利用 m_a.~A()         //回滚机制
            // 释放 m_a/m_p 本身所占内存空间  //回滚机制
            throw -1;
        }
        // ... 构造函数后续代码...
    }
    ~C() {
        delete m_p;
        cout << "~C() is invoked" << endl;
        // 对于m_a,利用 m_a.~A()
        // 释放 m_a/m_p 本身所占内存空间
    }
private:
    A m_a;
    int* m_p;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    try {
        C c; // 定义c,利用c.C()
    } // 如果c是完整构造的对象,将利用c.~C() , 但是如果c是残缺对象将不会调用~C()
    catch( ... ) {
    }
    return 0;
}

7? 析构函数中的异常

? ? ? ? 1)析构函数中主动抛出异常

? ? ? ? ? ? ? 在两种情况下,析构函数会被调用

? ? ? ? ? ? ? ? ? ? ? ? 一:正常销毁对象:离开作用域或显式delete

? ? ? ? ? ? ? ? ? ? ? ? 二:在异常传递的堆栈辗转开解(stack-unwinding)过程中

? ? ? ? ? ? ? 对于第二种情况,异常正处于激活状态,而析构函数也抛出了异常,即同时有两个

? ? ? ? ? ? ? 异常,这时C++将通过std::terminate()函数,令进程中止。这是不希望发生的~

? ? ? ? 2)对于可能引发异常的操作(被动抛异常),尽量在析构函数内部消化

??????????????????????????????????????????????????????????????try {...} catch (...) { ... }

// desconExcept.cpp 不 在析构函数中 "主动" 抛出异常
#include <iostream>
#include <cstdio>
using namespace std;

void foo() {
    throw "foo函数中抛出的异常";
}

void bar() {
    throw "bar函数中抛出的异常";
}

class A {
public:
    ~A() { 
        try {
            bar();
        }
        catch( const char* e ) {
            cout << "析构函数中捕获异常信息: " << e << endl;
        }
//        throw "析构函数中抛出的异常";
    }
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    try {
        A a;
        foo();
        //...后续代码...

    } // a.~A()  ...
    catch( const char* e ) {
        cout << "main中捕获异常信息: " << e << endl;
    }
    return 0;
}

8? 标准库异常类

? ? ? ? 建议抛以下类的异常:

????????

// exceptPractice 捕获异常练习
#include <iostream>
#include <stdexcept> //std::bad_alloc
#include <typeinfo>  //std::bad_cast
using namespace std;

/*
int main( void ) {
    try {
        new int[0xFFFFFFFFF];    
    }
    catch( bad_alloc& e ) {
        cout << "new 操作符申请内存失败" << endl;
    }
}
*/


class A {
public:
    virtual void foo() {}
};
class B : public A {};
class C : public B {};


int main( void ) {
    B b;
    A& a = b;
    try {
        dynamic_cast<C&>(a); // 如果成功 C类型的引用 引用了 B类对象 (有风险)
    }
    catch( bad_cast& e ) {
        cout << "动态类型转换失败" << endl;
    }
}

文章来源:https://blog.csdn.net/qq_33331020/article/details/135609313
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。