逆波兰表达式计算

#include<iostream>
#include<assert.h>
using namespace std;
class Stack
{
public:
Stack()
:_array(NULL)
, _size(0)
, _capacity(0)
{}
Stack(const Stack<T>& s)
:_array(new T[s._capacity])
, _size(s._size)
, _capacity(s._capacity)
{
for (int i = 0; i < s._size; ++i)
{
_array[i] = s._array[i];
}
}
Stack& operator=(Stack s)
{
swap(_array, s._array);
swap(_size, s._size);
swap(_capacity, s._capacity);
return *this;
}
~Stack()
{
//cout << "~Stack()" << endl;
delete[] _array;
_size = _capacity = 0;
}
void Push(const T& x)
{
_CheckCapacity();
_array[_size++] = x;
}
void Pop()
{
assert(!IsEmpty());
--_size;
}
bool IsEmpty()
{
return _size == 0;
}
bool IsFull()
{
return _size == _capacity;
}
size_t Size()
{
return _size;
}
const T&  Top()
{
return _array[_size - 1];
}
protected:
void  _CheckCapacity()
{
if (_size == _capacity)
{
_capacity = 2 * _capacity + 3;
T* tmp= new T[_capacity];
if (_array)
{
for (int i = 0; i < _size; ++i)
{
tmp[i] = _array[i];
}
delete[] _array;
}
_array = tmp;
}
}
public:
T *_array;
size_t _size;
size_t _capacity;
};
enum SYMBOL
{
ADD,
SUB,
MUL,
DIV
};
enum OpType
{
OP_NUM,
OP_SYMBOL
};
struct Cell//单元
{
OpType _type;
int _value;
};
//RNP逆波兰表达式
//12 3 4 + * 6 - 8 2 / +
//82
Cell RNPArray[11]=
{
{ OP_NUM, 12 }
,{ OP_NUM, 3 }
,{OP_NUM, 4}
,{OP_SYMBOL,ADD}
,{OP_SYMBOL, MUL}
, {OP_NUM,6}
, {OP_SYMBOL,SUB}
, {OP_NUM,8}
, {OP_NUM,2}
, {OP_SYMBOL,DIV}
, {OP_SYMBOL,ADD}
};
int CountRNP(Cell* RNPExp, size_t size)
{
Stack<int> s;
for (size_t i = 0; i < size; ++i)
{
if (RNPExp[i]._type == OP_NUM)
{
s.Push(RNPExp[i]._value);
}
else
{
int right = s.Top();
s.Pop();
int left = s.Top();
s.Pop();
switch (RNPExp[i]._value)
{
case ADD:
s.Push(left + right);
break;
case SUB:
s.Push(left - right);
break;
case MUL:
s.Push(left * right);
break;
case DIV:
//保证right!=0
// assert(!right);
s.Push(left / right);
break;
}
}
}
return s.Top();
}
int main()
{
//栈的特点：后进先出，只能从尾部进行操作
cout << CountRNP(RNPArray, 11) << endl;
system("pause");
return 0;
}