C++异常
前言：
异常处理就是处理程序中的错误。所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在，空指针，内存不足等等）
在对C语言的学习中，我们常常对错误的处理围绕着两种方法：一种是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。
但这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0标识错误；而有些函数返回0标识成功，返回非0表示错误。还有一个缺陷是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。
C++相比C语言在异常处理上有哪些优势呢？
我们可先看看下面异常语法的代码再进行总结。
//异常的基本语法
int func(int a, int b)
{
if (b == 0)
{
//第二步：
throw 10; //抛出一个int类型的异常
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
//把有可能出现异常的代码块放到try中
try
{
func(a, b); //第一步
}
catch (int) //第三步
{
cout << "接收一个int类型的异常" << endl;
}
}
回到上面的问题
- 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。
- 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。
- 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。
- 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。
异常具有严格的类型匹配
异常机制和函数机制互不干涉,但是捕捉方式是通过严格类型匹配。
int func(int a, int b)
{
if (b == 0)
{
throw 20.2f;
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
try
{
func(a, b);
}
catch (double s)
{
cout << "接收一个double类型的异常" << endl;
}
catch (char)
{
cout << "接收一个char类型的异常" << endl;
}
catch (...) //接收其他类型的异常
{
cout << "接收一个其他类型的异常" << endl;
}
}
栈解旋（unwinding）
异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding).
class Maker
{
public:
Maker()
{
cout << "Maker的构造" << endl;
}
Maker(const Maker& m)
{
cout << "Maker的拷贝构造" << endl;
}
~Maker()
{
cout << "Maker的析构" << endl;
}
};
void func()
{
//在抛出异常的函数中，如果抛出异常之后，但函数没有结束，这时，栈上申请的对象都会被释放
//这就叫栈解旋
Maker m;
throw m;//这个m是Maker m拷贝构造的
cout << "func函数结束" << endl;
}
void test()
{
try
{
func();
cout << "func()代码后" << endl;
}
catch (Maker)
{
cout << "接收一个Maker类型的异常" << endl;
}
}
运行结果:
异常接口声明
- 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。
- 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()
- 一个不抛任何类型异常的函数可声明为:void func() throw()
- 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。
void func() throw(int, char) //只允许抛出 int 或者 char异常
{
throw 10; //抛出一个double类型的异常
}
void test()
{
try
{
func();
}
catch (int)
{
cout << "抛出一个int型的异常";
}
catch (...)
{
cout << "抛出一个其他型的异常";
}
}
运行结果：
异常变量周期
产生三个对象
class Maker
{
public:
Maker()
{
cout << "Maker的构造" << endl;
}
Maker(const Maker& m)
{
cout << "Maker的拷贝构造" << endl;
}
~Maker()
{
cout << "Maker的析构" << endl;
}
};
//产生三个对象
void func1()
{
Maker m;//第一个对象，在异常接收前被释放
throw m;//第二个对象，是第一个对象拷贝过来的
}
void test01()
{
try
{
func1();
}
catch (Maker m1)//第三个对象，是第二个对象拷贝过来的
{
cout << "接收一个Maker类型的异常" << endl;
//第二个和第三个对象在catch结束时释放
}
}
产生两个对象
void func2()
{
//第一个对象
throw Maker();//匿名对象
}
void test02()
{
try
{
func2();
}
catch (Maker m1)//第二个对象
{
cout << "接收一个Maker类型的异常" << endl;
//第一个和第二个对象在catch结束时释放
}
}
产生一个对象
void func3() //常用这种方式
{
throw Maker();//匿名对象
}
void test03()
{
try
{
func3();
}
catch (Maker& m1)
{
cout << "接收一个Maker类型的异常" << endl;
}
}
异常的多态使用
//异常的基类
class Father
{
public:
virtual void printM()
{
}
};
//1、有继承
class SonNULL :public Father
{
public:
virtual void printM() //2、重写父类的虚函数
{
cout << "空指针的异常" << endl;
}
};
class SonOut :public Father
{
public:
virtual void printM()
{
cout << "越位溢出" << endl;
}
};
void func(int a,int b)
{
if (a == 0)
{
throw SonNULL();
}
if (b == 0)
{
throw SonOut();
}
}
void test()
{
int a = 0;
int b = 10;
try
{
func(a, b);
}
catch (Father& f) //3、父类引用指向子类对象
{
f.printM();
}
}