C++抛出异常与传递参数的区别

代码便已运行环境：VS2012+Debug+Win32

1.C++异常处理基本格式

C++的异常处理机制有3部分组成：try(检查)，throw(抛出)，catch(捕获)。把需要检查的语句放在try模块中，检查语句发生错误，throw抛出异常，发出错误信息，由catch来捕获异常信息，并加以处理。一般throw抛出的异常要和catch所捕获的异常类型所匹配。异常处理的一般格式为：

　　try
　　{
　　　　被检查语句
　　　　throw 异常
　　}
　　catch(异常类型1)
　　{
　　　　进行异常处理的语句1
　　}
　　catch(异常类型2)
　　{
　　　　进行异常处理的语句2
}
catch(...)    // 三个点则表示捕获所有类型的异常  
{  
进行默认异常处理的语句
}

2. 抛出异常与传递参数的区别

从语法上看，C++的异常处理机制中，在catch子句中申明参数与在函数里声明参数几乎没有什么差别。例如，定义了一个名为stuff的类，那么可以有如下的函数申明。

void f1(stuff w);
void f2(stuff& w);
void f3(const stuff& w);
void f4(stuff* p);
void f5(const stuff* p);

同样地，在特定的上下文环境中，可以利用如下的catch语句来捕获异常对象：

catch(stuff w);
catch (stuff& w);
catch(const stuff& w);
catch (stuff* p);
catch (const stuff* p);  

因此，初学者很容易认为用throw抛出一个异常到catch字句中与通过函数调用传递一个参数两者基本相同。它们有相同点，但存在着巨大的差异。造成二者的差异是因为调用函数时，程序的控制权最终还会返回到函数的调用处，但是当抛出一个异常时，控制权永远不会回到抛出异常的地方。相同点就是传递参数和传递异常都可以是传值、传引用或传指针。

下面考察二者的不同点。

（1）区别一：C++标准要求被作为异常抛出的对象必须被拷贝复制。

考察如下程序。

#include <iostream>
using namespace std;

class Stuff{
    int n;
    char c;
public:
    void addr(){
        cout<<this<<endl;
    }
    friend istream& operator>>(istream&, Stuff&);
};

istream& operator>>(istream& s, Stuff& w){
    w.addr();
    cin>>w.n;
    cin>>w.c;
    cin.get();//清空输入缓冲区残留的换行符
    return s;
}

void passAndThrow(){
    Stuff localStuff;
    localStuff.addr();
    cin>>localStuff;   //传递localStuff到operator>>
    throw localStuff;  //抛出localStuff异常
}

int main(){
    try{
        passAndThrow();
    }
    catch(Stuff& w){
        w.addr();
    }
}

程序的执行结果是：
0025FA20
0025FA20
5 c
0025F950

在执行输入操作是，实参localStuff是以传引用的方式进入函数operator>>，形参变量w接收的是localStuff的地址，任何对w的操作但实际上都施加到localStuff上。在随后的抛出异常的操作中，尽管catch子句捕捉的是异常对象的引用，但是捕捉到的异常对象已经不是localStuff，而是它的一个拷贝。原因是throw语句一旦执行，函数passAndThrow()的执行也将结束，localStuff对象将被析构从而结束其生命周期。因此需要抛出localStuff的拷贝。从程序的输出结果也可以看出在catch子句中捕捉到的异常对象的地址与localStuff不同。

即使被抛出的对象不会被释放，即被抛出的异常对象是静态局部变量，甚至是全局性变量，而且还可以是堆中动态分配的异常变量，当被抛出时也会进行拷贝操作。例如，如果将passAndThrow()函数声明为静态变量static，即：

void passAndThrow(){
    static Stuff localStuff;
    localStuff.addr();
    cin>>localStuff;   //传递localStuff到operator>>
    throw localStuff;  //抛出localStuff异常
}

当抛出异常时仍将复制出localStuff的一个拷贝。这表示尽管通过引用来捕捉异常，也不能在catch块中修改localStuff，仅仅能修改localStuff的拷贝。C++规定对被抛出的任何类型的异常对象都要进行强制复制拷贝， 为什么这么做，我目前还不明白。

（2）区别二：因为异常对象被抛出时需要拷贝，所以抛出异常运行速度一般会比参数传递要慢。

当异常对象被拷贝时，拷贝操作是由对象的拷贝构造函数完成的。该拷贝构造函数是对象的静态类型（static type）所对应的类的拷贝构造函数，而不是对象的动态类型（dynamic type）对应类的拷贝构造函数。

考察如下程序。

#include <iostream>
using namespace std;

class Stuff{
    int n;
    char c;
public:
    Stuff(){
        n=c=0;
    }
    Stuff(Stuff&){
        cout<<"Stuff's copy constructor invoked"<<endl;
        cout<<this<<endl;
    }

    void addr(){
        cout<<this<<endl;
    }
};


class SpecialStuff:public Stuff{
    double d;
public:
    SpecialStuff(){
        d=0.0;
    }

    SpecialStuff(SpecialStuff&){
        cout<<"SpecialStuff's copy constructor invoked"<<endl;
        addr();
    }
};

void passAndThrow(){
    SpecialStuff localStuff;
    localStuff.addr();
    Stuff& sf=localStuff;   
    cout<<&sf<<endl;
    throw sf;               //抛出Stuff类型的异常
}

int main(){
    try{
        passAndThrow();
    }
    catch(Stuff& w){
        cout<<"catched"<<endl;
        cout<<&w<<endl;
    }
}

程序输出结果：
0022F814
0022F814
Stuff’s copy constructor invoked
0022F738
catched
0022F738

程序输出结果表明，sf和localStuff的地址是一样的，这体现了引用的作用。把一个SpecialStuff类型的对象当做Stuff类型的对象使用。当localStuff被抛出时，抛出的类型是Stuff类型，因此需要调用Stuff的拷贝构造函数产生对象。在catch中捕获的是异常对象的引用，所以拷贝构造函数构造的Stuff对象与在catch块中使用的对象w是同一个对象，因为他们具有相同的地址0x0022F738。

在上面的程序中，将catch字句做一个小的修改，变成：

catch(Stuff w){…}

程序的输出结果就变成：
0026FBA0
0026FBA0
Stuff’s copy constructor invoked
0026FAC0
Stuff’s copy constructor invoked
0026FC98
catched
0026FC98

可见，类Stuff的拷贝构造函数被调用了2次。这是因为localStuff通过拷贝构造函数传递给异常对象，而异常对象又通过拷贝构造函数传递给catch字句中的对象w。实际上，抛出异常时生成的异常对象是一个临时对象，它以一种程序猿不可见的方式在发挥作用。

（3）区别三：参数传递和异常传递在类型匹配的过程不同，catch字句在类型匹配时比函数调用时类型匹配的要求要更加严格。
考察如下程序。

#include <math.h>
#include <iostream>
using namespace std;

void throwint(){
    int i=5;
    throw i;
}

double _sqrt(double d){
    return sqrt(d);
}

int main(){
    int i=5;
    cout<<"sqrt(5)="<<_sqrt(i)<<endl;
    try{
        throwint();
    }
    catch(double){
        cout<<"catched"<<endl;
    }
    catch(...){
        cout<<"not catched"<<endl;
    }
}

程序输出：
sqrt(5)=2.23607
not catched

C++允许从int到double的隐式类型转换，所以函数调用_sqrt(i)中，i被悄悄地转变为double类型，并且其返回值也是double。一般来说，catch字句匹配异常类型时不会进行这样的转换。可见catch字句在类型匹配时比函数调用时类型匹配的要求要更加严格。

不过，在catch字句中进行异常匹配时可以进行两种类型转换。第一种是继承类与基类见的抓换。即一个用来捕获基类的catch字句可以处理派生类类型的异常。这种派生类与基类间的异常类型转换可以作用于数值、引用以及指针。第二种是允许从一个类型化指针（typed pointer）转变成无类型指针（untyped pointer），所以带有const void*指针的catch字句能捕获任何类型的指针类型异常。

（4）区别四：catch字句匹配顺序总是取决于它们在程序中出现的顺序。函数匹配过程则需要按照更为复杂的匹配规则来顺序来完成。

因此，一个派生类异常可能被处理其基类异常的catch字句捕获，即使同时存在有能处理该派生类异常的catch字句与相同的try块相对应。考察如下程序。

#include <iostream>
using namespace std;

class Stuff{
    int n;
    char c;
public:
    Stuff(){
        n=c=0;
    }
};

class SpecialStuff:public Stuff{
    double d;
public:
    SpecialStuff(){
        d=0.0;
    }
};

int main(){
    SpecialStuff localStuff;
    try{
        throw localStuff;  //抛出SpecialStuff类型的异常
    }
    catch(Stuff&){
        cout<<"Stuff catched"<<endl;
    }
    catch(SpecialStuff&){
        cout<<"SpecialStuff catched"<<endl;
    }
}

程序输出：
Stuff catched

程序中被抛出的对象是SpecialStuff类型的，本应由catch(SpecialStuff&)字句捕获，但由于前面有一个catch(Stuff&)，而在类型匹配时是允许在派生类和基类之间进行类型转换的，所以最终是由前面的catch子句将异常捕获。不过，这个程序在逻辑上多少存在一些问题，因为处在前面的catch字句实际上阻止了后面的catch子句捕获异常。所以，当有多个catch字句对应同一个try块时，应该把捕获派生类对象的catch字句放在前面，而把捕获基类对象的catch子句放在后面。否则，代码在逻辑上是错误的，编译器也会发出警告。

与上面这种行为相反，当调用一个虚拟函数时，被调用的函数是由发出函数调用的对象的动态类型(dynamic type)决定的。所以说，虚拟函数采用最优适合法，而异常处理采用的是最先适合法。

3.总结

综上所述，把一个对象传递给函数（或一个对象调用虚拟函数）与把一个对象作为异常抛出，这之间有三个主要区别。
第一，把一个对象作为异常抛出时，总会建立该对象的副本。并且调用的拷贝构造函数是属于被抛出对象的静态类型。当通过传值方式捕获时，对象被拷贝了两次。对象作为引用参数传递给函数时，不需要进行额外的拷贝；
第二，对象作为异常被抛出与作为参数传递给函数相比，前者允许的类型转换比后者要少（前者只有两种类型转换形式）；
第三，catch子句进行异常类型匹配的顺序是它们在源代码中出现的顺序，第一个类型匹配成功的catch将被用来执行。

参考文献

[1]陈刚.C++高级进阶教程[M].武汉：武汉大学出版社，2008[P355-P364]
[2]http://blog.csdn.net/hanchaoman/article/details/5914204
[3]http://dev.yesky.com/171/2602671.shtml