后缀表达式求值

#include 
#include 
#include 

using namespace std;

typedef unsigned int DWORD;

class PostOrder
{
public:
	PostOrder（char *pInput）
	{
		assert（pInput != 0）;
		m_pszInput = pInput;
		m_dwSize = strlen（pInput）;
		assert（m_dwSize>=3）;
		m_pszOutput = new char[m_dwSize];
		assert（m_pszOutput!=0）;
		memset（m_pszOutput0m_dwSize）;
		m_dwOpIdx = 0;
		m_dwResult = 0;
	}

	DWORD GetPriority（char ch）
	{
		int prio = 0;
		switch （ch）
		{
		case ‘+‘:
		case ‘-‘:
			prio = 1;
			break;
		case ‘*‘:
		case ‘/‘:
			prio = 2;
			break;
		case ‘（‘:
		case ‘）‘:
			prio = 3;
			break;
		default:
			assert（0）;
		}
	
		return prio;
	}

	DWORD Process（）
	{
		char *pStack = new char[m_dwSize];
		int StackIdx = 0;
		DWORD StackBottomPrio = 0;

		for（DWORD i = 0; i< m_dwSize;i++）
		{
			char ch = m_pszInput[i];

			if （（‘0‘ <= ch）&&（‘9‘>= ch））
			{
				m_pszOutput[m_dwOpIdx] = ch;
				m_dwOpIdx++;
			}
			else
			{
				
				switch （ch）
				{
					case ‘+‘:
					case ‘-‘:
					case ‘*‘:
					case ‘/‘:

						if （GetPriority（ch）>StackBottomPrio）
						{
							pStack[StackIdx] = ch;
							StackIdx++;

							if （!StackBottomPrio） StackBottomPrio = GetPriority（ch）;
						
						}
						else
						{
							while（StackIdx > 0）
							{
								if （‘（‘ == pStack[--StackIdx]）
								{
									StackIdx++;
									break;
								}
								else
								{									
									m_pszOutput[m_dwOpIdx] = pStack[StackIdx];
									m_dwOpIdx++;	
								}
							}

							DWORD dwTEMP = StackIdx;

							if （!dwTEMP） StackBottomPrio = 0;
							else
							{
								dwTEMP--;
								while（（dwTEMP > 0） && （‘（‘ != pStack[dwTEMP-1]））
								{
									dwTEMP--;
								}

								StackBottomPrio = GetPriority（pStack[dwTEMP]）;	
							}

							pStack[StackIdx] = ch;
							StackIdx++;
							
						}
						break;

					case ‘（‘:
							pStack[StackIdx] = ch;
							StackIdx++;

							StackBottomPrio = 0;
							break;
							
					case ‘）‘:
						while（StackIdx > 0）
						{
							if （‘（‘ != pStack[--StackIdx]）
							{
								m_pszOutput[m_dwOpIdx] = pStack[StackIdx];
								m_dwOpIdx++;
							}
							else
								break;
						};

						break;
					default:
						assert（0）;
				}
			}
	
		}

		while（StackIdx > 0）
		{
			StackIdx--;
			m_pszOutput[m_dwOpIdx] = pStack[StackIdx];
			m_dwOpIdx++;
		}

		m_pszOutput[m_dwOpIdx] = 0;

		delete pStack;

		return 0;
	
	}

	void calculate（）
	{
		DWORD dwLen = strlen（m_pszOutput）;
		DWORD *pStack = new DWORD[dwLen] ;
		DWORD StackIdx = 0;
		for （DWORD dwIdx = 0; dwIdx < dwLen; dwIdx++）
		{