C++简单异常处理举例

#include <iostream.h>
#include <stdlib.h>

//【例15.1】编写一个除法函数Div，要求避免除数为零的情况。
//方法一：按照传统处理除数为零的问题，需先判断除数是否为零，若为零告警出错；非零做除法运算，返回结果。

double Div(double a,double b)
{
 if (b==0)    //除数b为零，出错告警中断
 {
  cout<<"Error:attempted to divid by zero!\n";
  exit(1);
 }
 else return a/b;  //除数b为非零，正常返回除法运算结果
}
void main15_1_1()
{
 cout<<"8.4/2.1="<<Div(8.4,2.1)<<endl;
 cout<<"8.4/0.0="<<Div(8.4,0.0)<<endl;
 cout<<"8.4/3.1="<<Div(8.4,3.1)<<endl;
}

//方法二：利用C++中提供的异常机制来处理除数为零的问题

double Div1(double a,double b)
{
 if (b==0) throw b;  //发现异常，抛出异常对象b
  return a/b;
}

void main15_1_2()
{
 try {
   cout<<"8.4/2.1="<<Div1(8.4,2.1)<<endl;
   cout<<"8.4/0.0="<<Div1(8.4,0.0)<<endl;
   cout<<"8.4/3.1="<<Div1(8.4,3.1)<<endl;
 }
 catch(double)  //异常处理程序
 {
  cout<<"Error:attempted to divid by zero!\n";
 }
}

//【例15.2】定义一个Vector类，它可以用异常来处理下标越界的错误。

class Vector
{
 int *p;  //p为Vector向量指针
 int sz;  //sz为Vector向量元素的大小
public:
 Vector(int size)
 {
  p=new int[size];
  sz=size;
 }
 ~Vector()
 { delete[]p;  }
 int size() {return sz;}
 class Range{};   //下标越界异常类
 int& operator[](int i)
 {
  if (i>=0&&i<sz) return p[i];
  throw Range();  //下标越界抛出Range()类型的异常对象
 }
};
//在Vector类内定义了一个空类Range，用它来生成Vector的异常对象表示下标越界。
//在重载下标运算符函数中，当检测到下标运算符越界时，用throw Range()抛出Range
//类型的异常对象。

void f(Vector& v)
{
 try {     //检测下标越界异常
       v[0]=1;
      v[v.size()+5]=10;   //下标越界的错误
      cout<<"Try block end."<<endl;
 }
 catch(Vector::Range){   //下标越界异常处理
     cout<<"Vector::out of range!"<<endl;
 }
 cout<<"Function f() end."<<endl;
}

void main15_2()
{
 Vector vv(5);
 f(vv);
}

//【例15.3】 自定义一个基类，并从该基类公有派生两个不同派生类，实现对各种不同类型的捕获后的异常处理。

class Base
{
public:
 Base(){ };
};
class Derive1:public Base
{
public:
 int s;
 Derive1(int ss)
 { s=ss; }
};

class Derive2:public Base
{
public:
 Derive2(){ };
};

void fun()
{
 Derive1 Li(0);   //定义一个Derive1类的对象Li
 int i,k=6;
 for (i=0;i<=k;i++)
 {
       try{
   switch(i){
    case 0: throw 10;   //抛出int型异常
    case 1: throw 10.5;   //抛出double型异常
    case 2:  throw 'a';   //抛出char型异常
    case 3:  throw Li;   //抛出Derive1类的Li异常对象
    case 4:  throw Derive2();  //抛出Derive2类的异常对象
    case 5:  throw "abcd";  //抛出字符串的异常
    case 6: throw Base();  //抛出Base类的异常对象
   }
   cout<<"switch end.\n";
  }
  catch(int)     //捕获int型异常后的异常处理
  { cout<<"catch a int.\n";}
  catch(double& value)   //捕获double型异常后的异常处理
  { cout<<"catch a double,this value is "<<value<<"\n";}
  catch(char)     //捕获char型异常后的异常处理
  { cout<<"catch a char.\n";}
  catch(Derive1)    //捕获Derive1类异常对象后的异常处理
  { cout<<"catch a Derive1 class.\n";}
  catch(Base)     //捕获Base类异常对象后的异常处理
  { cout<<"catch a Base class.\n";}
  catch(...)     //捕获前面未捕获异常的所有异常处理
  { cout<<"Nothing is caught.\n"; }
 }
}

void main15_3()
{ fun(); }

//【例15.4】当不能处理抛出对象时，可以显示一条自已定义的出错信息"….error!"

#include <eh.h>

typedef void(*PFV)();

void error_message()
{
 cout<<"....error!"<<endl;
}

void fun3()     //设置terminate()要调用的函数error_message()
{
 PFV p=set_terminate(&error_message);
 try {
     throw 'a';   //抛出char类型的异常对象
 }
 catch(int){        //捕获int类型的异常对象
     cout<<"catch a int.\n";
 }
 catch(double){   //捕获double类型的异常对象
     cout<<"catch a double.\n";
 }
 set_terminate(p);   //恢复terminate()要调用的系统函数abort
}

void main15_4()
{ fun(); }

//【例15.5】在Vector类中进行下标越界、数组尺寸超长异常处理。

class Vector5{
 int *p;
 int sz;
 enum{ max=3000};  //数组的最大尺寸
public:
 Vector5(int size){
  if (size<0||size>max)
  throw Size();  //抛出数组尺寸超长异常对象
  p=new int[size];
  sz=size;
 }
 ~Vector5()
 { delete[]p;  }
 int size() const { return sz;}
 class Range{};   //下标越界异常类
 class Size {};   //数组尺寸超长异常类
 int& operator[](int i){
 if (i>=0&&i<sz) return p[i];
     throw Range();   //抛出下标越界异常对象
 }
};

void UseVectors(int size,int range){
 Vector5 vv(size);   //定义一个大小为size的数组对象vv
 vv[range]=10;   //给数组中指定下标range的元素赋值为10
}

void f(int size,int range){
    try{
  UseVectors(size,range);
  cout<<"Unexception in this time.\n"; //没有异常发生
 }
 catch(Vector5::Range)    //捕获数组越界的异常处理
 { cout<<"Vector:: out of range!"<<endl; }
 catch(Vector5::Size)   //捕获数组尺寸超长的异常处理
 { cout<<"Vector5::Size error!"<<endl;
     size=size>0?--size:0;  //将数组尺寸进行正确的调整,进行size--
     cout<<size<<endl;
     f(size,range);   //递归进行调整数组尺寸size
 }
 cout<<"Function f() end."<<endl;
}

void main15_5()
{
 int size,range;
 cout<<"input size,range:";
 cin>>size>>range;
 f(size,range);
}

//【例15.6】对算术运算中出现的异常用异常枚举法处理

enum MatheErr{Overflow,Underflow,Zerodivide};

void fun6()
{
     //…
     try {
      //…
      throw Zerodivide;
  }
     catch(MatheErr fe)
  {
   switch(fe)
   {
    case Overflow:   //…
    case Underflow:  //…
    case Zerodivide:break; //…
   }
  }
   //…
}

void main15_6()
{
 fun6();
}