C++中异常类的使用方法

C++有很多的标准异常类：

namespace std

{

    //exception派生

    class logic_error; //逻辑错误,在程序运行前可以检测出来

 

    //logic_error派生

    class domain_error; //违反了前置条件

    class invalid_argument; //指出函数的一个无效参数

    class length_error; //指出有一个超过类型size_t的最大可表现值长度的对象的企图

    class out_of_range; //参数越界

    class bad_cast; //在运行时类型识别中有一个无效的dynamic_cast表达式

    class bad_typeid; //报告在表达试typeid(*p)中有一个空指针p

   

    //exception派生

    class runtime_error; //运行时错误,仅在程序运行中检测到

   

    //runtime_error派生

    class range_error; //违反后置条件

    class overflow_error; //报告一个算术溢出

    class bad_alloc; //存储分配错误

}

     请注意观察上述类的层次结构，可以看出，标准异常都派生自一个公共的基类exception。基类包含必要的多态性函数提供异常描述，可以被重载。下面是exception类的原型：

class exception

{

public:

    exception() throw();

    exception(const exception& rhs) throw();

    exception& operator=(const exception& rhs) throw();

    virtual ~exception() throw();

    virtual const char *what() const throw();

};

    其中的一个重要函数为what()，它返回一个表示异常的字符串指针。

    标准库异常类定义在以下四个头文件中

    1、exception头文件：定义了最常见的标准异常类，其类名为exception。只通知异常的产生，但不会提供更多的信息

    2、stdexcept头文件定义了以下几种常见异常类

   函数                                                     功能或作用

exception                                                最常见的问题

runtime_error                                          运行时错误：仅在运行时才能检测到的问题

range_error                                             运行时错误：生成的结果超出了有意义的值域范围

overflow_error                                        运行时错误：计算上溢

underflow_error                                      运行时错误：计算下溢

 

logic_error                                                逻辑错误：可在运行前检测到的问题

domain_error                                          逻辑错误：参数的结果值不存在

invalid_argument                                    逻辑错误：不合适的参数

length_error                                             逻辑错误：试图生成一个超出该类型最大长度的对象

out_of_range                                            逻辑错误：使用一个超出有效范围的值

    3、new头文件定义了bad_alloc异常类型，提供因无法分配内存而由new抛出的异常

    4、type_info头文件定义了bad_cast异常类型（要使用type_info必须包含typeinfo头文件）

    下面是使用异常类的例子：

    首先，我定义了几个异常类，这些类也可以从标准异常类进行派生，如下

class BadInitializers
{
public:
 BadInitializers() {}
};

class OutOfBounds
{
public:
 OutOfBounds(int i) { cout<<"Size "<<i<<" is illegal!!!"<<endl; }
};

class SizeMismatch
{
public:
 SizeMismatch() {}
};

 

然后要在程序中需要的地方使用throw来抛出异常类，两个抛出异常类的例子如下

template <class T>
Array1D<T>::Array1D(int sz)
{
 if(sz<0)
 {
    //throw BadInitializers();

    throw invalid_argument("Size has to be bigger than 0!!!");
 }
 size=sz;
 element=new T[size];
}

template <class T>
T &Array1D<T>::operator[](int i) const
{
 if(i<0||i>=size)
 {
  throw OutOfBounds(i);
 }
 return element[i];
}

 

然后在主程序中使用try...catch...来捕获异常，并进行相应的处理，如下

try
 {
  int i=0;
  Array1D<int> a1(5);
  a1[0]=1;
  a1[1]=3;
  a1[2]=5;
  a1[3]=7;
  a1[4]=8;
  Array1D<int> a2(a1);
  for(i=0;i<a2.Size();i++)
  {
   cout<<a2[i]<<" ";
  }
  cout<<endl;

  Array1D<int> a3(5);
  a3=a1+a2;
  cout<<a3;
   }
 catch(BadInitializers)
 {
  cout<<"Error:BadInitializers!!!"<<endl;
 }
 catch(OutOfBounds &e)
 {
  cout<<"Error:OutOfBounds!!!"<<endl;
 }
 catch(SizeMismatch &e)
 {
  cout<<"Error:SizeMismatch!!!"<<endl;
 }

 catch(invalid_argument &e)
 {
  cout<<"Error:"<<e.what()<<endl;
 }
 catch(...)
 {
  cout<<"An unknown error!!!"<<endl;
 }