异常，让一个函数可以在发现自己无法处理的错误时抛出一个异常，希望它的调用者可以直接或者间接处理这个问题。但传统错误的处理技术，检查到一个错误，返回退出码或者终止程序等等。此时我们只知道程序有错误，但不能更加清楚知道是很忙错误，所以使用异常，就是把错误和处理分开，由库函数抛出异常，由调用者捕获这个异常，调用者可以知道程序函数库调用出现了错误，并根据错误去处理，而是否终止程序就由调用者掌握了。
程序错误可以分为三种，分别是语法错误、逻辑错误和运行时错误：
1. 语法错误在编译和链接阶段就能发现，只有 100% 符合语法规则的代码才能生成可执行程序。语法错误是最容易发现、最容易定位、最容易排除的错误，程序员最不需要担心的就是这种错误。
2.逻辑错误是说我们编写的代码思路有问题，不能够达到最终的目标，这种错误可以通过调试来解决
3.运行时错误是指程序在运行期间发生的错误，例如除数为 0、内存分配失败、数组越界、文件不存在等。C++ 异常（Exception）机制就是为解决运行时错误而引入的。
（一）异常的抛出和处理
1.异常处理的语句
（1）throw：当问题出现时，程序会抛出一个异常，被抛出的异常可以是C++的内置类型（例如： throw int(1);），也可以是自定义类型。后面带一个类型的实例，它和catch的关系就像函数调用，catch指定形参，throw给出实参。编译器按照catch出现的顺序以及catch指定的参数类型确定一个异常应该由哪个catch处理。当然throw不一定非要出现在try随后的block中，它可以出现在任何需要的地方，只要最终会有catch可以捕获它即可。即使在catch随后的block中，仍然可以继续throw。这时候有两种情况，一种是throw一个新的类型异常，这与普通的throw一样。二是要rethrow当前的这个异常，在这种情况下，throw不带参数即可表达
（2）try：try块中的代码标识将被激活的特定异常，它后面通常跟着catch块。在发生了异常之后，需要通过throw抛出。try随后的block是可能抛出异常的地方。
（3）catch：在想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。catch带有一个参数，参数类型以及参数名称都由程序员指定，如果catch随后的block中并不打算引用这个异常对象那么变量名可以忽略。参数类型可以是基础类型，也可以是一个对象，或者一个对象指针/引用。如果希望捕获任意类型的异常，可以使用...作为catch的参数。
try { // ... } catch(int) { throw myException("Exception"); } catch(float) { throw; }抛出异常：
使用throw语句在代码块中的任何地方抛出异常。throw 语句的操作数可以是任意的表达式，表达式的结果的类型决定了抛出的异常的类型。
double division(int a,int b){ if(b==0){ throw "Division by zero condition"; } return (a/b); }捕获异常：
catch 块跟在 try 块后面，用于捕获异常。您可以指定想要捕捉的异常类型，这是由 catch 关键字后的括号内的异常声明决定的。
try { // 保护代码 }catch( ExceptionName e ) { // 处理 ExceptionName 异常的代码 }上面的代码会捕获一个类型为 ExceptionName 的异常。如果您想让 catch 块能够处理 try 块抛出的任何类型的异常，则必须在异常声明的括号内使用省略号 ...，如下所示：
try { // 保护代码 }catch(...) { // 能处理任何异常的代码 }抛出一个除以零的异常，并在catch块中捕获：
#include<iostream> 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*。当上面的代码被编译和执行时，它会产生下列结果：
异常处理流程：
抛出------>检测------->捕获
异常必须显式地抛出，才能被检测和捕获到；如果没有显式的抛出，即使有异常也检测不到。
在 C++ 中，我们使用 throw 关键字来显式地抛出异常，它的用法为：
exceptionData 是“异常数据”的意思，它可以包含任意的信息，完全有程序员决定。exceptionData 可以是 int、float、bool 等基本类型，也可以是指针、数组、字符串、结构体、类等聚合类型，请看下面的例子：
char str[] = "http://c.biancheng.net"; char *pstr = str; class Base{}; Base obj; throw 100; //int 类型 throw str; //数组类型 throw pstr; //指针类型 throw obj; //对象类型C/C++ 规定，数组一旦定义后，它的长度就不能改变了；换句话说，数组容量不能动态地增大或者减小。这样的数组称为静态数组（Static array）。静态数组有时候会给编码代码不便，我们可以通过自定义的 Array 类来实现动态数组（Dynamic array）。所谓动态数组，是指数组容量能够在使用的过程中随时增大或减小。
#include <iostream> #include <cstdlib> using namespace std; //自定义的异常类型 class OutOfRange{ public: OutOfRange(): m_flag(1){ }; OutOfRange(int len, int index): m_len(len), m_index(index), m_flag(2){ } public: void what() const; //获取具体的错误信息 private: int m_flag; //不同的flag表示不同的错误 int m_len; //当前数组的长度 int m_index; //当前使用的数组下标 }; void OutOfRange::what() const { if(m_flag == 1){ cout<<"Error: empty array, no elements to pop."<<endl; }else if(m_flag == 2){ cout<<"Error: out of range( array length "<<m_len<<", access index "<<m_index<<" )"<<endl; }else{ cout<<"Unknown exception."<<endl; } } //实现动态数组 class Array{ public: Array(); ~Array(){ free(m_p); }; public: int operator[](int i) const; //获取数组元素 int push(int ele); //在末尾插入数组元素 int pop(); //在末尾删除数组元素 int length() const{ return m_len; }; //获取数组长度 private: int m_len; //数组长度 int m_capacity; //当前的内存能容纳多少个元素 int *m_p; //内存指针 private: static const int m_stepSize = 50; //每次扩容的步长 }; Array::Array(){ m_p = (int*)malloc( sizeof(int) * m_stepSize ); m_capacity = m_stepSize; m_len = 0; } int Array::operator[](int index) const { if( index<0 || index>=m_len ){ //判断是否越界 throw OutOfRange(m_len, index); //抛出异常（创建一个匿名对象） } return *(m_p + index); } int Array::push(int ele){ if(m_len >= m_capacity){ //如果容量不足就扩容 m_capacity += m_stepSize; m_p = (int*)realloc( m_p, sizeof(int) * m_capacity ); //扩容 } *(m_p + m_len) = ele; m_len++; return m_len-1; } int Array::pop(){ if(m_len == 0){ throw OutOfRange(); //抛出异常（创建一个匿名对象） } m_len--; return *(m_p + m_len); } //打印数组元素 void printArray(Array &arr){ int len = arr.length(); //判断数组是否为空 if(len == 0){ cout<<"Empty array! No elements to print."<<endl; return; } for(int i=0; i<len; i++){ if(i == len-1){ cout<<arr[i]<<endl; }else{ cout<<arr[i]<<", "; } } } int main(){ Array nums; //向数组中添加十个元素 for(int i=0; i<10; i++){ nums.push(i); } printArray(nums); //尝试访问第20个元素 try{ cout<<nums[20]<<endl; }catch(OutOfRange &e){ e.what(); } //尝试弹出20个元素 try{ for(int i=0; i<20; i++){ nums.pop(); } }catch(OutOfRange &e){ e.what(); } printArray(nums); return 0; }Array 类实现了动态数组，它的主要思路是：在创建对象时预先分配出一定长度的内存（通过 malloc() 分配），内存不够用时就再扩展内存（通过 realloc() 重新分配）。Array 数组只能在尾部一个一个地插入（通过 push() 插入）或删除（通过 pop() 删除）元素。 我们通过重载过的[ ]运算符来访问数组元素，如果下标过小或过大，就会抛出异常（第53行代码）；在抛出异常的同时，我们还记录了当前数组的长度和要访问的下标。 在使用 pop() 删除数组元素时，如果当前数组为空，也会抛出错误。
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当发生数学下溢时，会抛出该异常。
定义新的异常
异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个处理代码。 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。 抛出异常后会释放局部存储对象，所以被抛出的对象也就还给系统了，throw表达式会初始化一个抛出特殊的匿名对象，异常对象由编译管理，异常对象在传给对应的catch处理之后撤销。
可以通过继承和重载exception类来定义新的异常，使用std::exception类来实现自己的异常：
#include <iostream> #include <exception> using namespace std; struct MyException :public exception{ const char *what() cosnt throw(){ return "C++ Exception"; } }; int main(){ try{ throw MyException(); } catch(MyException& e){ cout<<"MyException caught"<<endl; cout<<e.what()<<endl; }catch(std::exception &e){ } }在这里，what() 是异常类提供的一个公共方法，它已被所有子异常类重载。这将返回异常产生的原因。
throw用作异常规范
throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明当前函数能够抛出的异常类型，这称为异常规范（Exception specification），有些教程也称为异常指示符或异常列表。
double func(char param) throw(int);
声明一个名为 func 的函数，它的返回值类型为 double，有一个 char 类型的参数，并且只能抛出 int 类型的异常。如果抛出其他类型的异常，try 将无法捕获，只能终止程序。
函数会抛出多种类型的异常，那么可以用逗号隔开：
double func (char param) throw (int, char, exception);
函数不会抛出任何异常，那么( )中什么也不写：
double func (char param) throw ();
func() 函数就不能抛出任何类型的异常了，即使抛出了，try 也检测不到。
（1）虚函数中异常规范
派生类虚函数的异常规范必须与基类虚函数的异常规范一样严格，或者更严格。只有这样，当通过基类指针（或者引用）调用派生类虚函数时，才能保证不违背基类成员函数的异常规范
class Base{ public: virtual int fun1(int) throw(); virtual int fun2(int) throw(int); virtual string fun3() throw(int, string); }; class Derived:public Base{ public: int fun1(int) throw(int); //错！异常规范不如 throw() 严格 int fun2(int) throw(int); //对！有相同的异常规范 string fun3() throw(string); //对！异常规范比 throw(int,string) 更严格 }（2）异常规范与函数定义和函数声明
异常规范在函数声明和函数定义中必须同时指明，并且要严格保持一致，不能更加严格或者更加宽松。
//错！定义中有异常规范，声明中没有 void func1(); void func1() throw(int) { } //错！定义和声明中的异常规范不一致 void func2() throw(int); void func2() throw(int, bool) { } //对！定义和声明中的异常规范严格一致 void func3() throw(float, char*); void func3() throw(float, char*) { }异常规范的初衷是好的，它希望让程序员看到函数的定义或声明后，立马就知道该函数会抛出什么类型的异常，这样程序员就可以使用 try-catch 来捕获了。如果没有异常规范，程序员必须阅读函数源码才能知道函数会抛出什么异常。 不过这有时候也不容易做到。例如，func_outer() 函数可能不会引发异常，但它调用了另外一个函数 func_inner()，这个函数可能会引发异常。再如，您编写的函数调用了老式的库函数，此时不会引发异常，但是库更新以后这个函数却引发了异常。总之，异常规范的初衷实现起来有点困难，所以大家达成的一致意见是，最好不要使用异常规范。
