表达式转换并求其值（简易计算器）

后缀表达式，也称逆波兰表达式，是一种十分有用的表达式，它将复杂表达式转换为可以依靠简单的操作得到计算结果的表达式。因此对中缀表达式的求值可以首先转换为后缀表达式再对其求值。

这题是书本例题，书本上的例题考虑的情况比较少，只考虑了运算数不带正负号和整数的情况。在做题时经常会遇到运算数带符号和非整数的情况。所以我对书本例题进行了改进，使它能兼容这些情况。

第一部分：表达式转换

首先读入一串算式。

接着对算式里面的字符进行处理：

        遇到左括号直接入栈，继续处理下一个字符。

        如果是右括号，则将栈中元素依次弹出，直到遇到左括号（注意左括号也要弹出），继续处理下一个字符。

        对于‘+’、‘-’、‘*’、‘/’ 符号，首先将栈中元素依次弹出直到运算优先级比自己低的符号为止。然后再将改运算符入栈，继续处理下一个字符。其中‘+’、‘-’ 符号比较复杂，需要考虑它是运算符还是数字的正负号。

        数字则需要考虑多位和小数的清空，这里我使用字符串存储一个数字。遇到数字就循环判断下一个是否位数字或小数点，是则将它们都加在字符串末尾。

后缀表达式用一个字符串数组来存储，每一个字符串代表一个运算符或者数字。在上述对字符的处理中，每次有元素弹出就将它存储在字符串数组中，数字处理完后也将其存储。

	stack<string> st;
	string a;
	cin>>a;
	int i,j=0,d=0,k;
	int l=a.length();
	string postexp[Maxsize];    
	i=0;
	while(i<l)
	{	
		k=0;
		string t(Maxsize,'\0');		
		//自定义长度并分配内存，不分配内存直接使用下标访问会出错 
		//每次循环开始重新定义t并分配内存，防止上个数据修改字符串长度影响下一个数据
		switch (a[i]) {
			case '(':
				st.push("(");
				i++;
				break;
			case ')':
				while(st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				st.pop();
				i++;
				break;
			case '*':case '/':
				while(!st.empty() && st.top()!="+" && st.top()!="-" && st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				a[i]=='*'?st.push("*"):st.push("/");
				i++;
				break;
			case '+':case '-':
				if(i==0 && a[i]=='-'){	//首数字为负数 
				//	cout<<"-";
					t[k++]='-';i++;
					goto l;		//跳到数字操作，防止再次循环重新赋值t 
				}
				if(i+1<=l &&a[i+1]>='0' &&a[i+1]<='9' &&
				 ((a[i-1]<'0'||a[i-1]>'9') &&a[i-1]!=')' )){
				 		//中间数字带正负号 
					a[i]=='-'? t[k++]=a[i] : t[k++]=' ';i++;
					goto l;		//跳到数字操作 
				}
				while(!st.empty() && st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				a[i]=='+'?st.push("+"):st.push("-");
				i++;
				break;
			default:
l:				while( (a[i]>='0' && a[i]<='9') || a[i]=='.'){
				//	i==0?cout<<a[i]:cout<<" "<<a[i];
				//	postexp[j++]=a[i++];
					
					t[k++]=a[i++];
				//	d=d*10+a[i]-'0';
				}
				t.resize(k);//修改字符串长度，否则长度为设置的最大值100
				//即使赋值完后添加'\0'后仍然会越界访问，因为string类以长度做为结束标志 
				postexp[j++]=t;
				d==0? cout<<t : cout<<" "<<t;d=1;
				break;
		}
	}
	while(!st.empty())
	{
		cout<<" "<<st.top();
		postexp[j++]=st.top();
		st.pop();
	}
	cout<<endl;

由于我对string类的使用还不是太熟悉，刚开始写的时候出现了一些问题。

在未对string类进行赋值和分配内存时，直接使用下标对其进行访问会出错。因此必须首先对其进行分配内存。

string类并不是以'\0'结束的，即使在字符串末尾加上'\0'读取时仍会读取'\0'以后的数据，因为它的长度信息已经储存在类中，不需要用'\0'来判断是否到字符串尾。如果一开始定义了string类的长度，在后面赋值完后必须更新长度，否则读取时会一直读取到一开始定义的长度。

如果直接使用postexp来存储操作数和操作符就可以避免这些问题。

第二部分：表达式求值

循环遍历后缀表达式字符串数组：

        遇到数字先转换为浮点数，接着将其入栈，跳出本次循环。

        如果没遇到数字，则说明是运算符。首先从栈顶取两个元素，使用当前运算符进行计算，将运算结果入栈。

字符串全部处理完后，如果后缀表达式没有问题，则栈中最后一个元素即为最终结果。

	i=0;
	stack<double> sta;
	double p,q,s;
	for(i=0;i<j;i++)
	{
		if(postexp[i]!="+" && postexp[i]!="-"
		 && postexp[i]!="*" && postexp[i]!="/" ){
		 	s=stof(postexp[i].c_str());  //  由于postexp[i]中存储的是字符串，
            //需要先转换为浮点数
		 	sta.push(s);
		 	continue;
		 }
			p=sta.top();
			sta.pop();
			if(sta.empty()){
				cout<<"Expression Error: "<<s;
				exit(0);
			}
			q=sta.top();
			sta.pop();			
		switch (postexp[i][0]) {

			case '+':
				s=q+p;
				sta.push(s);
				break;
			case '-':
				s=q-p;
				sta.push(s);
				break;
			case '*':		
				s=q*p;	
				sta.push(s);
				break;
			case '/':
				if(s==0){
					cout<<"Error: "<<q<<"/0";
					exit(0);
				}		
				s=q/p;	
				sta.push(s);
				break;
		}
	
	}
	sta.pop();
	if(sta.empty())
		cout<<s<<endl;
	else
		cout<<"Expression Error: "<<s;

最终代码

#include<iostream>
#include<stack>
using namespace std;
//template <class T>
#define Maxsize 200
int main()
{
	stack<string> st;
	string a;
	cin>>a;
	int i,j=0,d=0,k;
	int l=a.length();
	string postexp[Maxsize];
	i=0;
	while(i<l)
	{	
		k=0;
		string t(Maxsize,'\0');		
		//自定义长度并分配内存，不分配内存直接使用下标访问会出错 
		//每次循环开始重新定义t并分配内存，防止上个数据修改字符串长度影响下一个数据
		switch (a[i]) {
			case '(':
				st.push("(");
				i++;
				break;
			case ')':
				while(st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				st.pop();
				i++;
				break;
			case '*':case '/':
				while(!st.empty() && st.top()!="+" && st.top()!="-" && st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				a[i]=='*'?st.push("*"):st.push("/");
				i++;
				break;
			case '+':case '-':
				if(i==0 && a[i]=='-'){	//首数字为负数 
				//	cout<<"-";
					t[k++]='-';i++;
					goto l;		//跳到数字操作，防止再次循环重新赋值t 
				}
				if(i+1<=l &&a[i+1]>='0' &&a[i+1]<='9' &&
				 ((a[i-1]<'0'||a[i-1]>'9') &&a[i-1]!=')' )){
				 		//中间数字带正负号 
					a[i]=='-'? t[k++]=a[i] : t[k++]=' ';i++;
					goto l;		//跳到数字操作 
				}
				while(!st.empty() && st.top()!="("){
					cout<<" "<<st.top();
					postexp[j++]=st.top();
					st.pop();
				}
				a[i]=='+'?st.push("+"):st.push("-");
				i++;
				break;
			default:
l:				while( (a[i]>='0' && a[i]<='9') || a[i]=='.'){
				//	i==0?cout<<a[i]:cout<<" "<<a[i];
				//	postexp[j++]=a[i++];
					
					t[k++]=a[i++];
				//	d=d*10+a[i]-'0';
				}
				t.resize(k);//修改字符串长度，否则长度为设置的最大值100
				//即使赋值完后添加'\0'后仍然会越界访问，因为string类以长度做为结束标志 
				postexp[j++]=t;
				d==0? cout<<t : cout<<" "<<t;d=1;
				break;
		}
	}
	while(!st.empty())
	{
		cout<<" "<<st.top();
		postexp[j++]=st.top();
		st.pop();
	}
	cout<<endl;
	for(i=0;i<j;i++)
		cout<<postexp[i]<<" ";	//测试 
	cout<<endl;


	i=0;
	stack<double> sta;
	double p,q,s;
	for(i=0;i<j;i++)
	{
		if(postexp[i]!="+" && postexp[i]!="-"
		 && postexp[i]!="*" && postexp[i]!="/" ){
		 	s=stof(postexp[i].c_str());
		 	sta.push(s);
		 	continue;
		 }
			p=sta.top();
			sta.pop();
			if(sta.empty()){
				cout<<"Expression Error: "<<s;
				exit(0);
			}
			q=sta.top();
			sta.pop();			
		switch (postexp[i][0]) {

			case '+':
				s=q+p;
				sta.push(s);
				break;
			case '-':
				s=q-p;
				sta.push(s);
				break;
			case '*':		
				s=q*p;	
				sta.push(s);
				break;
			case '/':
				if(s==0){
					cout<<"Error: "<<q<<"/0";
					exit(0);
				}		
				s=q/p;	
				sta.push(s);
				break;
		}
	
	}
	sta.pop();
	if(sta.empty())
		cout<<s<<endl;
	else
		cout<<"Expression Error: "<<s;
}

本算法存在一定的漏洞和不完善的地方，部分问题的解决方案不够合理，因此仅作为后缀表达式的学习参考，不建议直接使用。