栈的应用之后缀表达式

#include<iostream>  
#include<stack>
using namespace std;
enum Type
{
	_SYMBOL,  //操作符  
	_NUM,      //操作数  
	ADD,
	SUB,
	MUL,
	DIV,
};
struct Cell
{
	Type _type;     //每个传进来的单元的类型  
	int _value;    //操作数  
};
int CountRPN(Cell* rpn, size_t n)
{
	stack<int> s;
	for (size_t i = 0; i<n; i++)
	{
		//判断传进来的是操作符还是操作数压栈
		if (_NUM == rpn[i]._type)
		{
			s.push(rpn[i]._value);
		}
		if (_SYMBOL == rpn[i]._type)
		{
			int right = s.top();
			s.pop();
			int left = s.top();
			s.pop();
            //是操作符，就进行四则运算
			switch (rpn[i]._value)
			{
				case 2:
					s.push(left + right);
					break;
				case 3:
					s.push(left - right);
					break;
				case 4:
					s.push(right*left);
					break;
				case 5:
					if (right == 0)    //抛异常  
					{
						throw std::invalid_argument("参数错误！");
						//invalid_argument非法的参数，也是标准异常，  
					}
					s.push(left / right);
					break;
				default:
					throw std::invalid_argument("参数异常");
					break;
			}
		}
	}
	return s.top();
}
void Test()
{       //原来的式子是：17  
		//转换成后缀表达式：12 3 4 * -5 - 2 +
	Cell Rpn[] = {
		{ _NUM,  },
		{ _NUM, 3 },
		{ _NUM, 4 },
		{ _SYMBOL, MUL },
		{ _SYMBOL, SUB },
		{ _NUM, 5 },
		{ _SYMBOL, SUB },
		{ _NUM, 2 },
		{ _SYMBOL, ADD },
	};
	try
	{
		cout << CountRPN(Rpn, sizeof(Rpn) / sizeof(Rpn[0])) << endl;
	}
	catch (exception&e)   //捕获异常  
	{
		e.what();
		cout << "error" << endl;
	}
}
int main()
{
	Test();
	system("pause");
	return 0;
}