1.C++异常的出现

C语言中处理错误的方式

1.终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。

2. 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通

过把错误码放到errno中，表示错误实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

C++异常概念

 异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的

直接或间接的调用者处理这个错误。

throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。

catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异

常，可以有多个catch进行捕获。

try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。  

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛

出异常的代码，try 块中的代码被称为保护代码。

如果正常执行，没有发生异常，那就和try-catch没有关系了，就会正常进行。

举个例子：

double Division(int a, int b)
{
  // 当b == 0时抛出异常
  if (b == 0)
    throw "Division by zero condition!";// throw  const char*对象
  else
    return ((double)a / (double)b);
}
void Func()
{
  int len, time;
  cin >> len >> time;
  cout << Division(len, time) << endl; 
}
int main()
{
  try
  {
    Func();
  }
  catch (const char* errmsg)
  {
    cout << errmsg << endl;
    // 记录日志，进行统一处理
  }
  catch (int errid)
  {
    cout << errid << endl;
  }
  return 0;
}

可以看到，try中调用func函数，若调用这个函数过程中有异常抛出，就会直接跳到try下面的catch来捕获异常。那么异常具体要注意些什么，它的规则又是什么呢？

2.异常的抛出和匹配原则  

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

throw抛出的异常，必须要有类型匹配的catch所对应，如果没有类型匹配的catch，会直接报错，终止程序！

2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

当除数为0时，抛出异常，他会先找当前作用域的catch，如果没有，就会返回调用链中调用它的上一个中去找catch，如果没有catch，就会直接报错，终止程序。

同一位置可以有多个类型不用的catch，但是同一位置不可以有相同类型的catch，相同类型的catch必须分布在不同的位置（可以看作是提前catch）：

double Division(int a, int b)
{
  // 当b == 0时抛出异常
  if (b == 0)
    throw "Division by zero condition!";// throw  const char*对象
  else
    return ((double)a / (double)b);
}
void Func()
{
    try
  {
  int len, time;
  cin >> len >> time;
  cout << Division(len, time) << endl; 
  }
  catch (const char* errmsg) //const char*类型
  {
    cout << errmsg << endl;
    // 记录日志，进行统一处理
  }
}
int main()
{
  try
  {
    Func();
  }
  catch (const char* errmsg) //const char*类型
  {
    cout << errmsg << endl;
    // 记录日志，进行统一处理
  }
  catch (int errid)  //int 类型
  {
    cout << errid << endl;
  }
  return 0;
}

throw抛出的可以是异常对象：

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

当然，编译器会自动识别为将亡值，然后调用移动构造，直接构造。

4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。

如果出现这种情况：new出的对象因为catch而导致执行顺序混乱，没有释放就会导致内存泄漏。

double Division(int a, int b)
{
  // 当b == 0时抛出异常
  if (b == 0)
  {
    string s("Division by zero condition!");
    throw s;
  }
  else
    return ((double)a / (double)b);
}
void Func()
{
    //new的资源需要释放
  int* p1 = new int[10];
  try
  {
    int len, time;
    cin >> len >> time;
    cout << Division(len, time) << endl; // throw  const char*对象
    // func()   // throw double对象
  }
  catch (...)  // 表示可以捕获任意类型的异常
  {
    //cout << errmsg << endl;
    cout << "delete" << p1 << endl;
    delete[] p1;
    throw;  // 重新抛出，捕获到什么就抛出什么
  }
  //catch (const string& errmsg)
  //{
  //  //cout << errmsg << endl;
  //  cout << "delete" << p1 << endl;
  //  delete[] p1;
  //  throw errmsg;  // 重新抛出
  //}
  cout << "delete"<< p1 << endl;
  delete[] p1;
}
int main()
{
  try
  {
    Func();
  }
  catch (const char* errmsg) 
  {
    cout << errmsg << endl;
    // 记录日志，进行统一处理
  }
  catch (...)
  {
    cout << "未知异常" << endl;
  }
  return 0;
}

那么就可以在catch捕获异常里面，释放内存以后，再重新抛出异常throw;（但不知道是什么类型）  ，若无类型匹配就会直接停止程序，于是有 catch(...)可以捕获任意类型的异常，释放空间时，就可以直接在catch中写一次就可以。（但也不知道异常错误是什么）

所以为了在main中统一处理异常，这就要要求抛异常得规范，使得捕获以后可以识别异常类型。（后面继续看）

5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，

使用基类捕获，这个在实际中非常实用，后面会详细讲解。

异常规范：

// C++11 中新增的 noexcept ，表示不会抛异常

thread () noexcept ;

thread ( thread && x ) noexcept ;

3.在函数调用链中异常栈展开匹配原则

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则

调到catch的地方进行处理。

前面我们提到了，try中是保护代码，如果try中throw抛异常以后，首先看有没有对应的catch（类型匹配），没有的话直接报错，停止程序，有的话直接跳到catch来进一步解决。

2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

当然不是当前函数栈没有对应的catch就直接终止程序，会依次返回调用链的上一层去寻找，

知道调用链结束，没找到就直接报错，停止程序

3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的

catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异

常，否则当有异常没捕获，程序就会直接终止。

当然程序一般不会随便就结束，若没有对应的catch捕获异常匹配，为了防止程序结束，就会在最后加一个catch(...){}，防止程序结束。

4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。      

4.异常的特殊类型匹配（异常体系）

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家