C++ 异常处理

C++ 异常处理

1. 异常关键字

异常是程序在 执行期间 产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。

异常提供了一种 转移程序控制权 的方式。
C++ 异常处理涉及到三个关键字：try、catch、throw。

关键字	描述
throw	当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
catch	在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。
try	try关键字覆盖范围中的代码称为保护代码，这些代码可能通过 throw 关键字抛出异常，它后面通常跟着一个或多个 catch 块。

异常必须被抛出，才可以被捕获。也就是说如果想要 try / catch，必须有 throw。

使用 try / catch 语句的语法如下所示：

try
{
   // 可能通过 throw 抛出异常
}
catch( ExceptionName e1 )
{
   //捕获 ExceptionName 类型的异常并处理
}
catch( ExceptionName e2 )
{
    //捕获 ExceptionName 类型的异常并处理
}

2. 异常处理实例

#include 
using namespace std;

double division(int a, int b)
{
   if( b == 0 ){throw "Division by zero condition!";}
   return (a/b);
}

int main ()
{
   int x = 50;
   int y = 0;
   double z = 0;

   try 
   {
     z = division(x, y);
     cout << z << endl;
   }
   catch (const char* msg) {cerr << msg << endl;}

   return 0;
}

我们需要 保证抛出异常与捕获异常的类型相匹配，这里抛出了一个类型为 const char* 的异常，因此，当捕获该异常时，我们必须在 catch 块中使用 const char*；如果抛出的是 int ，那么捕获的时候也该是 int。

如果类型不匹配，那么是无法捕获异常的，程序会调用 adort 函数 终止程序。

catch(…) 表示捕捉任何类型的异常，不会存在类型不匹配的问题，缺点在于只能检测到出现异常，不能发现到底是哪里出现异常。

前面说到，一旦出现抛出异常没被处理的问题，系统将自动调用 abort() 函数，实际上，它触发的是 terminate，我们可以自定义 terminate 的处理方法：

#include  
#include  
using namespace std;  
  
void check(int y) 
{  
     if(y==0) throw "exception";  
}  

void myTerminate() 
{  
     cout<<"Unhandler exception!\n";  
     exit(-1);  
}  

int main()  
{  
    terminate_handler preHandler=set_terminate(myTerminate);  
    int x=100,y=0;  
    try  
    {  
        check(y);  
        cout<<x/y;  
    }  
    catch(int &e) //no catch sentence matches the throw type  
    {  
        cout<<e<<endl;  
    }  

    return 0;  
}  

异常类型不匹配，无法捕获异常，系统调用自定义 terminate 方法。

如果注释掉：
terminate_handler preHandler=set_terminate(myTerminate);

3. C++ 标准异常

C++ 提供了一系列标准的异常，定义在 “《exception》” 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过 new 抛出。
std::bad_cast	该异常可以通过 dynamic_cast 抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过 typeid 抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

4. 自定义异常

用户可以自定义异常类型，异常类型并不受到限制，可以是内建数据类型如 int,double等，也可以是自定义的类，也可以从C++某个异常类继承下来。

#include  
#include  
using namespace std;  
  
/*自定义异常类 myException，重载 exception 的 what 方法*/  
class myException:public exception  
{  
public:  
   const char* what()const throw()  
   {  
        return "ERROR! Don't divide a number by integer zero.\n";  
   }      
};  

void check(int y)  
{  
     if(y==0) throw myException();  
}  
  

int main()  
{  
 
    int x=100,y=0;  
    try  
    {  
        check(y);  
        cout<<x/y;  
    }  
    catch(myException& e) 
    {  
		cout << e.what() << endl;  
    }  
    return 0;  
}  

what() 是异常类提供的一个公共方法，它已被所有子异常类重载。这将返回异常产生的原因。

如果你想捕获标准异常 bad_alloc 抛出的异常，可以这样做。

catch(bad_alloc	& e) 
{  
	cout << e.what() << endl;  
}  

5. 被遗弃的标准

throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明函数能够抛出的异常类型。有些文档中称为异常列表。例如：

double func (char param) throw (int);

如果希望能够抛出多种类型的异常，可以用逗号隔开：

double func (char param) throw (int, char, exception);

如果不希望限制异常类型，那么可以省略：

double func (char param) throw ();

**C++标准已经不建议这样使用 throw 关键字了，**因为各个编译器对 throw 的支持不同，有的直接忽略，不接受 throw 的限制，有的将 throw 作为函数签名，导致引用函数时可能会有问题。上面的代码在 GCC 下运行时会崩溃，在 VS 下运行时则直接忽略 throw 关键字对异常类型的限制，try 可以正常捕获到抛出的异常，程序并不会崩溃。

参考 https://blog.csdn.net/u011068702/article/details/52012013
参考 https://blog.csdn.net/makenothing/article/details/43273137
参考 https://wizardforcel.gitbooks.io/w3school-cpp/content/Text/78.html