C++异常机制

最新推荐文章于 2025-03-27 09:37:09 发布

jonson_zc

最新推荐文章于 2025-03-27 09:37:09 发布

阅读量352

点赞数

分类专栏： C++

C++ 专栏收录该内容

9 篇文章

订阅专栏

一、简单实例
异常是通过抛出对象而引发的，抛出对象的类型决定应该激活那个处理代码，即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;
}