简易计算器

//function.h

bool  IsFullInput();			//检测输入是否过多字符
bool IsEmptyNum();			//判断操作数栈是否为空
bool IsEmptySym();			//判断操作符栈是否为空
void PushToNum(const double num);	//操作数压栈
void PushToSym(const char sym);		//操作符压栈
const double PopFromNum();	<span style="white-space:pre">	</span>//操作数出栈
const char PopFromSym();		//操作符出栈
const double TopNum();			//操作数栈栈顶元素
const char TopSym();			//操作符栈栈顶元素
void InitForInput();			//初始化输入表达式数组
void InitForOutput();			//初始化后缀表达式数组
void InitForNum();			//初始化操作数栈
void InitForSym();			//初始化操作符栈
void InitForAll();			//初始化函数
void InPut();				//用户输入表达式
void OutPut();				//程序输出答案
void Solve();				//核心函数
const int Priority(const char Sym);	//判断操作符优先级
void clear();				//清空消息队列
void save();				//保存计算结果在输出数组中
const double Calculate(const double one,const double two,const char Sym);	//对两个数进行计算
const double ToANum(int begin,int end,const char* array);			//将数字串转化为一个数字

//function.cpp

#include <iostream>
#include <math.h>
#include "function.h"
using namespace std;

char ArrayOfInput[50];		//输入表达式（中缀）
char ArrayOfOutput[50];		//输出结果
int SizeOfInput=0;		//输入表达式的长度
int SizeOfOutput=0;		//输出结果的长度
double StackOfNum[50];	        //操作数栈
char StackOfSym[50];	        //操作符栈
int TopOfNum=-1;		//操作数栈栈顶
int TopOfSym=-1;		//操作符栈栈顶

int main()
{
<span style="white-space:pre">	</span>while(1)
	{
		InPut();
		OutPut();
	}
	return 0;
}

//检测输入是否过多字符
bool  IsFullInput()
{
	return (SizeOfInput==50);
}

//判断操作数栈是否为空
bool IsEmptyNum()
{
	return (TopOfNum==-1);
}

//判断操作符栈是否为空
bool IsEmptySym()
{
	return (TopOfSym==-1);
}

//操作数压栈
void PushToNum(const double num)
{
	StackOfNum[++TopOfNum]=num;
}

//操作符压栈
void PushToSym(const char sym)
{
	StackOfSym[++TopOfSym]=sym;
}

//操作数出栈
const double PopFromNum()
{
	return StackOfNum[TopOfNum--];
}

//操作符出栈
const char PopFromSym()
{
	return StackOfSym[TopOfSym--];
}

//操作数栈栈顶元素
const double TopNum()
{
	return StackOfNum[TopOfNum];
}

//操作符栈栈顶元素
const char TopSym()
{
	return StackOfSym[TopOfSym];
}

//初始化输入表达式数组
void InitForInput()
{
	SizeOfInput=0;
}

//初始化后缀表达式数组
void InitForOutput()
{
	SizeOfOutput=0;
}

//初始化操作数栈
void InitForNum()
{
	TopOfNum=-1;
}

//初始化操作符栈
void InitForSym()
{
	TopOfSym=-1;
}

//初始化函数
void InitForAll()
{
	InitForInput();  <span style="white-space:pre">	</span>//初始化输入表达式数组
	InitForOutput();<span style="white-space:pre">	</span>//初始化后缀表达式数组
	InitForNum();	 <span style="white-space:pre">	</span>//初始化操作数栈
	InitForSym();    <span style="white-space:pre">	</span>//初始化操作符栈
}

//用户输入表达式
void InPut()
{
	bool Inputing=1;<span style="white-space:pre">	</span>//1：输入中，0：输入结束。
	InitForAll();
	cout << "输入表达式： " << endl;
	char key;
	while((key=cin.get()))
	{
		if(key=='\n')
		{
			if(Inputing)
				Solve();
			break;
		}
		if(IsFullInput())
		{
			cout << "输入字符过多!" << endl;
			clear();
			InPut();
		}
		else
		{
			if(key=='=')
			{
				Solve();
				Inputing=0;
			}
			else
			{
				if(key=='('&&ArrayOfInput[SizeOfInput-1]==')')
						ArrayOfInput[SizeOfInput++]='*';
				ArrayOfInput[SizeOfInput++]=key;
			}
		} //else
	}  //while
} //function

//程序输出答案
void OutPut()
{
	cout << "=" ;
	for(int i=0;i<SizeOfOutput;++i)
		cout << ArrayOfOutput[i];
	cout << endl;
}

//核心函数
void Solve()
{
	int Sym=-1;
	for(int i=0;i<SizeOfInput;++i)
	{
		if(Priority(ArrayOfInput[i]))
		{
			if(Sym!=i-1)<span style="white-space:pre">	</span>//“）”后面接一个运算符时，或“）”前面有一个运算符时
				PushToNum(ToANum(Sym+1,i-1,ArrayOfInput));
			switch(Priority(ArrayOfInput[i]))
			{
				case 1: 
				case 2: 
				case 3:	while(TopSym()!='(' && !IsEmptySym() && Priority(TopSym())>=Priority(ArrayOfInput[i]))
							PushToNum(Calculate(PopFromNum(),PopFromNum(),PopFromSym()));
						PushToSym(ArrayOfInput[i]);
						break;<span style="white-space:pre">	</span>//处理操作符“+”、“-”、“*”、“/”、“^”。

				case 4: PushToSym(ArrayOfInput[i]);
						break;	//处理操作符“(”

				case 5: while( TopSym()!='(')
							PushToNum(Calculate(PopFromNum(),PopFromNum(),PopFromSym()));
					    PopFromSym();
						break;  //处理操作符“)”
			}  //switch
			Sym=i;
		}  //if
	}  //for
	if(Sym!=SizeOfInput-1)
		PushToNum(ToANum(Sym+1,SizeOfInput-1,ArrayOfInput));<span style="white-space:pre">	</span>//将输入的表达式剩余操作数压入操作数栈中
	while(!IsEmptySym())
		PushToNum(Calculate(PopFromNum(),PopFromNum(),PopFromSym()));<span style="white-space:pre">	</span>//处理操作符栈中剩余操作符
	save();
} //function  

//保存计算结果在输出数组中
void save()
{
	double temp=PopFromNum();
	if(temp<0)
	{
		ArrayOfOutput[SizeOfOutput++]='-';
		temp=-temp;
	}
	int integer=int(temp);	//整数部分
	double decimals=temp-integer;	//小数部分
	//保存整数部分
	do
	{
		PushToSym(integer%10+'0');
		integer/=10;
	}while(integer);
	while(!IsEmptySym())
		ArrayOfOutput[SizeOfOutput++]=PopFromSym();

	//保存小数部分
	if(decimals!=0)
	{
		ArrayOfOutput[SizeOfOutput++]='.';
		ArrayOfOutput[SizeOfOutput++]=int(decimals*10)+'0';
	}
}

//对两个数进行计算
const double Calculate(const double one,const double two,const char Sym)
{
	switch(Sym)
	{
		case '+': return (one+two);
				  break;
		case '-': return (one-two);
				  break;
		case '*': return (one*two);
				  break;
		case '/': return (one/two);
				  break;
		case '^': return pow(one,two);
				  break;
	}
}

//判断操作符优先级
const int Priority(const char Sym)
{
	switch(Sym)
	{
		case '+':
		case '-': return 1;		//“+”、“-”的优先级为1
				  break;

		case '*': 
		case '/': return 2;		//“*”、“/”的优先级为2
				  break;

		case '^': return 3;		//“^”的优先级为3
				  break;

		case '(': return 4;
				  break;

		case ')': return 5;
				  break;

		default:  return 0;		//不是操作符！
	}
}

//将数字串转化为一个数字
const double ToANum(int begin,int end,const char* array)
{
	double integer=0,decimals=0;

	while(array[begin]!='.'&&begin<=end)
		integer=integer*10+(array[begin++]-'0');    //整数部分

	while(array[end]!='.'&&end>=begin)
		decimals=decimals*0.1+(array[end--]-'0')*0.1;   //小数部分

	return (integer+decimals);
}

//清空消息队列
void clear()
{
	while(cin.get()!='\n');
}