首先，先启动Visual Studio，这里以2005版做演示。
接着新建立一个MFC项目， 并命名为Calculator。
由于这个计算器的功能很简单，只需要使用“对话框”类型，并且允许使用最大化、最小化按钮。
下面两个页面的内容无须修改，使用默认设置就可以了。所以单击“完成”按钮关闭向导就可以了。
然后程序会完成整个工程的初始化工作，如果你的电脑内存在512MB以下，或是CPU主频在1.6GHZ以下，会卡上一镇，请稍等。
完成后到“资源视图”中找到如图所示的项目，打开红可以看到一个对话框。
这个默认的对话框里面，有一个静态文本控件和两个按钮，其中文本和“确定”按钮不是我们所需要的，可以删掉。然后到左边的“工具箱”里面，拖几个静态文本控件（Static Text）、编辑框（Edit）和按钮（Button）过来，到“属性”中把它们的Caption改好，结果如图所示。
然后给每一个编辑框添加变量，右键单击编辑框后选择添加变量，然后把类型改成Value，变量类型改成double（双精度浮点数）。
最后是为每一个按钮（“取消”除外）添加消息处理函数，否则就不能计算了。
双击后会自动跳转到编译器。
代码我帮你写好了，Copy就行了。
void CcaculatorDlg::OnBnClickedButton1()//“+”按钮消息处理函数
{
UpdateData(1)//将控件中用陆拍颤户输入的值传递给变量
m_result = m_data1 + m_data2 //加法计算
UpdateData(0)//将变量的值传给控件，程序会自动重画控件
}
void CcaculatorDlg::OnBnClickedButton2()//“-”按钮消息处理函数
{
UpdateData(1)//将控件中用户输入的值传递给变量
m_result = m_data1 + m_data2 //减法计算
UpdateData(0)//将变量的值传给控件，程序会自动重画控件
}
void CcaculatorDlg::OnBnClickedButton3()//“*”按钮消息处理函数
{
UpdateData(1)//将控件中用户输入的值传递给变量
m_result = m_data1 * m_data2 //乘法计算
UpdateData(0)//将早败变量的值传给控件，程序会自动重画控件
}
void CcaculatorDlg::OnBnClickedButton4()//“/”按钮消息处理函数
{
UpdateData(1)//将控件中用户输入的值传递给变量
if( m_data2 == 0 )//判断除数是否为零
{
MessageBeep(-1)//响铃，因为除数不能为零
}
else
{
m_result = m_data1 / m_data2 //除法计算
}
UpdateData(0)//将变量的值传给控件，程序会自动重画控件
}
最后按下F5…………OK，我们的计算器写成了！
二、简易的计算器，四则运算计算器C++原代码
，希望对你有帮助
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
/************/
#define STRING_LENGTH 1000
#define NUMBER_LENGTH 40
/*结构体定义*/
struct symbol
{
char c
struct symbol *next
}*symbol_head=NULL,*temp=NULL
struct number
{
double n
struct number *next
}*number_head=NULL,*temp_2=NULL
char result[NUMBER_LENGTH]
/**********/
/*函数声明*/
double ji_shuan(double a,char t,double b)/*两个double数据计算*/
void string_scan(char *str)/*字符串算式扫描*/
void operate(void)/*链表 *** 作*/
void operate(void)/*链表 *** 作*/
{
temp=symbol_head->next
symbol_head->next=symbol_head->next->next
number_head->n=ji_shuan(number_head->next->n,temp->c,number_head->n)
temp_2=number_head->next
number_head->next=number_head->next->next
free(temp)
free(temp_2)
}
double ji_shuan(double a,char t,double b)/*两个double数据计算*/
{
switch(t)
{
case '+':return a+bbreak
case '-':return a-bbreak
case '*':return a*bbreak
case '/':return a/bbreak
default:
printf("ji_shuan方法调用有误!任意键退出...")
getchar()
exit(0)//用于调试程序时出错指示
}
}
void string_scan(char *str)/*字符串算式扫描*/
{
int i=0
char temp_str[NUMBER_LENGTH]
struct symbol *t
/*ecvt函数用到的变量*/
char *string//存放字符串
int ndig//字符串长度
int dec//小数点位置
int sign//正负标记
/********************/
t=(struct symbol *)malloc(sizeof(struct symbol))
t->next=symbol_head
symbol_head=t
symbol_head->c='#'
for(i=0i<strlen(str)i++)
{
if((str[i]>='0'&&str[i]<='9')||(str[i]=='-'&&(str[i-1]<'0'||str[i-1]>'9')&&str[i-1]!=')'))//检测到数字,(出现"-"号,并且检测到前一个是除")"外的符号,则此为负号(不是减号),此数为负数)
{
struct number *t
int j=0
while((str[i]>='0'&&str[i]<='9')||str[i]=='.')
{
temp_str[j]=str[i]
i++
j++
}
temp_str[j]='\0'
t=(struct number *)malloc(sizeof(struct number))
t->next=number_head
number_head=t
number_head->n=atof(temp_str)//double atof(*char)为字符串转double函数
}
if(str[i]=='('||str[i]==')'||str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/'||str[i]=='=')
{
struct symbol *t
t=(struct symbol *)malloc(sizeof(struct symbol))
t->next=symbol_head
symbol_head=t
symbol_head->c=str[i]
if((str[i]=='+'||str[i]=='-')&&symbol_head->next->c!='#'&&symbol_head->next->c!='(')
{
operate()
if(symbol_head->next->c!='#'&&symbol_head->next->c!='(')
{
operate()
}
}
else if((str[i]=='*'||str[i]=='/')&&(symbol_head->next->c=='*'||symbol_head->next->c=='/'))
{
operate()
}
else if(str[i]=='=')
{
while(symbol_head->next->c!='#')
{
operate()
}
temp=symbol_head
symbol_head=symbol_head->next->next
free(temp)
}
else if(str[i]==')')
{
while(symbol_head->next->c!='(')
{
operate()
}
temp=symbol_head
symbol_head=symbol_head->next->next
free(temp)
}
}
}
/*用于调试*/
/*while(number_head!=NULL||symbol_head!=NULL)
{
if(number_head!=NULL)
{
printf("%f",number_head->n)
number_head=number_head->next
}
if(symbol_head!=NULL)
{
printf("%c",symbol_head->c)
symbol_head=symbol_head->next
}
}*/
printf("以double型输出的结果:\n%f\n",number_head->n)
gcvt(number_head->n,NUMBER_LENGTH,result)//调用double转字符串函数
if(result[strlen(result)-1]=='.')//如果最后位是小数点,则去掉
{
result[strlen(result)-1]=result[strlen(result)]
}
printf("调用浮点型转字符串函数gctv的输出结果:\n%s\n",result)
ndig=20//设置小数点后显示10位
string = ecvt(number_head->n, ndig, &dec, &sign)
printf("调用浮点型转字符串函数ectv的输出结果:\n字符串:%s 小数点在第%d位后 ",string,dec)
if(sign==0)
{
printf("此数为正数\n")
}
else
{
printf("此数为负数\n")
}
}
void main(void)/*入口函数*/
{
char str[STRING_LENGTH]/*最大算式长*/
int i=0,select=0
int bracket_flag=0/*括号对称性标记*/
while(1)
{
root: bracket_flag=0
printf("请输入算式,允许带括号的加减乘除四则运算,以\"=\"号结束\n")
scanf("%s",str)
/*******算式查错*********/
if((str[0]<'0'||str[0]>'9')&&str[0]!='-'&&str[0]!='(')
{
printf("算式错误!请重新输入...\n")
goto root
}
for(i=0i<strlen(str)-1i++)
{
if((str[i]<'0'||str[i]>'9')&&(str[i]!='+'&&str[i]!='-'&&str[i]!='*'&&str[i]!='/'&&str[i]!='('&&str[i]!=')'&&str[i]!='.'&&str[i]!='='))
{
printf("算式中含有非法字符!请重新输入...\n")
goto root
}
else if(str[i]=='(')
{
bracket_flag++
}
else if(str[i]==')')
{
bracket_flag--
if(bracket_flag==-1)/* 出现先有")"的情况 */
{
printf("括号不匹配!请重新输入...\n")
goto root
}
}
else if(str[i]=='=')
{
printf("算式中间不允许出现\"=\"号!请重新输入...\n")
goto root
}
if((str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/')&&(str[i+1]=='+'||str[i+1]=='-'||str[i+1]=='*'||str[i+1]=='/'||str[i+1]==')'))
{
printf("运算符输入有误!请重新输入...\n")
goto root
}
else if(str[i]=='('&&str[i+1]==')')
{
printf("括号内不可无数值!请重新输入...\n")
goto root
}
else if(str[i]==')'&&(str[i+1]!='+'&&str[i+1]!='-'&&str[i+1]!='*'&&str[i+1]!='/'))
{
printf("括号后不可无运算符!请重新输入...\n")
goto root
}
}
if(bracket_flag!=0)
{
printf("括号不匹配!请重新输入...\n")
goto root
}
if(str[strlen(str)-1]!='=')//自动添加"="
{
printf("未输入\"=\"号,自动添加...\n")
str[strlen(str)+1]=str[strlen(str)]
str[strlen(str)]='='
puts(str)
}
string_scan(str)
printf("\n计算完成!请选择:\n1.继续计算.\n2.退出.\n\n")
loop_2: scanf("%d",&select)
switch(select)
{
case 1: break
case 2: exit(0)
default :printf("选择错误!请重新选择...\n")goto loop_2break
}
}
}
三：实现功能：
1）具备整型数据、浮点型数据的算术（加、减、乘、除）运算功能。
依次输入第一个运算数、运算符（+，-，*，/）,第二个运算数，然后输出结果。
结果可以作为下一个运算的第一运算数。按‘C’清屏，按‘X’退出。
例如：输入：2
+
5
输出：7
2）实现单运算符表达式计算的功能。
输入的 *** 作数可以包含整数或浮点数。如果遇到错误的表达式，应输出错误提示信息。
输入表达式如下：
例如：输入：2+5
输出：7
表达式要求要可以有括号,并且+-*/要分优先级的
//文件名：caculate.cpp
#include <iostream.h>
#include <stdlib.h> //包含清屏函数的头文件
void first() //定义界面函数
{
cout<<"---------------------------------------------------------------"<<endl
cout<<" 欢迎使用计算器 "<<endl
cout<<"---------------------------------------------------------------"<<endl
cout<<"请选择以下功能："<<endl
cout<<endl
cout<<"1、按C键清屏 2、按R键返回主界面"<<endl
cout<<endl
}
void function(char)//申明功能函数
void caculate (double X,char op,double Y) //申明计算函数
void main()
{
first()
int n=0
char op // op定义为某个运算符号
double X,Y
cout<<"输入运算:"
cin>>X>>op>>Y
caculate(X,op,Y) // 调用计算函数
}
void function(char iteam) //定义功能函数
{
char op
double X,Y
if(iteam=='C')
{
system("cls") //如果是C，则清屏，调用清屏函数
cout<<"继续 *** 作请输入X,op,Y"<<endl //实现二次 *** 作的语句
cin>>X>>op>>Y
caculate(X,op,Y)
}
if(iteam=='R')
{
first()//如果是R，则返回主界面
cout<<"继续 *** 作请输入X,op,Y"<<endl
cin>>X>>op>>Y
caculate(X,op,Y)
}
}
void caculate (double X,char op,double Y) //定义计算函数
{
char opp
cout<<"输出结果:"
switch(op) //用switch语句定义加减乘除
{
case'+':X=X+Y
cout<<X<<endl
break
case'-':X=X-Y
cout<<X<<endl
break
case'*':X=X*Y
cout<<X<<endl
break
case'/':
if(Y!=0)
{
X=X/Y
cout<<X<<endl
}
else
cout<<"error!"<<endl
break
default:cout<<"error!"<<endl
}
cin>>opp
function(opp) //调用function语句判断是否是输入菜单中的命令
if(opp=='+'||opp=='-'||opp=='*'||opp=='/') //判断第一个输入的字符是不是+、-、*、/
{ //如果是运算符，那么再次输入一个运算数字，递规调用caculate函数，实现再次运算
cin>>Y
caculate(X,opp,Y)
}
else if(sizeof(double (opp))==8)
{
X=double(opp)-48 //强制类型转换,将字符型的op转换为double型
cin>>opp>>Y //如果不是运算符，那么再次输入运算符号，以及运算数字，递规调用caculate函数，实现再次运算
caculate(X,opp,Y)
}
}
三个单独都可实现，但是要求完美请三个一起用
1.125*3+125*5+25*3+252.9999*3+101*11*(101-92)
3.(23/4-3/4)*(3*6+2)
4. 3/7 × 49/9 - 4/3
5. 8/9 × 15/36 + 1/27
6. 12× 5/6 – 2/9 ×3
7. 8× 5/4 + 1/4
8. 6÷ 3/8 – 3/8 ÷6
9. 4/7 × 5/9 + 3/7 × 5/9
10. 5/2 -（ 3/2 + 4/5 ）
11. 7/8 + （ 1/8 + 1/9 ）
12. 9 × 5/6 + 5/6
13. 3/4 × 8/9 - 1/3
14. 7 × 5/49 + 3/14
15. 6 ×（ 1/2 + 2/3 ）
16. 8 × 4/5 + 8 × 11/5
17. 31 × 5/6 – 5/6
18. 9/7 - （ 2/7 – 10/21 ）
19. 5/9 × 18 – 14 × 2/7
20. 4/5 × 25/16 + 2/3 × 3/4
21. 14 × 8/7 – 5/6 × 12/15
22. 17/32 –游枣 3/4 × 9/24
23. 3 × 2/9 + 1/3
24. 5/7 × 3/25 + 3/7
25. 3/14 ×× 2/3 + 1/6
26. 1/5 × 2/3 + 5/6
27. 9/神桐拆22 + 1/11 ÷ 1/2
28. 5/3 × 11/5 + 4/3
29. 45 × 2/3 + 1/3 × 15
30. 7/19 + 12/19 × 5/6
31. 1/4 + 3/4 ÷ 2/3
32. 8/7 × 21/16 + 1/2
33. 101 × 1/5 – 1/5 × 21
34.50＋160÷40
35.120-144÷18+35
36.347+45×2-4160÷52
37（58+37）÷（64-9×5）
38.95÷（64-45）
39.178-145÷5×6+42
40.812-700÷（9+31×11）
41.85+14×（轮枯14+208÷26）
42.77+27÷（99-96）－3
43.120-36×4÷18+35
44.（58+37）÷（64-9×5）
45.(6.8-6.8×0.55)÷8.5
46.0.12× 4.8÷0.12×4.8
47.（3.2×1.5+2.5）÷1.6
48.6-1.6÷4= 5.38+7.85-5.37=
49.7.2÷0.8-1.2×5= 6-1.19×3-0.43=
50.6.5×（4.8-1.2×4）=
51.5.8×（3.87-0.13）+4.2×3.74
52.32.52-（6+9.728÷3.2）×2.5
53.[（7.1-5.6）×0.9-1.15] ÷2.5
54.5.4÷[2.6×（3.7-2.9）+0.62]
55.12×6÷（12-7.2）-6
56.12×6÷7.2-6
57.0.68×1.9+0.32×1.9
58.58+370）÷（64-45）
59.420+580-64×21÷28
60.136+6×（65-345÷23）
15-10.75×0.4-5.7
62.18.1＋（3－0.299÷0.23）×1
63.(6.8-6.8×0.55)÷8.5
64.0.12× 4.8÷0.12×4.8
65.（3.2×1.5+2.5）÷1.6
66.3.2×6+（1.5+2.5）÷1.6
67.0.68×1.9+0.32×1.9
68.10.15-10.75×0.4-5.7
69.5.8×（3.87-0.13）+4.2×3.74
70.32.52-（6+9.728÷3.2）×2.5
71.[（7.1-5.6）×0.9-1.15] ÷2.5
72.5.4÷[2.6×（3.7-2.9）+0.62]
73.12×6÷（12-7.2）-6
74.12×6÷7.2-6
75.33.02－（148.4－90.85）÷2.5
1) 86+49+114= 2) 240+(39-40)=
3) 255+(352+145+48)= 4) (345+377)+(55+23)=
5) 9+(80+191)= 6) (268+314+132)+86=
7) 5190÷15= 8) 495+(278+5)+222=
9) 174×36×25= 10) 399-199=
11) 48+(164+152)+36= 12) 133-(28+29)-43=
13) 1650÷25= 14) 260×8-8-8×59=
15) 996+500= 16) 6975÷25=
17) 196-95= 18) 328-(163-72)=
19) 199+(84-99)= 20) 885-1-201-298=
21) 460-35-3-262= 22) (98+59+2)+41=
23) 736×12-12-12×335= 24) 116+(112+184)=
25) 150×258+142×150= 26) 31×24×25=
27) 9000÷25= 28) 502-287-54-159=
29) 307+(92+93)= 30) 80×125=
31) 102×15= 32) 30+(63+70)+37=
33) 27+(73+73)+27= 34) 86+(98+14+2)=
35) 544-272-28= 36) 18000÷150÷4=
37) 103×69= 38) 25×64×125=
39) 343-188-12= 40) 509×11-11-11×8=
41) 79×24×25= 42) (145+25)+(155+275)=
43) (447+423)+(53+77)= 44) 46+15+54=
45) 589-109-(6+185)= 46) 8×125=
47) 20×25= 48) 89×245+155×89=
49) 92+(79+8+21)= 50) 222+15+78=
51) 96×125= 52) 30600÷25÷4=
53) 5996+3004= 54) 6015-(518+699)-2783=
55) 4003×2426= 56) 2467×70-70-70×466=
57) 84×25= 58) 4001-2002=
59) 1616×506+2494×1616= 60) 4×17+4+1982×4=
61) 799×660+340×799= 62) 3991×36×25=
63) 6076-875-(805+3320)= 64) 6056-679-40-4281=
65) 4134+(2819+866)+2181= 66) 5898-(2065-102)=
67) 3297×1273+2727×3297= 68) 1312+(153+688+1847)=
69) 2315-793-114-1093= 70) 3940+(1739-1940)=
71) 1455+(1768+1545)+1232= 72) 975+(1007+2025)=
73) 24×1951+24+48×24= 74) 30425÷25=
75) 1376+(1961+624+39)= 76) (686+1872+2314)+1128=
77) 2922+(260-922)= 78) 113600÷100÷4=
79) 2002×658= 80) 1428+(958+2572)=
81) 2001×786= 82) 190×760+190+3239×190=
83) 2976×1145+2855×2976= 84) 88×25=
85) 8122-(3084-1878)= 86) 879+(1295+2121)=
87) 3998+2001= 38) 2595×178-178-178×594=
89) 4467-2024-976= 90) 1319×1339+1661×1319=
91) 997×885= 92) 453×8×125=
93) 4928-(871+1928)= 94) 997×917=
95) 1526+(938-526)= 96) 803×12×25=
97) 114000÷1200= 98) 6933×332-332-332×2932=
99) 16×25= 100) 25×224×125=
101)9/22 + 1/11 ÷ 1/2
102)5/3 × 11/5 + 4/3
103)45 × 2/3 + 1/3 × 15
104) 7/19 + 12/19 × 5/6
106) 8/7 × 21/16 + 1/2
107) 101 × 1/5 – 1/5 × 21
108)50＋160÷40 （58+370）÷（64-45）
109)120-144÷18+35
110)347+45×2-4160÷52
111)（58+37）÷（64-9×5）
112)95÷（64-45）
113)178-145÷5×6+42 420+580-64×21÷28
114)812-700÷（9+31×11） （136+64）×（65-345÷23）
115)85+14×（14+208÷26）
116)（284+16）×（512-8208÷18）
117)120-36×4÷18+35
118)（58+37）÷（64-9×5）
119)(6.8-6.8×0.55)÷8.5
120)0.12× 4.8÷0.12×4.8
121)（3.2×1.5+2.5）÷1.6 （2）3.2×（1.5+2.5）÷1.6
121)6-1.6÷4= 5.38+7.85-5.37=
122)7.2÷0.8-1.2×5= 6-1.19×3-0.43=
123)6.5×（4.8-1.2×4）= 0.68×1.9+0.32×1.9
124)10.15-10.75×0.4-5.7
125)5.8×（3.87-0.13）+4.2×3.74
126)32.52-（6+9.728÷3.2）×2.5
127)[（7.1-5.6）×0.9-1.15] ÷2.5
128)5.4÷[2.6×（3.7-2.9）+0.62]
129）0.9+0.1÷0.1 0.3×0.3×0.3
130）0.5÷0.5÷0.5 0.8-0.8×0.5
131）0.8÷0.8×0.5 2.7+2.3÷0.2
132）5.4÷1.8-1.8 11.2-1.93+0.8
133）0.38×2.9+0.38 0.5-0.5×0.5
134）0.8÷0.8×0.5 2.7+2.3÷0.2
135）5.4÷1.8-0.8 11.2-1.93+8.07
136）1-1÷4 0.65×102
137）9.87-（5.87+2.9）
138）（0.25+0.45）×0.4
139）（0.36+1.29）÷3 0.008+0.992×2.5×40
140）4.84+0.3×15÷0.2+77.5 0.15×（3.79-1.9）+1.11×0.15
141）0.05×[30-(18.4+27.83÷4.6)] (6.8-6.8×0.55)÷8.5
142）0.12× 4.8÷0.12×4.8 1.6-1.6÷4
143）5.38+7.85-5.37 7.2÷0.8-1.2×5
144）6-1.19×3-0.43 6.5×（4.8-1.2×4）
145）0.68×1.9+0.32×1.9 10.15-10.75×0.4-5.7
147）146）5.8×（3.87-0.13）+4.2×3.74 32.52-（6+9.728÷3.2）×2.5
148）[（7.1-5.6）×0.9-1.15] ÷2.5 5.4÷[2.6×（3.7-2.9）+0.62]
149）5.47+12.81+3.53+7.19 0.83×12.5×8
2.9×102 3.8×6.9+3.8×2.1+3.8
150）109+(72+91)-93×24×125=
一、设计的流程：
1． 主界面设计，选择练习或测试，按ESC结束程序。
2． 题型选择界面设计，选择加、减、乘、除或混合运算，按ESC返回主界面。
3． 系统随机出题，运算数及结果均在100以内，乘、除法应能整除，显示算式。
4． 练习时脊樱，系统随机出题，键入结果，正确和错误均有提示，出错时允许再输入，最多三次机会，若还不正确，给出答案。继续出题，按ESC，显示总题数，正确数和正确率。
5． 测试时，系统自动出10道题，每题只给一次机会，每题10分，统计得分。结束后，给出总分，显示各题的对错信息，错误的给出答案。中间按ESC键结束。显示已作题的对错信息，错误的给出答案，不显示得分，按任意键返回题型选择界面。
相关知识：按键 *** 作、数组、指针、结构体等
二、例程：
#include<stdlib.h>#include<stdio.h>
#include<conio.h>
#include<time.h>
void main()
{
int a[10],b[10],d[10],c[10],num=0,result,add=0
float val
char fa[5]={'+','-','*','/'}
/* 出10道题 */
while(1)
{
srand((unsigned)time(NULL))
d[num]=abs(rand())%4/* 保证出题算法的随机性 */
while(1) /* 保证出题成功 */
{
c[num]=-1
a[num]=abs(rand())%100
b[num]=abs(rand())%100
if(d[num]==0) c[num]=a[num]+b[num]
else if(d[num]==1) c[num]=a[num]-b[num]
else if(d[num]==2) c[num]=a[num]*b[num]
else if(d[num]==3)
{
if(b[num]>0)val=1.0*a[num]/b[num]
else val=-1
}
if(d[num]<=2)
{
if(c[num]>=0 && c[num]<=100) break
纤野旅 }
else
{
if(a[num]==int(val)*b[num] && val>=0)
{c[num]=val break}
毁凳 }
}
num++
if(num==10) break
}
/* 回答 */
num=0
while(1)
{
printf("%d %c %d= ",a[num],fa[d[num]],b[num])
scanf("%d",&result)
if(result==c[num])
{
printf("回答正确!\n")
add+=10
}
else
printf("错误,正确答案: %d\n",c[num])
num++
if(num==10) break
}
printf("\n得分:%d\n",add)
getch()
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）