问题

• 抛出异常时发生了什么？

解答

#include <stdio.h>  #include <string.h>    #define _mNT    throw()    class Exce{   char exceName[16];  public:   Exce(const char *__name)_mNT{    strcpy(exceName,__name);    printf("Exce: %s\n",exceName);   }     ~Exce()_mNT{ printf("Exce: ~%s\n",exceName); }     Exce(const Exce & __exce)_mNT{    exceName[0]='_';exceName[1]='\0';    strcat(exceName,__exce.exceName);    printf("Exce: %s -> %s\n",      __exce.exceName,      this->exceName);   }    };    void exce1()throw(Exce){   Exce exce11("exce1");   throw exce11;   return ;  }    void exce2()throw(Exce){   Exce exce22("exce2");   try{ exce1(); }   catch(int __e){ ; }   return ;  }    void exce3()throw(Exce){   Exce exce33("exce3");   try{ exce2(); }   catch(const Exce &__e){ ; }   return ;  }    int main(int argc,char *argv[]){   exce3();   return 0;  }

Exce: exce3  Exce: exce2  Exce: exce1  Exce: exce1 -> _exce1     Exce: ~exce1  /* throw表达式没有处在try块中,所以执行堆栈展开 */  Exce: ~exce2  /* 虽然处在try快中但是没有匹配的catch子句,所以继续执行堆栈展开 */  Exce: ~_exce1  /* 找到匹配的catch子句,执行完毕后.处在全局区的异常对象会被释放 */  Exce: ~exce3

1. 在全局区创建异常对象的副本(对于类类型，调用复制构造函数，所以用作异常的类型复制构造函数必须可用) 即上方的'Exce: exce1 -> _exce1'；
2. 如果throw表达式没有处在try块中或者没有匹配的catch子句,则执行堆栈展开：
   
   • 释放函数所占的内存空间
   • 对于类类型的局部对象调用她们的析钩函数(所以析钩函数应该不抛出任何异常)来清理对象
     
3. 否则执行catch子句，并且一般情况下执行完catch子句后，处在全局区的异常对象会被释放(除非catch子句中使用了重新抛出'throw;)

抛出时对指针解引用

#include <stdio.h>    class A{  public:   A(){ printf("A\n"); }   A(const A &__a){ printf("A -> "); }   virtual ~A(){ ; }  };    class B:public A{  public:   B():A(){ printf("B\n"); }   B(const B &__b):A(){ printf("B ->"); }   virtual ~B(){ ; }  };    int main(int argc,char *argv[]){   B b;   A *a=&b;   try{    throw *a;       }catch(const B &__b){    printf("Catch: B\n");   }catch(const A &__a){    printf("Catch: A\n");   }     return 0;  }

#include <stdio.h>    struct A{      int a;      A():a(0){ printf("A:%p\n",this); }      A(const A &a){ printf("A:%p->%p\n",&a,this); }      ~A(){ printf("A:~%p\n",this); }  };    void f(){      A a1;      throw a1;      return ;  }    void f1(){      try{ f(); }      catch(A &a1){ ++__a1.a; throw; }      / throw与throw a1是不同 */      return ;  }    void f2(){      try{ f1(); }      catch(A &a){ printf("%d\n",a.a); }  }    int main(int argc,char *argv[]){      f2();      return 0;  }</pre> 
  
throw;：重新抛出，是将全局区的异常对象继续沿着函数调用链向上传递；不会释放该异常对象； 
  
throw a1：此时根据a1重新在全局区创建一个新的异常对象，然后将处在全局区的a1释放；然后在堆栈展开...balabala </li>  </ul>  
匹配所有类型 
  
catch(...){};匹配所有类型的异常对象，如果'catch(...)'处在catch子句的第一位，那么其他catch是不会得到机会的； 
  
函数测试块 
  
用于捕获构造函数初始化列表中的异常：
  不过测试发现：会在捕获处理后将初始化列表中发生的异常重新抛出('throw;'那种) 
  

  
  
#include <stdio.h>    struct A{   int a;   A():a(0){ printf("A:%p\n",this); }   A(const A &__a){ printf("A:%p->%p\n",&__a,this); }   ~A(){ printf("A:~%p\n",this); }  };    int f(){   A a1;   throw a1;   return 0;  }    class B{   int a;  public:   B()try:a(f()){/* 注意try的位置,初始化列表之前 */    ;   }catch(...){/* 会捕获初始化列表与构造函数体中抛出的异常,不过在处理后又会重新抛出 */    printf("B:Catch\n");   }  };      int main(int argc,char *argv[]){   try{ B b; }   catch(...){ printf("main:Catch\n"); }   return 0;  }    /* 执行结果： */  A:0x7fffc45fbae0  A:0x7fffc45fbae0->0x1afd090  A:~0x7fffc45fbae0  B:Catch  main:Catch      A:~0x1afd090 /* 确定是重新抛出 */    
 
RAII 
  
资源分配即初始化，即通过一个类来包装资源的分配与释放，这样可以保证异常发生时资源会被释放； 
  
异常说明 
  

  
  
void f()throw(Type)  /* f 会抛出Type类型或其派生类型的异常 */  void f()throw()  /* f()不会抛出任何异常,此时编译器可能会执行一些被可能抛出异常的代码抑制的优化 */  void f()  /* f()会抛出任何类型的异常 */
 

  
  
违反了异常说明 
  
如果抛出了不在异常说明列表中的异常，则会执行堆栈展开退出当前函数后直接调用标准库函数 unexcepted()[默认调用 terminate()终止程序 ] ；而不会沿着函数调用链向上...如： 
  

  
  
#include <stdio.h>    struct A{   int a;   A():a(0){ printf("A:%p\n",this); }   A(const A &__a){ printf("A:%p->%p\n",&__a,this); }   ~A(){ printf("A:~%p\n",this); }  };    int f()throw(){   A a1;   throw a1;   return 0;  }    void f1(){   A a2;   f();   return ;  }      int main(int argc,char *argv[]){   try{ f1(); }   catch(...){ printf("main:Catch\n"); }   return 0;  }
 
继承层次中的异常说明 
  
派生类虚函数异常说明中的异常列表⊆基类虚函数异常说明中的异常列表，这个主要是为了： 
  
当通过基类指针调用派生类虚函数，这条限制可以保证派生类虚函数不会抛出新的异常 
  
#include <stdio.h>    class A1{ virtual ~A1(){ ; } };  class B1:public A1{  };    class A{  public:   virtual void print()throw(A1){    return ;   }   virtual ~A(){ ; }  };    class B:public A{  public:   virtual void print()throw(B1){    return ;   }   virtual ~B(){ ; }  };    int main(int argc,char *argv[]){   B b; b.print();   return 0;  }
只要满足批注中的条件即可，如上例也编译通过 

  
  
异常说明与析钩函数 
  

  
  
class A{  public:   virtual void print()throw(A1){    return ;   }   virtual ~A()throw(){ ; }  };    class B:public A{  public:   virtual void print()throw(B1){    return ;   }   virtual ~B(){ ; }  };
因为 ~A() 不会抛出任何类型的异常，所以 ~B() 也不能抛出任何类型的异常，如上例编译不会通过； 

  
  
异常说明与函数指针 
  

  
  
int (*fptr)()throw(int,double);  /* fptr作为一个函数指针，指向着一个函数：   * 该函数没有参数，返回类型为int   * 并且可能抛出int，double类型的异常 */  int (*fptr1)()throw();
 

  
  
当给函数指针赋值的时候，源指针异常声明的类型列表⊆目的指针异常声明的类型列表，这样主要是为了保证： 
  
  
当通过目的指针调用函数时，函数抛出的异常不会多于目的函数指针异常列表中的异常 
  但实际上，下列代码编译成功了： 

  
  
  
#include <stdio.h>      int f()throw(int,double){   throw 1;   return 0;  }    int main(int argc,char *argv[]){   int (*fptr1)()throw();   fptr1=f;/* 这里赋值应该是失败的... */   try{ fptr1(); }      /* fptr1的异常说明不会抛出任何异常，所以这里抛出异常时应该是       * 调用unexpected()的；但实际上异常被捕获了 */   catch(...){ ; }   return 0;  }