C++异常

定义：

异常是一种程序控制机制，与函数机制独立和互补

异常设计目的:

栈机制是一种高度节律性控制机制,面向对象编程却要求对象之间有方向、有目的的控制传动,从一开始，异常就是冲着改变程序控制结构，以适应面向对象程序更有效地工作这个主题，而不是仅为了进行错误处理。

异常设计出来之后，却发现在错误处理方面获得了最大的好处。

异常的错误处理机制：

1)C++的异常处理机制使得异常的引发和异常的处理不必在同一个函数中，这 样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调 用者可以再适当的位置设计对不同类型异常的处理。
2)异常是专门针对抽象编程中的一系列错误处理的，C++中不能借助函数机 制，因为栈结构的本质是先进后出，依次访问，无法进行跳跃，但错误处理的 特征却是遇到错误信息就想要转到若干级之上进行重新尝试。
3)异常超脱于函数机制，决定了其对函数的跨越式回跳。
4)异常跨越函数

 //抛掷异常的程序段
void func(){
  throw 表达式；
}
 
//捕获并处理异常的程序段
 try{
  复合语句；
func();
}
catch(异常类型声明){    //如 catch(int)
}
catch(类型 (形参)){    //如catch(int e)
}
catch(...){.  //捕获所有异常
}

• 若有异常则通过throw操作创建一个异常对象并抛掷。
• 将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try 语句，然后执行try块内的保护段。
• 如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执
  行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去。
• catch子句按其在try块后出现的顺序被检查。匹配的catch子句将捕获并处理 异常(或继续抛掷异常)。
• 如果匹配的处理器未找到，则运行函数terminate将被自动调用，其缺省功 能是调用abort终止程序。
• 处理不了的异常，可以在catch的最后一个分支，使用throw语法，向上扔。

栈解旋

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反。这一过程称为栈的解旋(unwinding)。

也就是在执行throw前，在try执行期间所构造的所有对象被自动析构后，才会进入catch匹配。注意这里是不包括throw 出去的类对象。

void cfun(){
A a,b; //a，b被析构，匿名对象A（）不被析构
throw A();
}

异常接口声明

• 1)为了加强程序的可读性，可以在函数声明中列出可能抛出的所有异常类 型，例如: void func() throw (A, B, C ,
  D); //这个函数func()能够且只能抛出类 型A B C D及其子类型的异常。
• 2)如果在函数声明中没有包含异常接口声明，则次函数可以抛掷任何类型的 异常，例如: void func();
• 3)一个不抛掷任何类型异常的函数可以声明为: void func() throw();

如果一个函数抛出了它的异常接口声明所不允许抛出的异常，unexpected 函数会被调用，该函数默认行为调用terminate函数中止程序。

• 注意：throw 自定义类时，要注意类内要写拷贝构造函数，深拷贝，不然匿名对象拷贝指向的空间会析构两次

异常类型和异常变量的生命周期
1)throw的异常是有类型的，可以使，数字、字符串、类对象。
2)throw的异常是有类型的，catch严格按照类型进行匹配。
3)注意 异常对象的内存模型 。

异常变量的生命周期：

1.catch(Myexception e){}:
throw出去的异常对象，只有当catch块执行完才会析构,这里throw时构造匿名对象，将匿名对象通过拷贝构造给了e，最后catch执行完后，匿名对象和异常对象e都要析构。

2.catch(Myexception & e){} ： 用引用去接
这里throw出去时构造了异常对象。然后e是引用了匿名对象，匿名对象被拨正成异常对象e，这里没有触发拷贝构造，catch执行完后析构异常对象。

3.throw &(Myexception(“abc”))
catch(Myexception* e){}
这里是用指针去接，但会在catch执行完前提前析构。

解决方案：
throw new Myexception(“abc”);
catch(Myexception* e){
cout<<“asjkdhasjkdh”<<endl;
delete e; //需要手动析构掉
}

标准异常类的成员:

1 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
2 logic_error类及其子类、runtime_error类及其子类，它们的构造函数 是接受一个string类型的形式参数，用于异常信息的描述;
3 所有的异常类都有一个what()方法，返回const char* 类型(C风格字 符串)的值，描述异常信息。

编写自己的异常类

为什么要编写自己的异常类？

1.标准库中的异常是有限的
2.在自己的异常类中，可以添加自己的信息。（标准库中的异常类允许设置一个用来描述异常的字符串）。

如何编写自己的异常类？

1.建议自己的异常类要继承标准异常类，因为c++中可以抛出任何类型的异常，所以我们的异常可以不继承异常，但这样可能会导致程序混乱，尤其是但我们多人协同开发时，
2.当继承标准异常类时，应该重载父类的what函数和虚析构函数。
3.因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的拷贝构造函数。

#include <iostream>
#include <exception>
#include<string>
using namespace std;
 
class Teacher
{
public:
Teacher(int age) //构造函数, 通过异常机制 处理错误 
{
    if (age > 100){
    throw out_of_range("年龄太大");
}
    this->age = age;
} 
protected:
    private:
        int age;
};
 
class MyOutOfRange : public exception{
public:
    MyOutOfRange(const char* error){
        pError=new char[strlen(error)+1];
        strcpy(pError,error);
    }
    ~MyOutOfRange() _NOEXCEPT{   //这里不加_NOEXCEPT会报错，具体加什么要去excption的定义看，大概是环境不同的原因
        if(pError!=NULL){
            delete[] pError;
        }
    }
    virtual const char * what()const _NOEXCEPT{
        return pError;
    }
public:
    char* pError;
};
 
void func(){
    throw MyOutOfRange("年龄超过了");
}
 
int main() {
try
    {
        Teacher t1(102);
    }
    catch (out_of_range e)
    {
        cout << e.what() << endl;
    }
 
try
    {
        func();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
return 0; 
}