1.传统的C语言错误处理方法

    （1）在函数中返回一个错误信息。比如Linux经常返回-1代表错误。
    也可以设定一个全局的变量，比如errno
    （2）用信号函数signal和raise捕捉信号
    （3）用setjmp和longjmp两个非局部跳转函数，这种方法很困难，耦合度也很高，因为它和goto不一样，他会跳转到其他地方，而不是局部地点。
    以上三种方法都有自己的问题。第一个显得代码过于冗长，第二个信号处理标准不一致就会出很大问题，第三个问题更大，因为它会跳到栈区的其他地方，不会自动调用析构函数，行为危险，结果未知。

2.C++的异常处理方式

2.1 try-throw-catch结构

   try代码块负责运行正常代码，在代码中的错误会通过throw抛出，catch负责接受抛出的错误，做出相应的处理。

（1）throw：抛出异常

#include
#include
//抛出一个异常
//设置一个错误类
class MyError{
private:const char* const data;
public:MyError(const char* const msg = 0):data(msg){}//构造函数};void f()
{throw MyError("something bad happened");
}int main()
{f();
}
//f()函数抛出一个错误，生成了MyError对象，这是程序创建的一个对象的拷贝，f()函数返>回了这个对象。

2.2.捕获异常 catch

catch(type value)

{

        some code       

}

2.3.try块

在try块中编写的代码，所产生的错误都会被根据程序员所设计的throw所抛出，程序会返回到错误开始的地方，如果不对错误做出处理，程序到此就结束了。
    try的使用方法为
    try{
        代码
    }

2.4异常处理器

    处理抛出的异常的地方就叫异常处理器，他会接住throw抛出的异常，异常处理对继承和多态同样有效

使用方法：
    try{
        代码
    }
    catch(类型1 id1)
    {
        处理方法1
    }
    catch(类型2 id2)
    {
        处理方法2
    }
    ……
    异常抛出后，会一一匹配catch，如果类型符合，就能够执行catch块的语句

    异常被抛出以后，会按照顺序匹配异常处理器，一旦找到能够匹配的，就会开始处理，不会继续匹配下一个，即使下面的更加合适。
    匹配一个异常，并不要求异常和处理器之间完全相关，一个对象或者是指向派生类对象的引用都会与其基类处理器匹配。如果不是引用或者指针，而是派生类对象和基类相匹配，
    则会发生截断，派生类对象会被截断，与基类相匹配。

#includeclass X{
public:class Trouble{};class Small:public Trouble{};class Big:public Trouble{};void fun(){throw Big();}};int main(){X x;try{x.fun();}catch(X::Trouble&){std::cout << "捕获到Trouble"<

#include
using std::cout;class Except1{};
class Except2{
public:Except2(const Except1&){}//类型转换，将Except1转换为其他类型
};
void fun()
{throw Except1();//抛出一个异常，类型是Except1
}
int main()
{try{fun();}catch(Except2&){cout << "inside catch(except2)\n";}catch(Except1&){cout << "inside catch(except1)\n";}return 0;
}

#include
#include
using namespace std;
void terminator()
{cout << "terminator 回来了\n";
}
//设置一个函数指针，指向set_terminator
void (*Myterminator)(void)  = set_terminate(terminator);
class Botch
{
public:class Fruit{};void fun(){cout << "Botch::f()"<

#include
using namespace std;class Cat{
public:Cat(){ cout << "cat()" <

#include
#include
using namespace std;template
class PWrap
{
private:T* ptr;
public:class RangeError{};//异常类PWrap(){ptr = new T[sz];cout << "PWrap constructor"<= 0 && i < sz)return ptr[i];throw RangeError();}
};class Cat{
public:Cat(){cout << "Cat()" << endl;}~Cat(){cout << "~Cat()"< cats;PWrap dog;};int main()
{try{UseResource ur;}catch(int){cout << "inside handler" << endl;}catch(...){cout << "inside catch(...)" << endl;}return 0;
}

#include
using namespace std;
int main()try
{throw "主函数抛出异常";}
catch(const char* msg){cout << msg << endl;}