异常机制

c++的异常机制与大多数语言相同，分为三个部分：

• 引发异常；
• 使用处理程序捕获异常；
• 使用try块；

通常，c++引发异常之后会有两种做法，一种是通过调用abort()函数返回错误并终止程序（有点像exit()），另一种是通过throw关键字指出异常的特征，并且跳转到另一条语句。

这里主要说第二种方法，程序使用异常处理程序来捕获异常，catch关键字表示捕获异常，随后是位于括号内的类型声明，指出响应的类型，然后是一个花括号，指出采取的措施。try块标示其中特定的异常可能被激活的代码块，后面可以跟一个或多个catch块。

  void compare(int a,int b) {
    a==b?a:throw "a!=b";
  }
  try {
    compare(a,b);
  }
  catch (const char *str) {
    std::cout<<"There's a warning"<<*str;
  }

如果其中的某条语句导致异常被引发，则后面的catch块将对异常进行处理。如果程序在try块外面调用compare()，则无法处理异常。

异常类型

c++中，所有的变量类型都可以作为异常的类型，但是为了区分不同函数在不同情况下引发的异常，通常以对象为异常类型。

  class compare {
    private:
      int a1,b1;
    public:
      compare(int a=0,int b=0):a1(a),b1(b) { }
      void mesg();
  };
  inline compare::mesg() {
    std::cout<<a1<<"!="<<b1;
  };

  class another_compare {
    private:
      int a1,b1;
    public:
      another_compare(int a=0,int b=0):a1(a),b1(b) { }
      void mesg();
  };
  inline another_compare::mesg() {
    std::cout<<a1<<"=="<<b1;
  };
  
  void work(int a,int b) {
    if(a!=b)
      throw compare(a,b);
    else
      throw another_compare(a,b);  
  }
    
  //main()
  try {
    work(a,b);
  }
  catch (compare & warning) {
    warning.mesg();
  }
  catch (another_compare & warning) {
    warning.mesg();
  }

throw-catch机制虽然与函数调用类似，但还是有些不同的地方。其中之一便是函数中的返回语句会将控制权交还给调用改函数的函数，但throw 语句将控制权交给包含能够捕获相应异常的try-catch组合的函数。另一个不同之处在于引发异常时编译器总是创建一个临时拷贝，即使catch块中规定的类型是引用。

  compare oops;
  throw oops;
  
  //main()
  catch(compare &p) {
    //...
  }

在上例中，p指向的并不是oops，而是oops的副本。原因也很简单，执行完oops所在函数之后，oops会调用析构函数（oops不再存在）。
然而，为何代码中还需要使用引用呢？毕竟，将引用作为返回值的通常原因是避免创建副本以提高效率。这里用到的其实是引用的另一个特征：基类引用可以执行派生类对象，假设有一组通过继承关联起来的异常类型，则在异常规范中只叙列出一个基类引用，它将与任何派生类对象匹配。

栈解退

假设try快没有直接调用引发异常的函数，而是调用了对引发异常的函数进行调用的函数，则程序流程将从引发异常的函数跳到包含try块和处理程序的函数。

  void third_call(int a,int b) {
    if(a!=b)
      throw compare(a,b);
  }
  void second_call(int a,int b) {
    third_call(a,b);
    std::out<<"this is the second call";
  }

  void first_call(int a,int b) {
    second_call(a,b);
    std::cout<<"this is the first call";
  }
  //main()
  try{
    first_call(a,b);
  }
  catch(compare &warning) {
    warning.mesg();
  }

当third_call()抛出异常时，程序并不会执行first_call()和second_call()中的输出语句，而是直接跳转至main()中的catch模块。
为什么会有这种情况呢？这就要涉及到栈解退。当函数由于异常而终止，则程序将一直释放栈（处理函数调用）中的内存，直到找到第一个位于try块的返回地址。随后控制权将转到块尾的异常处理程序，而不是函数调用后的第一句。这个过程被称作栈解退。

有关异常的注意事项

• 由于栈解退的性质，可能导致动态申请的内存未能被释放；
• c++98标准中新增了异常规范功能，c++11标准已将这个功能摒弃，但是引入noexpect关键字指出函数不会引发异常;
• catch块中，异常类型为引用时需要注意，由于异常对象将会被第一个与之匹配的catch块捕获，所以catch块排列顺序应与派生顺序相反;

  class compare_1 {...};
  class compare_2 :public compare_1 {...};
  class compare_3 :public compare_2 {...};
  //main()
  try {
    work();
  }
  catch(compare_3 &p) {...}
  catch(compare_2 &p) {...}
  catch(compare_1 &p) {...}

感想

1. c++博大精深；
2. 第一次用markdown排版，可能格式还不是太标准，希望大家谅解；
3. 其实学了之后写一遍学习笔记还是挺有用，印象更深了；
   就这样吧