C++基础：异常机制的处理原理

异常机制的处理原理：

大型和十分复杂的程序往往会产生一些很难查找的甚至是无法避免的运行时错误。

当发生运行时错误时，不能简单地结束程序运行，而是退回到任务的起点，指出错误，

并由用户决定下一步工作。面向对象的异常处理机制是C++语言用以解决这个问题的有力工具。

<span style="font-size:18px;">#include <iostream>
using namespace std;

float Div(int a, int b)
{
	if(b==0)
	{
		throw b;   //抛出异常
	}

	return a/b;
}

void main()
{
	int a = 10;
	int b = 0;

	try                 //尝试有可能发生异常的代码块
	{
		float result  = Div(a,b);
	}

	catch(int)           //捕获异常
	{
		cout<<"Div Error (int),b == 0"<<endl;
	}
	catch(short)
	{
		cout<<"Div Error (short),b == 0"<<endl;
	}
	catch(...)     //cathc all
	{
		cout<<"Div Error (all), b == 0"<<endl;
	}

	cout<<"result = "<<result<<endl;

}</span>

函数执行时，放在try（测试）程序块中的任何类型的数据对象发生异常，都可被throw块抛出，

随即沿调用链退回，直到被catch块捕获，并在此执行异常处理，报告出现的异常等情况。

从抛出到捕获，应将各嵌套调用函数残存在栈中的自动对象、自动变量和现场保护内容等进行清除。

如果已退到入口函数还未捕获则由abort()来终结入口函数。

自定义异常类与标准异常类：

#include <iostream>
#include <string>
using namespace std;

template<typename Type>
class PushOnStackFull     //异常类
{
public:
	PushOnStackFull(const char *s, int val):str(s),value(val)
	{}
	~PushOnStackFull()	
	{}
public:
	void _What()const
	{
		cout<<str<<endl;
		cout<<value<<"not push stack!"<<endl;
	}
private:
	Type value;
	string str;
};

template<typename Type>
class Stack
{
public:
	Stack(int sz = STACK_SIZE)
	{
		capacity = si > STACK_SIZE ? sz : STACK_SIZE;
		data = new Type[capacity];
		top = 0;
	}
	~Stack()
	{
		delete []data;
		data = NULL;
		capacity = top = 0;
	}
public:
	bool IsFull()const
	{
		return top >=capacity;
	}
	bool Push(const Type &x)
	{
		if(IsFull())
		{
			throw PushOnStackFull<Type>("栈已满，不能入栈!",x);
		}
		data[top++] = x;
		return true;
	}
public:
	void Show_Stack()const
	{
		for(int i = top - 1; i>=0; --i)
			cout<<data[i]<<endl;
	}
private:
	enum{STACK_SIZE = 8};
	Type *data;
	size_t capacity;
	size_t top;
};


void main()
{
	Stack<int> st;
	try
	{
		for(int i = 1; i <= 8; ++i)
		{
			st.Push(i);
		}
	}
	catch(PushOnStackFull<int> &e)
	{
		e._What();
	}
	st.Show_Stack();
}