C语言实现 计算器(堆栈)

合集下载

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语言编写软件完成以下任务:在实数范围内支持加、减、乘、除运算,同时支持正弦、正切,及其反三角函数运算。

用户可以选择运算的类型,并可以在界面进行数据的输入和输出。

被运算的数据、运算的类型、运算的结果应能够保存到文件myfile.txt 中。

保存的形式可以参考如下所示:4*2=8;sin(0.5)=0.479426。

三、课程设计要求1. 程序质量:✧贯彻结构化的程序设计思想。

✧用户界面友好,功能明确,操作方便。

✧用户界面中的菜单至少应包括“运算选项”、“数据输入”、“保存结果”、“退出”4项。

✧代码应适当缩进,并给出必要的注释,以增强程序的可读性。

2. 课程设计说明书:课程结束后,上交课程设计说明书和源程序。

课程设计说明书的格式和内容参见提供的模板。

目录一.需求分析 (1)二.流程图 (1)三.核心技术的实现方法及程序 (3)四.总结 (4)五.参考文献 (5)六.源程序 (5)一需求分析经过对程序设计题目的分析可知,整个程序的设计实现大致分为2个模块。

其中每一个模块对应一个函数,他们的功能分别是:运算和保存。

二.程序流程图(1)用switch语句完成:图(1)运算流程图图(2)程序整体流程图三.核心技术的实现方法及程序本程序主要由一个主函数和8个自定义函数组成,其中主函数以菜单的形式调用其他函数来实现要求的所有功能。

下面分别进行说明:1.选择函数:定义函数名称,分别编号,按照数字选择。

进入调试状态,页面显示“choose the right number”选择计算函数进行下一步的运算,具体程序段如下:void main(){int n;double a,b,c;FILE *fp;fp=fopen("c:\\myfile.txt","w+");while(1){printf("***********计算器************************ \n ");printf("*********************1-sum*************** *********** \n" );printf("********************2-jian**************** ********* \n");printf("********************3-cheng************** ********** \n ");printf("********************4-chu************************* \n ");printf("********************5-zhengxuan******************** \n ");printf("********************6-zhengqie************ ******** \n ");printf("********************7-fanzhengxuan******** ********** \n ");printf("********************8-fanzhengqie******************* \n ");printf("*********************9-exit*************** ********** \n ");printf("choose the ringt number:\n");2.运算函数:用switch语句实现,分别计算,然后跳出。

用c语言设计一个多功能计算器

用c语言设计一个多功能计算器

用C语言设计一个多功能计算器实现功能:1)具备整型数据、浮点型数据的算术(加、减、乘、除)运算功能。

依次输入第一个运算数、运算符(+,-,*,/),第二个运算数,然后输出结果。

结果可以作为下一个运算的第一运算数。

按‘C’清屏,按‘X’退出。

例如:输入:2+5输出:72)实现单运算符表达式计算的功能。

输入的操作数可以包含整数或浮点数。

如果遇到错误的表达式,应输出错误提示信息。

输入表达式如下:例如:输入:2+5输出:7目录摘要 (1)第一章引言 (3)1.1 计算器概述 (3)第二章设计任务及要求 (5)2.1 设计任务 (5)2.2 设计要求 (6)第三章计算器硬件设计 (7)3.1 方案说明 (7)3.2 设计单片机主体电路图 (8)第四章软件设计 (9)4.1 模块介绍 (9)4.2 程序流程图 (10)4.3 程序部分 (11)第五章总结 (16)参考文献 (17)摘要:[目录]一、课程设计题目及任务要求二、设计思路三、部分程序介绍四、程序框图五、汇编程序六、参考资料[原文]一、课程设计题目及任务要求请设计十进制加减法计算器。

要求能(不同时)显示3位输入和4位输出。

二、设计思路1、操作显示设备显示设备采用八片七段共阴极LED显示器,共设置16 个键,其中数字键0~9 共十个,接下来依次是加号键、减号键、等于号、清除键。

操作设备是两行八列共16键的简单键盘。

第一行从左至右分别为0、1、2、3、4、5、6、7,第二行分别为8、9、A(+)、B(-)、C(=)、D(清除键)、E (清除键)、F(清除键),“清除键”表示程序初始化,为下次输入准备。

2、程序实现功能(1)十进制加减法计算:输入范围为(1~999),该程序输入两个定点数,每个3位,输出4位;A为加,B为减,C为等于,输出为四位计算结果。

数据输入采用规范化输入,即必须输入3个数才算完成一个运算数的输入,两个运算数之间输入运算符A或者B,输入完成按C显示计算结果;(2)计算机复位功能:DEF均为清零重启,任何时候按下DEF中一个将重新开始;三、部分程序介绍(1)主程序(START)程序开始运行初始化程序,设置输入输出口PA、PB、PC,扫描键盘,输入两个待求数据和运算符,存入寄存器,等待输入等号同时显示第二个数,运行计算程序,并将计算结果分离,输出到显示器;(2)读键子程序(RD_KB)程序分别扫描两行键盘,若有键按下则通过移位的方式计算键码;若无键按下,则将键码缓存设置为10H,判断后进行相应的跳转。

计算器编程c语言

计算器编程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语言堆栈是一种常见的数据结构,它符合先进后出的原则。

在四则运算中,我们可以借助堆栈这种数据结构实现运算,方便高效,不易出错。

堆栈的实现包括两个基本操作:Push(入栈)和Pop(出栈)。

我们可以以此设计四则运算。

首先,我们需要将输入的四则运算表达式转换成后缀表达式。

后缀表达式也叫逆波兰表达式,相对于中缀表达式而言,运算符在后面,操作数在前面,这样方便计算机进行读取和计算。

例如:中缀表达式:5+3*2后缀表达式:5 3 2 * +将中缀表达式转换成后缀表达式,我们需要用到堆栈。

具体的实现方法是,从左向右遍历表达式,如果是数字,则直接输出;如果是符号,则将其与堆栈顶的符号进行比较,如果优先级高就入栈,否则不断将符号出栈并输出,直到当前符号优先级大于堆栈顶符号优先级,最后将当前符号入栈。

例如:表达式:5+3*2堆栈操作:1.将5输出,堆栈为空2.遇到+号,入栈3.将3输出,堆栈顶为+号4.遇到*号,入栈5.将2输出,堆栈顶为*号6.输出*号,堆栈顶为+号7.输出+号,堆栈为空得到后缀表达式:5 3 2 * +有了后缀表达式,我们可以用堆栈进行计算。

具体方法是,从左向右遍历后缀表达式,如果是数字则入栈,如果是符号则将栈顶两个数字出栈并进行计算,将结果入栈,最终得到最终的计算结果。

例如:后缀表达式:5 3 2 * +堆栈操作:1.将5入栈2.将3入栈3.遇到*号,出栈3和2,进行计算得到6,将6入栈4.将栈顶元素5出栈5.遇到+号,出栈6和5,进行计算得到11,将11入栈得到计算结果:11通过堆栈实现四则运算,可以有效简化我们的计算流程,避免复杂的优先级判断和计算错误。

同时,堆栈为我们提供了一种更加高效的数据结构,不仅在四则运算中可以发挥作用,在其他应用中也很常见。

当然,在实际应用中,我们需要考虑到多种情况的处理,例如负数、小数、括号等,以及错误处理等细节问题,才能保证算法的正确性和可靠性。

MCS51单片机程序设计时堆栈的计算方法解析

MCS51单片机程序设计时堆栈的计算方法解析

MCS51单片机程序设计时堆栈的计算方法解析[导读]用C语言进行MCS51系列单片机程序设计是单片机开发和应用的必然趋势。

Keil公司的C51编译器支持经典8051和8051派生产品的版本,通称为Cx51。

应该说,Cx51是C 语言在MCS51单片机上的扩展,既有C语言的共性,又有它自己的特点。

本文介绍的是Cx51程序设计时堆栈的计算方法。

用C语言进行MCS51系列单片机程序设计是单片机开发和应用的必然趋势。

Keil公司的C51编译器支持经典8051和8051派生产品的版本,通称为Cx51。

应该说,Cx51是C语言在MCS51单片机上的扩展,既有C语言的共性,又有它自己的特点。

本文介绍的是Cx51程序设计时堆栈的计算方法。

1.堆栈的溢出问题。

MCS51系列单片机将堆栈设置在片内RAM中,由于片内RAM资源有限,堆栈区的范围也是有限的。

堆栈区留得太大,会减少其他数据的存放空间,留得太少则很容易溢出。

所谓堆栈溢出,是指在堆栈区已经满了的时候还要进行新的压栈操作,这时只好将压栈的内容存放到非堆栈区的特殊功能寄存器(SFR)中或者堆栈外的数据区中。

特殊功能寄存器的内容影响系统的状态,数据区的内容又很容易被程序修改,这样一来,之后进行出栈操作(如子程序返回)时内容已变样,程序也就乱套了。

因此,堆栈区必须留够,宁可大一些。

要在Cx51程序设计中防止堆栈的溢出,要解决两个问题:第一,精确计算系统分配给用户的堆栈大小,假设是M;第二,精确计算用户需要堆栈的大小,假设是N。

要求M≥N,下面分别分析这两个问题。

2.计算系统分配给用户的堆栈大小Cx51程序设计中,因为动态局部变量是长驻内存中的,实际上相当于局部静态变量,即使在函数调用结束时也不释放空间(这一点不同于标准C语言)。

Cx51编译器按照用户的设置,将所有的变量存放在片内和片外的RAM中。

片内变量分配好空间后,将剩下的空间全部作为堆栈空间,这个空间是最大可能的堆栈空间。

C语言实现简易计算器(可作加减乘除)

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语言stack(栈)和heap(堆)的使用详解

c语言stack(栈)和heap(堆)的使用详解

c语⾔stack(栈)和heap(堆)的使⽤详解⼀、预备知识—程序的内存分配⼀个由C/C++编译的程序占⽤的内存分为以下⼏个部分1、栈区(stack)—由编译器⾃动分配释放,存放函数的参数值,局部变量的值等。

其操作⽅式类似于数据结构中的栈。

2、堆区(heap)—⼀般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。

注意它与数据结构中的堆是两回事,分配⽅式倒是类似于链表。

3、全局区(静态区)(static)—全局变量和静态变量的存储是放在⼀块的,初始化的全局变量和静态变量在⼀块区域,未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域。

程序结束后由系统释放。

4、⽂字常量区—常量字符串就是放在这⾥的。

程序结束后由系统释放。

5、程序代码区—存放函数体的⼆进制代码。

⼆、例⼦程序复制代码代码如下://main.cppint a=0; //全局初始化区char *p1; //全局未初始化区main(){intb;栈char s[]="abc"; //栈char *p2; //栈char *p3="123456"; //123456\0在常量区,p3在栈上。

static int c=0; //全局(静态)初始化区p1 = (char*)malloc(10);p2 = (char*)malloc(20); //分配得来得10和20字节的区域就在堆区。

strcpy(p1,"123456"); //123456\0放在常量区,编译器可能会将它与p3所向"123456"优化成⼀个地⽅。

}三、堆和栈的理论知识2.1申请⽅式stack:由系统⾃动分配。

例如,声明在函数中⼀个局部变量int b;系统⾃动在栈中为b开辟空间heap:需要程序员⾃⼰申请,并指明⼤⼩,在c中⽤malloc函数如p1=(char*)malloc(10);在C++中⽤new运算符如p2=(char*)malloc(10);但是注意p1、p2本⾝是在栈中的。

C语言简易计算器的实现

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语言编写的计算器源代码

作品:科学计算器作者:欧宗龙编写环境:vc++6.0语言:c#include"stdafx.h"#include<stdio.h>#include<windows.h>#include<windowsx.h>#include"resource.h"#include"MainDlg.h"#include<math.h>#include<string.h>#definePI3.141593BOOLA_Op=FALSE;BOOLWINAPIMain_Proc(HWNDhWnd,UINTuMsg,WPARAMwParam,LPARAMlParam) {switch(uMsg){HANDLE_MSG(hWnd,WM_INITDIALOG,Main_OnInitDialog);HANDLE_MSG(hWnd,WM_COMMAND,Main_OnCommand);HANDLE_MSG(hWnd,WM_CLOSE,Main_OnClose);}returnFALSE;}BOOLMain_OnInitDialog(HWNDhwnd,HWNDhwndFocus,LPARAMlParam){returnTRUE;}voidTrimNumber(chara[])//判断并删除小数点后无用的零{for(unsignedi=0;i<strlen(a);i++){if(a[i]=='.'){for(unsignedj=strlen(a)-1;j>=i;j--){if(a[j]=='0'){a[j]='\0';}elseif(a[j]=='.'){a[j]='\0';}elsebreak;}}}}doubleOperate(charOperator,doublen1,doublen2)//判断符号,进行相应的运算{if(Operator=='0'){}if(Operator=='+'){n2+=n1;}if(Operator=='-'){n2=n1-n2;}if(Operator=='*'){n2*=n1;}if(Operator=='/'){n2=n1/n2;}if(Operator=='^'){n2=pow(n1,n2);}return n2;}////////////////////////////////////////////////voidIntBinary(chara[],intn){if(n>1)IntBinary(a,n/2);sprintf(a,"%s%i",a,n%2);}voiddecimal(chara[],doublem){if(m>0.000001){m=m*2;sprintf(a,"%s%d",a,(long)m);decimal(a,m-(long)m);}}voidBinary(chara[],doubleNum){charDecP[256]="";doublex,y;double*iptr=&y;x=modf(Num,iptr);decimal(DecP,x);IntBinary(a,(int)y);strcat(a,".");strcat(a,DecP);}////////////////////////////////////voidMain_OnCommand(HWNDhwnd,intid,HWNDhwndCtl,UINTcodeNotify) {staticDELTIMES=0;staticcharstr[256];staticcharOperator='0';staticdoubleRNum[3];switch(id){caseIDC_BUTTONN1://数字1{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"1");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN2://数字2{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"2");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN3://数字3{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"3");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN4://数字4{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"4");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN5://数字5{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"5");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN6://数字6{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"6");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN7://数字7{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"7");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN8://数字8{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"8");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN9://数字9{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"9");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;caseIDC_BUTTONN0://数字0{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));strcat(str,"0");SetDlgItemText(hwnd,IDC_EDIT,str);RNum[1]=atof(str);A_Op=FALSE;}break;case{if(A_Op){SetDlgItemText(hwnd,IDC_EDIT,NULL);}GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));if(DELTIMES==0){strcat(str,".");}DELTIMES++;SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=FALSE;}break;caseIDC_BUTTONADD://加法运算{RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);Operator='+';DELTIMES=0;A_Op=TRUE;}break;caseIDC_BUTTONSUB://减法运算{RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);DELTIMES=0;A_Op=TRUE;Operator='-';}break;caseIDC_BUTTONMUL://乘法运算{RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);Operator='*';DELTIMES=0;A_Op=TRUE;}break;caseIDC_BUTTONDIV://除法运算{RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);Operator='/';DELTIMES=0;A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);Operator='^';DELTIMES=0;}break;caseIDC_BUTTONPI://圆周率PI,弧度{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));if(atof(str)!=0){RNum[2]=atof(str)*PI;sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);}else{sprintf(str,"%f",PI);SetDlgItemText(hwnd,IDC_EDIT,str);}A_Op=TRUE;}break;caseIDC_BUTTONSQRT://开根号{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=sqrt(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;caseIDC_BUTTONSIN://三角函数sin函数{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=sin(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=cos(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=tan(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;caseIDC_BUTTONSQ://平方{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=atof(str)*atof(str);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=atof(str)*atof(str)*atof(str);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=exp(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=pow(10,atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;caseIDC_BUTTONLN://lnx{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=log(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;caseIDC_BUTTONLOG10://log10{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=log10(atof(str));sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;caseIDC_BUTTONBINARY://十进制转换为二进制{chara[256]="";GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[2]=atof(str);Binary(a,RNum[2]);strcpy(str,a);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);A_Op=TRUE;}break;case{DELTIMES=0;Operator='0';RNum[0]=RNum[1]=RNum[2]=0;memset(str,0,sizeof(str));SetDlgItemText(hwnd,IDC_EDIT,NULL);A_Op=FALSE;}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));inti=strlen(str);str[i-1]='\0';SetDlgItemText(hwnd,IDC_EDIT,str);}break;case{GetDlgItemText(hwnd,IDC_EDIT,str,sizeof(str));RNum[1]=atof(str);RNum[0]=RNum[1];RNum[1]=RNum[2];RNum[2]=Operate(Operator,RNum[1],RNum[0]);sprintf(str,"%f",RNum[2]);TrimNumber(str);SetDlgItemText(hwnd,IDC_EDIT,str);Operator='0';DELTIMES=0;}break;default:break;}}voidMain_OnClose(HWNDhwnd){EndDialog(hwnd,0);}本人拙作,如有不足之处请谅解。

C语言实现简单计算器程序

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语言数据结构之栈的基本操作

C语言数据结构之栈的基本操作

C语言数据结构之栈的基本操作栈是一种特殊的数据结构,它按照后进先出(LIFO)的原则进行操作。

栈可以用数组或链表来实现,下面将介绍栈的基本操作。

1.初始化栈:栈的初始化就是为栈分配内存空间,并将栈顶指针设置为-1(如果是数组实现)或者NULL(如果是链表实现)。

2.判断栈空:栈空表示栈中没有任何元素。

如果栈顶指针等于-1或者NULL,则表示栈空。

3.判断栈满:栈满表示栈中已经存满了元素。

如果栈顶指针等于栈的最大容量减1,则表示栈满。

4. 进栈(push):进栈操作就是将元素放入栈中。

如果栈不满,则将栈顶指针加1,并将元素放入栈顶位置。

5. 出栈(pop):出栈操作就是从栈中取出一个元素。

如果栈不空,则将栈顶指针减1,并返回栈顶元素。

6. 获取栈顶元素(getTop):获取栈顶元素操作不改变栈的状态,只返回栈顶元素的值。

如果栈不空,则返回栈顶元素值;否则,返回空值。

7.清空栈:清空栈操作就是将栈中的所有元素全部出栈,即将栈顶指针设置为-1或者NULL。

8.销毁栈:销毁栈操作是释放栈的内存空间,将栈的指针设置为NULL。

栈的应用:栈在计算机领域有广泛的应用,其中一个常见的应用是函数调用栈。

当一个函数调用另一个函数时,当前函数的状态(包括局部变量、返回地址等)会被压入到栈中。

当被调用函数执行完成后,栈顶的元素会被弹出,然后继续执行调用该函数的代码。

另一个常见的应用是表达式求值。

在表达式求值过程中,需要用到运算符优先级。

我们可以利用栈来处理运算符的优先级。

将运算符入栈时,可以先与栈顶运算符比较优先级,如果栈顶运算符的优先级高于当前运算符,则将栈顶运算符出栈,并继续比较。

这样可以确保栈中的运算符按照优先级从高到低的顺序排列。

此外,栈还可以用于处理括号匹配问题。

当遇到左括号时,将其入栈;当遇到右括号时,判断栈顶元素是否为对应的左括号,如果是,则将栈顶元素弹出,否则表示括号不匹配。

如果最后栈为空,则表示所有括号都匹配。

c语言计数器程序代码

c语言计数器程序代码

c语言计数器程序代码计数器是一种常用的程序功能,可以用来记录某个事件的发生次数或者进行循环计数。

在C语言中,可以使用变量和循环结构来实现一个简单的计数器程序。

下面是一个简单的计数器程序的代码示例:```c#include <stdio.h>int main() {int count = 0; // 初始化计数器变量为0printf("开始计数...\n");// 循环执行计数操作,每次循环计数器加1,直到达到目标计数值while (count < 10) {printf("当前计数:%d\n", count);count++; // 计数器自增1}printf("计数结束。

\n");return 0;}```上述代码使用了一个整型变量 `count` 作为计数器,并将初始值设为0。

然后使用 `while` 循环进行计数操作,每次循环中打印出当前计数值,并使计数器自增1,直到计数器的值达到目标值(此处为10)时结束循环,最后打印出计数结束的提示信息。

通过运行上述代码,我们可以得到如下的输出结果:```开始计数...当前计数:0当前计数:1当前计数:2当前计数:3当前计数:4当前计数:5当前计数:6当前计数:7当前计数:8当前计数:9计数结束。

```上述代码示例只是一个最简单的计数器程序,实际应用中可以根据需要进行扩展和修改。

下面是一些相关参考内容,供进一步学习和开发计数器程序时参考:1. C语言基础知识:了解C语言的基本语法、数据类型、变量和运算符等,是学习和编写计数器程序的基础。

2. 循环结构:掌握C语言中的循环结构,包括 `for` 循环、`while` 循环和 `do-while` 循环等,以及循环控制语句如 `break` 和 `continue`,可以灵活运用于计数器程序的实现。

3. 程序流程控制:了解C语言中的条件语句如 `if-else` 和`switch`,以及逻辑运算符、比较运算符等,可以根据需要在计数器程序中加入条件判断,实现更加灵活的计数器功能。

c语言实现栈详细代码

c语言实现栈详细代码

c语言实现栈详细代码栈(Stack),又称堆栈,是一种后进先出(LIFO,Last In First Out)的数据结构,它只允许在一段端点进行插入和删除操作,这个端点被称为栈顶。

C语言实现栈的基本思路是建立一个结构体,结构体中包含一个数组和栈顶指针top。

数组用来存放栈中元素,top指针指向栈顶元素的下标。

实现栈的操作包括压栈(push)、出栈(pop)和获取栈顶元素(get_top)。

下面是详细代码:```#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100 //栈的最大长度typedef struct stack {int data[MAX_SIZE]; //栈中元素int top; //栈顶指针} Stack;//初始化栈void init(Stack *s) {s->top = -1; //栈顶指针初始化为-1,表示栈为空}//判断栈是否为空int is_empty(Stack *s) {return s->top == -1;}//判断栈是否已满int is_full(Stack *s) {return s->top == MAX_SIZE-1;}//压栈void push(Stack *s, int value) {if (is_full(s)) {printf("Stack is full, cannot push!\n");return;}s->data[++(s->top)] = value; //栈顶指针先加1,再将元素入栈}//出栈void pop(Stack *s) {if (is_empty(s)) {printf("Stack is empty, cannot pop!\n");}s->top--; //栈顶指针减1,表示栈顶元素已删除}//获取栈顶元素int get_top(Stack *s) {if (is_empty(s)) {printf("Stack is empty, cannot get top element!\n"); return -1;}return s->data[s->top]; //返回栈顶元素}int main() {Stack s;init(&s); //初始化栈for (i = 0; i < 5; i++) {push(&s, i); //压入5个元素}printf("Top element: %d\n", get_top(&s)); //获取栈顶元素while (!is_empty(&s)) {printf("%d ", get_top(&s)); //依次输出栈中元素pop(&s); //弹出栈顶元素}return 0;}```代码中定义了一个结构体,包含一个整型数组data和一个整型变量top,数组用来存放栈中元素,top表示栈顶指针。

C语言计算器程序源代码

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语言实现计算器,附源码,超简单!

20
// 下面这得注意,接收double型的数据得用lf%,接收float用f%
21
scanf("%lf",&x1);
22
23
printf("请输入运算操作(+ - * /):\n");
24
m = getche();
25
printf("\n");
26
27
printf("请输入第二个数:\n");
28
40
result = x1 - x2;
41
printf("%lf - %lf = %lf\n",x1,x2,result);
42
break;
43
44
case '*':
45
printf("乘法\n");
46
result = x1 * x2;
47
printf("%lf * %lf = %lf\n",x1,x2,result);
scanf("%lf",&x2);
29
30
switch(m)
31
{
32
case '+':
33
printf("加法\n");
34
result = x1 + x2;
35
printf("%lf + %lf = %lf\n",x1,x2,result);
36
break;
37
38
case '-':

c语言实现虚拟计算器代码

c语言实现虚拟计算器代码

c语言实现虚拟计算器代码以下是一个简单的C语言虚拟计算器代码示例: c.#include <stdio.h>。

int main() {。

char operator;float num1, num2, result;printf("请输入运算符(+, -, , /): ");scanf("%c", &operator);printf("请输入两个数字: ");scanf("%f %f", &num1, &num2);switch(operator) {。

case '+':result = num1 + num2; break;case '-':result = num1 num2; break;case '':result = num1 num2; break;case '/':if(num2 != 0) {。

result = num1 / num2;} else {。

printf("错误,除数不能为0\n"); return 1; // 退出程序。

}。

break;default:printf("错误,无效的运算符\n");return 1; // 退出程序。

}。

printf("结果: %f %c %f = %f\n", num1, operator,num2, result);return 0;}。

这段代码首先要求用户输入运算符和两个数字,然后根据用户输入的运算符进行相应的计算,并输出结果。

在这个示例中,我们使用了switch语句来根据不同的运算符执行不同的计算操作。

另外,我们还对除数为0的情况进行了处理,以避免出现除以0的错误。

当然,这只是一个简单的示例代码,实际的虚拟计算器可能会更复杂,包括更多的功能和更完善的用户界面。

C语言课程设计(计算器)

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语⾔时,实验课上写的计算器功能,挺有意思。

所以在此分享给学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 语⾔,作为编程⼊门语⾔,⼤家⼀定要学习好此门语⾔,⽽且如果学好了,其实学习其他编程语⾔就很容器上⼿的,不同语⾔其实⼤同⼩异,只要你编程思维提升了,基础语法掌握了,才能学习更加深⼊的知识。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

cout &lt;&lt;&quot;最终结果:&quot;&lt;&lt;result(inputString)&lt;&lt;endl;
} //计算最终的结果
}
return 0;
}
/********************************************************************
34+p(u89-12.3)k/3# 期望结果:59.5667
89.5*749+25)# 期望结果:输入有误
89.5*749+25# 期望结果:67060.500000
(8*(7-4)# 期望结果:输入有误
65*(72+98)(70-45) # 期望结果:输入有误
void MakeEmpty();
bool empty();
private:
int NumItem;
StackNode&lt;Type&gt; *_top;
};
template&lt;class Type&gt;
void Stack&lt;Type&gt;::push(Type item)
6*# 期望结果:输入有误
)5+3(# 期望结果:输入有误
(3+)(4)# 期望结果:输入有误
3....2*10+8# 期望结果:40
+23-4*# 期望结果:输入有误
23-4*# 期望结果:输入有误
+23-4# 期望结果:输入有误
具体内容:
I: 如果算式里面有计算式不应该出现的字符,则将其智能略去 如:将(1.4a54+2f.6)*3.09s+4ff看成(1.454+2.6)*3.09+4
II: 检查括号是否匹配,如果匹配,再检查是否出现在合法位置 如:(8*(7-4)不匹配,以及65*(72+98)(70-45)匹配但是不合法
char inputString[MAX_LENGHT]; //为了不改变输入的字符串,用来充当计算过程中的inputString0
while(1){
gets( inputString0 ); //从键盘接收输入的计算字符串inputString0
strcpy( inputString , inputString0 ); //为了不改变输入的字符串inputString0,用inputString来充当计算过程中的
//inputString0.以后计算
用到计算字符串的时候都将inputString传递,而原始字符串
//inputString0不变
if(check(inputString)==false)
{
3+-2# 期望结果:输入有误
4+++++++++++++++5# 期望结果:9
********************************************************************/
/********************************************************************
{
_top=new StackNode&lt;Type&gt;(item,_top);
NumItem++;
}
template&lt;class Type&gt;
void Stack&lt;Type&gt;::pop()
{
StackNode&lt;Type&gt; *p;
* 主函数 *
********************************************************************/
int main()//主函数
{
char inputString0[MAX_LENGHT]; //定义输入的字符串
bool Stack&lt;Type&gt;::empty()
{
return _top==NULL;
}
template&lt;class Type&gt;
void Stack&lt;Type&gt;::MakeEmpty()
{
delete _top;
}
/********************************************************************
template &lt;class Stack_type&gt; //用计算符号op计算数字number_1 和 number_2
Stack_type caculate( char op, const Stack_type number_1, const Stack_type number_2 );
template&lt;class Type&gt;
class StackNode
{
friend class Stack&lt;Type&gt;;
private:
Type data;
StackNode&lt;Type&gt; *link;
StackNode(Type D=0,StackNode&lt;Type&gt; *L=NULL):link(L),data(D){}
(3+3)*3+1*(1+3)-3/2+3*3# 期望结果:29.5
1+2*(4-5)+45# 期望结果:44.000000
(1.454+2.6)*3.09+4# 期望结果:16.5269
(1.4a54+2f.6)*3.09s+4ff# 期望结果:16.5269
(56-23)/8-4# 期望结果:0.125
/********************************************************************
* 用堆栈做的计算器程序 *
//#define Stack stack //之所以不直接用stack是因为我打算完成整个程序后自己练习写个&quot;Stack.h&quot;
#define MAX_LENGHT 50 //预先
假设计算字符串最多有500个字符
#define MAX 10 //一般情况下输入要计算的数不会超过10位
/********************************************************************
p=_top;
_top=_top-&gt;link;
delete p;
NumItem--;
}
template&lt;class Type&gt;
Type Stack&lt;Type&gt;::top()
{
return _top-&gt;data;
}
template&lt;class Type&gt;
VI: 接V:如果判断能够改正,则-------------------------------&gt; 将4++++++++++++5看成4+5并计算
VII:检测“0”是否出现在分母上
【下边是检测数据,检测结果与ቤተ መጻሕፍቲ ባይዱ望结果吻合】
【注:输入数据结尾没有“#”,以为在我的程序里面要它没用】
()*2+3# 期望结果:输入有误
III: 检查计算数与计算符号的数量是否合格 如:+23-4* 、23-4*、+23-4 等等
IV: 检查输入小数的时候小数点是否输入过多以及智能改正 如:将3....2*10+8 看成3.2*10+8
V: 检查连续输入大于两个符号时候是否能智能修改,“不能”则-&gt; 对于3+-2 给出判断结果:输入有误
* 自定义函数 *
********************************************************************/
bool isOperand(char ch); //检查是否为操作数
int priority( char op); //设置操作等级并返回操作符op的等级
* 程序中所用到的头文件 *
********************************************************************/
#include&lt;iostream&gt;
#include&lt;cstring&gt;
char *mark(char string[]); //将符号和数字放在同一个堆栈里面时,两个数字可能会连在一起,导致无法区分
//哪个是第一个数哪个是第二个数,这里我用了小方法,就是在每个数字后边加个
//字母a来将两个连着的数字区分开
相关文档
最新文档