C++异常机制

一、简单实例

异常是通过抛出对象而引发的，抛出对象的类型决定应该激活那个处理代码，即catch中的语句；被处理代码是调用链中与该抛出对象类型匹配，并且离抛出异常位置最近的那一个；例如：

void test(){
throw string("eeror");
}
int main(){
try{
test();
}catch(string& e){
cout<<e<<endl;
}

}

上述中throw抛出string类型的异常，catch捕获string类型异常，并且会输出string中的内容；假如catach中没有接受string类型的代码，那么该异常就会传给系统

catch(int& e)

;假如catch语块中有catch(…),那么最终还是能接受到异常，但不知道到底是什么异常；

其中，异常的传播方向如下图：



左边表示函数f3调用f2，f2调用f1,右边表示异常的传播方向；假如f1引发异常，但处理不了，就会向上传播，传递给f2，f2也处理不了就会传递给f3，如果f3能处理异常，异常就被处理，假如不能，最终交给系统；即异常传播方向是向上传播；

二、

1、 在C++中异常往往用类（class）来实现，以栈为例，测到栈满或空就抛出一个异常。栈的异常类声明如下：

2、注意pushOnFull是类，C++要求抛出的必须是对象，所以必须有“()”，即调用构造函数建立一个对象。异常并非总是类对象，throw表达式也可以抛出任何类型的对象，如枚举、整数等等。但最常用的是类对象。

3、throw表达式抛出异常为异常处理的第一步

4、在堆栈的压栈和出栈操作中发生错误而抛出的异常，应由调用堆栈的程序来处理。首先采用关键字try，构成一个try块（try block），它包含了抛出异常的语句或这样的调用语句——该语句所调用的函数中有能够抛出异常的语句。然后由catch子句捕获并处理异常

5、由catch子句捕获并处理异常是第二步

6、异常对象是在抛出点被创建，与catch子句是否显式要求创建一个异常对象无关，该对象总是存在，在catch子句中只是为了调用异常处理对象的成员函数才声明对象eObj，不用类。

7、catch子句的异常声明与函数参数声明类似，可以是按值传送，也可以是按引用传递。对大型类对象减少不必要的复制是很有意义的，所以对于类类型的异常，其异常声明最好也是被声明为引用

#include<iostream>
using namespace std;

template<typename T>class pushOnFull{
T _value;
public:
pushOnFull(T i){_value=i;}
T value(){return _value;}
void print(){cerr<<"栈满，"<<value()<<"未压入栈"<<endl;}
};
template<typename T>class popOnEmpty{
public:
void print(){cerr<<"栈已空，无法出栈"<<endl;}
};

template<typename T>class Stack{
int top;                                    //栈顶指针（下标）
T *elements;                               //动态建立的数值
int maxSize;                               //栈最大允纳的元素个数
public:
Stack(int=20);                              //栈如不指定大小，设为20元素
~Stack(){delete[] elements;}
void Push(const T &data) ;        //压栈
T Pop();                            //弹出，top--
T GetElem(int i){return elements[i];}                 //返回指定元素，top不变
void MakeEmpty(){top= -1;}                            //清空栈
bool IsEmpty() const{return top== -1;}                //判栈空
bool IsFull() const{return top==maxSize-1;}           //判栈满
void PrintStack();                                    //输出栈内所有数据
};
template<typename T> Stack<T>::Stack(int maxs){
maxSize=maxs;
top=-1;
elements=new T [maxSize];                     //建立栈空间
}
template<typename T> void Stack<T>::PrintStack(){
for(int i=0;i<=top;i++) cout<<elements[i]<<'\t';
cout<<endl;
}
template<typename T> void Stack<T>::Push(const T &data) {
if(IsFull())  throw pushOnFull<T>(data);                   //栈满则抛出异常
elements[++top]=data;          //栈顶指针先加1，元素再进栈，top是指向栈顶元素
}
template<typename T>T Stack<T>::Pop() {
if(IsEmpty())  throw popOnEmpty<T>();          //栈已空则不能退栈，抛出异常
return elements[top--];                        //返回栈顶元素，同时栈顶指针退1
}

int main(){
int a[9]={1,2,3,4,5,6,7,8,9}, b[9]={0},i;
Stack<int>istack(8);
try{
for(i=0;i<9;i++)  istack.Push(a[i]);//到a[8]时栈满,异常
istack.PrintStack();
}
catch(pushOnFull<int>&eObj){eObj.print();}
try{for(i=0;i<9;i++) b[i]=istack.Pop();}
catch(popOnEmpty<int>&eObj){ eObj.print();}
cout<<"出栈次序为：";
for(i=0;i<9;i++) cout<<b[i]<<'\t';
cout<<endl;
return 0;
}

三、虚函数是类层次结构中多态性的基本手段，异常类层次结构中也可以定义虚拟函数

#include<iostream>
using namespace std;

class Excp{                                   //为了简化，本例未用模板
public:
virtual void print(){cerr<<"发生异常"<<endl;}
};
class stackExcp:public Excp{
public:
virtual void print(){cerr<<"栈发生异常"<<endl;}
};
class pushOnFull:public stackExcp{
public:
virtual void print(){cerr<<"栈满,不能压栈"<<endl;}
};
class popOnEmpty:public stackExcp{
public:
void print(){cerr<<"栈已空，无法出栈"<<endl;}
};

class Stack{
int top;                                     //栈顶指针（下标）
int *elements;                               //动态建立的数值
int maxSize;                                 //栈最大允纳的元素个数
public:
Stack(int=20);                               //栈如不指定大小，设为20元素
~Stack(){delete[] elements;}
void Push(const int &data);                  //压栈
int Pop();                                   //弹出，top--
int GetElem(int i){return elements[i];}      //返回栈顶元素，top不变
void MakeEmpty(){top= -1;}                   //清空栈
bool IsEmpty() const{return top== -1;}       //判栈空
bool IsFull() const{return top==maxSize-1;}  //判栈满
void PrintStack();                           //输出栈内所有数据
};
Stack::Stack(int maxs){
maxSize=maxs;
top=-1;
elements=new int [maxSize];                     //建立栈空间
}
void Stack::PrintStack(){
for(int i=0;i<=top;i++) cout<<elements[i]<<'\t';
cout<<endl;
}
void Stack::Push(const int &data){
if(IsFull())  throw pushOnFull();             //栈满则抛出异常
elements[++top]=data;                         //栈顶指针先加1，元素再进栈，top是指向栈顶元素
}
int Stack::Pop(){
if(IsEmpty())  throw popOnEmpty();            //栈已空则不能退栈，抛出异常
return elements[top--];                       //返回栈顶元素，同时栈顶指针退1
}

int main(){
int a[9]={1,2,3,4,5,6,7,8,9}, b[9]={0},i;
Stack istack(8);
try{
for(i=0;i<9;i++)  istack.Push(a[i]);      //到a[8]时栈满,异常
istack.PrintStack();
}
catch(Excp&eObj){
eObj.print();                             //调用虚函数pushOnFull::print()
}
try{for(i=0;i<9;i++) b[i]=istack.Pop();}
catch(Excp&eObj){
eObj.print();                             //调用虚函数popOnEmpty::print()
}
for(i=0;i<9;i++) cout<<b[i]<<'\t';
cout<<endl;
return 0;
}

更加具体的信息可以访问：http://www.weixueyuan.net/cpp/