中缀表达式到后缀表达式的转换
　　要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。 如果所有操作符优先级一样，那么求值顺序就取决于它们的结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。
转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：
1. 初始化一个空堆栈，将结果字符串变量置空。
2. 从左到右读入中缀表达式，每次一个字符。
3. 如果字符是操作数，将它添加到结果字符串。
4. 如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
5. 如果字符是个开括号，把它压入堆栈。
6. 如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
7. 如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。

后缀表达式求值
　　对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：
1. 初始化一个空堆栈
2. 从左到右读入后缀表达式
3. 如果字符是一个操作数，把它压入堆栈。
4. 如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
5. 到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。

数据结构
　　在这两个算法中都要利用堆栈。因此这里首先给出一个堆栈的C++模板类，这个模板相当间接，只包含了表达式计算中必须要的功能。Pop Push Getsize 如下：
template <class T,int SIZE> class CArrayStackTemp
{
public:
CArrayStackTemp (){top= -1;}; //缺省构造函数,构造一个空堆栈
~CArrayStackTemp (){};//析构函数
bool Push(T element); //入栈
bool Pop(T& element);//出栈
int GetSize(){return top+1;};//取元素个数
private:
T Buffer[SIZE];
int top;
};
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: Push (T element)
{
top++;
if (top>SIZE-1) {top--; return false;}//满
Buffer[top]=element;
return true;
}
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: Pop (T& element)
{
if (top==-1) return false;//空
element=Buffer[top];
top--;
return true;
}

　　本文重在讲述原理和实现，因此以下算法只包含了+-*/()的处理，操作数自动转换为double型浮点数。是y=f(x)函数的计算，因此表达式中支持'X'字符，不分大小写，比如：y=(x-5)+2/(x+1)，下面的算法代码就是计算y值。

中缀表达式到后缀表达式的转换代码
LPCTSTR lpszS:表达式字串
CString &szD:结果
return =0:ok
int g_Mid2Behind(LPCTSTR lpszS,CString &szD)//中置->后置 只支持() + - * / 和X变量
{
CArrayStackTemp <char, 256> stk;//堆栈
CString szs=lpszS,szt="";
szs.TrimLeft(); szs.TrimRight();szs.MakeUpper();//大写
int i,len=szs.GetLength();
char c,cc,buf[256];;
for(i=0;i<len;i++)
{
c=szs[i];
if((c>'9')&&(c!='X')) return 1;//含有非法字符
if((c==' ')||(c=='\t')||(c==0x0d)||(c==0x0a)) continue;
szt+=c;
}
len=szt.GetLength();
if(len > 255) return 2;//太长
sprintf(buf,"%s",szt);
buf[len]=0;
char *p=(char *)buf;
szt=""; szD="";
bool bret;
while(*p != 0)
{
c=*p;
if( ((c>='0')&&(c<='9'))|| (c=='X')|| (c=='.') ){szt+=c;p++;continue;}
else
{
if(!szt.IsEmpty())//操作数,添加到结果字符串
{
len=szt.GetLength();
for(i=0;i<len;i++) szD+=szt[i];
szt="";
}
if((c == '+')||(c=='-'))
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD += cc;
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
stk.Push(c);
}
else if((c == '*')||(c=='/'))
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-')) szD += cc;
}while((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-'));
if((cc=='(')||(cc=='-')||(cc=='+')) stk.Push(cc);
stk.Push(c);
}
else if(c == '(') stk.Push(c);
else if(c == ')')
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD += cc;
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
}
else return 3;//操作符错误
}
p++;
}
if(!szt.IsEmpty())//操作数,添加到结果字符串
{
len=szt.GetLength();
for(i=0;i<len;i++) szD+=szt[i];
szt="";
}
while(stk.GetSize())
{
bret=stk.Pop(cc);
if((bret==true)&&(cc!='(')) szD += cc;
}
return 0;
}

后缀表达式求值代码
LPCTSTR lpszParse:后置表达式
double xval:变量X的值
double *pResult:计算结果
无错时返回TRUE
BOOL CalBehindParse(LPCTSTR lpszParse,double xval,double *pResult)
{
char c;
const char *pc=lpszParse;
double v1,v2;
CArrayStackTemp <double, 256> stk;//堆栈
CString szt="";
while(*pc != NULL)
{
c=*pc;
if(c=='X') stk.Push(xval);
else if( ((c>='0')&&(c<='9')) || (c=='.') ) {szt+=c;pc++;continue;}
else
{
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if(c=='+') stk.Push(v1+v2);
else if(c=='-') stk.Push(v1-v2);
else if(c=='*') stk.Push(v1*v2);
else if(c=='/') stk.Push(v1/v2);
else return FALSE;//非法运算符
}
pc++;
}
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(stk.GetSize()!=1) return FALSE;
return stk.Pop(*pResult);
}

把 CalBehindParse()稍作修改就可以得到后置表达式正确性检查的函数，如下：
BOOL CheckBehindParse(LPCTSTR lpszParse)//检查后置表达式
{
char c;
const char *pc=lpszParse;
double v1,v2;
CArrayStackTemp <double, 256> stk;
CString szt="";
while(*pc != NULL)
{
c=*pc;
if(c=='X') stk.Push(1);
else if( ((c>='0')&&(c<='9')) || (c=='.') ) {szt+=c;pc++;continue;}
else
{
if(!szt.IsEmpty()){stk.Push(atof(szt)); szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if((c=='+')||(c=='-')||(c=='*')||(c=='/')) stk.Push(1);
else return FALSE;//非法运算符
}
pc++;
}
if(stk.GetSize()!=1) return FALSE;
return TRUE;
}

综合以上这些函数，可以得到中置表达式的直接计算和检查函数：
BOOL CheckParse(LPCTSTR lpszParse)//检查中置表达式是否正确
{
CString szb;
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()) return TRUE;
return CheckBehindParse(szb);
}
BOOL CalParse(LPCTSTR lpszParse,double dblVar,double *pResult)//计算中置表达式
{
CString szb;
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()){*pResult=0; return TRUE;}
return CalBehindParse(szb,dblVar,pResult);
}

你可以用下面的测试例子去测试上面的函数：
double dblResult;
BOOL bret=CalParse("X / 2 * (X + 2.5)",2,&dblResult);//计算中置表达式