C/C++编程：理解”抛出一个异常“与”传递一个参数“或“调用一个虚函数“间的差异

你的名字 2022-10-24 11:44 8阅读 0赞

从语法上看，在函数里声明参数与在catch子句中声明参数几乎没有什么差别

class Widget{..}; //一个类，具体是什么差别不重要
    
    void f1(Widget w);
    void f2(Widget &w);
    void f3(const Widget &w);
    void f4(Widget *w);
    
    ...
    catch(Widget w);
    catch(Widget& w);
    catch(const Widget& w);
    catch(Widget * w);

用throw抛出一个异常到catch子句中与通过函数调用传递一个参数有相同点也有不同点

*  相同点是：传递函数参数和catch到的异常都可以是传值、传递引用、传递指针
 *  不同点是：传递参数和异常时，系统所要完成的操作过程完全不同。产生这个差异的原因是：当你调用函数时，程序的控制权最终还是会返回到函数的调用处，但是当你抛出一个异常，控制权永远不会回到抛出异常的地方。

看个例子：

istream operator>>(istream &s, Widget &w);
    
    void passAndThrowWidget(){
    
        Widget localWidget;
        cin >> localWidget;    //传递localWidget到operator>>
        thorw localWidget;     // 抛出localWidget异常
    }

*  当传递一个localWidget到函数operator>>里，不用进行拷贝操作，而是把operator>>内的引用类型变量w指向localWidget，任何对w的操作实际上都施加到localWidget上。这与抛出localWidget异常有很大不同
 *  不论是通过传值捕获异常还是通过引用捕获(不能通过指针捕获这个异常，因为类型不匹配)都将进行localWidget的拷贝操作，也就是说传递到catch子句中的是localWidget的拷贝。必须这么做，因为当localWidget离开了生存空间后，其析构函数将被调用。如果localWidget本身传递给catch子句1，这个子句收到的只是一个被析构了的Widget，一个Widget的”尸体“。这是无法使用的。因此**C++规范要求被作为异常抛出的对象必须被复制**。

即使被抛出的对象不会被释放，也就进行拷贝操作。比如如果localWidget为静态变量时：

istream operator>>(istream &s, Widget &w);
    
    void passAndThrowWidget(){
    
        static Widget localWidget;
        cin >> localWidget;    //和上面一样运行
        thorw localWidget;     // 仍将对localWidget进行拷贝操作
    }

*  这也给暗示了不可能在catch块中修改localWidget：仅仅能修改localWidget的副本。
 *  对异常进行强制复制操作，这个限制有助于我们理解参数传递与抛出异常的第一个差异：**抛出异常运行速度比参数传递要慢**

**当异常对象被拷贝时，拷贝操作是由对象的拷贝构造函数完成的。该拷贝构造函数是对象的静态类型所对应的拷贝构造函数，而不是对象的动态类型对应的拷贝构造函数**。（不过由一种技巧可以让你根据对象的动态类型进行拷贝）比如：

class Widget{};
    class SpecialWidget : public Widget{};
    
    void passAndThrowWidgetp(){
    
        SpecialWidget localSpecilaWidget;
        ...
        Widget & rw = localSpecilaWidget;      // rw 静态类型是Widget；动态类型是localSpecilaWidget
        throw rw;                               //它抛出一个类型为Widget的异常
        
    }

异常是其他对象的拷贝，这个事实影响你如何在catch块中再抛出一个异常。比如下面两个catch：

catch(Widget &w) {     //捕获Widget 异常
        ...                //处理异常
        throw；            //重新抛出异常，让它继续传递
    }
    
    
    catch(Widget &w) {     //捕获Widget 异常
        ...                //处理异常
        throw w；          //重新抛出异常，传递被捕获异常的拷贝
    }

*  这两个catch块的差别在于第一个catch块中重新抛出的是当前捕获的异常，而第二个catch块中重新抛出的是当前捕获异常的一个新的拷贝。
 *  第一个块中重新抛出的是当前异常，无论它是什么类型。

一般来说，应该用throw来重新抛出当前的异常，因为这样不会改变被传递出去的异常类型，而且更有效率，因为不用生成一个新拷贝。

对象作为函数传参和从异常点传递到catch子句里所采用的方法不同，这只是参数传递和异常传递的一个方面；第二个差异是在函数调用者或抛出异常者与异常捕获者之间大的类型匹配的过程不同。比如：

//double sqrt(double);
    
    int i;
    double sqrtOfi = sqrt(i);   //C++允许int到double的隐式类型转换

毫无疑问，C++允许进行int到double的隐式类型转换。但是一般来说，catch子句匹配异常类型时不会进行这样的转换。比如：

void f(int value){
    
        try{
    
            if(someFunction()){
                throw value;  //抛出整形
    
            }
        }catch(double d){  //只处理double类型的异常
    
            ...
        }
    }

**在try块中抛出的int异常不会被double异常的catch子句捕获。该子句只能捕获double的异常，不能进行类型转换。如果想要捕获int异常，必须使用带有int或int&参数的catch子句。**

不过在catch子句中进行异常匹配时可以进行两者类型转换：

*  **继承类与基类间的转换** ,**捕获基类的catch子句也可以处理派生类的异常**。

比如标准C++库定义的异常类层次中的诊断部分捕获runtime\_errors异常的catch子句可以捕获range\_error类型和overflow\_error类型。比如接受根类exception异常的catch子句能够捕获任意派生类的异常

这种派生类与基类间的异常转换可以作用于数值、引用以及指针上：

catch(runtime_error)...
    catch(runtime_error&)...
    catch(const runtime_error&)...
    
    catch(runtime_error*)...
    catch(const runtime_error*)...

*  **允许从一个类型化的指针转换为无类型指针**，所以带有const void\*指针的catch子句能够捕获任何类型的指针异常

catch(const void *) ...   //捕获任何指针类型异常

传递参数和传递异常间的最后一点差别是catch子句匹配顺序总是取决于它们在程序中出现的顺序（最近）。因此一个派生类异常可能被处理其基类异常的catch子句捕获，即使同时存在有直接处理该派生类异常的catch子句，与相同的try跨相对性

try{
    
        ...
    }  catch(logic_error& ex){  //这个catch块，将捕获所有logic_error异常，包括它的派生类
    
    
    } catch(invalid_argument &ex){  //永远不会执行，因为invalid_argument 是logic_error派生类
    
    
    }

而当对象调用虚拟函数时，被调用的函数位于与发出函数调用的对象的对象类型最相近的那个（最优）。

因此：不要把处理基类的catch子句放在派生类catch子句的前面

总结：把一个对象传递给函数或一个对象调用虚拟函数与把一个对象作为异常抛出的区别

*  异常对象在传递时总是被拷贝（传值方法捕获异常会拷贝两次）。对象作为函数传参时不一定被拷贝
 *  对象作为异常抛出与作为函数参数相比，前者的类型转换比后者少（前者只有两种转换形式）
 *  catch子句进行异常匹配的顺序是最先(第一个类型匹配成功的catch子句被执行)；当对象调用一个虚函数时处理顺序时最优(匹配的最好的那个)