简单的四则运算计算器程序.docx
《简单的四则运算计算器程序.docx》由会员分享，可在线阅读，更多相关《简单的四则运算计算器程序.docx（14页珍藏版）》请在冰豆网上搜索。
简单的四则运算计算器程序
简单的四则运算计算器程序
实验目的与要求：
目的：
1、掌握类、构造函数/析构函数、栈等概念，掌握字符串操作；
2、步了解类的设计方法，初步了解词法分析、表达式求值的算符优先算法等内容。
要求：
以接收由键盘输入的整数四则运算表达式（由整数和加、减、乘、除、圆括号组成），计算出该表达式的值，然后输出结果。
方法、步骤：
设计2个栈，分别用于存放操作数和操作符，其中操作符有优先级。
栈内存放的操作数用一个类名为Operand的类存放；操作符用Operator类存放，并且设置相应运算符的优先级。
将用户输入的整个四则运算表达式字符串可看作由操作数，运算符和左右括弧（）组成的字符串，并用事先定义的操作数类、操作符类来表示相应的对象。
用一个叫分析器的类（Analyzer）对输入的四则运算进行分析扫描，每次返回一个字符串；定义一个名为calculate的函数将Analyzer的静态方法返回的字符串构造为相应的对象，放入各自的栈，并利用四则运算规则，计算相应的结果。
calculate函数利用四则运算的规则：
乘、除优先级高于加、减，放入操作符栈的规则为：
1、操作符栈里符号进栈规则是，后进栈的操作符优先级必须高于已经进栈符号的优先级，比方如果接收的操作符优先级等于或小于（<=）栈顶操作符优先级，则先对栈顶操作符进行出栈，运算；再将后面的操作符入栈保存。
这样保证操作符栈里符号优先级为由低到高，符合优先级高的操作符先出栈，参与运算的规则。
2、遇到左括弧“（”时，先将左括弧“（”进栈，当扫描到右括弧“）”时候，取操作符栈运算符出栈计算，直到栈顶为左括弧为止。
3、分析完输入字符串后，全部计算完成，计算结果便从操作数栈中取出。
实验过程及内容：
实验中整个用一个名为sizheyunsuan.cpp的C++源文件。
详细过程见附件程序清单。
该源文件中相关类的成员变量以及成员函数如下所示：
类：
Operand：
操作数类，包含私有成员operS，表示操作数的数值。
Operator：
操作符类，包含私有成员operF，priority，分别表示操作符的符号，以及运算优先级。
templateclassSTACK：
用于存放操作数和操作符的栈
Analyzer：
字符串扫描分析类，包含静态函数analysis（char*str,unsignedint&mark,char*returns）
函数：
voidcalculate（char*temp,STACK&sOperator,STACK&sOperand）：
对扫描返回的字符串分析，构造相应的对象，并依照运算规则进行计算。
voidmain（）：
程序主函数。
对象以及变量：
STACKsOperator：
存放操作数的栈
STACKsOperand：
存放操作符的栈
Analyzeranalyzer：
扫描分析器
charStr_input[MAX]：
存放用户输入的四则表达式
chartemp[12]：
存放分析器返回的字符串
unsignedintmark：
“游标”的作用，标示分析器每一次调用分析操作对应的输入字符串的位置。
运算结果图示：
（（2+5）*3-4*6+5）/2+10-6*（3-1）
数据处理分析：
1、接收用户输入，并作检查，判断用户是否正确输入。
2、如果输入正确，则进行计算：
计算过程，跟踪栈出入结果，表达式分析如下图：
（见下一页）
计算过程，跟踪栈出入结果，表示如下：
结果验证，计算结果正确
实验结论：
上述的“四则运算表达式”算法可以计算任意正整数的四则运算表达式，输入的原始表达式中的操作数只能为正整数、或者负数用2元表达式的形式，比方（-2）用（0-2）代替，操作符包含加、减、乘、除和括号。
原始表达式的长度100个字符（比这个长的表达式，不多了吧），但必须符合正整数“四则运算表达式”的运算法则。
指导教师批阅意见：
成绩评定：
指导教师签字：
年月日
备注：
注：
1、报告内的项目或内容设置，可根据实际情况加以调整和补充。
2、教师批改学生实验报告时间应在学生提交实验报告时间后10日内。
附件：
程序源代码
//sizheyunsuan.cpp:
Definestheentrypointfortheconsoleapplication.
#include
#include
constintMAX=100;
classOperand{
private:
doubleoperS;
public:
Operand（）{}
Operand（doubleopers）{
operS=opers;}
voidset（doubleopers）{
operS=opers;}
doubleget（）{
returnoperS;}
};
classOperator{
private:
charoperF;
intpriority;
public:
Operator（）{}
Operator（charoperf）{
operF=operf;
switch（operf）
{
case'（':
priority=-1;break;
case'+':
priority=0;break;
case'-':
priority=0;break;
case'*':
priority=1;break;
case'/':
priority=1;break;
case'）':
priority=2;break;
}
}
voidset（charoperf）{
operF=operf;}
charget（）{
returnoperF;}
intgetpriority（）{
returnpriority;}
};
template
classSTACK{//定义栈类
private:
Typebase[MAX];
intSize;
public:
STACK（）{Size=0;};
voidpush（Typea）{
base[Size]=a;
Size++;}
Typepop（）{
returnbase[--Size];}
TypegetTop（）{
returnbase[Size-1];}
intsize（）{
returnSize;}
};
classAnalyzer
{
public:
staticintanalysis（char*str,unsignedint&mark,char*returns）
{
inti=0;if（str[mark]=='（'||str[mark]=='）'||str[mark]=='*'||str[mark]=='+'||str[mark]=='-'||str[mark]=='/'）
{
returns[0]=str[mark++];
return0;
}
elseif（int（str[mark]）>=48&&int（str[mark]）<=57）
{
for（;int（str[mark]）>=48&&int（str[mark]）<=57;）
returns[i++]=str[mark++];
returns[i]='\0';
return0;
}
}
};
voidcalculate（char*temp,STACK&sOperator,STACK&sOperand）
{
if（temp[0]=='（'||temp[0]=='）'||temp[0]=='*'||temp[0]=='+'||temp[0]=='-'||temp[0]=='/'）
{
//cout<<"符号：
"<//--------------------------
//calculate计算
charch=temp[0];
doublea,b;
if（ch=='（'）
{
Operatoroper（'（'）;
sOperator.push（oper）;
//cout<<"符号：
"<}
elseif（ch=='）'）
{
while（sOperator.getTop（）.getpriority（）!
=-1）
{
b=sOperand.pop（）.get（）;
a=sOperand.pop（）.get（）;
switch（sOperator.pop（）.get（））
{
case'*':
a=a*b;break;
case'/':
{
if（b==0）
{
cout<<"程序错误，0作为除数出现！
";
}
else
a=a/b;
}break;
case'+':
a=a+b;break;
case'-':
a=a-b;break;
default:
{}break;
}
Operandoper（a）;
sOperand.push（oper）;
//cout<<"计算,并将结果压：
"<//cout<<"计算1次\n";
}
if（sOperator.getTop（）.getpriority（）==-1）
sOperator.pop（）;
}
elseif（ch=='+'||ch=='-'）
{
while（sOperator.size（）>0&&（sOperator.getTop（）.getpriority（）==1||sOperator.getTop（）.getpriority（）==0））
{
b=sOperand.pop（）.get（）;
a=sOperand.pop（）.get（）;
switch（sOperator.pop（）.get（））
{
case'*':
a=a*b;break;
case'/':
{
if（b==0）
{
cout<<"程序错误，0作为除数出现！
";
}
else
a=a/b;
}break;
case'+':
a=a+b;break;
case'-':
a=a-b;break;
default:
{}break;
}
Operandoper（a）;
sOperand.push（oper）;
//cout<<"计算,并将结果压：
"<//cout<<"计算1次\n";
}
Operatoroper（ch）;
sOperator.push（oper）;
//cout<<"符号：
"<}
elseif（ch=='*'||ch=='/'）
{
if（sOperator.size（）>0&&（sOperator.getTop（）.getpriority（）==1））
{
b=sOperand.pop（）.get（）;
a=sOperand.pop（）.get（）;
switch（sOperator.pop（）.get（））
{
case'*':
a=a*b;break;
case'/':
{
if（b==0）
{
cout<<"程序错误，0作为除数出现！
";
}
else
a=a/b;
}break;
default:
{}break;
}
Operandoper（a）;
sOperand.push（oper）;
//cout<<"计算,并将结果压：
"<//cout<<"计算1次\n";
}
Operatoroper（ch）;
sOperator.push（oper）;
//cout<<"符号：
"<}
//--------------------------
}
else
{
intt=0;
for（unsignedinti=0;i{
t=t*10+int（（temp[i]）-48）;
}
doublea=double（t）;
OperandoperS（a）;
sOperand.push（operS）;
//cout<<"操作数数：
"<}
};
voidmain（）
{
charStr_input[MAX];
chartemp[12];
unsignedintmark=0;
STACKsOperator;
STACKsOperand;
Analyzeranalyzer;
//do{
cout<<"该程序功能为根据表达式进行计算。
\n"
<<"可以实现的计算为带括弧（）的加减乘除四则运算，\n"
<<"在下方输入处输入表达式，以回车结束。
\n";
for（inty=0;y<12;y++）
temp[y]='\0';
for（intm=0;mStr_input[m]='\0';
cin>>Str_input;
cout<<'\n';
for（unsignedintn=0;n{cout<cout<<'\n';
for（unsignedinti=0;i{
if（!
（（int（Str_input[i]）<=57&&int（Str_input[i]）>=48）||Str_input[i]=='（'||Str_input[i]=='）'||Str_input[i]=='*'||Str_input[i]=='+'||Str_input[i]=='-'||Str_input[i]=='/'））
{
cout<<"输入字符串有非法字符，请重新输入：
\n";
break;
}
}
for（;mark{
for（inty=0;y<12;y++）
{temp[y]='\0';}
analyzer.analysis（Str_input,mark,temp）;
calculate（temp,sOperator,sOperand）;
}
for（;sOperator.size（）>0;）
{
doublea,b;
b=sOperand.pop（）.get（）;
a=sOperand.pop（）.get（）;
switch（sOperator.pop（）.get（））
{
case'*':
a=a*b;break;
case'/':
{
if（b==0）
{
cout<<"程序错误，0作为除数出现！
";
}
else
a=a/b;
}break;
case'+':
a=a+b;break;
case'-':
a=a-b;break;
default:
{}break;
}
Operandoper（a）;
sOperand.push（oper）;
//cout<<"计算,并将结果压：
"<//cout<<"计算1次\n";
}
if（sOperator.size（）==0&&sOperand.size（）==1）
cout<<"\n四则运算表达式计算结果为：
"<//}while（）;
}
升级会员 