C++的异常处理

对于我们常遇到的比如指针作为变量时候的判空是一个异常的处理情况，这时候我们就会使用assert()或者自己写出一个提示用户的异常处理，这时候我们就会使用类似return exit()这类的使这个进程，这个程序整体停止，这样有时候给程序员的调试带来很多不变，有时候我们做平常的事情也会希望有应急的预案，确保整体的事情继续执行下去，所以C++给程序员提供了一种异常处理的机制

1.以前的对于异常的处理方式

int Dev(int a,int b)
{
assert(b!=0);
return a/b;
}

int Dev(int a,int b)
{
if(b==0)

{
cout<<"Error!!!!!!\n";
return ;//exit(0);
}
return a/b;

}

2.用C++的异常处理机制

int Dev(int a,int b)
{
if(b==0)
{
throw int();//  throw b;这里可以认为int就是一个类，直返回类的一个对象，其实就是一个整型对象，这样有助于对后边抛出对象类型的理解
}
return a/b;

}

void main()
{
try
{
cout<<Dev(10,0)<<endl;
}//try 块与catch块之间不能有其他语句
catch(int)//只接受类型
{
cout<<"Error!!!!!!\n";
}
cout<<"这一句也可以执行！\n";

}

//函数其实左边返回值是正常的返回右边的返回式异常返回
//所以有异常规范右边加上throw()括号之内是规定的可以处理异常的类型throw()括号中必须写出要规定的处理类型，但是对于VC6.0来说可以运行，GCC就不行
int Dev(int a,int b)throw(int ,float)
{
if(b==0)
{
throw char();
}
return a/b;

}

void main()
{
try
{
cout<<Dev(10,0.0)<<endl;
cout<<"发生异常，这一句就不会执行！\n";
}
catch(int)
{
cout<<"Int_Error!!!!!!\n";
}
catch(float)
{
cout<<"Float_Error!!!!!!\n";
}
catch(...)//可以理解为switch case 中的default
{
cout<<"All Error!!\n";
}

}

class Object
{
public:
void Handler()
{
cout<<"Object 来处理!"<<endl;
}
};

class Base : public Object
{
public:
Base(int f=1):flag(f)
{}
void Handler()
{
if(flag)
{
cout<<"Base 异常!"<<endl;
}
else
{
cout<<"Object 异常!!"<<endl;
}
}
private:
int flag;
};

class D : public Base
{
public:
D(int x, int y):a(x),b(y)
{}
int div()
{
if(b == 0)
{
throw Base(0); //抛出无名对象
}
return a/b;
}
private:
int a;
int b;
};

void main()
{
D d(10,0);
try
{
cout<<d.div()<<endl;
}
catch(Base &e)//接受对象
{
cout<<"接受Base 抛出！\n";
try
{
e.Handler();
throw (Object ());//抛出无名对象
}
catch(Object &obj)//接受对象
{
obj.Handler();
}
}
}

#define DefaultArraySize 10

template<typename elemType>//类模板
class Array
{
private:
int  size;
elemType * ia ;
public:
explicit Array(int sz=DefaultArraySize)
{
size=sz;
ia=new elemType [size];
}
~ Array()
{
delete []ia;
}
elemType & operator[](int ix) const//重载[]加上数组越界管理
{
if(ix<0||ix>=size)
{
string eObj="out_of_range error in Array<elemType>::operator[]()";//系统的string类
throw out_of_range(eObj);
}
return  ia[ix];
}
};

void main()
{
Array<int> ar;
try
{
for(int i=1; i<=11; ++i)
{
ar[i-1] = i;
}
}
catch(out_of_range &e)//调用系统的数组越界检查
{
cout<<e.what()<<endl;//调用系统的what函数
}
}

上边是调用系统的函数，我么可以使用继承调用自己的函数

class Out
{
public:

Out(char *a=""):m_data(a)
{

}
char* w()
{
return m_data;
}
private:
char* m_data;

};

#define DefaultArraySize 10

template<typename elemType>
class Array :public Out
{
int  size;
elemType * ia ;
public:
explicit Array(int sz=DefaultArraySize)
{
size=sz;
ia=new elemType [size];
}
~ Array()
{
delete []ia;
}
elemType & operator[](int ix) const
{
if(ix<0||ix>=size)
{
char* eObj="out_of_range error in Array<elemType >::operator[]()";
throw Out(eObj);
}
return  ia[ix];
}
};

void main()
{
Array<int> ar;
try
{
for(int i=1; i<=11; ++i)
{
ar[i-1] = i;
}
}
catch(Out &e)
{
cout<<e.w()<<endl;
}
}

栈的异常类处理

//异常类
template<class Type>
class PushOnFull//入栈判满的异常处理类
{
public:
PushOnFull(char* s=""):str(s)
{}
Type GetData()const
{
return data;
}
Type what()
{
return str;
}
bool ReMalloc()
{
return true;
}
private:
//Type data;
Type str;
};

template<class Type>
class PopOnEmpty//出栈判空的异常处理类
{
public:
PopOnEmpty(char* s=""):str(s)
{}
Type what()const
{
return str;
}
private:
Type str;
};

template<class Type>//Stack类模板
class Stack
{
public:
Stack(int sz=SIZE)
{
capacity = sz>SIZE?sz:SIZE;
base = new Type[capacity];
top = 0;
}
~Stack()
{
delete []base;
base = NULL;
}
public:
bool IsFull()const
{return top >= capacity;}
bool IsEmpty()const
{return top==0;}
void Push(const Type &x)
{
if(IsFull())
{
char* str="栈满入栈异常发生！";
throw PushOnFull<char*>(str);
}
base[top++] = x;
}
void Pop()
{
if(IsEmpty())
{
char *str ="发生栈空出栈异常!";
throw PopOnEmpty<char*>(str);
}
top--;
}

private:
enum{SIZE=8};
Type *base;
size_t capacity;
int    top;
};

void main()
{
Stack<int> st;
try
{
for(int i=1; i<=5; ++i)
{
st.Push(i);
}
}
catch(PushOnFull<char*> &e)
{
cout<<e.what()<<endl;//
e.ReMalloc();
}

try
{
for(int i=0; i<10; ++i)
{
st.Pop();
}
}
catch(PopOnEmpty<char*> &exp)
{
cout<<exp.what()<<endl;
}
}