vc++课程设计计算器四则混合运算程序

用vc编写计算器程序，实现简单的四则混合运算~

第一种方法：
#include
#include
#include
#include
#include
#define MaxSize 99
char calc[MaxSize],expr[MaxSize];
int i,t;

struct
{
char data[MaxSize];
int top;
}Sym;

struct
{
double data[MaxSize];
int top;
}Num;

double ston(char x[],int *p)
{
int j=*p+1,i;
double n=0;
char sign=x[*p];

if(sign=='+'||sign=='-') *p=*p+1;
while(x[j]>='0'&&x[j]<='9')
{
j++;
}
for(i=*p;i<j;i++)
{
n=n*10+(x[i]-'0');
}
if(x[j]=='.')
{
*p=++j;
while(x[j]>='0'&&x[j]<='9')
{
j++;
}
for(i=*p;i<j;i++)
{
n=n+pow(0.1,i-*p+1)*(x[i]-'0');
}
}
*p=j;
if(sign=='-') return(-n);
return(n);
}

void InitStack()
{
Sym.top=Num.top=-1;
}

void SymPush()
{
if(Sym.top<MaxSize-1)
{
Sym.data[++Sym.top]=calc[i++];
}
else
{
printf("Sym栈满
");
return;
}
}


void SymPop()
{
if(Sym.top>=0)
{
expr[++t]=Sym.data[Sym.top--];
}
else
{
printf("Sym栈空
");
return;
}
}

void NumPush()
{
if(Num.top<MaxSize-1)
{
Num.data[++Num.top]=ston(expr,&i);
}
else
{
printf("Num栈满
");
return;
}
}

void NumPop()
{
if(Num.top>=0)
{
if(expr[i]!=' ')
{
switch(expr[i])
{
case '+':Num.data[Num.top-1]=Num.data[Num.top-1]+Num.data[Num.top];break;
case '-':Num.data[Num.top-1]=Num.data[Num.top-1]-Num.data[Num.top];break;
case '*':Num.data[Num.top-1]=Num.data[Num.top-1]*Num.data[Num.top];break;
case '/':Num.data[Num.top-1]=Num.data[Num.top-1]/Num.data[Num.top];break;
case '^':Num.data[Num.top-1]=pow(Num.data[Num.top-1],Num.data[Num.top]);break;
}
Num.top--;
}
}
else
{
printf("Num栈空
");
return;
}
}

int main(void)
{
loop1:
i=0,t=-1;
system("cls");
printf("中缀表达式：");
InitStack(),gets(calc);
while(calc[i]!='\0'&&calc[i]!='=')
{
if(calc[i]>='0'&&calc[i]<='9')
{
while((calc[i]>='0'&&calc[i]<='9')||(calc[i]=='.'))
{
loop2:
expr[++t]=calc[i++];
}
expr[++t]=' ';
}
else if(calc[i]=='(')
{
SymPush();
}
else if(calc[i]==')')
{
while(Sym.data[Sym.top]!='(')
{
SymPop();
expr[++t]=' ';
}
Sym.data[Sym.top--]='\0';
i++;
}
else if((calc[i]=='+'||calc[i]=='-'))
{
if((i==0)||(!(calc[i-1]>='0'&&calc[i-1]<='9')&&calc[i-1]!=')')) goto loop2;
while(Sym.top>=0&&Sym.data[Sym.top]!='(')
{
SymPop();
expr[++t]=' ';
}
SymPush();
}
else if(calc[i]=='*'||calc[i]=='/')
{
while(Sym.top>=0&&(Sym.data[Sym.top]=='*'||Sym.data[Sym.top]=='/'||Sym.data[Sym.top]=='^'))
{
SymPop();
expr[++t]=' ';
}
SymPush();
}
else if(calc[i]=='^')
{
while(Sym.top>=0&&Sym.data[Sym.top]=='^')
{
SymPop();
expr[++t]=' ';
}
SymPush();
}
else
{
i++;
}
}
while(Sym.top>=0)
{
SymPop();
expr[++t]=' ';
}
expr[++t]=Sym.data[++Sym.top]='\0';
printf("后缀表达式：%s
",expr);
for(i=0;expr[i]!='\0';i++)
{
if((expr[i]>='0'&&expr[i]='0'&&expr[i+1]<='9')))
{
NumPush();
}
else
{
NumPop();
}
}
printf("运算结果为：%g
",Num.data[0]);
printf("Continue(y/n)?");
switch(getch())
{
case 'y':{system("cls");goto loop1;}
case 'n':
default :exit(0);
}
getch();
return(0);
}

后缀表达式是一种十分有用的表达式，它将中缀表达式转换为可以依靠简单的操作就能得到运算结果的表达式。例如，(a+b)*(c+d)转换为a,b,+,c,d,+,*。

它的优势在于只用两种简单的操作，入栈和出栈就可以解决任何中缀表达式的运算。其运算方式为：如果当前字符为数字或变量，则压入栈内；如果是运算符，则将栈顶两个元素弹出栈外并作相应运算，再将结果压入栈内。当后缀表达式扫描结束时，栈里的就是中缀表达式运算的最终结果。

中缀表达式--->后缀表达式
a+b ---> a,b,+
a+(b-c) ---> a,b,c,-,+
a+(b-c)*d ---> a,b,c,-,d,*,+
a=1+3 ---> a=1,3,+

将中缀表达式转换为后缀表达式的一般算法是：
[1] 首先构造一个运算符栈(也可放置括号)，运算符(以括号分界点)在栈内遵循越往栈顶优先级越高的原则。
[2] 从左至右扫描中缀表达式，从左边第一个字符开始判断：
[2.1] 如果当前字符是数字，则分析到数字串的结尾并将数字串直接输出。
[2.2] 如果是运算符，则比较优先级。如果当前运算符的优先级比栈顶运算符的优先级更高(当栈顶是括号时，直接入栈)，则将运算符直接入栈；否则将栈顶运算符出栈并输出，直到当前运算符的优先级比栈顶运算符的优先级更高(当栈顶是括号时，直接入栈)，再将当前运算符入栈。
[2.3] 如果是括号，则根据括号的方向进行处理。如果是左括号，则直接入栈；否则，遇左括号前将所有的运算符全部出栈并输出，遇左括号后将右左的两括号一起删除。
[3] 重复上述操作[2]直至扫描结束，将栈内剩余运算符全部出栈并输出。中缀表达式也就转换为后缀表达式了。

各运算符及符号优先级：
)：遇(前，将运算符全部出栈并输出；遇(后，将两括号一起删除
(：直接入栈
+、-：1
*、/、%：2
^：3

第二种方法：
#include
#include
#include
#include
#include

double fun1();
double fun2();
double fun3();
double fun4();
double fun5();
char calc[64];
int n;

double fun1()
{
double t;
t=fun2();
while((calc[n]=='+')||(calc[n]=='-'))
{
switch(calc[n])
{
case '+':n++,t=t+fun2();break;
case '-':n++,t=t-fun2();break;
}
}
return(t);
}

double fun2()
{
double t;
t=fun3();
while((calc[n]=='*')||(calc[n]=='/'))
{
switch(calc[n])
{
case '*':n++,t=t*fun3();break;
case '/':n++,t=t/fun3();break;
}
}
return(t);
}

double fun3()
{
double t;
t=fun4();
while(calc[n]=='^')
{
n++,t=pow(t,fun4());
}
return(t);
}

double fun4()
{
char num[16];
int i=0;
double t;
if(calc[n]=='(')
{
n++,t=fun1(),n++;
}
else if(fun5())
{
while(fun5())
{
num[i++]=calc[n++];
}
num[i]='\0';
t=atof(num);
}
return(t);
}

double fun5()
{
if(((calc[n]>='0'&&calc[n]0&&(calc[n-1]=='+'||calc[n-1]=='-'||calc[n-1]=='*'||calc[n-1]=='/'||calc[n-1]=='^')))
return(1);
else
return(0);
}

int main(void)
{
loop1:
n=0;
printf("Input a calculation method like 1+2^(3-4)*5/10=↙
Please:");
gets(calc);
printf("Result=%g
",fun1());
printf("Continue(y/n)?");
switch(getch())
{
case 'y':{system("cls");goto loop1;}
case 'n':
default :exit(0);
}
getch();
return(0);
}

送你一个命令行计算器

#include
#include
#define MAX_STACK_SIZE 100
#define STACK_OVERFLOW_ERROR 1
#define STACK_UNDERFLOW_ERROR 2
#define UNKNOWN_CHARACTER_ERROR 4
#define UNMATCHED_PARENTHESES 8
#define OPERATOR_ERROR 16
#define NULL_EXPRESSION 32
#define DIVIED_BY_ZERO 64
typedef struct
{
double s[MAX_STACK_SIZE];
int size;
}stack;

int global_error_flag = 0;

int error()
{
return global_error_flag>0;
}

void set_error_flag(int clear = 0)
{
global_error_flag = global_error_flag | clear;
}

void clear_error_flag(int clear = global_error_flag)
{
if(global_error_flag & clear > 0)
global_error_flag = global_error_flag ^ clear;
}

void init(stack* s)
{
s->size = 0;
}

void push(stack* s, double i)
{
if(s->size>=MAX_STACK_SIZE)
{
fputs("Stack Overflow",stderr);
set_error_flag(STACK_OVERFLOW_ERROR);
}
s->s[(s->size)++] = i;
}

double top(stack* s)
{
if(s->size<=0)
{
fputs("Stack Underflow",stderr);
set_error_flag(STACK_UNDERFLOW_ERROR);
}
return s->s[(s->size)-1];
}

double pop(stack* s)
{
double temp = top(s);
--(s->size);
return temp;
}


int empty(stack* s)
{
return s->size == 0;
}

void show_error_msg(char* s, char* p, char* e, char* msg)
{
fputs("Error:",stderr);
fputc('
',stderr);
fputs(s,stderr);
fputc('
',stderr);
while(s<p)
{
fputc(' ',stderr);
s++;
}
while(s<e)
{
fputc('^',stderr);
s++;
}
fputc('
',stderr);
fputs(msg,stderr);
fputc('
',stderr);
fputc('
',stderr);
}

int isnum(char p, int start)
{
if((p>='0'&&p<='9')||p=='.'||(start==0&&p=='e'))
return 1;
return 0;
}

double parse(char* s, char* st, char* se)
{
stack S;
double temp;
char* p = st;
char* e = se;
char* t;
char op = '+';
int needop = 0;
int needoperand = 0;
int canplus = 1;
int canmul = 0;
int deep = 0;
init(&S);
while(p<e&&*p==' ') p++;
while(p<e&&*(e-1)==' ') e--;
if(p==e)
{
set_error_flag(NULL_EXPRESSION);
show_error_msg(s,st,se,"null expression");
}
while(!error()&&p<e)
{
while(p<e && *p==' ') p++;
if(p==e) break;
if(*p=='+' || *p=='-')
{
if(!canplus)
{
set_error_flag(OPERATOR_ERROR);
show_error_msg(s,p,p+1,"operator not understanded");
}
op = *p;
canplus = canmul = 0;
needop = 0;
needoperand = 1;
p++;
}
else if(*p=='*' || *p=='/')
{
if(!canmul)
{
set_error_flag(OPERATOR_ERROR);
show_error_msg(s,p,p+1,"operator not understanded");
break;
}
op = *p;
canplus = canmul = 0;
needop = 0;
needoperand = 1;
p++;
}
else if(*p=='(' || isnum(*p,1))
{
if(needop)
{
set_error_flag(OPERATOR_ERROR);
show_error_msg(s,p,p+1,"missing operator.");
break;
}
if(*p=='(')
{
deep = 1;
t = p+1;
while(t<e)
{
if(*t=='(')
deep++;
else if(*t==')')
deep--;
if(deep==0) break;
t++;
}
if(deep!=0)
{
set_error_flag(UNMATCHED_PARENTHESES);
show_error_msg(s,p,p+1,"Parentheses can not be matched.");
}
else
{
temp = parse(s,p+1,t);
p = t+1;
}
}
else
{
sscanf(p,"%lf",&temp);
while(p<e&&isnum(*p,0)) p++;
}
switch(op)
{
case '+':
push(&S,temp);
break;
case '-':
push(&S,-temp);
break;
case '*':
temp *= pop(&S);
push(&S,temp);
break;
case '/':
if(temp==0)
{
set_error_flag(DIVIED_BY_ZERO);
show_error_msg(s,p-1,p,"diviede by zero");
}
else
{
temp = pop(&S) / temp;
push(&S,temp);
}
break;
}
needop = 1;
canplus = canmul = 1;
needoperand = 0;
}
else if(*p==')')
{
set_error_flag(UNMATCHED_PARENTHESES);
show_error_msg(s,p,p+1,"Parentheses can not be matched.");
}
else
{
set_error_flag(UNKNOWN_CHARACTER_ERROR);
show_error_msg(s,p,p+1,"character not understanded.");
}
}
if(error())
{
return -1;
}
if(needoperand)
{
set_error_flag(OPERATOR_ERROR);
show_error_msg(s,p-1,p,"missing operand / redundant operator");
return -1;
}
temp = 0;
while(!empty(&S))
{
temp += pop(&S);
}
return temp;
}

int main()
{
char buffer[10000];
double ans;
while(gets(buffer))
{
global_error_flag = 0;
ans = parse(buffer,buffer,buffer+strlen(buffer));
if(!error())
printf("Result: %g
",ans);
}
}

#include "stdafx.h"
#include "计算器.h"
#include "计算器Dlg.h"
#include "math.h"
#include "time.h" //可以不用 ,屏蔽srand()
#include "stdlib.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
C计算器Dlg::C计算器Dlg(CWnd* pParent /*=NULL*/)
: CDialog(C计算器Dlg::IDD, pParent)
, n(0)
, setxiaoshu(false)
, xiaoshui(0)
, innum(0)
, n_2(0)
, operate(0)
, setnew(false)
BEGIN_MESSAGE_MAP(C计算器Dlg, CDialog)
……. //系统消息和控件的函数
主要实现代码：（dlg.cpp文件）：//注:下面所有控件名称使用加粗字体和下划线表示该按键

void C计算器Dlg::OnPaint() //重写OnPaint(),实现,界面颜色的改变
{
int c_r,c_g,c_b,c; //3个变量分别代表R/G/B
// srand(time(0)); //控制随机函数rand()的取值时间(间隔1s左右更新值),后来为实现每次按键都变色把这句去掉了
c_r=rand()%256; // rand()%256代表变量取值为0-255之间的整数,下同
c_g=rand()%256;
c_b=rand()%256;
c=rand()%4; //c=0-3,即分为4种情况,分别绘制不同的颜色方案.实现更多色彩.
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
if (c==0) //蓝色渐变,其他两种颜色随机
{
CPaintDC dc(this);
CRect rc;
GetClientRect(&rc);
int nHeight=rc.Height();
for(int i=0;nHeight>=0;nHeight--,i++)
{
CPen pen;
pen.CreatePen(PS_SOLID,1,RGB(c_r,c_g,i));
CPen *pOldPen=dc.SelectObject(&pen);
dc.MoveTo(rc.left,i);
dc.LineTo(rc.right,i);
dc.SelectObject(pOldPen);
pen.DeleteObject();
}
}
else if(c==1) //绿色渐变, 其他两种颜色随机
{
CPaintDC dc(this);
CRect rc;
GetClientRect(&rc);
int nHeight=rc.Height();
for(int i=0;nHeight>=0;nHeight--,i++)
{
CPen pen;
pen.CreatePen(PS_SOLID,1,RGB(c_r,i,c_b));
CPen *pOldPen=dc.SelectObject(&pen);
dc.MoveTo(rc.left,i);
dc.LineTo(rc.right,i);
dc.SelectObject(pOldPen);
pen.DeleteObject();
}
}
else if(c==2) //红色渐变, 其他两种颜色随机
{
CPaintDC dc(this);
CRect rc;
GetClientRect(&rc);
int nHeight=rc.Height();
for(int i=0;nHeight>=0;nHeight--,i++)
{
CPen pen;
pen.CreatePen(PS_SOLID,1,RGB(i,c_g,c_r));
CPen *pOldPen=dc.SelectObject(&pen);
dc.MoveTo(rc.left,i);
dc.LineTo(rc.right,i);
dc.SelectObject(pOldPen);
pen.DeleteObject();
}
}
else //都不渐变,所有随机
{
CPaintDC dc(this);
CRect rc;
GetClientRect(&rc);
int nHeight=rc.Height();
for(int i=0;nHeight>=0;nHeight--,i++)
{
CPen pen;
pen.CreatePen(PS_SOLID,1,RGB(c_r,c_g,c_r));
CPen *pOldPen=dc.SelectObject(&pen);
dc.MoveTo(rc.left,i);
dc.LineTo(rc.right,i);
dc.SelectObject(pOldPen);
pen.DeleteObject();
}
}
}
}

void C计算器Dlg::OnBnClickedButton31() // 控件pi对应的函数 按键pi的处理
n=3.14159265358979; // 把pi值3.14159265358979赋给n
UpdateData(false);
Invalidate(); //重新执行OnPaint()函数实现每一次按键,界面自动变色.下面各控件对应函数也调用这函数,如控件对应函数//没有直接显示,就是在被调用的函数中有该函数
}

////////////////////////////////////////以下部分处理方式相似(数字录入)//////////////////
void C计算器Dlg::OnBnClickedButton0() //控件0对应的函数.调用inum()产生预期的数.包括整数/小数/正数/负数.下面1 - 9同
{ 按键0的处理
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate(); // setnew为true,清除所有控制变量, 在上次计算出结果后
innum=0; // 把0赋给变量inum,执行相应的+++- //可以不用按C键清除直接按数字键开始下一个运
C计算器Dlg::inum(innum); //完成数据的输入过程. //算.setnew=true会在每个单元运算符和等号中出现. setnew
UpdateData(false); //在屏幕上显示当前n的值,下同 //为false,继续输入该数据. setnew=false出现在每个双元运算
} //符中.因OnBnClickedButton23()中已包含Invalidate(),但OnBnClickedButton23()不是 每次都执行, //为避免代码的重复执行,采用if else形式.
void C计算器Dlg::OnBnClickedButton1() //控件1对应的函数 按键1的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=1;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton2() //控件2对应的函数 按键2的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=2;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton3() //控件3对应的函数 按键3的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=3;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton4() //控件4对应的函数 按键4的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=4;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton5() //控件5对应的函数 按键5的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=5;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton6() //控件6对应的函数 按键6的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=6;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton7() //控件7对应的函数 按键7的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=7;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton8() //控件8对应的函数 按键8的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=8;
C计算器Dlg::inum(innum);
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton9() //控件9对应的函数 按键9的处理
{
if (setnew) C计算器Dlg::OnBnClickedButton23(); else Invalidate();
innum=9;
C计算器Dlg::inum(innum);
UpdateData(false);
}
////////////////////////////////////////////////结束////////////////////////////////////////////////////////

///////////////////////////////////以下部分处理方式相似(双元运算)////////////////// /////
void C计算器Dlg::OnBnClickedButton16() //控件+对应的函数. 下面的 - * / x^y 同 +符号的处理
{
C计算器Dlg::OnBnClickedIsButton(); // 自动完成上次未完成的运算.当上一次计算完双元运算没有按等号键时候,如只按 //下1 + 1而没有按=的时候,直接按+.可以实现连续计算,从而省去每次都按=的麻烦, //更符合使用的习惯.
n_2=n; // 因为是双元运算,按下+后,把输入值存入另一个数据中，开始输入新的数据
C计算器Dlg::setempty(); // 置空n的各项参数，便于以后重新输入新n值时不影响
setnew=false; //setnew=false(由数字录入部分做出相应).不是在重新输入数据,下面按数字键时接着录入部分执行相应操作
operate='+'; // 操作符为+,，由OnBnClickedIsButton()处理加法运算
}
void C计算器Dlg::OnBnClickedButton15() //控件-对应的函数. -符号的处理
{
C计算器Dlg::OnBnClickedIsButton();
n_2=n;
C计算器Dlg::setempty();
setnew=false;
operate='-';
}
void C计算器Dlg::OnBnClickedButton14() //控件*对应的函数. *符号的处理
{
C计算器Dlg::OnBnClickedIsButton();
n_2=n;
C计算器Dlg::setempty();
setnew=false;
operate='*';
}
void C计算器Dlg::OnBnClickedButton13() //控件/对应的函数. /符号的处理
{
C计算器Dlg::OnBnClickedIsButton();
n_2=n;
C计算器Dlg::setempty();
setnew=false;
operate='/';
}
void C计算器Dlg::OnBnClickedButton27() //控件x^y对应的函数. x^y符号的处理
{
C计算器Dlg::OnBnClickedIsButton();
n_2=n;
C计算器Dlg::setempty();
operate='y';
setnew=false;
}
////////////////////////////////////////////////结束///////////////////////////////////////////////////////

////////////////////////////////////////以下部分处理方式相似(单元运算)//////////////////
void C计算器Dlg::OnBnClickedButton19() //控件1/x对应的函数. 下面符号处理类似 1/x符号的处理
{
operate='x'; //下面执行1/x的运算
C计算器Dlg::operation(operate); // 单元运算,按下该符号直接进行运算
UpdateData(false);
operate='0'; //在这个运算符算出的数据后,输入另外一个数据时候,按下双元运算符因为会先执行OnBnClickedIsButton(),操 //作符为0,什么也不执行
setnew=true; //在数字录入部分做出判断, setnew=true按下数字键时候,执行OnBnClickedButton23(),清空变量.开始新的运算
void C计算器Dlg::OnBnClickedButton17() // 控件sqrt对应的函数. sqrt符号的处理
{
operate='q';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
void C计算器Dlg::OnBnClickedButton24() // 控件sin对应的函数. sin符号的处理
{
operate='s';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
void C计算器Dlg::OnBnClickedButton25() // 控件cos对应的函数. cos符号的处理
{
operate='c';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
void C计算器Dlg::OnBnClickedButton26() // 控件tan对应的函数. tan符号的处理
{
operate='t';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
void C计算器Dlg::OnBnClickedButton29() // 控件ln对应的函数. ln符号的处理
{
operate='n';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
void C计算器Dlg::OnBnClickedButton30() // 控件lg对应的函数. lg符号的处理
{
operate='g';
C计算器Dlg::operation(operate);
UpdateData(false);
operate='0';
setnew=true;
}
////////////////////////////////////////////////结束////////////////////////////////////////////////

////////////////////////////////////////以下为主要处理函数//////////////////////////////
void C计算器Dlg::OnBnClickedIsButton() // 控件=对应的函数. =符号的处理
{
C计算器Dlg::operation(operate); // 完成之前输入数据的计算
operate='0'; // 置空当前输入符号,避免连续+等操作,采用错误操作符
setnew=true; // 开始执行新的操作了
UpdateData(false);
}
void C计算器Dlg::OnBnClickedButton21() // 控件Backspace对应的函数. 删除一个字符 Backspace符号的处理
{
if (n==0) {xiaoshui=0;} // n=0时候,把小数点置空.
else if (xiaoshui>0) // n为小数时候的处理方案
{
n=(long (n*pow(10.0,(xiaoshui-1))))*pow(10.0,-(xiaoshui-1)); // 把该数乘以(原小数位数-1)得到数取整后在扩大,
xiaoshui=xiaoshui-1; // 每次执行删除一位,小数点要前移一位. // 相同倍数即间接删除小数的最后一位了
if (xiaoshui==0) setxiaoshu=false; // 如果小数点为0了,执行setxiaoshu=false,结束小数输入过程
setnew=false; // 不是重新输入数据,这点同所有的setnew=false

}
else //n为整数
{
n=long(n/10); // n除以10,取整.
xiaoshui=0; // 小数点为0
setnew=false; // 可以继续输入数据
}
UpdateData(false);
Invalidate(); // 同所有的Invalidate(),重新执行:OnPaint(),生成新的颜色
}
void C计算器Dlg::setempty(void) // 置空中间变量
{
xiaoshui=0; // 小数部分的位数变量为0
setxiaoshu=false; // 使默认输入变成整数
n=0; // 重置n为0,继续输入第二个运算的数据
}
void C计算器Dlg::OnBnClickedButton22() // 控件CE对应的函数. CE符号的处理: 清除当前输入 CE符号的处理
{
C计算器Dlg::setempty(); //见上函数
UpdateData(false);
Invalidate();
}
void C计算器Dlg::OnBnClickedButton23() //控件C对应的函数. C符号的处理:所有置空 ,C和CE区别就是C清空所有变
{ //量,CE仅清空当前输入的//数据 C符号的处理
C计算器Dlg::setempty();
n_2=0;
operate='0';
UpdateData(false);
Invalidate();
}
void C计算器Dlg::OnBnClickedButton11() //控件+/-对应的函数. 改变正负号 +/-的处理
{
n=-n; //按一次改变n为-n
UpdateData(false);
Invalidate();
}
void C计算器Dlg::inum(int i) // 输入字符为预期数据,i为0-9的变量
{
if (n==fabs(n)) // 判断n的正负(n为正数), 因为负数在录入时候会出现如按下2 – 2时应该显示”-22”但结果却显示”-18”的 { // 情况,分开讨论
if (!setxiaoshu) // 判断是否在输入小数(非按下小数点情况)(n为正数)
n=10*n+i;
else // 按下小数点情况(n为正数)
{
xiaoshui=xiaoshui+1; // 小数正在输入的位数,每输入一次xiaoshui+1 , xiaoshui初始值为0
n=n+pow(10.0,-xiaoshui)*i; // 产生预期的n,
}
}
else // n为负数
{
if (!setxiaoshu) // 非按下小数点情况(n为负数)
{
n=-10*n+i; // 先把负数变为正数,按整数处理,避免负数录入出错
n=-n; // 变成负数
}
else // 按下小数点情况(n为负数)
{
xiaoshui=xiaoshui+1;
n=-n+pow(10.0,-xiaoshui)*i;
n=-n;
}
}
setnew=false;
}
void C计算器Dlg::OnBnClickedButton12() // 控件.对应的函数. 小数点的判断 .的处理
{
setxiaoshu=true; // 按下开始输入小数部分
Invalidate();
}
void C计算器Dlg::operation(char ope) //执行选定运算
{
switch (ope)
{
case '+':{n=n_2+n;}break;
case '-':{n=n_2-n;}break;
case '*':{n=n_2*n;}break;
case '/':{n=n_2/n;}break;
case 'x':{n=1/n;}break;
case 'q':{if (n>0) n=sqrt(n); else n=0;}break;
case 's':{n=sin(double (n*3.1415926535897932384626433832795/180));}break;
case 'c':{n=cos(double (n*3.1415926535897932384626433832795/180));}break;
case 't':{n=tan(double (n*3.1415926535897932384626433832795/180));}break;
case 'n':{if (n>0)n=log(n);else n=0;}break;
case 'g':{if (n>0) n=log(n)/log(10.0);else n=0;}break;
case 'y':{n=pow(n_2,n);}break;
default:; //operate='0',不执行任何代码
}
Invalidate(); //这里加上该函数可以使包含该函数的函数不再重复添加该函数就实现每次按键变色效果
}

试一下吧，应该还行！

---

石门县18395946518： 用c++做一个四则运算计算器(支持加减乘除混合运算,支持括号,倒数,正负号,求你们了快点 - ？
鄣盆全龟：[答案] 很简单,用mfc基于对话框,如果你mfc不会,就不好办了.

石门县18395946518： C++四则运算用c++设计一个简单的四则运算的计算器,要求能完成任意两个数的加减乘除. - ？
鄣盆全龟：[答案] float a,b,y1,y2,y3,y4; cin>>a,b; y1=a+b; y2=a-b; y3=a*b; y4=a/b; cout解析看不懂?免费查看同类题视频解析查看解答

石门县18395946518： 用C++语言设计一个简单计算器.用户输入四则运算表达式,程序输出正确结果(有追加) - ？
鄣盆全龟： 已经过测试,完全满足你的要求哈. #include ＂iostream＂ #include ＂string＂ using namespace std;void check(char *input, double &x, double &y, int &op, char * &err); double chage(char *ch);int main() {double x,y;int op;char input[40],*err;...

石门县18395946518： 用c++做一个四则运算计算器( - ？
鄣盆全龟： 很简单,用mfc基于对话框,如果你mfc不会,就不好办了.

石门县18395946518： 求四则运算计算器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=...

石门县18395946518： VC++Builder关于四则混合运算的算法!! - ？
鄣盆全龟： 可以用Edit作为输入要计算的数;用Label去显示结果 如:在确定按钮单击事件中写:Label2->Caption=Edit1->Text.ToDouble()+Edit2->Text.ToDouble(); 同样+ -* /都能用 如:在确定按钮单击事件中写:Label2->Caption=1+5*2-6/5;那单击按钮就会在Label2中显示答案;

石门县18395946518： 用C++设计一个计算四则运算的程序, 程序循环从标准输入读入表达式 输入x+x回车 则输出x+x=x？
鄣盆全龟： #include &lt;iostream&gt; using namespace std; void main() { double a, b; int i; char s[30]; char c; while (1) { cout &lt;&lt; ＂please intput: ＂; cin &gt;&gt; s; if (!strcmp(s, ＂完了＂)) { return; } a = atof(s); for (i = 0; i != strlen(s); ++i) { if (s[i] == '+' || s[i] ==...

石门县18395946518： 求一C++编写的计算器,要求能运算简单的四则运算,并且包括括号和小数! 谢谢~~~~？
鄣盆全龟： 这个程序我以前刚好写过,是分文件组织的,下面我就把代码贴给你吧,这个程序完全满足你的要求当然还包括能够运算乘方,整数和小数都能运行,而且能够判断表达式的错误并作出处理,很健壮 头文件有两个: 第一个是:Calulator.h //...

石门县18395946518： C++如果要写个四则运算的混合运算函数该怎么写? - ？
鄣盆全龟： #include <iostream> using namespace std; int main() {int m,n; double a; char ch; cout<<＂输入两个数＂<<endl; cin>>m>>n; cout<<＂输入运算符(+,-,*,/)＂<<endl; cin>> ch;switch(ch) { case '+': cout<<＂和是＂<<m+n<<endl; break; case '-':...

石门县18395946518： 关于VC++四则混合运算的算法？
鄣盆全龟： 以前用c语言做的一个,不能有括号的小东西 #include <stdio.h> void main() {char c[256]; int a[256]={0}; int i,j,k; int x=0,y,z; int n=0; for(i=0;c[i-1]!=10;i++)//i是字符串长度,下面有用 scanf(＂%c＂,&c[i]);//输入字符串,存数组中 for(j=0,k=0;j<i;j++) ...