用C实现简单计算器.docx
《用C实现简单计算器.docx》由会员分享,可在线阅读,更多相关《用C实现简单计算器.docx(15页珍藏版)》请在冰点文库上搜索。
用C实现简单计算器
一、需求描述
度这次c++课程设计作业,我们小组选择的是设计一个简单的计算器。
我们平常所用的计算器都是可视化界面计算器,对于计算一些混合的四则算术运算不是很方便,所以我们此次设计的计算器则是可以进行四则混合运算,用户可以从键盘输入算式,可以进行加、减、乘、除混合运算,运算的优先级也已经考虑在内,并且用户可以按任何的运算符出现顺序进行输入,输入的计算式的长也是不限定。
这样就方便了我们对于一些混合算式的计算。
但是我们的程序也还存在一定问题,关于括号“()”优先级运算就没有实现,还有简单的三角函数,只要输入一个数就能求出值。
二、流程图
四则运算。
三角函数的流程图也是类似
在编码过程中,我们在编码过程中主要有一个counter类,counter里面一共有三个函数,分别是input()输入函数、suanfa()计算函数和show()显示函数,体现了类的封装性,另外还有一个不同函数进行程序说明。
本程序实现加、减、乘、除的基本运算,并能按照四则运算的基本法则进行运算,,在除法运算中,当被除数为零的时候,系统会报错,提示被除数不能为零,则会退出程序。
三、编码
#include
usingnamespacestd;
classcomplex
{
private:
intn;
doublea[100];
charfh[100];
public:
input();
suanfa();
show();
};
//四则运算
complex:
:
input()
cout<<"请输入表达式,并且以“=”结尾"<for(inti=0;i<100;i++){cin>>a[i];cin>>fh[i];if(fh[i]=='=')//"="为结束符标志{n=i;break;}}}complex::suanfa(){charsign;for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-'){a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];}elseif(fh[j]=='/'){if(fh[j-1]=='+'){if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{cout<<"除数为0,退出程序!"<exit(0);}}elseif(fh[j-1]=='-'){if(a[j+1]!=0){a[j+1]=-a[j]/a[j+1];a[j]=0;}else{cout<<"除数为0,退出程序!"<exit(0);}}else{if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];}else{cout<<"除数为0,退出程序!"<exit(0);}}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
for(inti=0;i<100;i++)
cin>>a[i];
cin>>fh[i];
if(fh[i]=='=')//"="为结束符标志
n=i;
break;
}
suanfa()
charsign;
for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-'){a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];}elseif(fh[j]=='/'){if(fh[j-1]=='+'){if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{cout<<"除数为0,退出程序!"<exit(0);}}elseif(fh[j-1]=='-'){if(a[j+1]!=0){a[j+1]=-a[j]/a[j+1];a[j]=0;}else{cout<<"除数为0,退出程序!"<exit(0);}}else{if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];}else{cout<<"除数为0,退出程序!"<exit(0);}}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
if(fh[j]=='*')
if(fh[j-1]=='+')
a[j+1]=a[j]*a[j+1];
a[j]=0;
fh[j]='+';
elseif(fh[j-1]=='-')
a[j+1]=-a[j]*a[j+1];
elsea[j+1]=a[j]*a[j+1];
elseif(fh[j]=='/')
if(a[j+1]!
=0)
a[j+1]=a[j]/a[j+1];
else
cout<<"除数为0,退出程序!
"<exit(0);}}elseif(fh[j-1]=='-'){if(a[j+1]!=0){a[j+1]=-a[j]/a[j+1];a[j]=0;}else{cout<<"除数为0,退出程序!"<exit(0);}}else{if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];}else{cout<<"除数为0,退出程序!"<exit(0);}}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
exit(0);
a[j+1]=-a[j]/a[j+1];
"<exit(0);}}else{if(a[j+1]!=0){a[j+1]=a[j]/a[j+1];}else{cout<<"除数为0,退出程序!"<exit(0);}}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
"<exit(0);}}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
if(fh[i]=='+')
a[i+1]=a[i]+a[i+1];
elseif(fh[i]=='-')
if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}complex::show(){cout<<"该表达式的结果为:";cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
a[i+1]=-(a[i+1]-a[i]);
a[i+1]=a[i]-a[i+1];
show()
cout<<"该表达式的结果为:
";
cout<}intmain(){charsign;intm,n,p;complexb;cout<<"\t\t****************************************************\n";cout<<"\t\t*C++课程设计*\n";cout<<"\t\t*1、简单的计算器*\n";cout<<"\t\t*2、三角函数*\n";cout<<"\t\t****************************************************\n";cout<<"\n说明:可以进行四则混合运算,但是不能进行括号优先级运算\n";cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
intmain()
intm,n,p;
complexb;
cout<<"\t\t****************************************************\n";
cout<<"\t\t*C++课程设计*\n";
cout<<"\t\t*1、简单的计算器*\n";
cout<<"\t\t*2、三角函数*\n";
cout<<"\n说明:
可以进行四则混合运算,但是不能进行括号优先级运算\n";
cout<cout<<"\t\t*请选择计算类型*\n";cin>>m;switch(m){case1:b.input();b.suanfa();b.show();break;//三角函数:case2:cout<<"\t\t****************************************************\n";cout<<"\t\t*1、正弦*\n";cout<<"\t\t*2、余弦*\n";cout<<"\t\t*3、正切*\n";cout<<"\t\t****************************************************\n";cout<<"\t\t*请选择三角函数类型*\n";cin>>n;cout<<"\t\t*请输入要求的数*\n";cin>>p;switch(n){case1:cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
cout<<"\t\t*请选择计算类型*\n";
cin>>m;
switch(m)
{case1:
b.input();
b.suanfa();
b.show();
//三角函数:
case2:
cout<<"\t\t*1、正弦*\n";
cout<<"\t\t*2、余弦*\n";
cout<<"\t\t*3、正切*\n";
cout<<"\t\t*请选择三角函数类型*\n";
cin>>n;
cout<<"\t\t*请输入要求的数*\n";
cin>>p;
switch(n)
cout<break;case2:cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
cout<break;case3:cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
case3:
cout<break;}}while(true){cout<<"是否继续?输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
while(true)
cout<<"是否继续?
输入y表示继续,n表示退出"<cin>>sign;if(sign=='y'){b.input();b.suanfa();b.show();}else{break;}}return0;}四、测试报告1、关于算法结构的逐步完善。原来算法的源代码如下:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
cin>>sign;
if(sign=='y')
return0;
四、测试报告
1、关于算法结构的逐步完善。
原来算法的源代码如下:
counter:
for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]*a[j+1];a[j]=0; fh[j]='+';}}elseif(fh[j]=='/'){if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}else{a[j+1]=-a[j]/a[j+1];a[j]=0;fh[j]='+';}}}for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
for(inti=0;i{if(fh[i]=='+')a[i+1]=a[i]+a[i+1];elseif(fh[i]=='-'){if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
if(a[i]{a[i+1]=-(a[i+1]-a[i]);}elsea[i+1]=a[i]-a[i+1];}}}测试结果:当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。如输入以下测试实例:“1+2*3=”,正确结果因为“7”“1+4/2=”,正确结果因为“3”“5-6/3=”,正确结果因为“3”“7-2*3=”,正确结果因为“1”但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。如以下测试实例:“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”改进后的程序代码:counter::suanfa(){for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
测试结果:
当先输入加减“+、-”运算符,再输入乘除“*、/”时,计算结果是正确的。
如输入以下测试实例:
“1+2*3=”,正确结果因为“7”
“1+4/2=”,正确结果因为“3”
“5-6/3=”,正确结果因为“3”
“7-2*3=”,正确结果因为“1”
但是如果先输入乘除“*、/”时,再输入加减“+、-”运算符,则会出现错误。
如以下测试实例:
“2*3+1=”,正确结果因为“7”,但是程序结果却为“-5”
“4/2-1=”,正确结果因为“1”,但是程序结果却为“-3”
改进后的程序代码:
for(intj=0;j{if(fh[j]=='*'){if(fh[j-1]=='+'){a[j+1]=a[j]*a[j+1];a[j]=0;fh[j]='+';}elseif(fh[j-1]=='-')//此处有修改{a[j+1]=-a[j]*a[j+1];a[j]=0;fh[j]='+';}elsea[j+1]=a[j]*a[j+1];//此处有修改}elseif(fh[j]=='/')//此处有修改{if(fh[j-1]=='+'){a[j+1]=a[j]/a[j+1];a[j]=0;fh[j]='+';}测试结果:修改后的算法,对于先输入什么运算符号,结果都没有影响。输入以下测试实例:“2*3+1=”,正确结果因为“7”“4/2-1=”,正确结果因为“1”五、个人总结通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
{if(fh[j]=='*')
{if(fh[j-1]=='+')
{a[j+1]=a[j]*a[j+1];
elseif(fh[j-1]=='-')//此处有修改
{a[j+1]=-a[j]*a[j+1];
fh[j]='+';}
elsea[j+1]=a[j]*a[j+1];//此处有修改
elseif(fh[j]=='/')//此处有修改
{a[j+1]=a[j]/a[j+1];
修改后的算法,对于先输入什么运算符号,结果都没有影响。
输入以下测试实例:
“2*3+1=”,正确结果因为“7”
“4/2-1=”,正确结果因为“1”
五、个人总结
通过这次课程设计的制作,使我对于类的封装性,以及类函数的调用有了更深一步的了解。
在程序设计最初,是准备将函数的输入和结果的输出都写在主函数中,但是在后来的编码过程中,发现如果需要重复使用,这样写,很不方便。
但是如果在类当中,通过构造函数来实现输入输出,那么在主函数中只要新建一个类对象就可以重复使用。
另外,在我的主要算法函数中,我是通过多重循环嵌套来实现的。
通过这次课程设计,我,因为我的编程基础都比较薄弱,但是一次次讨论、尝试,最终还是基本完成此次作业。
copyright@ 2008-2023 冰点文库 网站版权所有
经营许可证编号:鄂ICP备19020893号-2