用C语言编写一个简单的可以进行加减乘除运算混合运算的计算器的方法：
1、打开visual C++ 6.0-文件-新建-文件-C++ Source File；
2、输入预处理命令和主函数：
#include<stdio.h>/*函数头：输入输出头文件*/
void main()/*空类型：主函数*/
3、定义变量：
int a,b,d； /*定义变量的数据类型为整型*/
char c；/*定义变量的数据类型为字符型*/
4、输入四则运算式：
printf("输入如“3*4”或“5+2”的四则运算式：")；/*输出文字提示*/
scanf("%d%c%d",&a,&c,&b)；/*输入四则运算式*/
5、判断运算符号：
switch(c) /*判断运算符号*/
{
case'+':d=a+bbreak；/*进行加法运算*/
case'-':d=a-bbreak；/*进行减法运算*/
case'*':d=a*bbreak；/*进行乘法运算*/
case'/':d=a/bbreak； /*进行除法运算*/
}
6、输出结果：
printf("%d%c%d=%d\n",a,c,b,d)；/*输出结果*/
完整的源代码：
#include<stdio.h>/*函数头：输入输出头文件*/
void main()/*空类型：主函数*/
{
int a,b,d；/*定义变量的数据类型为整型*/
char c；/*定义变量的数据类型为字符型*/
printf("输入如“3*4”或“5+2”的四则运算式：")；/*输出文字提示*/
scanf("%d%c%d",&a,&c,&b)；/*输入四则运算式*/
switch(c)/*判断运算符号*/
{
case'+':d=a+bbreak；/*进行加法运算*/
case'-':d=a-bbreak；/*进行减法运算*/
case'*':d=a*bbreak；/*进行乘法运算*/
case'/':d=a/bbreak；/*进行除法运算*/
}
printf("%d%c%d=%d\n",a,c,b,d)；/*输出结果*/
}
四则混合运算代码：#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
char token[61]/*存放表达式字符串的数组*/
int n=0
void error(void) /*报告错误函数*/
{
printf("ERROR!\n")
exit(1)
}
void match(char expected) /*检查字符匹配的函数*/
{
if(token[n]==expected)
token[++n]=getchar()
else error()
}
double term(void)/*计算乘除的函数*/
double factor(void)/*处理括号和数字的函数*/
double exp(void) /*计算加减的函数*/
{
double temp=term()
while((token[n]=='+')||(token[n]=='-'))
switch(token[n])
{
case'+':match('+')
temp+=term()
break
case'-':match('-')
temp-=term()
break
}
return temp
}
double term(void)
{
double div
double temp=factor()
while((token[n]=='*')||(token[n]=='/'))
switch(token[n])
{
case'*':match('*')
temp*=factor()
break
case'/':match('/')
div=factor()
if(div==0) /*处理除数为零的情况*/
{
printf("The divisor is zero!\n")
exit(1)
}
temp/=div
break
}
return temp
}
double factor(void)
{
double temp
char number[61]
int i=0
if(token[n]=='(')
{
match('(')
temp=exp()
match(')')
}
else if(isdigit(token[n])||token[n]=='.')
{
while(isdigit(token[n])||token[n]=='.') /*将字符串转换为浮点数*/
{
number[i++]=token[n++]
token[n]=getchar()
}
number[i]='\0'
temp=atof(number)
}
else error()
return temp
}
main()
{
double result
FILE *data=fopen("61590_4.dat","at")
if(data==NULL)
data=fopen("61590_4.dat","wt")
if(data==NULL)
return 0
token[n]=getchar()
result=exp()
if(token[n]=='\n')
{
token[n]='\0'
printf("%s=%g\n",token,result)
fprintf(data,"%s=%g\n",token,result)
}
else error()
fclose(data)
return 0
getch()
}
#include <cstdlib>
#include <iostream>
using namespace std
int main()
{
int a,b//a是输出结果，b是临时输入数据
char x//x是标点符号输入
cin>>a//先输入第一个数
while(1)//由于不知道运算式一共多长，所以用一个死循环不断读取
{
cin>>x//输入运算符
if(x=='=')//'='特殊处理，输出结果
{
cout<<a<<endl
break//退出循环，跳到return 0；
}
else//如果是运算符就输入下一个数
{
cin>>b
switch(x)//判断符号类型，并进行相应计算
{
case '+':a+=bbreak//每个case后面必须加break；否则将后面所有运算式全走一遍
case '-':a-=bbreak
case '*':a*=bbreak
case '/':a/=bbreak
}
}
}
return 0
}
汗，又改变条件了，这次你的要求和原来要求可是截然不同的程序啊，涉及到很多算法的，二叉树，堆栈等，我如果重写了初学者不一定能看懂了。我下面就给你贴一下差不多的代码吧。只是这个不需要输入等号，回车自动计算。如果需要去掉那些繁琐的代码估计没人为了这几个虚拟分给你去掉的。
#include<iostream>
#include<string>
#include<stack>
#include "Tree.h"
#include<windows.h>
bool isok(string exp) //此函数验证式子是否正确，即是否符合运算规则。
{
char check
int error=0
int lb=0
int rb=0
if(exp.size()==1 && exp[0]!='-')return false
else if((IsOperator(exp[0])&& exp[0]!='-' ||IsOperator(exp[exp.size()-1]))&&exp[0]!='('&&exp[exp.size()-1]!=')') //此处若不加，在遇到某些式子时，会出现非法 *** 作。
return false
for(int m=0m<exp.size()m++)
{
check=exp[m]
if(m==0 && check=='-' && (isdigit(exp[1])!=0 || exp[1]=='(' ) )check=exp[++m]
if(IsOperand(check)) //如果是数字，跳过，不管。
else if(IsOperator(check))
{
if(check==')')
{
rb++
if(IsOperator(exp[m+1])&&(exp[m+1]=='+'||exp[m+1]=='-'||exp[m+1]=='*'||exp[m+1]=='/'||exp[m+1]=='^'||exp[m+1]==')'))
{
m++
if(exp[m]==')')
rb++
}
else if(IsOperator(exp[m+1]))
error++
}
else if(check=='(')
{
lb++
if(exp[m+1]=='(')
{
m++
lb++
}
else if(IsOperator(exp[m+1])&&exp[m+1]!='-')
error++
}
else
{
if(IsOperator(exp[m+1])&&exp[m+1]=='(')
{
m++
lb++
}
else if(IsOperator(exp[m+1]))
error++
}
}
else
error++
}
if(error==0&&lb==rb)
return(true)
else
return(false)
}
int main()
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE)
SetConsoleTitle("四则运算器二叉树版")
SetConsoleTextAttribute(hOut,BACKGROUND_GREEN+FOREGROUND_BLUE)
binary_tree etree
stack<binary_tree>NodeStack
stack<char>OpStack
string infix
char choice='y'
system("cls")
cout<<"*******************************************************************"<<endl
cout<<"* *"<<endl
cout<<"* 十进制四则运算计算器 ※※※※※※※※※※※※ *"<<endl
cout<<"* ※ ※ *"<<endl
cout<<"* (二叉树版) ※※※※※※※※※※※※ *"<<endl
cout<<"* *"<<endl
cout<<"*******************************************************************"<<endl
char c
while(choice=='y'||choice=='Y')
{
cout<<"\n请输入表达式，不要带空格:\n"
cin>>infix
cout<<"--------------------------------------------------------------------------------"<<'\n'
cout<<"表达式为: "<<infix<<'\n'
if(isok(infix))
{
for(int i=0i<infix.size()i++)
{
c=infix[i]
if(i==0 && c=='-') //若开始为负，则把零压入运算数栈，把'-'压入运算符栈
{
binary_tree temp
temp.root=build_node("0")
NodeStack.push(temp)
OpStack.push('-')
}
else
if(IsOperand(c))
{
string tempstring
tempstring=tempstring+c
while(i+1<infix.size()&&IsOperand(infix[i+1]))
{
tempstring+=infix[++i]
}
binary_tree temp
temp.root=build_node(tempstring)
NodeStack.push(temp)
}
else if(c=='+'||c=='-'||c=='*'||c=='/'||c=='^')
{
if(OpStack.empty())
OpStack.push(c)
else if(OpStack.top()=='(')
OpStack.push(c)
else if(TakesPrecedence(c,OpStack.top()))
OpStack.push(c)
else
{
while(!OpStack.empty()&&(TakesPrecedence(OpStack.top(),c)||addition(OpStack.top(),c)))
{
binary_tree temp_tree
string thisstring=""
thisstring=thisstring+OpStack.top()
OpStack.pop()
etree.root=build_node(thisstring)
copy(temp_tree.root,NodeStack.top().root)
NodeStack.pop()
etree.root->right_child=temp_tree.root
temp_tree.root=NULL
copy(temp_tree.root,NodeStack.top().root)
etree.root->left_child=temp_tree.root
NodeStack.pop()
temp_tree.root=NULL
copy(temp_tree.root,etree.root)
NodeStack.push(temp_tree)
etree.root=NULL
}
OpStack.push(c)
}
}
else if(c=='(') //若中间遇到括号，则判断下一位是否为'-'
{OpStack.push(c)
if(infix[i+1]=='-')
{
binary_tree temp
temp.root=build_node("0")
NodeStack.push(temp)
OpStack.push('-')
++i
}
}
else if(c==')')
{
while(OpStack.top()!='(')
{
binary_tree temp_tree
string thisstring=""
thisstring=thisstring+OpStack.top()
OpStack.pop()
etree.root=build_node(thisstring)
copy(temp_tree.root,NodeStack.top().root)
NodeStack.pop()
etree.root->right_child=temp_tree.root
temp_tree.root=NULL
copy(temp_tree.root,NodeStack.top().root)
etree.root->left_child=temp_tree.root
NodeStack.pop()
temp_tree.root=NULL
copy(temp_tree.root,etree.root)
NodeStack.push(temp_tree)
etree.root=NULL
}
OpStack.pop()
}
}
////////////////////////////////////////////////////////
while(!OpStack.empty())
{
binary_tree temp_tree
string thisstring=""
thisstring=thisstring+OpStack.top()
OpStack.pop()
etree.root=build_node(thisstring)
copy(temp_tree.root,NodeStack.top().root)
NodeStack.pop()
etree.root->right_child=temp_tree.root
temp_tree.root=NULL
copy(temp_tree.root,NodeStack.top().root)
etree.root->left_child=temp_tree.root
NodeStack.pop()
temp_tree.root=NULL
copy(temp_tree.root,etree.root)
NodeStack.push(temp_tree)
if(!OpStack.empty())
{
etree.root=NULL
}
}
cout<<"打印结点如下: "
etree.print()
cout<<'\n'
cout<<"结点个数为："<<etree.counter()<<'\n'
cout<<"以下是，中间的计算结果："<<'\n'
etree.evaluate()
cout<<'\n'
cout<<"结果是: "
cout<<etree.root->data<<'\n'
cout<<'\n'<<"--------------------------------------------------------------------------------"<<'\n'
cout<<"\n\n是否要重新运行?输入<Y/N>: "
cin>>choice
}
else
{
cout<<"************************************************"<<'\n'
cout<<"错误:输入的表达试有误！"<<'\n'
cout<<"************************************************"<<'\n'
cout<<"\n\n是否要重新运行?输入<Y/N>: "
cin>>choice
}
}
return 0
}
课程设计报告
设计题目：十进制四则运算计算器
实习目的
通过实习，了解并初步掌握设计、实现较大系统的完整过程，包括系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及 *** 作方法，为进一步的应用开发打好基础。
二．问题描述
在以二叉树表示算术表达式的基础上，设计一个十进制的四则运算的计算器。[设计要求]实现整数浮点数的四则运算。
三．需求分析
该程序实现的是实数型的四则运算，并在此运算上又加入了幂”^”运算，该程序用一二叉树表示整个输入的算术表达式:
(1)实现对结点的打印，便于结果分析；
(2)实现对结点的统计；
(3)实现中间结果的显示，可以看打印的结点，验证运算结果的正确与否。
四．概要设计
系统用到的抽象数据类型定义：
1．ADT node_type{
数据对象V：一个集合，该集合中的所有元素具有相同的特性
数据关系R：R={VR}
VR={<x,y>|P(x,y)^(x,y属于V)}
基本 *** 作：
（1） node_type(string k)；
*** 作结果：对结点进行初始化
}ADT node_type
2．ADT binary_tree{
数据对象D：一个集合，该集合中的所有元素具有相同的特性
数据关系R：若D为空，则为空树。若D中仅含有一个数据元素，则R为空集，否则R={H}，H为如下二元关系：
（1） 在D中存在唯一的称为根的数据元素root，它在关系H中没有前驱
（2） 除root以外，D中每个结点在关系H下有且仅有一个前驱。
基本 *** 作：
（1） print(node_type *r)CopyTimeTree(p,q)；
*** 作结果：对结点进行打印
（2） evaluate(node_type *prt)；
*** 作结果：对一二叉树进行计算
（3） counter()；
*** 作结果：计算一棵二叉树中的结点个数
}ADT binary_tree
系统中子程序及功能要求：
1. ADT node_type build_node(string x)：建立一个结点
2. addition(char OperatorA,char OperatorB):判断两 *** 作符是否相等,若相等返回True
3. TakesPrecedence(char OperatorA,char OperatorB):判别符号的优先级。A>B，返回为TRUE
4. copy(ADT node_type *&r1, ADT node_type *r2):拷贝整个二叉树
5. isok(string exp):验证表达式是否输入正确，若正确返回TRUE
五.测试分析（运行结果）
第一个表达式:10-（-3）*（（（21+3/5）*8/3）*（-2））
第二个表达式：-（32.7-3210.3）/((8.0+0.9)*8.9)+4.4
依次把运算符和 *** 作数放入堆栈中，过程中依次把中间运算结果打印出来
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）