C++异常处理机制

try| throw | catch

异常处理

抛出异常即检测是否产生异常，在C++中，采用throw语句实现，如检测到产生异常，则抛出异常。

如在try语句块的程序段中（包括在其中调用的函数）发现了异常，且抛弃了该异常，则这个异常就可以被try语句块后的某个catch语句所捕获并处理，捕获和处理的条件是被抛弃的异常的类型与catch的异常类型相匹配。由于C++使用数据类型来区分不同的异常，因此在判断异常时，throw语句中的表达式的值就没有实际意义，而表达式的类型就特别重要。

try
{
      //发现异常，抛出异常
}
catch(类型名 [形参名])//捕获特定类型的异常
{
}
catch(类型名 [形参名])//捕获特定类型的异常
catch(...)//三个点表示捕获所有类型的异常
{
}

 

例：除数为0的异常

int main(int argc,char *argv[])
{
       try
       {
                double x,y;
                cin>>x>>y;
                if(y<0.00000001>)
                        throw y;//除数为0，抛出异常
                cout<<"The result ofx/y is:"<<x/y<<endl;
       }
       catch(double)
       {
                cerr<<"error ofdividing zero.\n";
                exit(1);//异常退出程序
       }
}

异常的接口声明

1. 可在函数的声明中列出函数可能抛出的所有异常类型（例：void fun() throw(A,B,C,D);表明此函数可能且只能抛出类型(A,B,C,D)及其子类型的异常）。

优点：用户快速了解所用函数抛出异常类型。

2. 函数声明中未包括异常的接口声明，则函数可以抛出任何类型的异常（例：void fun();）。

3. 函数不会抛出任何类型的异常（例：void fun() throw();）。

异常处理中需要注意的问题

1.如果抛出的异常一直没有函数捕获(catch)，则会一直上传到c++运行系统那里，导致整个程序的终止

2. 一般在异常抛出后资源可以正常被释放，但注意如果在类的构造函数中抛出异常，系统是不会调用它的析构函数的，处理方法是：如果在构造函数中要抛出异常，则在抛出前要记得删除申请的资源。

3. 异常处理仅仅通过类型而不是通过值来匹配的，所以catch块的参数可以没有参数名称，只需要参数类型。

4. 函数原型中的异常说明要与实现中的异常说明一致，否则容易引起异常冲突。 

5. 应该在throw语句后写上异常对象时，throw先通过Copy构造函数构造一个新对象，再把该新对象传递给 catch. 

      那么当异常抛出后新对象如何释放？

      异常处理机制保证：异常抛出的新对象并非创建在函数栈上，而是创建在专用的异常栈上，因此它才可以跨接多个函数而传递到上层，否则在栈清空的过程中就会被销毁。所有从try到throw语句之间构造起来的对象的析构函数将被自动调用。但如果一直上溯到main函数后还没有找到匹配的catch块，那么系统调用terminate()终止整个程序，这种情况下不能保证所有局部对象会被正确地销毁。

 6.catch块的参数推荐采用地址传递而不是值传递，不仅可以提高效率，还可以利用对象的多态性。另外，派生类的异常扑获要放到父类异常扑获的前面，否则，派生类的异常无法被扑获。   

7.编写异常说明时，要确保派生类成员函数的异常说明和基类成员函数的异常说明一致，即派生类改写的虚函数的异常说明至少要和对应的基类虚函数的异常说明相同，甚至更加严格，更特殊。

自定义异常类：

#include"stdafx.h"
#include<stdlib.h>
#include<crtdbg.h>
#include<iostream>

//内存泄露检测机制
#define _CRTDBG_MAP_ALLOC
#ifdef_DEBUG
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

//自定义异常类
classMyExcepction
{
public:
        //构造函数,参数为错误代码
        MyExcepction(interrorId)
        {
                std::cout<<"MyExcepctioniscalled"<<std::endl;//输出构造函数被调用信息
                m_errorId=errorId;
        }
        
        //拷贝构造函数
        MyExcepction(MyExcepction&myExp)
        {
                std::cout<<"copyconstructiscalled"<<std::endl;//输出拷贝构造函数被调用信息
                this->m_errorId = myExp.m_errorId;
        }
        
        ~MyExcepction()
        {
                std::cout<<"~MyExcepctioniscalled"<<std::endl; //输出析构函数被调用信息
        }
        
        int getErrorId(){returnm_errorId;}//获取错误码
        
        private:
        int m_errorId; //错误码
};
        
int main(intargc,char*argv[])
{
        //内存泄露检测机制
        _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
        
        //可以改变错误码,以便抛出不同的异常进行测试
        int throwErrorCode=110;
        
        std::cout<<"inputtestcode:"<<std::endl;
        std::cin>>throwErrorCode;
        
        try
        {
                if(throwErrorCode==110)
                {
                        MyExcepctionmyStru(110);

                        //抛出对象的地址->由catch(MyExcepction* pMyExcepction)捕获
                        //这里该对象的地址抛出给catch语句,不会调用对象的拷贝构造函数
                        //传地址是提倡的做法,不会频繁地调用该对象的构造函数或拷贝构造函数
                        //catch语句执行结束后,myStru会被析构掉
                        throw &myStru;
                }
                else if(throwErrorCode==119)
                {
                        MyExcepctionmyStru(119);
        
                        //抛出对象,这里会通过拷贝构造函数创建一个临时的对象传出给catch
                        //由catch(MyExcepction myExcepction)捕获
                        //在catch语句中会再次调用通过拷贝构造函数创建临时对象复制这里传过去的对象
                        //throw结束后myStru会被析构掉
                        throw myStru;
                }
                else if(throwErrorCode==120)
                {
                        //不提倡这样的抛出方法
                        //这样做的话,如果catch(MyExcepction* pMyExcepction)中不执行delete操作则会发生内存泄露
                        //由catch(MyExcepction* pMyExcepction)捕获
                        MyExcepction*pMyStru=newMyExcepction(120);
                        throw pMyStru;
                }
                else
                {
                        //直接创建新对象抛出
                        //相当于创建了临时的对象传递给了catch语句
                        //由catch接收时通过拷贝构造函数再次创建临时对象接收传递过去的对象
                        //throw结束后两次创建的临时对象会被析构掉
                        throw MyExcepction(throwErrorCode);
                }
        }
        catch(MyExcepction*  pMyExcepction)
        {
                std::cout<<"执行了catch(MyExcepction*  pMyExcepction)"<<std::endl;
                std::cout<<"errorCode:"<<pMyExcepction->getErrorId()<<std::endl;
        
                //异常抛出的新对象并非创建在函数栈上，而是创建在专用的异常栈上,不需要进行delete
                //delete pMyExcepction;
        }
        catch(MyExcepction myExcepction)
        { 
                std::cout<<"执行了catch(MyExcepctionmyExcepction)"<<std::endl;
                std::cout<<"errorCode:"<<myExcepction.getErrorId()<<std::endl; 
        }
        catch(...)
        {
                std::cout<<"执行了catch(...)"<<std::endl; //输出本语句被执行信息
        
                throw; //处理不了,重新抛出给上级
        }
        
        //暂停
        int temp;
        std::cin>>temp;
        return 0;
}

 

原文摘自：c++异常处理机制示例及讲解