c语言计算器
C语言实现计算器的两种方法

C语⾔实现计算器的两种⽅法本⽂实例为⼤家分享了C语⾔实现计算器的具体代码,供⼤家参考,具体内容如下C语⾔计算器两种⽅法//⼀般做法#include<stdio.h>#include<windows.h>//#include<assert.h>void menu(){printf("**************************\n");printf("****欢迎来到计算器页⾯****\n");printf("**** 1.add 2.mul *****\n");printf("*****3.sub 4.div1 *****\n");printf("*****0.exit *****\n");printf("**************************\n");}int add(int x, int y){return x + y;}int mul(int x, int y){return x * y;}int sub(int x, int y){return x - y;}int div1(int x, int y){return x / y;}int main(){int n = 1;menu();while (n){printf("请输⼊选项:\n");scanf("%d", &n);int x = 0, y = 0;/*printf("请输⼊两个整数!\n");scanf("%d%d", &x, &y);*///若将两个数字输⼊放在此处会出现输⼊错误时不能退出系统,⽽是显⽰“输⼊两个整数”的提⽰switch (n){case 1:printf("请输⼊两个整数!\n");scanf("%d%d", &x, &y);printf("%d\n", add(x, y));break;case 2:printf("请输⼊两个整数!\n");scanf("%d%d", &x, &y);printf("%d\n", mul(x, y));break;case 3:printf("请输⼊两个整数!\n");scanf("%d%d", &x, &y);printf("%d\n", sub(x, y));break;case 4:printf("请输⼊两个整数!\n");scanf("%d%d", &x, &y);printf("%d\n", div1(x, y));break;case 0:printf("退出计算器!\n");break;default:printf("输⼊错误,请重新输⼊!\n");}}}//使⽤函数指针数组解决计算器问题#include<stdio.h>#include<windows.h>//#include<assert.h>void menu(){printf("**************************\n");printf("****欢迎来到计算器页⾯****\n");printf("**** 1.add 2.mul *****\n");printf("*****3.sub 4.div1 *****\n");printf("*****0.exit *****\n");printf("**************************\n");}int add(int x, int y){return x + y;}int mul(int x, int y){return x * y;}int sub(int x, int y){return x - y;}int div1(int x, int y){return x / y;}int main(){int n = 1;menu();while (n){printf("请输⼊选项:\n");scanf("%d", &n);int(*arr[5])() = { 0,add,mul,sub,div1 };//转移表 //定义⼀个函数指针数组,存放函数地址if (n >= 0 && n < 5){int x = 0, y = 0;printf("请输⼊两个整数:>\n");scanf("%d%d", &x, &y);printf("%d\n", (*arr[n])(x,y));//输出结果}else{printf("输⼊有误,请重新输⼊!\n");scanf("%d", &n);}}system("pause");return 0;}两种⽅法相⽐,第⼀种相似代码较多,⽐较冗余;第⼆种代码简洁直观,程序效率⾼。
C语言实现计算器功能

C语言实现计算器功能C语言计算器实现是一种基本的编程练习,可以结合简单的数学表达式解析和计算功能来实现一个基本的计算器。
以下是一个简单的示例,它可以接受用户输入的数学表达式并返回计算结果。
首先,我们需要包含标准输入/输出库(stdio.h)和字符串处理库(string.h)。
我们还需要定义一些函数来处理数学表达式的解析和计算。
```c#include <stdio.h>#include <string.h>//返回运算符的优先级int precedence(char op)if (op == '+' , op == '-')return 1;if (op == '*' , op == '/')return 2;return 0;//执行四则运算int calculate(int a, int b, char op)switch (op)case '+':return a + b;case '-':return a - b;case '*':return a * b;case '/':return a / b;}return 0;//解析数学表达式并计算结果int evaluate(char *expression)int i;//创建两个空栈,用于操作数和运算符int values[100];int top_values = -1;char ops[100];int top_ops = -1;//遍历表达式的每个字符for (i = 0; i < strlen(expression); i++)//如果字符是一个数字,将其解析为整数,并将其推到操作数栈中if (expression[i] >= '0' && expression[i] <= '9')int value = 0;while (i < strlen(expression) && expression[i] >= '0' && expression[i] <= '9')value = value * 10 + (expression[i] - '0');i++;}values[++top_values] = value;}//如果字符是一个左括号,将其推到运算符栈中else if (expression[i] == '(')ops[++top_ops] = expression[i];}//如果字符是一个右括号,执行所有高优先级的运算else if (expression[i] == ')')while (top_ops > -1 && ops[top_ops] != '(')int b = values[top_values--];int a = values[top_values--];char op = ops[top_ops--];values[++top_values] = calculate(a, b, op);}top_ops--;}//如果字符是一个运算符,执行所有高优先级的运算elsewhile (top_ops > -1 && precedence(ops[top_ops]) >= precedence(expression[i]))int b = values[top_values--];int a = values[top_values--];char op = ops[top_ops--];values[++top_values] = calculate(a, b, op);}ops[++top_ops] = expression[i];}}//执行剩余的运算while (top_ops > -1)int b = values[top_values--];int a = values[top_values--];char op = ops[top_ops--];values[++top_values] = calculate(a, b, op);}//返回最终结果return values[top_values];int mainchar expression[100];printf("请输入数学表达式:");scanf("%s", expression);int result = evaluate(expression);printf("结果:%d\n", result);return 0;```上面的代码使用了栈来解析和计算数学表达式。
c语言制作简单的计算器

c语言制作简单的计算器在计算机编程领域中,C语言是一种广泛使用的编程语言之一。
它具有简单易学的特点,并且能够进行复杂的计算和逻辑处理。
今天,我们就来学习一下如何使用C语言来制作一个简单的计算器。
首先,我们需要明确我们计算器的功能和界面设计。
本次制作的计算器将具有基本的四则运算功能,即加法、减法、乘法和除法。
我们将在控制台中实现计算器的操作,并通过简单的用户界面进行交互。
接下来,我们需要创建一个C语言程序的框架。
首先,我们需要包含头文件,以便在程序中使用各种函数和变量。
我们可以使用"#include" 来引入头文件,例如:```c#include <stdio.h>```然后,我们需要定义主函数 `main()`。
在这个函数中,我们将编写计算器的逻辑代码。
让我们开始编写函数吧!首先,我们需要声明一些变量来存储用户输入的数字和运算符。
我们可以使用 `int` 来定义整数变量,并用 `char` 定义字符变量。
例如:```cint num1, num2, result;char operator;```接下来,我们需要提示用户输入要进行的运算,并读取用户输入的数字和运算符。
我们可以使用 `printf` 和 `scanf` 函数来完成这个任务,例如:```cprintf("请输入第一个数字: ");scanf("%d", &num1);printf("请输入运算符(+, -, *, /): ");scanf(" %c", &operator);printf("请输入第二个数字: ");scanf("%d", &num2);```注意,我们在读取运算符之前添加了空格,这是为了消除输入缓冲区中可能残留的换行符等字符。
接下来,我们需要编写代码来进行实际的计算操作。
C语言实现计算器功能

C语言实现计算器功能计算机科学中的计算器功能是一个非常常见的问题。
在C语言中,我们可以使用各种技术和算法来实现这个功能。
在本文中,我将介绍一种简单的实现方法,该方法可以处理基本的四则运算。
首先,我们需要定义我们的计算器结构。
在C语言中,我们可以使用结构来组织相关的数据和函数。
我们可以定义一个名为 Calculator 的结构体,它包含两个浮点数类型的操作数和一个字符类型的操作符。
```ctypedef structfloat operand1;float operand2;char operator;} Calculator;```接下来,我们可以定义一些辅助函数来执行各种计算。
我们可以使用switch 语句来根据操作符执行相应的操作。
我们可以使用 scanf 函数来读取用户输入的操作数和操作符。
```cfloat add(float operand1, float operand2)return operand1 + operand2;float subtract(float operand1, float operand2)return operand1 - operand2;float multiply(float operand1, float operand2)return operand1 * operand2;float divide(float operand1, float operand2)return operand1 / operand2;void calculate(Calculator* calculator)switch(calculator->operator)case '+':printf("Result: %f\n", add(calculator->operand1, calculator->operand2));break;case '-':printf("Result: %f\n", subtract(calculator->operand1, calculator->operand2));break;case '*':printf("Result: %f\n", multiply(calculator->operand1, calculator->operand2));break;case '/':printf("Result: %f\n", divide(calculator->operand1,calculator->operand2));break;default:printf("Invalid operator\n");break;}```现在我们可以编写一个主函数来演示我们的计算器功能。
c语言简易计算器

#include <stdio.h>char token;/*定义程序要使用到的一些函数*/void match( char expectedToken ) /*对当前的标志进行匹配*/{if( token == expectedToken ) token = getchar(); /*匹配成功,获取下一个标志*/ else{printf("cannot match\n");exit(1); /*匹配不成功,退出程序*/}}int low( void )/*用于计算表达式中级别最低的运算*/{int result = mid(); /*计算比加减运算优先级别高的部分*/while(( token == '+' ) || ( token == '-' ))if ( token == '+'){match('+'); /*进行加法运算*/result += mid();break;}else if ( token == '-'){match('-'); /*进行减法运算*/result -= mid();break;}return result;}int mid( void )/*用于计算表达式中级别较高的运算*/{int div; /*除数*/int result = high(); /*计算比乘除运算优先级别高的部分*/while(( token == '*' ) || ( token == '/' ))if ( token == '*'){match('*'); /*进行乘法运算*/result *= high();break;}else if (token == '/'){match('/'); /*进行除法运算*/div = high();if( div == 0 ) /*需要判断除数是否为0*/{printf( "除数为0.\n" );exit(1);}result /= div;break;}return result;}int high( void )/*用于计算表达式中级别最高的运算,即带()的运算*/{int result;if( token == '(' ) /*带有括号的运算*/{match( '(' );result = low();/*递归计算表达式*/match(')');}else if ( token>= '0'&&token<='9' ) /*实际的数字*/{ungetc( token, stdin ); /*将读入的字符退还给输入流,为读取整个数*/scanf( "%d", &result ); /*读出数字*/token = getchar(); /*读出当前的标志*/}else{printf("The input has unexpected char\n"); /*不是括号也不是数字*/exit(1);}return result;}main(){int result; /*运算的结果*/printf("*****************************************\n");printf("**Welcome to use this simple calculator**\n");printf("**Please input a multinomial like **\n");printf("** 6-3*(5-1)/2+14/7 **\n");printf("*****************************************\n");token = getchar(); /*载入第一个符号*/result = low(); /*进行计算*/if( token == '\n' ) /* 是否一行结束*/printf( "The answer is : %d\n", result );else{printf( "Unexpected char!");exit(1); /* 出现了例外的字符*/}scanf("%d",result);return 0;}。
计算器编程c语言

计算器编程 c语言用C语言设计计算器程序源代码#include <dos.h> /*DOS接口函数*/#include <math.h> /*数学函数的定义*/#include <conio.h> /*屏幕操作函数*/函数*/#include <stdio.h> /*I/O#include <stdlib.h> /*库函数*/变量长度参数表*/#include <stdarg.h> /*图形函数*/#include <graphics.h> /*字符串函数*/#include <string.h> /*字符操作函数*/#include <ctype.h> /*#define UP 0x48 /*光标上移键*/#define DOWN 0x50 /*光标下移键*/#define LEFT 0x4b /*光标左移键*/#define RIGHT 0x4d /*光标右移键*/#define ENTER 0x0d /*回车键*/void *rar; /*全局变量,保存光标图象*/使用调色板信息*/struct palettetype palette; /*int GraphDriver; /* 图形设备驱动*/int GraphMode; /* 图形模式值*/int ErrorCode; /* 错误代码*/int MaxColors; /* 可用颜色的最大数值*/int MaxX, MaxY; /* 屏幕的最大分辨率*/double AspectRatio; /* 屏幕的像素比*/void drawboder(void); /*画边框函数*/初始化函数*/void initialize(void); /*计算器计算函数*/void computer(void); /*改变文本样式函数*/ void changetextstyle(int font, int direction, int charsize); /*窗口函数*/void mwindow(char *header); /*/*获取特殊键函数*/int specialkey(void) ;设置箭头光标函数*//*int arrow();/*主函数*/int main(){设置系统进入图形模式 */initialize();/*运行计算器 */computer(); /*系统关闭图形模式返回文本模式*/closegraph();/*/*结束程序*/return(0);}/* 设置系统进入图形模式 */void initialize(void){int xasp, yasp; /* 用于读x和y方向纵横比*/GraphDriver = DETECT; /* 自动检测显示器*/initgraph( &GraphDriver, &GraphMode, "" );/*初始化图形系统*/ErrorCode = graphresult(); /*读初始化结果*/如果初始化时出现错误*/if( ErrorCode != grOk ) /*{printf("Graphics System Error: %s\n",显示错误代码*/grapherrormsg( ErrorCode ) ); /*退出*/exit( 1 ); /*}getpalette( &palette ); /* 读面板信息*/MaxColors = getmaxcolor() + 1; /* 读取颜色的最大值*/MaxX = getmaxx(); /* 读屏幕尺寸 */MaxY = getmaxy(); /* 读屏幕尺寸 */getaspectratio( &xasp, &yasp ); /* 拷贝纵横比到变量中*/计算纵横比值*/ AspectRatio = (double)xasp/(double)yasp;/*}/*计算器函数*/void computer(void){定义视口类型变量*/struct viewporttype vp; /*int color, height, width;int x, y,x0,y0, i, j,v,m,n,act,flag=1;操作数和计算结果变量*/float num1=0,num2=0,result; /*char cnum[5],str2[20]={""},c,temp[20]={""};定义字符串在按钮图形上显示的符号 char str1[]="1230.456+-789*/Qc=^%";/**/mwindow( "Calculator" ); /*显示主窗口 */设置灰颜色值*//*color = 7;getviewsettings( &vp ); /* 读取当前窗口的大小*/width=(vp.right+1)/10; /* 设置按钮宽度 */设置按钮高度 */height=(vp.bottom-10)/10 ; /*/*设置x的坐标值*/x = width /2;设置y的坐标值*/y = height/2; /*setfillstyle(SOLID_FILL, color+3);bar( x+width*2, y, x+7*width, y+height );/*画一个二维矩形条显示运算数和结果*/setcolor( color+3 ); /*设置淡绿颜色边框线*/rectangle( x+width*2, y, x+7*width, y+height );/*画一个矩形边框线*/设置颜色为红色*/setcolor(RED); /*输出字符串"0."*/outtextxy(x+3*width,y+height/2,"0."); /*/*设置x的坐标值*/x =2*width-width/2;设置y的坐标值*/y =2*height+height/2; /*画按钮*/for( j=0 ; j<4 ; ++j ) /*{for( i=0 ; i<5 ; ++i ){setfillstyle(SOLID_FILL, color);setcolor(RED);bar( x, y, x+width, y+height ); /*画一个矩形条*/rectangle( x, y, x+width, y+height );sprintf(str2,"%c",str1[j*5+i]);/*将字符保存到str2中*/outtextxy( x+(width/2), y+height/2, str2);移动列坐标*/x =x+width+ (width / 2) ;/*}y +=(height/2)*3; /* 移动行坐标*/x =2*width-width/2; /*复位列坐标*/}x0=2*width;y0=3*height;x=x0;y=y0;gotoxy(x,y); /*移动光标到x,y位置*/显示光标*/arrow(); /*putimage(x,y,rar,XOR_PUT);m=0;n=0;设置str2为空串*/strcpy(str2,""); /*当压下Alt+x键结束程序,否则执行下面的循环while((v=specialkey())!=45) /**/{当压下键不是回车时*/while((v=specialkey())!=ENTER) /*{putimage(x,y,rar,XOR_PUT); /*显示光标图象*/if(v==RIGHT) /*右移箭头时新位置计算*/if(x>=x0+6*width)如果右移,移到尾,则移动到最左边字符位置*//*{x=x0;m=0;}else{x=x+width+width/2;m++;否则,右移到下一个字符位置*/} /*if(v==LEFT) /*左移箭头时新位置计算*/if(x<=x0){x=x0+6*width;m=4;} /*如果移到头,再左移,则移动到最右边字符位置*/else{x=x-width-width/2;m--;} /*否则,左移到前一个字符位置*/if(v==UP) /*上移箭头时新位置计算*/if(y<=y0){y=y0+4*height+height/2;n=3;} /*如果移到头,再上移,则移动到最下边字符位置*/else{y=y-height-height/2;n--;} /*否则,移到上边一个字符位置*/if(v==DOWN) /*下移箭头时新位置计算*/if(y>=7*height){ y=y0;n=0;} /*如果移到尾,再下移,则移动到最上边字符位置*/else{y=y+height+height/2;n++;} /*否则,移到下边一个字符位置*/putimage(x,y,rar,XOR_PUT); /*在新的位置显示光标箭头*/ }将字符保存到变量c中*/c=str1[n*5+m]; /*判断是否是数字或小数点*/if(isdigit(c)||c=='.') /*{如果标志为-1,表明为负数*/if(flag==-1) /*{将负号连接到字符串中*/strcpy(str2,"-"); /*flag=1;} /*将标志值恢复为1*/将字符保存到字符串变量temp中*/ sprintf(temp,"%c",c); /*将temp中的字符串连接到str2中*/strcat(str2,temp); /*setfillstyle(SOLID_FILL,color+3);bar(2*width+width/2,height/2,15*width/2,3*height/2);显示字符串*/outtextxy(5*width,height,str2); /*}if(c=='+'){将第一个操作数转换为浮点数*/num1=atof(str2); /*将str2清空*/strcpy(str2,""); /*做计算加法标志值*/act=1; /*setfillstyle(SOLID_FILL,color+3);bar(2*width+width/2,height/2,15*width/2,3*height/2);显示字符串*/outtextxy(5*width,height,"0."); /*}if(c=='-'){如果str2为空,说明是负号,而不是减号*/ if(strcmp(str2,"")==0) /*设置负数标志*/flag=-1; /*else{将第二个操作数转换为浮点数*/num1=atof(str2); /*将str2清空*/strcpy(str2,""); /*act=2; /*做计算减法标志值*/setfillstyle(SOLID_FILL,color+3);画矩形*/ bar(2*width+width/2,height/2,15*width/2,3*height/2); /*显示字符串*/outtextxy(5*width,height,"0."); /*}}if(c=='*'){将第二个操作数转换为浮点数*/num1=atof(str2); /*strcpy(str2,""); /*将str2清空*/做计算乘法标志值*/act=3; /*setfillstyle(SOLID_FILL,color+3); bar(2*width+width/2,height/2,15*width /2,3*height/2);显示字符串*/outtextxy(5*width,height,"0."); /*}if(c=='/'){将第二个操作数转换为浮点数*/num1=atof(str2); /*strcpy(str2,""); /*将str2清空*/做计算除法标志值*/act=4; /*setfillstyle(SOLID_FILL,color+3);bar(2*width+width/2,height/2,15*width/2,3*height/2);outtextxy(5*width,height,"0."); /*显示字符串*/}if(c=='^'){将第二个操作数转换为浮点数*/num1=atof(str2); /*将str2清空*/strcpy(str2,""); /*做计算乘方标志值*/act=5; /*设置用淡绿色实体填充*/ setfillstyle(SOLID_FILL,color+3); /*画矩形*/ bar(2*width+width/2,height/2,15*width/2,3*height/2); /*显示字符串*/outtextxy(5*width,height,"0."); /*}if(c=='%'){将第二个操作数转换为浮点数*/num1=atof(str2); /*strcpy(str2,""); /*将str2清空*/做计算模运算乘方标志值*/act=6; /*setfillstyle(SOLID_FILL,color+3); /*设置用淡绿色实体填充*/画矩形*/ bar(2*width+width/2,height/2,15*width/2,3*height/2); /*显示字符串*/outtextxy(5*width,height,"0."); /*}if(c=='='){将第二个操作数转换为浮点数*/num2=atof(str2); /*根据运算符号计算*/switch(act) /*{case 1:result=num1+num2;break; /*做加法*/case 2:result=num1-num2;break; /*做减法*/case 3:result=num1*num2;break; /*做乘法*/case 4:result=num1/num2;break; /*做除法*/case 5:result=pow(num1,num2);break; /*做x的y次方*/case 6:result=fmod(num1,num2);break; /*做模运算*/ }设置用淡绿色实体填充*/ setfillstyle(SOLID_FILL,color+3); /*覆盖结果区*/ bar(2*width+width/2,height/2,15*width/2,3*height/2); /*将结果保存到temp中*/sprintf(temp,"%f",result); /*outtextxy(5*width,height,temp); /*显示结果*/}if(c=='c'){num1=0; /*将两个操作数复位0,符号标志为1*/num2=0;flag=1;strcpy(str2,""); /*将str2清空*/设置用淡绿色实体填充*/ setfillstyle(SOLID_FILL,color+3); /*覆盖结果区*/ bar(2*width+width/2,height/2,15*width/2,3*height/2); /*显示字符串*/outtextxy(5*width,height,"0."); /*}如果选择了q回车,结束计算程序*/if(c=='Q')exit(0); /*}putimage(x,y,rar,XOR_PUT); /*在退出之前消去光标箭头*/返回*/return; /*}/*窗口函数*/void mwindow( char *header ){int height;cleardevice(); /* 清除图形屏幕 */setcolor( MaxColors - 1 ); /* 设置当前颜色为白色*//* 设置视口大小 */ setviewport( 20, 20, MaxX/2, MaxY/2, 1 );height = textheight( "H" ); /* 读取基本文本大小 */settextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );/*设置文本样式*/settextjustify( CENTER_TEXT, TOP_TEXT );/*设置字符排列方式*/输出标题*/outtextxy( MaxX/4, 2, header ); /*setviewport( 20,20+height+4, MaxX/2+4, MaxY/2+20, 1 ); /*设置视口大小*/ 画边框*/drawboder(); /*}画边框*/void drawboder(void) /*{定义视口类型变量*/struct viewporttype vp; /*setcolor( MaxColors - 1 ); /*设置当前颜色为白色 */setlinestyle( SOLID_LINE, 0, NORM_WIDTH );/*设置画线方式*/将当前视口信息装入vp所指的结构中*/getviewsettings( &vp );/*画矩形边框*/rectangle( 0, 0, vp.right-vp.left, vp.bottom-vp.top ); /*}/*设计鼠标图形函数*/int arrow(){int size;定义多边形坐标*/int raw[]={4,4,4,8,6,8,14,16,16,16,8,6,8,4,4,4}; /*设置填充模式*/setfillstyle(SOLID_FILL,2); /*/*画出一光标箭头*/fillpoly(8,raw);测试图象大小*/size=imagesize(4,4,16,16); /*分配内存区域*/rar=malloc(size); /*存放光标箭头图象*/getimage(4,4,16,16,rar); /*putimage(4,4,rar,XOR_PUT); /*消去光标箭头图象*/return 0;}/*按键函数*/int specialkey(void){int key;等待键盘输入*/while(bioskey(1)==0); /*key=bioskey(0); /*键盘输入*/只取特殊键的扫描值,其余为0*/ key=key&0xff? key&0xff:key>>8; /*return(key); /*返回键值*/}。
C语言实现简易计算器(可作加减乘除)

C语⾔实现简易计算器(可作加减乘除)C语⾔实现简易计算器(加减乘除)计算器作为课设项⽬,已完成答辩,先将代码和思路(注释中)上传⼀篇博客已增添、修改、整理⾄⽆错且可正常运⾏虽使⽤了栈,但初学者可在初步了解栈和结构语法后理解代码#include <stdlib.h>#include <stdio.h>#include <string.h>#define IsDouble 0#define IsChar 1//_______________________________________________________________________________________________________________________________________________________ //1.⽀持浮点数和字符的栈typedef struct {char * buffer;int typesize;int top;int max;} stack;stack * CreateStack(int max, int typesize);//创建⼀个栈void DestroyStack(stack *);//释放栈的空间void ClearStack(stack *);//清空栈int Push(stack *, void *);//⼊栈int Pop(stack *, void *);//出栈int GetSize(stack *s);//得到栈的⼤⼩int GetTop(stack *, void *);//找到栈顶int IsEmpty(stack *);//判断是否为空栈,空则下溢int IsFull(stack *);//判断栈是否已满,满则溢出stack * CreateStack(int max, int typesize){stack * s = (stack*)malloc(sizeof(stack));//为栈s malloc内存if (!s) return 0;//为结构中buffer元素malloc内存s->buffer = (char *)malloc(sizeof(char) * max * typesize);if (!s->buffer) return 0;//初始化结构中的栈顶,最⼤值,类型⼤⼩s->top = -1;s->max = max;s->typesize = typesize;return s;}void DestroyStack(stack* s){free(s->buffer);//先释放buffer的空间free(s);//在释放s的空间}void ClearStack(stack * s){s->top = -1;//清空栈(栈头位置归零)}int Push(stack * s, void * data){if (IsFull(s)) return 0;//如果栈已满则return 0,防⽌溢出//栈未满则将栈头移动打动下⼀位置,并将data中的元素拷⼊栈中buffer的第top位置s->top++;memcpy(s->buffer + s->top*s->typesize, data, s->typesize);//⼊栈成功return 1return 1;}int Pop(stack * s, void * data){if (IsEmpty(s)) return 0;//出栈判断栈是否为空,若为空则return 0//栈未空则将buffer中top位置的字符拷⼊data记录,并让栈头向前移动⼀个位置memcpy(data, s->buffer + s->top*s->typesize, s->typesize);s->top--;//成功则return 1return 1;}int GetSize(stack *s){return s -> top+1;//栈头位置+1得到⼤⼩}int GetTop(stack *s, void * data){if (IsEmpty(s)) return 0;//如果栈空return 0//栈不为空则将top位置的字符拷回data记录,得到栈头memcpy(data, s->buffer + s->top*s->typesize, s->typesize);//成功则return 1;return 1;}int IsEmpty(stack * s){return s->top == -1;//如果top为-1则栈空}int IsFull(stack * s){return s->top == s->max-1;//如果top为max-1则栈满}//___________________________________________________________________________________________________________________________________________________ //2.定义⼀个cal类型,其中data存数时sign为IsDouble,存字符时,sign为Ischartypedef struct {double data;char sign;} cal;//3.查找对应符号(找到则返回该符号下标)(找不到则说明该部分为数字返回-1)int SearchCode(char ch){char * code = "+-*/()@";//@为终⽌符,算式输⼊结束int index = 0;//while (code[index]){if (code[index] == ch) return index;index++;}return -1;}//4.得到两个符号间的优先级//与SearchCode相对应,char GetPriority(char ch, char next){//创建⼀个perferen表,第i⾏(列)对应SearchCode函数中code中的第i个字符char perferen[7][7] = {">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<=E",">>>>E>>","<<<<<E="};//找到两个形参对应的字符int c = SearchCode(ch);int n = SearchCode(next);//如果找不到对应运算符(字符不是运算符⽽是为数字)return Eif (c==-1 || n==-1) return 'E';//如果找到两个对应运算符则按照优先级表返回两个运算符的优先级return perferen[c][n];}//5.四则运算double add(double a, double b) { return a+b; }double sub(double a, double b) { return a-b; }double mul(double a, double b) { return a*b; }double ddiv(double a, double b) { return a/b; }//整合四种运算double calcu(double a, char ch, double b){double (*calculation[4])(double,double) = {add,sub,mul,ddiv};return calculation[SearchCode(ch)](a,b);}//6.检测字符串int CheckStr(char * buffer){int n;//遍历字符串确保算式中⽆⾮法字符若检测到⾮法字符return 0,若都合法则return 1for (n = 0;buffer[n];n++){if ((SearchCode(buffer[n]) != -1 || buffer[n] == '.' || (buffer[n] >= '0' && buffer[n] <= '9')) && buffer[n] != '@') continue;else return 0;}buffer[n] = '@';//加上终⽌符,表⽰算式结束buffer[n+1] = '\0';return 1;}//7.得到数据转化为double类型存⼊rsint GetDigit(char * buffer, int * n, double * rs){char str[30];int i,j = 0;for (i = 0;SearchCode(buffer[*n]) == -1;i++){str[i] = buffer[*n];//从*n位置开始,将这⼀串数字字符存⼊str(*n)++;}str[i] = '\0';for (i = 0;str[i];i++){if (str[i] == '.') j++;}//如果⼀段⼩数有多个⼩数点或⼩数点在数字⾸尾,return 0if (j>1 || str[i-1] == '.' || str[0] == '.') return 0;//rs接收转化为double的数据*rs = atof(str);//操作成功return 1return 1;}//8.将⽤户输⼊的buffer字符串转化为可供程序运算的calstr数组int resolu(char * buffer, cal * calstr){int i = 0, j = 0;cal c;while (buffer[i]){if (SearchCode(buffer[i]) == -1){//如果得到数据不成功则return 0if (GetDigit(buffer,&i, &c.data) == 0) return 0;//如果成功得到数据则在c.sign标记为浮点数c.sign = IsDouble;//将c存⼊数组calstr中calstr[j++] = c;}else{//若符号为运算符//判断正负号if (buffer[i] == '-' && (buffer[i-1] == '('||buffer[i-1] == '+'||buffer[i-1] == '-'||buffer[i-1] == '*'||buffer[i-1] == '/') || (i==0 && buffer[0] == '-')){ i++;if (GetDigit(buffer,&i, &c.data) == 0) return 0;//在符号的下⼀位开始查找,若找不到数字return 0//否则,给数字取相反数,c.sign标记为浮点数,存⼊calstr中c.data = 0 - c.data;c.sign = IsDouble;calstr[j++] = c;} else//如果是正号,与符号处理⽅式同理if (buffer[i] == '+' && (buffer[i-1] == '('||buffer[i-1] == '+'||buffer[i-1] == '-'||buffer[i-1] == '*'||buffer[i-1] == '/') || (i==0 && buffer[0] == '+')){ i++;if (GetDigit(buffer, &i, &c.data) == 0) return 0;c.sign = IsDouble;calstr[j++] = c;}else{//如果不是正负号,则为运算符,先强制转换为double类型存在c.data⾥,然后c.sign标记为char类型,存⼊calstrc.data = (double)buffer[i++];c.sign = IsChar;calstr[j++] = c;}}}//操作蔡成功则return 1return 1;}//9.计算出结果int result(cal * calstr, double * rs){stack * pst = CreateStack(100,sizeof(char));//运算符栈stack * pnd = CreateStack(100,sizeof(double));//数据栈double num1,num2;int n = 0;char ch = '@';Push(pst, &ch);//在转换得到的calstr中遍历直到终⽌符'@"while(ch != '@' || !(calstr[n].sign == IsChar && (char)calstr[n].data == '@')){//如果calstr的n位上是浮点数,则将这个data压栈进⼊数据栈pnd中if (calstr[n].sign == IsDouble){Push(pnd, &(calstr[n].data));n++;}//反之,如果是运算符,则要检测优先级else{switch( GetPriority(ch, (char)calstr[n].data)){//如果运算符优先级较⼩,则让ch等于优先级⼤的符号并压⼊符号栈pst中case '<':ch = (char)calstr[n].data;Push(pst, &ch);n++;break;//如果结果为等号,让符号出栈暂存到ch中case '=':if (!Pop(pst, &ch)) return 0;n++;break;//如果ch优先级较⾼,则将前两个数字及运算符出栈,分别储存⾄num2,ch,num1中,进⾏运算,得到的结果再次压栈进⼊pnd中 case '>':if (!(Pop(pnd,&num2) && Pop(pst,&ch) && Pop(pnd,&num1))) return 0;num1 = calcu(num1,ch,num2);Push(pnd, &num1);break;//如果符号顺序出错,return 0case 'E':return 0;}}//检测是否可以得到栈顶符号,栈空则return 0if (!GetTop(pst, &ch)) return 0;}//如果栈中得到了最终结果,并且取出pnd中的最终结果到rs,return 1if (GetSize(pnd) == 1 && GetTop(pnd,rs)){DestroyStack(pst);DestroyStack(pnd);return 1;}//否则 return 0else{return 0;}}//10.⽤户交互函数void treatment(){char buffer[100];//⽤户输⼊的字符串(算式)cal calstr[50];//计算⽤的数组double rs = 0;//计算结果printf("Enter your equation:");gets(buffer);//让⽤户输⼊算式buffer//⽤户不输⼊"exit"就不退出while (!(buffer[0]=='e' && buffer[1]=='x' && buffer[2]=='i' && buffer[3]=='t')){//检查buffer中字符君合法,成功将buffer转化为⽤于计算的calstr数组,成功计算出结果存⼊rsif (CheckStr(buffer) && resolu(buffer,calstr) && result(calstr,&rs)){printf("\n%lf\n",rs);}else{printf("\nError!\n");}printf("Enter \"exit\"to quit");printf("\nEnter your equation:");gets(buffer);//再次让⽤户输⼊算式}printf("\nbye\n");}//11.主函数int main(){treatment();}参考⽂献链接如下[参考⽂献]()。
C语言计算器源代码

C语言计算器源代码 The document was prepared on January 2, 2021C++语言编写。
#include<iostream>#include<cmath>#include<string>using namespace std;const double pi = 3.;const double e = ;const int SIZE = 1000;typedef struct node{i++;ge = 0;biao_dian = 1;}if(line[i] == 'P'){shu[++p] = pi;i++;break;}if(line[i] == 'E'){shu[++p] = e;i++;break;}if(flag1){h = h * 10 + (line[i] - '0');flag = 1;i++;if(biao_dian)ge++;}elsebreak;}if(flag){if(biao_dian){int r = 1;for(int k = 1; k <= ge; k++)r *= 10;h /= r;}shu[++p] = h; + ^(乘方) F(off) Enter(=) "<<endl; cout<<"对于对数输入 L2_5 表示以2为底5的对数"<<endl;cout<<"M(在前面结果的基础上继续计算,如:上次结果为10,现输入+*2)"<<endl;cout<<"D(清零并继续输入)"<<endl;cout<<"F(计算机关闭)"<<endl;cout<<"输入 P 就代表输入圆周率, 输入 E 代表输入自然对数"<<endl<<endl; }void print(){system("color 2");cout<<" 欢迎使用本计算器"<<endl;cout<<"输入一个字符串 on, 计算器开始启动"<<endl;}void if_start()//是否启动计算器{string start;print();while(cin>>start){if(start != "on"){cout<<"您所输入的字符无效, 请按照介绍的继续输入:"<<endl;continue;}elsebreak;}if(start == "on"){system("color 5");//颜色的处理system("cls");//刷屏}introduce();//对计算器的简要介绍cout<<"现在,请输入您所要计算的表达式"<<endl;input();//输入所要计算的表达式}int main(){if_start();//调用是否启动计算器函数return 0;}。
用c语言写的简单计算器

⽤c语⾔写的简单计算器这是⾃⼰在学习C语⾔,凭借⾃⼰的兴趣,将课本的知识运⽤后整理的关于C语⾔计算器的代码。
计算器实现的功能有:加、减、乘、除、求余。
功能简单,但对于初学者的我来说能把它写出来,排除每个错误依旧是个难题。
前后两种代码是由⾃⼰所学东西的质量决定的,如有错误,请前辈指出。
最初版本的计算器:1 #include<stdio.h>23int checkPassword();45int add(int x,int y);67int sub(int x,int y);89int multi(int x,int y);1011float quo(float x1,float y1);1213int com(int x,int y);1415int x,y;1617int result;1819int select;2021float result1;2223float x1,y1;2425int success,psw;2627int a;2829int i;3031int t;323334353637void main()3839 {4041 printf("请输⼊密码:\n");4243 i=0;4445do{46474849 scanf("%d",&a);50515253if( a!=1234 && i<2)5455 printf("请重新输⼊密码:\n");5657else5859 i=3;6061 i++;6263 }while( i<=2);6465if(a==1234)6667 {6869for(t=1;t!=6;t=select)7071 {72737576777879 printf("+=============================+\n"); 8081 printf("+======计=算=器=主=菜=单======+\n"); 8283 printf("+=============================+\n"); 8485 printf("+==========1、加法==========+\n"); 8687 printf("+==========2、减法==========+\n"); 8889 printf("+==========3、乘法==========+\n"); 9091 printf("+==========4、除法==========+\n"); 9293 printf("+==========5、求余==========+\n"); 9495 printf("+==========6、退出==========+\n"); 9697 printf("+=============================+\n"); 9899100101102103 printf("请输⼊你的选择:\n");104105 scanf("%d",&select);106107108109switch(select)110111 {112113114115case1:116117 printf("请输⼊两个数:\n");118119 scanf("%d%d",&x,&y);120121 result=add(x,y);122123 printf("%d+%d=%d\n",x,y,result);124125break;126127case2:128129 printf("请输⼊两个数:\n");130131 scanf("%d%d",&x,&y);132133 result=sub(x,y);134135 printf("%d-%d=%d\n",x,y,result);136137break;138139case3:140141 printf("请输⼊两个数:\n");142143 scanf("%d%d",&x,&y);144145 result=multi(x,y);146147 printf("%d*%d=%d\n",x,y,result);148149break;150151case4:152153 printf("请输⼊两个数:\n");154155 scanf("%f%f",&x1,&y1);156157 result1=quo(x1,y1);159 printf("%f/%f=%f\n",x1,y1,result1); 160161break;162163case5:164165 printf("请输⼊两个数:\n");166167 scanf("%d%d",&x,&y);168169 result=com(x,y);170171 printf("%d/%d=%d\n",x,y,result); 172173break;174175case6:176177break;178179default:180181 printf("请输⼊1~5之间的数\n"); 182183break;184185186187188189 }190191 }192193 }194195 }196197int add(int x,int y)198199 {200201int sum;202203 sum=x+y;204205return sum;206207 }208209int sub(int x,int y)210211 {212213int sub;214215 sub=x-y;216217return sub;218219 }220221int multi(int x,int y)222223 {224225int multi;226227 multi=x*y;228229return multi;230231 }232233float quo(float x,float y)234235 {236237float quo;238239 quo=x/y;240241return quo;243 }244245int com(int x,int y)246247 {248249int com;250251 com=x%y;252253return com;254255 }256257int checkPassword( int psw)258259 {260261if(psw==1234)262263 success=1;264265else266267 success=-1;268269return success;270271 }改版后的计算器:1 #include<stdio.h>23int yanzheng(int );45void caidan();67void jiafa(int,int);89void jianfa(int,int);1011void chengfa(float,float);1213void chufa(float,float);1415void mo(int,int);16171819void main(){2021int x,m;2223int y;2425float a,b;2627 printf("请输⼊密码:\n");2829 scanf("%d",&x);3031 m=yanzheng(x);3233if(m==1){3435 caidan();3637//int y;3839//float a,b;4041for(;y!=6;){4243 printf("请输⼊选项:\n"); 4445 scanf("%d",&y);4647if(y>=1 && y<6){4849 printf("请输⼊要运算的两个数:\n");5051 scanf("%f%f",&a,&b);5253 }54555657switch(y){5859case1 :jiafa(a,b);break;6061case2 :jianfa(a,b);break;6263case3 :chengfa(a,b);break;6465case4 :chufa(a,b);break;6667case5 :mo(a,b);break;6869case6 :break;7071default : printf("选项输⼊错误!请重试\n");break; 7273 }7475 }7677 }7879 }808182838485int yanzheng(int x){8687int i,m;8889for(i=1,m=0;i<3;i++){9091if(x==1234){9293 m=1;9495break;9697 }9899 printf("请重新出⼊密码:");100101 scanf("%d",&x);102103104105 }106107return m;108109 }110111112113void caidan(){114115 printf("+=============================+\n"); 116117 printf("+======计=算=器=主=菜=单======+\n"); 118119 printf("+=============================+\n"); 120121 printf("+==========1、加法==========+\n"); 122123 printf("+==========2、减法==========+\n"); 124125 printf("+==========3、乘法==========+\n"); 126127 printf("+==========4、除法==========+\n"); 128129 printf("+==========5、求余==========+\n"); 130131 printf("+==========6、退出==========+\n"); 132133 printf("+=============================+\n"); 134135 }136137138139void jiafa(int x,int y){140141int sum;142143 sum=x+y;144145 printf("%d\n", sum);146147 }148149150151void jianfa(int x,int y){152153int cha;154155 cha=x-y;156157 printf("%d\n", cha);158159 }160161162163void chengfa(float x,float y){164165float ji;166167 ji=x*y;168169 printf("%f\n", ji);170171 }172173174175void chufa(float x,float y){176177float shang;178179 shang=x/y;180181 printf("%f\n", shang);182183 }184185186187void mo(int x,int y){188189int mo;190191 mo=x%y;192193 printf("%d\n", mo);194195 }。
C语言简易计算器的实现

C语言简易计算器的实现C语言简易计算器是一种用于进行基本数学运算的程序。
实现一个简易计算器的关键是要能够解析用户输入的数学表达式,并将其转化为计算机可以理解的形式,然后进行计算,并输出结果。
下面是一个大约1200字以上的示例实现。
```c#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#include <ctype.h>#define MAX_SIZE 100//定义操作符的优先级int getPriority(char op)if (op == '+' , op == '-')return 1;else if (op == '*' , op == '/')return 2;elsereturn 0;//进行四则运算int calculate(int a, int b, char op)switch (op)case '+': return a + b;case '-': return a - b;case '*': return a * b;case '/': return a / b;default: return 0;}//将中缀表达式转换为后缀表达式void infixToPostfix(char* infixExp, char* postfixExp) char stack[MAX_SIZE];int top = -1;int j = 0;for (int i = 0; infixExp[i] != '\0'; i++)if (isdigit(infixExp[i])) { // 数字直接输出到后缀表达式while (isdigit(infixExp[i]))postfixExp[j++] = infixExp[i++];}postfixExp[j++] = ' ';i--;}else if (infixExp[i] == '(') { // 左括号压入栈stack[++top] = infixExp[i];}else if (infixExp[i] == ')') { // 右括号弹出栈内所有操作符并输出到后缀表达式,直到遇到左括号while (top != -1 && stack[top] != '(')postfixExp[j++] = stack[top--];postfixExp[j++] = ' ';}top--; // 弹出栈顶的左括号}else { // 操作符while (top != -1 && getPriority(stack[top]) >=getPriority(infixExp[i]))postfixExp[j++] = stack[top--];postfixExp[j++] = ' ';stack[++top] = infixExp[i];}}while (top != -1) { // 将栈内剩余操作符弹出并输出到后缀表达式postfixExp[j++] = stack[top--];postfixExp[j++] = ' ';}postfixExp[j] = '\0';//计算后缀表达式的值int evaluatePostfix(char* postfixExp)char stack[MAX_SIZE];int top = -1;for (int i = 0; postfixExp[i] != '\0'; i++)if (isdigit(postfixExp[i])) { // 数字压入栈int num = 0;while (isdigit(postfixExp[i]))num = num * 10 + (postfixExp[i++] - '0');stack[++top] = num;i--;}else if (postfixExp[i] == ' ')continue;}else { // 操作符,弹出栈顶的两个数进行计算,并将结果压入栈int b = stack[top--];int a = stack[top--];int result = calculate(a, b, postfixExp[i]);stack[++top] = result;}}return stack[top];int maichar infixExp[MAX_SIZE];printf("请输入中缀表达式:");fgets(infixExp, sizeof(infixExp), stdin); // 读取用户输入//将中缀表达式转换为后缀表达式char postfixExp[MAX_SIZE];infixToPostfix(infixExp, postfixExp);printf("后缀表达式为:%s\n", postfixExp);//计算后缀表达式的值并输出int result = evaluatePostfix(postfixExp);printf("计算结果为:%d\n", result);return 0;```这个简易计算器的实现基于栈的数据结构。
C语言实现简单计算器程序

C语⾔实现简单计算器程序这两天在看⼀个C语⾔写的计算器程序,做了不少的功夫,跟着作者⼀步步的进⾏完善,了解了许多细节性的东西,在此⾃⼰做个总结,加深⾃⼰对程序的印象,也算是梳理。
在该计算器程序,能进⾏加减乘除、sin、cos、exp等操作,同时能进⾏数值保存功能。
⽽该计算器使⽤逆波兰表⽰法。
即所有运算符都跟在操作数的后⾯,⽐如下列表达式:(1 - 2) * (4 + 5)采⽤逆波兰表⽰法表⽰为:1 2 - 4 5 + *逆波兰表达法中不需要圆括号,只要知道每个运算符需要⼏个操作数就不会引起歧义。
计算器程序实现很简单,具体原理如下:while(/* 下⼀个运算符或操作数不是⽂件结束指⽰符 */)if(/* 是数 */)/* 将该数压⼊到栈中 */else if (/* 是运算符 */)/* 弹出所需数⽬的操作数 *//* 执⾏运算 *//* 将结果压⼊到栈中 */else if (/* 是换⾏符 */)/* 弹出并打印栈顶的值 */else/* 出错 */在程序设计中,使⽤模块化思想,getop函数来进⾏读⼊,该函数返回⼀个标识,⽤来标识读⼊的是什么类型。
主循环体中根据该标识执⾏相应的动作。
以下是该程序:(我将所有函数和变量放在同⼀⽂件)#include <stdlib.h>#include <stdio.h>#include <string.h>#define MAXOP 100#define NUMBER '0' //标识读⼊的是数字#define NAME 'n' //标识读⼊的是字符串(函数名或⾮法字符串)#define ALPHA 26int getop(char []);void push (double); //压栈double pop(void); //出栈void clear(void); //清空栈void mathfnc(char []); //执⾏相应的数学函数sin、cos、exp等int main(void){int type;int i, var = 0;double op1, op2,v;char s[MAXOP];double variable[ALPHA];for (i = 0; i < ALPHA; i++) //初始化⽤于保存数值的变量数组variable[i] = 0.0;while ((type = getop(s)) != EOF) //读取输⼊{switch (type){case NUMBER:push (atof(s));break;case NAME:mathfnc(s);break;case '+':push (pop() + pop());break;case '*':push (pop() * pop());break;case '-':op2 = pop();push (pop() - op2);break;case '/':op2 = pop();if (op2 != 0.0)push (pop() / op2);elseprintf ("error: zero divisor\n");break;case '%':op2 = pop();if (op2 != 0.0)push (fmod(pop(), op2));elseprintf ("error: zero divisor\n");break;case '?': //打印栈顶元素op2 = pop();printf ("\t%.8g\n", op2);push (op2);break;case '=': //保存数值pop();if (var >= 'A' && var <= 'Z')variable[var - 'A'] = pop();elseprintf ("error: no variable name\n");break;case 'c':clear();break;case 'd': //复制栈顶元素op2 = pop();push(op2);push(op2);break;case 's': //交换栈元素op1 = pop();op2 = pop();push(op1);push(op2);case '\n':v = pop(); //v保存最后的⼀次结果printf ("\t%.8g\n", v);break;default:if (type >= 'A' && type <= 'Z')push(variable[type - 'A']);else if (type == '@') //输⼊的字符@表⽰最近⼀次结果值 push(v);elseprintf ("error: unknown command %s\n", s);break;}var = type;}return 0;}/* ----------------------------------------------------------- */#define MAXVAL 100int sp = 0; //标识栈顶double val[MAXVAL];void push(double f){if (sp < MAXVAL)val[sp++] = f;elseprintf ("error: stack full, can't push %g\n", f);}double pop(void){if (sp > 0)return val[--sp];else{printf ("error: statck empty\n");return 0.0;}}void clear(void){sp = 0;}void mathfnc (char s[]){double op2;if (strcmp (s, "sin") == 0)push(sin(pop()));else if(strcmp (s, "cos") == 0)push(cos(pop()));else if(strcmp (s, "exp") == 0)push(exp(pop()));else if(strcmp (s, "pow") == 0){op2 = pop();push (pow(pop(), op2));}elseprintf ("error: %s not supported\n", s);}/* ----------------------------------------------------------- */#include <ctype.h>int getch(void);void ungetch(int);int getop(char s[]){int i, c;while ((s[0] = c = getch()) == ' ' || c == '\t') //过滤开头的空⽩字符;s[1] = '\0';i = 0;if (islower(c)) //判断是否为⼩写字母,也即读取由⼩写字母组成的字符串 {while (islower(s[++i] = c = getch()));s[i] = '\0';if (c != EOF)ungetch(c);if (strlen (s) > 1)return NAME;elsereturn c;}if (!isdigit(c) && c != '.' && c != '-')return c;if (c == '-') //⽤于判断是负数还是减操作{if (isdigit(c = getch()) || c == '.')s[++i] = c;else{if (c != EOF)ungetch(c);return '-';}}if (isdigit(c)) //收集整数部分while (isdigit(s[++i] = c = getch()));if (c == '.') //收集⼩数部分while (isdigit(s[++i] = c = getch()));s[i] = '\0';if (c != EOF)ungetch(c);return NUMBER;}/* ----------------------------------------------------------- *//** 引⽤以下两个函数是因为:程序不能确定它已经读⼊的输⼊是否⾜够 ** 除⾮超前多读⼊⼀些输⼊,在本程序中,读⼊⼀些字符合成⼀个数字 ** 所以在看到第⼀个⾮数字字符之前,已经读⼊的数的完整性是不能确定的* 由于程序要超前读⼊⼀个字符,这样就导致最后⼜⼀个字符不属于当前所要读⼊的数*/#define BUFSIZE 100char buf[BUFSIZE];int bufp = 0;int getch(void){return (bufp > 0) ? buf[--bufp] : getchar();}void ungetch (int c){if (bufp >= BUFSIZE)printf ("ungetch: too many characters\n");elsebuf[bufp++] = c;}该程序虽然简单,但是还是存在⼀些⼩⼩的问题,⽐如没有数据时进⾏pop的话,会打印栈中⽆数据同时返回数值0.0,在循环体中许多执⾏操作会将该数值保存到栈中,之后打印该值,⽤户体验度⽐较差。
C语言计算器代码

printf("小组组长:");Sleep(1000);
puts("尹化荣\n");Sleep(300);
printf("小组成员:");Sleep(300);
printf("尹化荣,");Sleep(300);
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}
void hidden()//隐藏光标
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
//------------------------------------------------------------------||
//迷宫游戏,所有声明:
#define Height 23 //迷宫的高度,必须为奇数
#define Width 39 //迷宫的宽度,必须为奇数
#define Wall 1
double jiafa(double a,double b);
double jianfa(double a,double b);
double chengfa(double a,double b);
double chufa(double a,double b);
intqiuyu(int a,int b);
CONSOLE_CURSOR_INFO cci;
计算器c语言代码

计算器c语言代码计算器C语言代码计算器是一种常见的工具,用于进行数值计算和数学运算。
计算器通常具有基本的四则运算功能,可以执行加法、减法、乘法和除法运算,同时还可以进行其他高级计算,比如开方、求幂、取余等。
在本文中,我们将介绍如何使用C语言编写一个简单的计算器。
我们需要定义计算器的基本功能。
我们可以使用函数来实现不同的计算操作。
下面是一个示例代码,实现了加法、减法、乘法和除法四种功能:```c#include <stdio.h>// 加法函数double add(double a, double b) {return a + b;}// 减法函数double subtract(double a, double b) {return a - b;}// 乘法函数double multiply(double a, double b) { return a * b;}// 除法函数double divide(double a, double b) { if (b == 0) {printf("除数不能为零!\n"); return 0;}return a / b;}int main() {double num1, num2;char operator;printf("请输入两个操作数:");scanf("%lf %lf", &num1, &num2); printf("请输入操作符:");scanf(" %c", &operator);switch (operator) {case '+':printf("结果:%lf\n", add(num1, num2));break;case '-':printf("结果:%lf\n", subtract(num1, num2));break;case '*':printf("结果:%lf\n", multiply(num1, num2));break;case '/':printf("结果:%lf\n", divide(num1, num2));break;default:printf("无效的操作符!\n");break;}return 0;}```在上面的代码中,我们使用了四个函数来实现不同的计算操作。
c语言计算器原理

c语言计算器原理随着计算机技术的发展,计算器作为基本的数学运算工具,已经广泛地应用于各个领域。
在计算机编程中,C语言是一种通用的、面相过程的编程语言,它可以用来开发各种类型的应用程序,包括计算器。
本文将介绍使用C语言编写计算器的原理和方法。
一、计算器的基本原理计算器的基本原理是利用数学运算的原理,通过编程实现加、减、乘、除等基本运算功能。
在C语言中,可以使用各种运算符和函数来实现这些运算,例如“+”、“-”、“*”、“/”等运算符,以及“abs”、“sqrt”等函数。
这些运算符和函数可以被嵌入到程序中,以实现各种复杂的数学运算。
二、计算器的设计思路设计一个计算器需要考虑到以下几个问题:1.用户界面:计算器需要有一个直观、易于使用的用户界面,以便用户能够输入要计算的表达式并得到结果。
2.表达式解析:计算器需要能够解析用户输入的表达式,并将其转换为计算机能够处理的数学运算。
3.运算执行:计算器需要能够执行解析后的表达式,并输出结果。
4.错误处理:计算器需要能够处理各种可能的错误情况,例如无效的输入、除以零等。
基于以上思路,我们可以设计一个简单的计算器程序,它使用命令行界面,支持基本的加、减、乘、除运算,并能够处理一些常见的错误情况。
三、计算器的实现方法实现一个计算器需要使用C语言的输入输出函数、字符串处理函数和数学函数等。
下面是一个简单的计算器程序示例:```c#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>intmain(){charexpression[100];printf("请输入表达式(如:2+3*4):");fgets(expression,sizeof(expression),stdin);expression[strcspn(expression,"\n")]='\0';//去掉换行符doubleresult=0;intsign='+';//默认运算符为加号inti=0;while(expression[i]!='\0'){if(expression[i]==sign){//如果是运算符,则执行相应的运算if(i+2>strlen(expression)){//确保后面还有数字printf("无效的表达式\n");return1;//返回错误码}doublenum1=atof(expression+i+1);//获取第一个数字result+=num1;//进行运算i+=2;//跳过运算符和数字}elseif(isdigit(expression[i])){//如果是数字,则添加到结果中result+=expression[i]-'0';//进行加法运算}else{//遇到非数字和非运算符字符时,结束表达式解析并输出结果break;}i++;//移动到下一个字符}printf("结果为:%f\n",result);//输出结果return0;//返回正常结束代码}```以上代码实现了一个简单的命令行计算器程序,它使用fgets函数从标准输入读取用户输入的表达式,并使用字符串处理函数和数学函数进行表达式解析和运算。
C语言计算器实现(中缀表示法后缀表示法)

C语⾔计算器实现(中缀表⽰法后缀表⽰法)————————————————————————————————————————————实现原理:每个操作数都被依次压⼊栈中,当⼀个运算符到达时,从栈中弹出相应数⽬的操作数(对于⼆元运算符来说是两个操作数),把该运算符作⽤于弹出的操作数,并把运算结果再压⼊栈中- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -计算器(后缀表达式)相关知识:后缀表达式(逆波兰表⽰法):在逆波兰中,所有运算符都跟在操作数后⾯,如下:(1 - 2) *(4 + 5) 采⽤逆波兰表⽰法表⽰为:1 2 - 4 5 + *,不需要圆括号,只要知道每个运算符需要⼏个操作数就不会引起歧义实现功能:输⼊后缀表达式,以换⾏结束,计算四则运算结果。
对于 1 2 - 4 5 + * 来说,⾸先把1和2压⼊到栈中,再⽤两者之差-1取代它们;然后将4和5压⼊到栈中,再⽤两者之和9取代它们。
最后从栈中取出栈顶的-1和9,并把它们的积-9压⼊到栈顶。
到达输⼊⾏的末尾时,把栈顶的值弹出来并打印。
伪代码:while 读⼊值不为换⾏时if 是数字压⼊栈中else if 是运算符弹出两个运算数,计算并压栈else 输⼊错误并退出end if读⼊值弹出最终结果并打印实现代码:1/* 实现功能:输⼊后缀表达式,以换⾏结束,计算四则运算结果 */2/* 这种后缀表⽰法只需要⼀个栈就可以了,遇到符号则弹运算数,但是中缀就不⼀样 */3 #include <stdio.h>4 #include <stdlib.h>5#define OK 16#define ERROR 07#define OVERFLOW -28#define STACK_INIT_SIZE 1009#define STACKINCREAMENT 1010 typedef int Status;11 typedef char SElemType;12 typedef struct13 {14 SElemType *top;15 SElemType *base;16int stacksize;17 } SqStack;18 Status InitStack(SqStack *s)19 {20 s->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));21if (!s->base) exit(OVERFLOW);22 s->top = s->base;23 s->stacksize = STACK_INIT_SIZE;24return OK;25 }26 Status Push(SqStack *s, SElemType e)27 {28if (s->top - s->base == s->stacksize)29 {30 s->base = (SElemType *)realloc(s->base, (s->stacksize + STACKINCREAMENT) * sizeof(SElemType)); 31if (!s->base) exit(OVERFLOW);32 s->top = s->base + s->stacksize;33 s->stacksize += STACKINCREAMENT;34 }35 s->top++;36 *(s->top) = e;37return OK;38 }39 Status Pop(SqStack *s, SElemType *e)40 {41if (s->top == s->base) exit(OVERFLOW);42 *e = *(s->top);43 s->top--;44return OK;45 }46 Status Empty(SqStack s)47 {48if (s.top - s.base == 0)49return OK;50else51return ERROR;52 }53int main()54 {55 SqStack OPND; //OPTR是运算符 OPND是运算数56char c, num1, num2;57 InitStack(&OPND);58while((c = getchar()) != '\n')59 {60switch(c)61 {62case'0':63case'1':64case'2':65case'3':66case'4':67case'5':68case'6':69case'7':70case'8':71case'9':72 Push(&OPND, c - '0');73break;74case'+':75 Pop(&OPND, &num2);76 Pop(&OPND, &num1);77 Push(&OPND, num1 + num2);78break;79case'-':80 Pop(&OPND, &num2);81 Pop(&OPND, &num1);82 Push(&OPND, num1 - num2);83break;84case'*':85 Pop(&OPND, &num2);86 Pop(&OPND, &num1);87 Push(&OPND, num1 * num2);88break;89case'/':90 Pop(&OPND, &num2);91 Pop(&OPND, &num1);92 Push(&OPND, num1 / num2);93break;94default:95break;96 }97 }98while(!Empty(OPND))99 {100 Pop(&OPND, &c);101 printf("%d ", c);102 }103return OK;104 }- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -计算器(中缀表⽰法)运算符优先级:+-*/()# +>><<<>>->><<<>>*>>>><>>/>>>><>>(<<<<<=0)>>>>0>>#<<<<<0=执⾏过程:在计算 #4+3*(5-10)/5# 时栈中的执⾏过程如下步骤输⼊字符执⾏操作OPTR OPND 1#Push(#)#24Push(4)#43+'#'<'+',Push(+)# +443Push(3)# + 4 35*'+'<'*',Push(*)# + * 4 36('*'<'(',Push(()# + * ( 4 375Push(5)# + * ( 4 3 58-'('<'-',Push(-)# + * ( - 4 3 5910Push(10)# + * ( - 4 3 5 1010)'-'>')',计算并压⼊结果# + * ( 4 3 -511'('=')',脱括号# + * 4 3 -5 12/'*'>'/'计算并压⼊结果# + 4 -1513'+'<'/',Push(/)# + / 4 -15145Push(5)# + / 4 -15 5 15#'/'>'#',计算并压⼊结果# + 4 -316'+'>'#',计算并压⼊结果#117'#'='#',脱括号1伪代码:初始化运算符栈;压⼊#;初始化运算数栈;获取输⼊;while 获取输⼊不为#或栈顶不为#if 输⼊的是数字压⼊运算数栈获取输⼊if 新输⼊的也是数字⼗位数百位数运算end ifelseswitch 运算符栈顶与当前输⼊优先级⽐较压⼊运算符栈获得输⼊弹出运算符栈顶(或#获得输⼊弹出运算符栈顶弹出两个运算数计算并将结果压⼊运算数栈//此时不获取新输⼊,该循环输⼊的运算符作为c重新进⼊循环end ifend while输出运算数栈中剩的运算数实现代码:1/* 只能运算-128~127之间的结果 */2 #include <stdio.h>3 #include <stdlib.h>4 #include <math.h>5#define OK 16#define ERROR 07#define SPILL -2 //math.h中已有OVERFLOW,则改⽤SPILL8#define STACK_INIT_SIZE 1009#define STACKINCREAMENT 1010 typedef char SElemType;11 typedef int Status;12 typedef struct13 {14 SElemType *top;15 SElemType *base;16int stacksize;17 } SqStack;18 Status InitStack(SqStack *s)19 {20 s->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));21if (!s->base)22 exit(SPILL);23 s->top = s->base;24 s->stacksize = STACK_INIT_SIZE;25return OK;26 }27 Status EmptyStack(SqStack s)28 {29if (s.top - s.base == 0)30return OK;31else32return ERROR;33 }34 Status Push(SqStack *s, SElemType e)35 {36if (s->top - s->base == s->stacksize)37 {38 s->base = (SElemType *)realloc(s->base, (s->stacksize + STACKINCREAMENT) * sizeof(SElemType)); 39if (!s->base)40 exit(SPILL);41 s->top = s->base + s->stacksize;42 s->stacksize += STACKINCREAMENT;43 }44 s->top ++;45 *(s->top) = e;46return OK;47 }48 Status Pop(SqStack *s, SElemType *e)49 {50if (s->top == s->base)51 exit(SPILL);52 *e = *(s->top);53 s->top--;54return OK;55 }56 SElemType GetTop(SqStack s)57 {58return *(s.top);59// *e = *(s.top);60// return OK;61 }62/* 判断如果是数字则返回OK,运算符返回ERROR,⾮法输⼊则退出 */63 Status InputJudge(SElemType c)64 {65switch(c)66 {67case'0':68case'1':69case'2':70case'3':71case'4':72case'5':73case'6':74case'7':75case'8':76case'9':77return OK;78break;79case'+':80case'-':81case'*':82case'/':83case'(':84case')':85case'#':86return ERROR;87break;88default:89 exit(SPILL);90break;91 }92 }93/* 当前输⼊的运算符和前⼀个运算符⽐较优先级 */94 SElemType PriorityJudge(SElemType optr1, SElemType optr2)95 {96int i, j;97char priorityTable[7][7] =98 {99 {'>', '>', '<', '<', '<', '>', '>'},100 {'>', '>', '<', '<', '<', '>', '>'},101 {'>', '>', '>', '>', '<', '>', '>'},102 {'>', '>', '>', '>', '<', '>', '>'},103 {'<', '<', '<', '<', '<', '=', '0'},104 {'>', '>', '>', '>', '0', '>', '>'},105 {'<', '<', '<', '<', '<', '0', '='}106 };107switch(optr1)108 {109case'+':110 i = 0;111break;112case'-':113 i = 1;114break;115case'*':116 i = 2;117break;118case'/':119 i = 3;120break;121case'(':122 i = 4;123break;124case')':125 i = 5;126break;127case'#':128 i = 6;129break;130 }131switch(optr2)132 {133case'+':134 j = 0;135break;136case'-':137 j = 1;138break;139case'*':140 j = 2;141break;142case'/':143 j = 3;144break;145case'(':146 j = 4;147break;148case')':149 j = 5;150break;151case'#':152 j = 6;153break;154 }155return priorityTable[i][j];156 }157/* 四则运算 */158 SElemType Calc(SElemType optr, SElemType num1, SElemType num2)159 {160switch(optr)161 {162case'+':163return (num1 + num2);164break;165case'-':166return (num1 - num2);167break;168case'*':169return (num1 * num2);170break;171case'/':172return (num1 / num2);173break;174 }175 }176int main()177 {178char c, optr, num1, num2, temp;179 SqStack OPND, OPTR;180 InitStack(&OPTR);181 Push(&OPTR, '#');182 InitStack(&OPND);183 c = getchar();184while(c != '#' || GetTop(OPTR) != '#')185// while(!EmptyStack(OPTR))186//严蔚敏⽼师书上的算法是判断输⼊⾮#或栈顶⾮#时循环,个⼈认为判断运算符栈不为空也可以,当初始化时压⼊的#闭合,结束运算187 {188if (InputJudge(c))189 {190 Push(&OPND, c - '0');191 c = getchar();192/* 当连续输⼊数字时,计算⼗位数和百位数 */193while(InputJudge(c))194 {195int i = 1;196 Pop(&OPND, &temp);197 Push(&OPND, temp * pow(10, i) + (c - '0'));198 i++;199 c = getchar();200 }201 }202else203switch(PriorityJudge(GetTop(OPTR), c))204 {205case'<':206 Push(&OPTR, c);207 c = getchar();208break;209case'=':210 Pop(&OPTR, &c);211 c = getchar();212break;213case'>':214 Pop(&OPTR, &optr);215 Pop(&OPND, &num2);216 Pop(&OPND, &num1);217 Push(&OPND, Calc(optr, num1, num2)); 218break;219 }220 }221while(!EmptyStack(OPND))222 {223 Pop(&OPND, &c);224 printf("%d\n", c);225 }226return OK;227 }。
C语言计算器程序源代码

C语⾔计算器程序源代码//strcmp(s1,s2) 当s1⼤于s2时,返回1 ,s1⼩于s2时,返回-1,相等时,返回0 #include "stdio.h"#include "ctype.h"#include "string.h"#include "math.h"#define MAX 256#define STACK_SIZE 128#define WORD_LEN 8#define POP 1#define PUSH 0#define ERR -1#define END 2#define OPER 0#define NUM 1#define WORD 2#define ADD 1#define SUB 2#define MUL 3#define DIV 4#define POW 5#define FAC 6#define BRA_L 7#define BRA_R 8#define SIN 9#define COS 10#define TAN 11#define CTG 12#define LG 13 //以10为底的常⽤对数//#define LN 14//#define LOG 15//⾏标为当前操作符代号,列标为栈顶元素代号//2表⽰计算结束,0表⽰当前操作符进栈,1表⽰栈顶操作符出栈// \0 + - * / ^ ! ( ) sin cos tg ctg lgint Priority[14][14]={2, 1, 1, 1, 1, 1, 1,-1,-1, 1, 1, 1, 1, 1, /* \0 */0, 1, 1, 1, 1, 1, 1, 0,-1, 1, 1, 1, 1, 1, /* + */0, 1, 1, 1, 1, 1, 1, 0,-1, 1, 1, 1, 1, 1, /* - */0, 0, 0, 1, 1, 1, 1, 0,-1, 1, 1, 1, 1, 1, /* * */0, 0, 0, 1, 1, 1, 1, 0,-1, 1, 1, 1, 1, 1, /* / */0, 0, 0, 1, 1, 1, 1, 0,-1, 0, 0, 0, 0, 0, /* ^ */0, 0, 0, 0, 0, 0, 1, 0,-1, 0, 0, 0, 0, 0, /* ! */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, /* ( */-1,1, 1, 1, 1, 1, 1, 1,-1, 1, 1, 1, 1, 1, /* ) */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, /* sin */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, /* cos */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, /* tg */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0, /* ctg */0, 0, 0, 0, 0, 0,-1, 0,-1, 0, 0, 0, 0, 0}; /* lg */char KeyWord[36][WORD_LEN+1]={"sin", //前12个为函数,多余的⽤于扩展"cos","tan","tg","ctg","lg","","","","","","","","","","help", // 后⾯为命令,多余的为扩展"version","set","digit", //精度,⼩数点后的位数"color","radian", //弧度"degree", //⾓度"file","clr","clear","window", //窗⼝模式"fullscr", //全屏模式"","","","","","","","",""};int OperCode(char c){int code;switch(c){case '\0':code=0;break;case '+':code=1;break;case '-':code=2;break;case '*':code=3;break;case '/':code=4;break;case '^':code=5;break;case '!':code=6;break;case '(':code=7;break;case ')':code=8;break;case 's':code=9;break; //sincase 'c':code=10;break; //coscase 't':code=11;break; //tgcase 'C':code=12;break; //ctgcase 'l':code=13;break; //log default:code=-1;break;};return code;}int WordCode(char* word){int i;for(i=0;i<25;i++)if(strcmp(KeyWord[i],word)==0) break;if(i>=25)return -1;else}void help(){printf("显⽰帮助信息!\n");return;}void version(){printf("显⽰版本信息!\n");return;}void Err(int errcode,int position,char *p){printf("\n ERR:%d Position:%d %s",errcode,position,p); return;}double long factorial(int i){if(i==1 || i==0)return(1.0);elsereturn(i*factorial(i-1));}main(){char Expression[MAX+1];int Operator[STACK_SIZE];int OperStackTop;double long Number[STACK_SIZE];int NumStackTop;double long NumList[STACK_SIZE];int NumCursor,NumListSize;int OperList[STACK_SIZE];int OperCursor,OperListSize;int WordList[STACK_SIZE];int WordCursor,WordListSize;int Index[MAX+1];int IndexCursor,IndexSize;char Word[WORD_LEN+1];double long num,num1,num2,weight,tempnum;int Oper;int isDecimal,isErr,isNumber,isEnd;char CurrentOper;int i,j,k,m,n;char ch;num=0.0;num2=0.0;tempnum=0.0;Oper=-1;while(1){for(i=0;i<=MAX;i++) //表达式初始化,中间表索引初始化{Expression[i]='\0';Index[i]=-1;}for(i=0;i{Operator[i]='0';Number[i]=0.0;NumList[i]=0.0;OperList[i]=-1;WordList[i]=-1;}NumStackTop=-1; //栈顶指针初始化OperStackTop=0; //操作符栈压⼊\0Operator[OperStackTop]=OperCode('\0');NumCursor=0; //各种中间表指针初始化,各种中间表的长度初始化NumListSize=0;OperCursor=0;OperListSize=0; //操作符表中先写⼊第⼀个操作符'\0'WordCursor=0;WordListSize=0;IndexCursor=0;IndexSize=0;// Index[0]=OPER;printf("Cal>"); //初始化完成,输出提⽰符i=0;while((ch=getchar())!='\n'){if(i>MAX) /*输⼊超长,则出错*/{Err(0,i,"输⼊的表达式长度超过规定值!\n");isErr=1;break;}if(isupper(ch))ch=tolower(ch);Expression[i]=ch;i++;}if(isErr==1){isErr=0;continue;}if(strlen(Expression)==0) //直接回车continue;if(strcmp("end",Expression)==0 ||strcmp("exit",Expression)==0 || strcmp("quit",Expr ession)==0)break;//⼀下代码为编译预处理,主要处理负号,并检查括号是否配对k=0;for(i=0;Expression[i]!='\0';i++){if((i==0&&Expression[i]=='-') || (i>0&&Expression[i]=='-'&&Expression[i-1]=='(')){for(j=strlen(Expression);j>i;j--)Expression[j]=Expression[j-1];Expression[i]='0';}if(Expression[i]=='(') //检查括号k++;if(Expression[i]==')')k--;}if(k>0) //如果括号不配对{Err(1,-1,"缺少右括号 )\n");continue;}if(k<0){Err(1,-1,"缺少左括号 (\n");continue;}//编译预处理结束i=0; //词法分析while(1){if(Expression[i]=='\0'){OperList[OperListSize]=OperCode(Expression[i]);OperListSize++;Index[IndexSize]=OPER;IndexSize++;// printf("IndexSize=%d,Index[IndexSize]=%d,Expression[i]=%c\n",IndexSize,Index[IndexSize],Expression[i]); break;}isDecimal=0;isNumber=0;while(isdigit(Expression[i])||Expression[i]=='.') //读取数字{isNumber=1;if(Expression[i]=='.'){if((i<(MAX-1) && !isdigit(Expression[i+1])) || (i+1)==MAX) //不正确的⼩数点位置{Err(2,i,"⼩数点位置不正确!\n");isErr=1;isNumber=0;i++;break;}isDecimal=1;weight=0.1;i++;continue;}if(isDecimal==0)num=num*10.0+(double long)(Expression[i]-'0');{num=num+(double long)(Expression[i]-'0')*weight;weight=weight*0.1;}i++;} //数字读完if(isErr==1)break;if(isNumber==1) //如果刚才成功读取了数字,则数字⼊栈{NumList[NumListSize]=num;NumListSize++;isNumber=0;num=0.0;Index[IndexSize]=NUM;// printf("IndexSize=%d,Index[IndexSize]=%d\n",IndexSize,Index[IndexSize]); IndexSize++;}for(k=0;k<=WORD_LEN;k++)Word[k]='\0';j=0;while(isalpha(Expression[i])){if(j>=WORD_LEN) //超过长度仍然未匹配,则出错{Err(3,i,"单词长度超过规定值/未定义的单词:");printf("%s\n",Word);isErr=1;break;}Word[j]=Expression[i];j++;// printf("WORD:%s\n",Word);if(WordCode(Word)==-1) //匹配不成功{if(!isalpha(Expression[i+1]))//匹配不成功,但是下⼀个字符已经不是字母,{Err(4,i,"未定义的单词:"); //则出错,并跳出循环printf("%s\n",Word);isErr=1;break;} //匹配不成功且还能继续读取字符,则继续读取下⼀个字母i++;continue;}else //匹配成功,则单词⼊表,读取下⼀个字符{switch(WordCode(Word)){case 0:ch='s';break;case 1:ch='c';break;case 2:case 3:ch='t';break;case 4:ch='C';case 5:ch='l';break;default:ch='\0';WordList[WordListSize]=WordCode(Word);WordListSize++;Index[IndexSize]=WORD;IndexSize++;break;};if(ch!='\0'){OperList[OperListSize]=OperCode(ch);OperListSize++;Index[IndexSize]=OPER;IndexSize++;}i++;break;}} //单词读完if(isErr==1)break;if(Expression[i]==' ')i++;if(!isdigit(Expression[i]) && !isalpha(Expression[i]) && Expression[i]!='\0') {if(OperCode(Expression[i])==-1){isErr=1;Err(5,i,"未定义的操作符:");printf("%c\n",Expression[i]);break;}else{OperList[OperListSize]=OperCode(Expression[i]);OperListSize++;Index[IndexSize]=OPER;IndexSize++;i++;}} //操作符读完if(isErr==1)break;} //词法分析结束if(isErr==1){isErr=0;continue;}/* for(k=0;kprintf("NumList[%d]=%f\n",k,NumList[k]);for(k=0;kprintf("OperList[%d]=%d\n",k,OperList[k]);for(k=0;kprintf("WordList[%d]=%d\n",k,WordList[k]);for(k=0;kprintf("Index[%d]=%d\n",k,Index[k]);printf("\n\n IndexCursor=%d IndexSize=%d,\n",IndexCursor,IndexSize);printf("OperStacktop=%d,Operator[OperStackTop]=%d,NumStackTop=%d\n",OperStackTop,Operator[OperStackTop],NumStackTop); // continue;*/isEnd=0;IndexCursor=0;while(1){if(Index[IndexCursor]==NUM){if(NumCursor<0 || NumListSize<0){Err(10,-1,"索引列表与操作数列表信息不匹配\n");isErr=1;break;}NumStackTop++;Number[NumStackTop]=NumList[NumCursor];NumCursor++;IndexCursor++;continue;} //数字处理if(Index[IndexCursor]==OPER){m=OperList[OperCursor];n=Operator[OperStackTop];switch(Priority[m][n]){case ERR:Err(20,IndexCursor,"不可预见的错误!\n");isErr=1;break;case PUSH:OperStackTop++;Operator[OperStackTop]=m;OperCursor++;IndexCursor++;break;case END:isEnd=1;break;case POP:Oper=Operator[OperStackTop];OperStackTop--;switch(Oper){case BRA_L: IndexCursor++;OperCursor++;break;case ADD:if(NumStackTop>=1){num2=Number[NumStackTop];NumStackTop--;num1=Number[NumStackTop];NumStackTop--;tempnum=num1+num2;NumStackTop++;Number[NumStackTop]=tempnum;num1=0.0;num2=0.0;tempnum=0.0;}else{Err(11,IndexCursor,"加法运算缺少操作数!\n");isErr=1;}break;case SUB:if(NumStackTop>=1){num2=Number[NumStackTop];NumStackTop--;num1=Number[NumStackTop];NumStackTop--;tempnum=num1-num2;NumStackTop++;Number[NumStackTop]=tempnum;num1=0.0;num2=0.0;tempnum=0.0;}else{Err(12,IndexCursor,"减法运算缺少操作数!\n");isErr=1;}break;case MUL:if(NumStackTop>=1){num2=Number[NumStackTop];NumStackTop--;num1=Number[NumStackTop];NumStackTop--;tempnum=num1*num2;NumStackTop++;Number[NumStackTop]=tempnum;num1=0.0;num2=0.0;tempnum=0.0;}else{Err(13,IndexCursor,"乘法运算缺少操作数!\n");isErr=1;}break;case DIV:if(NumStackTop>=1){num2=Number[NumStackTop];NumStackTop--;if(num2==0.0){Err(14,IndexCursor,"除数为 0 ,不能进⾏除法运算!\n"); isErr=1;break;}num1=Number[NumStackTop];NumStackTop--;tempnum=num1/num2;NumStackTop++;Number[NumStackTop]=tempnum;num1=0.0;num2=0.0;tempnum=0.0;}else{Err(15,IndexCursor,"除法运算缺少操作数!\n"); isErr=1;}break;case POW:if(NumStackTop>=1){num2=Number[NumStackTop]; NumStackTop--;num1=Number[NumStackTop]; NumStackTop--;tempnum=pow(num1,num2); NumStackTop++;Number[NumStackTop]=tempnum;num1=0.0;num2=0.0;tempnum=0.0;}else{Err(16,IndexCursor,"乘⽅运算缺少操作数!\n"); isErr=1;}break;case FAC:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;tempnum=factorial(num2); NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(17,IndexCursor,"阶乘运算缺少操作数!\n"); isErr=1;}break;case SIN:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;tempnum=sin(num2);NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}{Err(18,IndexCursor,"正弦函数缺少参数!\n"); isErr=1;}break;case COS:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;tempnum=cos(num2);NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(19,IndexCursor,"余弦函数缺少参数!\n"); isErr=1;}break;case TAN:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;tempnum=tan(num2);NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(20,IndexCursor,"正切函数缺少参数!\n");isErr=1;}break;case CTG:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;tempnum=1.0/tan(num2); NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(21,IndexCursor,"余切函数缺少参数!\n"); isErr=1;}break;/* case LN:if(NumStackTop>=0)num2=Number[NumStackTop]; NumStackTop--;if(num2<=0.0){Err(20,IndexCursor,"⾃然对数函数真数:"); printf(" %f ⼩于0!\n",num2);isErr=1;break;}tempnum=log(num2);NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(17,IndexCursor,"⾃然对数函数缺少参数!\n"); isErr=1;}break; */case LG:if(NumStackTop>=0){num2=Number[NumStackTop]; NumStackTop--;if(num2<=0.0){Err(23,IndexCursor,"常⽤对数函数真数:"); printf(" %f ⼩于0!\n",num2);isErr=1;break;}tempnum=log10(num2);NumStackTop++;Number[NumStackTop]=tempnum;num2=0.0;tempnum=0.0;}else{Err(22,IndexCursor,"常⽤对数函数缺少参数!\n"); isErr=1;}break;default:Err(100,IndexCursor,"运算符(代码:"); printf(" %d )暂不⽀持!\n",Oper);isErr=1;break;/*#define SIN 9#define COS 10#define TAN 11#define CTG 12#define LOG 13 */}; //switch 语句结束break;};//switchif(isErr==1 || isEnd==1)break;continue;} //运算符处理if(Index[IndexCursor]==WORD){printf(" 单词尚未处理!\n");break;}//在这⾥处理单词}//核⼼计算结束if(isErr==1){isErr=0;continue;}if(NumStackTop>0){Err(1000,-1,"多余的操作数:");printf("%f!\n",Number[NumStackTop]);}elseif(NumStackTop==0 && isEnd==1){if(fabs(Number[NumStackTop])>1e20) printf(" %.20e\n",Number[NumStackTop]); elseprintf(" %f\n",Number[NumStackTop]); isEnd=0;}}//主循环结束}//主函数结束。
C语言计算器源代码

C++语言编写。
#include<iostream>#include<cmath>#include<string>using namespace std;const int SIZE = 1000;typedef struct node//为了处理符号而建立的链表(如: 1+(-2)) {char data;node *next;}node;typedef struct stack_num//存储数的栈{double *top;double *base;}stack_num;typedef struct stack_char//存储运算符号的栈{char *top;char *base;}stack_char;stack_num S_num;//定义stack_char S_char;//定义char fu[18] = {'\n', ')', '+', '-', '*', '/', '%', '^','Q', 'L', 'C', 'S', 'T', 'c', 's', 't', '('};int compare[1000];//表现出各运算符号的优先级double shu[1000];//存储 "数" 的数组double dai_result;//运算的结果,是为了处理 M 运算(简介函数里有M的定义)int biao = 0;//和dia_result 一样,为了处理 M 运算char line[SIZE];//输入的所要计算的表达式void init()//初始化{compare[fu[0]] = -2;//用数字的大小表现出符号的优先级compare[fu[1]] = -1;compare[fu[2]] = 2;compare[fu[3]] = 2;compare[fu[4]] = 4;compare[fu[5]] = 4;compare[fu[6]] = 4;compare[fu[7]] = 5;for(int i = 8; i <= 15; i++)compare[fu[i]] = 6;compare[fu[16]] = 7;S_num.base = (double*)malloc(sizeof(double)*SIZE);//为栈开辟空间S_char.base = (char*)malloc(sizeof(char)*SIZE);//同上S_num.top = S_num.base;S_char.top = S_char.base;}void push_num(double n)//数字进栈{* ++S_num.top = n;}void push_char(char c)//运算符号进栈{* ++S_char.top = c;}double pop_num()//数字出栈{double m = *S_num.top;S_num.top--;return m;}char pop_char()//运算符号出栈{char cc = *S_char.top;S_char.top--;return cc;}char get_top_char()//得到运算符号的栈中最顶端的运算符号{return *S_char.top;}double operate(double y, char c, double x)//对两个数计算(含是双目运算符:如 *, / 等等){double r;if(c == '-')r = x - y;else if(c == '+')r = x + y;else if(c == '/' && y != 0)r = x / y;else if(c == '*')r = x * y;else if(c == '^'){r = 1;for(int i = 1; i <= y; i++)r *= x;}else if(c == '%'){int r0 = (int)x % (int)y;r = double(r0);}return r;}double operate_one(double one, char cc)//对一个数运算(含单目运算符:如log(L), sin(S) 等等){double r;if(cc == 'Q')r = sqrt(one);else if(cc == 'C')r = cos(one);else if(cc == 'S')r = sin(one);else if(cc == 'T')r = tan(one);else if(cc == 'c')r = acos(one);else if(cc == 's')r = asin(one);else if(cc == 't')r = atan(one);return r;}double operate_L(double a, double b, char dian)//求对数的值{double r = log(b) / log(a);return r;}double compute()//对整个表达式的计算{char c;//表示运算符号int p = 0;//用于shu[++p], 先初始化int i, j;init();//进行初始化push_char('\n');line[strlen(line)] = '\n';line[strlen(line)+1] = '\0';if(biao)push_num(dai_result);//把运算的结果先进栈, 在这个结果的基础上继续进行运算biao = 0;for(i = 0; line[i] != '\0';)//把表达式中的数字字符串转化成可计算的数字{int flag = 0;int flag1 = 1;//标记是否是运算符号// int flag2 = 1;//标记是否出现'_';double h = 0;int ge;//位数int biao_dian = 0;//是否是小数的类型while(1){flag1 = 1;for(j = 0; j <= 16; j++){if(line[i] == fu[j]){flag1 = 0;break;}}if(line[i] == '_') {break;}if(line[i] == '.') {i++;ge = 0;biao_dian = 1; }if(line[i] == 'P') {shu[++p] = pi;i++;break;}if(line[i] == 'E') {shu[++p] = e;i++;break;}if(flag1){h = h * 10 + (line[i] - '0');flag = 1;i++;if(biao_dian)ge++;}elsebreak;}if(flag){if(biao_dian){int r = 1;for(int k = 1; k <= ge; k++)r *= 10;h /= r;}shu[++p] = h;//把转化而来的数字存于数组}if(line[i] == '+')shu[++p] = -1;else if(line[i] == '-')shu[++p] = -2;else if(line[i] == '*')shu[++p] = -3;else if(line[i] == '/')shu[++p] = -4;else if(line[i] == '%')shu[++p] = -5;else if(line[i] == '^')shu[++p] = -6;else if(line[i] == 'Q')shu[++p] = -7;else if(line[i] == 'L')shu[++p] = -8;else if(line[i] == 'C')shu[++p] = -9;else if(line[i] == 'S')shu[++p] = -10;else if(line[i] == 'T')shu[++p] = -11;else if(line[i] == 'c')shu[++p] = -12;else if(line[i] == 's')shu[++p] = -13;else if(line[i] == 't')shu[++p] = -14;else if(line[i] == '(')shu[++p] = -15;else if(line[i] == ')')shu[++p] = -16;else if(line[i] == '\n')shu[++p] = -17;i++;}i = 1;while(shu[i] != -17 || get_top_char() != '\n') {double m = shu[i];if(m >= 0){push_num(m);i++;}else{if(m == -1)c = '+';else if(m == -2)c = '-';else if(m == -3)c = '*';else if(m == -4)c = '/';else if(m == -5)c = '%';else if(m == -6)c = '^';else if(m == -7)c = 'Q';else if(m == -8)c = 'L';else if(m == -9)c = 'C';else if(m == -10)c = 'S';else if(m == -11)c = 'T';else if(m == -12)c = 'c';else if(m == -13)c = 's';else if(m == -14)c = 't';else if(m == -15)c = '(';else if(m == -16)c = ')';else if(m == -17)c = '\n';char ch = get_top_char();//得到最顶端运算符号if(compare[ch] < compare[c])//运算符号级别的比较{push_char(c);i++;}else if(ch == '(' && c == ')'){pop_char();i++;}else if(compare[ch] >= compare[c] && ch != '(' && ch != '\n') {if(ch == 'Q' || ch == 'C' || ch == 'S'|| ch == 'T' || ch == 'c' || ch == 's' || ch == 't'){double one = pop_num();char dian = pop_char();push_num(operate_one(one, dian));}else if(ch == 'L'){double one_L = pop_num();double two_L = pop_num();char dian = pop_char();push_num(operate_L(two_L, one_L, dian));}else{double x = pop_num();double y = pop_num();char dian = pop_char();if(dian == '/' && x == 0)//判断是否除了"零"{cout<<"由于您除了零,结果将是错误的"<<endl;}push_num(operate(x, dian, y));//把进行一次计算的结果入栈}}else{push_char(c);i++;}}}double result = pop_num();//得到结果return result;}int check_kuohao()//检查表达式括号是否匹配{int i, f = 0;int kuo[SIZE], key = 1;memset(kuo, 0, sizeof(kuo));for(i = 0; line[i] != '\0'; i++){if(line[i] == '(')kuo[++f] = 1;else if(line[i] == ')'){if(kuo[f] == 1){kuo[f] = 0;f--;}else{key = 0;break;}}}if(key && f == 0)return 1;elsereturn 0;}int check_char()//检查运算符号是否合法(如: 1 +* 4){int i, ge;for(i = 0; line[i] != '\0'; ){ge = 0;while(line[i] == '+' || line[i] == '-' || line[i] == '*' || line[i] == '/' || line[i] == '%' || line[i] == '^'|| line[i] == 'Q' || line[i] == 'L' || line[i] == 'S'|| line[i] == 'C' || line[i] == 'T' || line[i] == 's'|| line[i] == 'c' || line[i] == 't'){ge++;i++;}i++;}if(ge >= 3)return 0;elsereturn 1;}void output(double result)//打出结果{printf("所得结果是: ");cout<<result<<endl;}void check()//检查表达式是否合法{void introduce();char cc;//决定计算器按哪种功能进行计算double result;//结果void input();//定义if( check_kuohao() && check_char() )//看是否合法, 合法则计算{result = compute();output(result);cout<<"输入一个字符'M'或'D'或'F', 决定是否继续: "<<endl;while(cin>>cc){if(cc == 'M'){system("cls");introduce();printf("您上次所得结果为: ");cout<<result<<endl;cout<<"在上次计算结果的基础上, 请继续输入想计算的表达式"<<endl;dai_result = result;biao = 1;input();//输入表达式break;}else if(cc == 'D'){system("cls");introduce();cout<<"计算器已清零, 请输入您所要计算的表达式"<<endl;input();//输入表达式break;}else if(cc == 'F'){system("cls");cout<<"计算器关闭, 谢谢使用!"<<endl;break;}else{cout<<"所输入字符无效, 请输入一个字符'M'或'D'或'F'!"<<endl;continue;}}}else//不合法,分两种不合法{if(check_kuohao() == 0 && check_char() == 1){cout<<"您所输入的表达式括号不匹配, 请重新输入:"<<endl;input();//输入表达式}else{cout<<"您所输入的表达式不合法, 请重新输入:"<<endl;input();//输入表达式}}}void tackle_fuhao()//处理负号{node *root, *head, *p, *q, *p1;root = head = new node;head->next = NULL;int i;for(i = 0; line[i] != '\0'; i++)//建立链表{p = new node;p->data = line[i];p->next = head->next;head->next = p;head = p;}// delete p;q = (node*)malloc(sizeof(node));head = root;if(root->next->data == '+' || root->next->data == '-')//处理第一个字符{p = new node;p->data = '0';p->next = head->next;head->next = p;}if(root->next != NULL){for(q = root->next; q; q = q->next){if(q->data == '(' && (q->next->data == '-' || q->next->data == '+')){p = new node;p->data = '0';p->next = q->next;q->next = p;}}}// delete q;p1 = new node;int qi = -1;for(p1 = root->next; p1; p1 = p1->next){line[++qi] = p1->data;}line[++qi] = '\0';}void input()//输入{cin>>line;if(biao == 0)tackle_fuhao();//处理负号check();//检查表达式是否合法}void introduce()//对计算器的符号功能的简要介绍{cout<<"计算器简要介绍"<<endl;cout<<"C(cos) S(sin) T(tan) a(arccos) c(arcsin) "<<endl;cout<<"7 8 9 / on t(arctan) "<<endl;cout<<"4 5 6 * % L(log)"<<endl;cout<<"1 2 3 - M(M+) Q(sqrt) "<<endl;cout<<"0 . + ^(乘方) F(off) Enter(=) "<<endl;cout<<"对于对数输入 L2_5 表示以2为底5的对数"<<endl;cout<<"M(在前面结果的基础上继续计算,如:上次结果为10,现输入+10.5*2)"<<endl;cout<<"D(清零并继续输入)"<<endl;cout<<"F(计算机关闭)"<<endl;cout<<"输入P 就代表输入圆周率, 输入 E 代表输入自然对数"<<endl<<endl;}void print(){system("color 2");cout<<" 欢迎使用本计算器"<<endl;cout<<"输入一个字符串 on, 计算器开始启动"<<endl;}void if_start()//是否启动计算器{string start;print();while(cin>>start){if(start != "on"){cout<<"您所输入的字符无效, 请按照介绍的继续输入:"<<endl;continue;}elsebreak;}if(start == "on"){system("color 5");//颜色的处理system("cls");//刷屏}introduce();//对计算器的简要介绍cout<<"现在,请输入您所要计算的表达式"<<endl;input();//输入所要计算的表达式}int main(){if_start();//调用是否启动计算器函数return 0;}。
C语言课程设计(计算器)

目录1 前言 (2)2 需求分析 (2)2.1要求 (2)2.2任务 (2)2.3运行环境 (2)2.4开发工具 (2)3 概要设计 (2)3.1系统流程图 (3)3.2查询函数流程图 (4)4 详细设计 (8)4.1分析和设计 (8)4.2具体代码实现 (9)5 课程设计总结 (25)参考文献 (25)致谢 (26)1 前言编写一个程序来实现算术计算器。
通过结构体数组和共用体数组来存放输入的每一数字或运算符号的记录(包括1.2.3等数字, +、--、*、等运算符号), 然后将其信息存入文件中。
输入一个算术计算式, 就在屏幕上显示结果。
2 需求分析2.1要求(1)用C语言实现程序设计;(2)利用结构体、共用体进行相关信息处理;(3)画出查询模块的流程图;(4)系统的各个功能模块要求用函数的形式实现;(5)界面友好(良好的人机互交), 程序要有注释。
2.2任务(1)定义一个结构体类型数组, 输入0~9及+、--、*等符号的信息, 将其信息存入文件中;(2)输入简单的加减乘除算术计算式, 并在屏幕上显示计算结果;(3)画出部分模块的流程图;(4)编写代码;(5)程序分析与调试。
2.3运行环境(1)WINDOWS2000/XP系统(2)TurboC2.0编译环境2.4开发工具C语言3 概要设计3.1系统流程图如图3.1所示。
图3.1系统流程图3.2查询函数流程图4 详细设计4.1分析和设计在程序的开头部分定义了结构替类型, 用来存放按钮信息struct s_button /*按键的结构体*/{int sx,sy,ex,ey;char *head;int press;}button[17]; /*图表按键数*/char far *vid_mem;static int tx=32,ty=3; /*静态变量*/float v1=0.0,v2=0.0;用输入函数input()来输入按键放在s_button数组中。
C语言编写一个计算器界面(可视化界面和多功能)

C语⾔编写⼀个计算器界⾯(可视化界⾯和多功能)⽬录引⾔计算器总结引⾔在⼤学期间,C 语⾔或者数据结构等课程,⽼师会要求学⽣编写⼀个⼩项⽬练⼿,或者期末编写⼀个⼩软件等课程设计。
今天在电脑看到⼤⼀学C语⾔时,实验课上写的计算器功能,挺有意思。
所以在此分享给学C语⾔的学弟学妹,记得收藏保留!计算器简单版本计算器,主要实现的是简单两个数的加法,减法,乘法,除法,求余功能。
⽤户可以在主菜单选择需要计算的功能,然后根据⽤户输⼊的数字,进⾏计算,输出结果。
⾸先,我们定义五个⽅法,实现两个数的加法,减法,乘法,除法,求余功能。
代码如下:// 加法float add(float a, float b) {return a + b;}// 减法float sub(float a, float b) {return a - b;}// 乘法float mul(float a, float b) {return a * b;}// 除法float mod(float a, float b) {return a / b;}// 求余int com(int a, int b) {return a % b;}然后定义⼀个打印主菜单界⾯的函数,使⽤简介美观的菜单界⾯,供⽤户选择要计算的功能,代码如下:// 打印主功能菜单void printMenu() {// 清屏// system("cls");printf("|----------------------- 计算器 -----------------------|\n");printf("| |\n");printf("| By -- 陈⽪的JavaLib |\n");printf("| |\n");printf("|---------------------- 1:加法 -----------------------|\n");printf("|---------------------- 2:减法 -----------------------|\n");printf("|---------------------- 3:乘法 -----------------------|\n");printf("|---------------------- 4:除法 -----------------------|\n");printf("|---------------------- 5:求余 -----------------------|\n");printf("|---------------------- 6:退出 -----------------------|\n");printf("| |\n");printf("|----------------------- 计算器 -----------------------|\n");}最后,我们在主函数 main 中,定义⼀个 while 循环代码块,不断读取⽤户输⼊的内容,进⾏数字计算,代码如下:int main() {// 选择的功能int select = 0;// 定义算术的两个数float a, b;while (select != 6){select = 0;// 打印主菜单printMenu();// 只允许选择菜单栏内的数字,不是则重新选择while (select < 1 || select > 6) {printf("请输⼊菜单功能(1-6):");scanf("%d", &select);}if (6 == select) {printf("\n|----------------- 欢迎使⽤计算器!再见!-----------------|\n"); return 0;}printf("\n请输⼊两个数(⽤空格隔开两个数):");scanf("%f %f", &a, &b);switch (select) {case 1:printf("%f+%f=%f\n\n", a, b, add(a, b));break;case 2:printf("%f-%f=%f\n\n", a, b, sub(a, b));break;case 3:printf("%f*%f=%f\n\n", a, b, mul(a, b));break;case 4:printf("%f/%f=%f\n\n", a, b, mod(a, b));break;case 5:printf("%f/%f=%d\n\n", a, b, com((int)a, (int)b));break;case 6:default:break;}}}下⾯我们演⽰⼏个例⼦,能更加直观体验计算器的功能:菜单功能选择错误,会提⽰重新选择加法除法退出简单版本计算器,完整代码如下:#include <stdio.h>#include <stdlib.h>// 加法float add(float a, float b) {return a + b;}// 减法float sub(float a, float b) {return a - b;}// 乘法float mul(float a, float b) {return a * b;}// 除法float mod(float a, float b) {return a / b;}// 求余int com(int a, int b) {return a % b;}// 打印主功能菜单void printMenu() {// 清屏// system("cls");printf("|----------------------- 计算器 -----------------------|\n");printf("| |\n");printf("| By -- 陈⽪的JavaLib |\n"); printf("| |\n");printf("|---------------------- 1:加法 -----------------------|\n");printf("|---------------------- 2:减法 -----------------------|\n");printf("|---------------------- 3:乘法 -----------------------|\n");printf("|---------------------- 4:除法 -----------------------|\n");printf("|---------------------- 5:求余 -----------------------|\n");printf("|---------------------- 6:退出 -----------------------|\n");printf("| |\n");printf("|----------------------- 计算器 -----------------------|\n");}/*** 简单版本计算器功能 By -- 陈⽪的JavaLib* @return*/int main() {// 选择的功能int select = 0;// 定义算术的两个数float a, b;while (select != 6){select = 0;// 打印主菜单printMenu();// 只允许选择菜单栏内的数字,不是则重新选择while (select < 1 || select > 6) {printf("请输⼊菜单功能(1-6):");scanf("%d", &select);}if (6 == select) {printf("\n|----------------- 欢迎使⽤计算器!再见!-----------------|\n");return 0;}printf("\n请输⼊两个数(⽤空格隔开两个数):");scanf("%f %f", &a, &b);switch (select) {case 1:printf("%f+%f=%f\n\n", a, b, add(a, b));break;case 2:printf("%f-%f=%f\n\n", a, b, sub(a, b));break;case 3:printf("%f*%f=%f\n\n", a, b, mul(a, b));break;case 4:printf("%f/%f=%f\n\n", a, b, mod(a, b));break;case 5:printf("%f/%f=%d\n\n", a, b, com((int)a, (int)b));break;case 6:default:break;}}}总结在⼤学期间,如果是计算机类的专业,⼀般都会学习 C 语⾔,作为编程⼊门语⾔,⼤家⼀定要学习好此门语⾔,⽽且如果学好了,其实学习其他编程语⾔就很容器上⼿的,不同语⾔其实⼤同⼩异,只要你编程思维提升了,基础语法掌握了,才能学习更加深⼊的知识。
用c语言编写计算器

这就涉及到C语言中函数返回指针的问题了
int i=20;
char cStr[3];
itoa(i,cStr,10);
char* f1()
{
return "adsfadsfasd";
}
在函数内部返回函数内构建的指针有可能出现数据混乱.
DWORD dwMydrivers;
dwMydrivers = GetLogicalDrives();
TCHAR cDrivers[256];
itoa(dwMydrivers,cDrivers,2); //转换为字符串
strrev(cDrivers); //反转字符串
(8)思考:这个计算两个数的和程序有什么缺陷?没有阻止用户输入非数字
(9)作业:做一个面积计算器,用户输入半径,在另外一个文本框中显示面积。
5、得到系统中有哪些逻辑驱动器
DWORD GetLogicalDrives(VOID);
返回值的二进制位标志着存在哪些驱动器。其中,位0设为1表示驱动器A存在于系统中;位1设为1表示存在B驱动器;以次类推。
编辑Main_OnCommand方法:
void Main_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
switch(id)
{
case IDC_BTNHELLO:
MessageBox(NULL,TEXT("世界你好"),TEXT("问好"),MB_OK);
{
switch(id)
{
case IDC_OK:
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
setcolor( color+3 ); /*设置淡绿颜色边框线*/
rectangle( x+width*2, y, x+7*width, y+height );
/*画一个矩形边框线*/
setcolor(RED); /*设置颜色为红色*/
outtextxy(x+3*width,y+height/2,"0."); /*输出字符串"0."*/
x =2*width-width/2; /*设置x的坐标值*/
y =2*height+height/2; /*设置y的坐标值*/
for( j=0 ; j<4 ; ++j ) /*画按钮*/
GraphDriver = DETECT; /* 自动检测显示器*/
initgraph( &GraphDriver, &GraphMode, "" );
/*初始化图形系统*/
ErrorCode = graphresult(); /*读初始化结果*/
if( ErrorCode != grOk ) /*如果初始化时出现错误*/
if(v==DOWN) /*下移箭头时新位置计算*/
if(y>=7*height)
{
y=y0;
n=0;
} /*如果移到尾,再下移,则移动到最上边字符位置*/
else
{
y=y+height+height/2;
n=3;
} /*如果移到头,再上移,则移动到最下边字符位置*/
else
{
y=y-height-height/2;
n--;
} /*否则,移到上边一个字符位置*/
int x, y,x0,y0, i, j,v,m,n,act,flag=1;
float num1=0,num2=0,result; /*操作数和计算结果变量*/
char cnum[5],str2[20]={""},c,temp[20]={""};
char str1[]="1230.456+-789*/Qc=^%";/* 定义字符串在按钮图形上显示的符号 */
MaxColors = getmaxcolor() + 1; /* 读取颜色的最大值*/
MaxX = getmaxx(); /* 读屏幕尺寸 */
MaxY = getmaxy(); /* 读屏幕尺寸 */
getaspectratio( &xasp, &yasp ); /* 拷贝纵横比到变量中*/
else
{
x=x-width-width/2;
m--;
} /*否则,左移到前一个字符位置*/
if(v==UP) /*上移箭头时新位置计算*/
if(y<=y0)
{
y=y0+4*height+height/2;
void drawboder(void); /*画边框函数*/
void initialize(void); /*初始化函数*/
void computer(void); /*计算器计算函数*/
void changetextstyle(int font, int direction, int charsize); /*改变文本样式函数*/
mwindow( "Calculator" ); /* 显示主窗口 */
color = 7; /*设置灰颜色值*/
getviewsettings( &vp ); /* 读取当前窗口的大小*/
width=(vp.right+1)/10; /* 设置按钮宽度 */
{
if(flag==-1) /*如果标志为-1,表明为负数*/
{
strcpy(str2,"-"); /*将负号连接到字符串中*/
flag=1;
} /*将标志值恢复为1*/
sprintf(temp,"%c",c); /*将字符保存到字符串变量temp中*/
{
for( i=0 ; i<5 ; ++i )
{
setfillstyle(SOLID_FILL, color);
setcolor(RED);
bar( x, y, x+width, y+height ); /*画一个矩形条*/
{
printf("Graphics System Error: %s\n",
grapherrormsg( ErrorCode ) ); /*显示错误代码*/
exit( 1 ); /*退出*/
}
getpalette( &palette ); /* 读面板信息*/
void mwindow(char *header); /*窗口函数*/
int specialkey(void) ; /*获取特殊键函数*/
int arrow(); /*设置箭头光标函数*/
/*主函数*/
int main()
{
initialize();/* 设置系统进入图形模式 */
height=(vp.bottom-10)/10 ; /*设置按钮高度 */
x = width /2; /*设置x的坐标值*/
y = height/2; /*设置y的坐标值*/
setfillstyle(SOLID_FILL, color+3);
bar( x+width*2, y, x+7*width, y+height );
while((v=specialkey())!=45) /*当压下Alt+x键结束程序,否则执行下面的循环*/
{
while((v=specialkey())!=ENTER) /*当压下键不是回车时*/
{
putimage(x,y,rar,XOR_PUT); /*显示光标图象*/
x =x+width+ (width / 2) ; /*移动列坐标*/
}
y +=(height/2)*3; /* 移动行坐标*/
x =2*width-width/2; /*复位列坐标*/
}
x0=2*width;
#include <stdarg.h> /*变量长度参数表*/
#include <graphics.h> /*图形函数*/
#include <string.h> /*字符串函数*/
#include <ctype.h> /*字符操作函数*/
#define UP 0x48 /*光标上移键*/
}
if(c=='+')
{
num1=atof(str2); /*将第一个操作数转换为浮点数*/
y0=3*height;
x=x0;
y=y0;
gotoxy(x,y); /*移动光标到x,y位置*/
arrow(); /*显示光标*/
putimage(x,y,rar,XOR_PUT);
m=0;
n=0;
strcpy(str2,""); /*设置str2为空串*/
AspectRatio = (double)xasp/(double)yasp;/* 计算纵横比值*/
}
/*计算器函数*/
void computer(void)
{
struct viewporttype vp; /*定义视口类型变量*/
int color, height, width;
#include <dos.h> /*DOS接口函数*/
#include <math.h> /*数学函数的定义*/
#include <conio.h> /*屏幕操作函数*/
#include <stdio.h> /*I/O函数*/
#include <stdlib.h> /*库函数*/
rectangle( x, y, x+width, y+height );
sprintf(str2,"%c",str1[j*5+i]);
/*将字符保存到str2中*/
outtextxy( x+(width/2), y+height/2, str2);
strcat(str2,temp); /*将temp中的字符串连接到str2中*/
setfillstyle(SOLID_FILL,color+3);
bar(2*width+width/2,height/2,15*width/2,3*height/2);
outtextxy(5*width,height,str2); /*显示字符串*/
n++;
} /*否则,移到下边一个字符位置*/
putimage(x,y,rar,XOR_PUT); /*在新的位置显示光标箭头*/
}
c=str1[n*5+m]; /*将字符保存到变量c中*/
if(isdigit(c)||c=='.') /*判断是否是数字或小数点*/
computer(); /*运行计算器 */