c语言编写简单计算器代码,c语言计算器程序编写代码

　　这个计算器其实是我老师布置的C语言作业。我在想我做了这么久的东西不能浪费，所以分享一下我的代码和大致思路。

　　给我关注和赞，以后我会分享更多我们学生党的作业问题。

　　白嫖，聚会会先看代码，我会先加载完整的代码。操！

　　前言：

　　为了达到目的，我先自学了栈：我按照先进后出的原则存储数据。第一个数据被推到堆栈的底部，最后一个数据在堆栈的顶部。当我需要读取数据时，我开始从栈顶弹出数据。允许插入和删除操作的一端称为栈顶，另一端为栈底)；堆栈的。栈底是固定的，栈顶是浮动的；当栈元素的个数为零时，称为空栈。一般插入叫PUSH，删除叫POP。允许插入和删除操作的一端称为栈顶，另一端为栈底)；堆栈的。栈底是固定的，栈顶是浮动的；当栈元素的个数为零时，称为空栈。一般插入叫PUSH，删除叫POP。其次，是通过查阅各种资料，结合所学知识编写的。

　　(1)InitStack初始化：初始化一个新的堆栈。

　　(2)Empty(S) stack不为空：如果stack s不为空，则返回TRUE；否则，返回FALSE。

　　(3)Push(S，x) stack:在堆栈S的顶部插入元素x，返回FALSE如果堆栈已满；否则，返回TRUE。

　　(4)弹出堆栈：如果堆栈S不为空，则返回堆栈顶部的元素，并从堆栈顶部删除该元素；否则，返回空元素NULL。

　　(5)GetTop(S)取栈顶元素：如果栈S不为空，则返回栈顶元素；否则，返回空元素NULL。

　　(6)SetEmpty(S)设置栈空操作：将栈S设置为空栈。

　　(7) top=-1常用来表示空栈。

　　推送算法

　　(1)如果TOPn，给出溢出信息，进行错误处理(入栈前检查栈是否满，满了就溢出；如果不满意，做)；

　　 Set TOP=TOP 1(堆栈地址的堆栈指针加1)；

　　S(TOP)=X，end (X为新增元素)

　　POP算法

　　如果TOP0，则给出下溢信息并进行错误处理(返回前检查堆栈是否为空，为空则溢出；非空则)；

　　X=S(TOP)，(退栈后的元素赋给X):

　　TOP=TOP-1，end(栈指针减1，指向栈顶)

　　(1)功能及作用介绍：可以实现连续运算和混合运算，基本可以相当于手机上的计算器。只有加减乘除四则运算。(强调操作中的括号必须是英文版，否则操作会出错。写表达式也可以加“=”，不加也不会影响运行结果，最后用enter结束得到结果)。如果能在visualc中运行，稍微调整一下，就可以用内置的函数设置一个界面，可以和手机自带的计算器一样。

　　加法：1 2回车得3，连续运算1 2 3 4 5回车得15。

　　减法运算：1-2回车返回-1，连续运算后5-1-2回车返回2。

　　乘法：23回车6，连续运算23*4回车24

　　第24/4部分回车6，第24/2部分回车6，

　　混合运算：(5 ^ 2)* 2输入14

　　(1)软件环境：Devc我用这个软件。个人感觉这里功能简单，特别好用。看图，是不是简单不复杂？

　　(2)设计方案根据自学栈存储和输出数据和符号。首先，建立一个单独的数据堆栈符号堆栈。我们用top=-1作为判断是否为空栈的标准。当然，我们也使用学习到的struct来构建堆栈。先把人物放进去吧。在其中，我们必须执行操作，然后显示给我们。所以我们需要用四种开关来表示加减乘除四则运算。这可以是一个简单的操作。带括号的混合运算呢？所以我们需要判断优先级。加减乘除分别处于同一水平。首先，读左括号到右括号。我们需要停下来，这样我们才能

　　(3)函数功能：用到了第八章内容结构结合自学内容构造栈，开关表达式来判断优先级，主要用到的为自学的栈推进栈，流行出栈，top=-1划分是否为空字符，在前言写很清楚了。

　　（四)全代码：#include stdio.h

　　#包含标准库

　　/*数据栈*/

　　struct shuju //struct结构体构建栈

　　{

　　int data[100]；

　　栈顶

　　};

　　/*符号栈*/

　　结构付豪

　　{

　　字符符号[100];

　　栈顶

　　};

　　void InitOperateNum(struct shuju * stack num)//数据栈非空

　　{

　　堆栈编号top=-1；

　　}

　　void InitOperateSymbol(结构付豪*堆栈符号)//符号栈非空

　　{

　　堆栈符号-top=-1；

　　}

　　/*存入数据栈*/

　　shuju中的void(struct Shu ju * stack num，int num)

　　{

　　栈顶数；

　　堆栈编号-数据[堆栈编号-顶部]=编号；

　　}

　　/*存入符号栈*/

　　空符号（结构付豪*堆栈符号，字符通道)

　　{

　　堆栈符号-顶部；

　　stack symbol-symbol[stack symbol-top]=ch；

　　}

　　/*读取数据栈*/

　　int Randshuju(struct shuju * stack num)

　　{

　　返回堆栈编号数据[堆栈编号顶部]；

　　}

　　/*读取符号栈*/

　　char Randfuhao(结构付豪*堆栈符号)

　　{

　　返回堆栈符号-符号[堆栈符号-顶部]；

　　}

　　/*从数据栈取出数据*/

　　int put shuju(struct shuju * stack num)

　　{

　　int x；

　　x=堆栈编号-数据[堆栈编号-顶部]；

　　堆栈编号-top-；

　　返回x；

　　}

　　/*从符号栈取出符号*/

　　char Putfuhao(结构付豪*堆栈符号)

　　{

　　char c；

　　c=堆栈符号-符号[堆栈符号-顶部]；

　　堆栈符号-顶部-;

　　返回c；

　　}

　　/*符号优先级判断*/

　　int judge(char ch) {

　　if(ch==()

　　{

　　返回1;

　　}

　　if(ch== ch==-) {

　　return 2；

　　}

　　else if(ch==* ch==/) {

　　返回3;

　　}

　　else if(ch==)) {

　　返回4;

　　}

　　}

　　/*四则运算*/

　　int Math(int v1，int v2，char c)

　　{

　　求和函数

　　开关(c) {

　　案例"":

　　总和=v1 v2

　　打破；

　　}

　　大小写- : {

　　sum=v1-v2；

　　打破；

　　}

　　案例 * : {

　　总和=v1 * v2

　　打破；

　　}

　　案例/ : {

　　总和=v1/v2；

　　打破；

　　}

　　}

　　返回总和；

　　}

　　int main()

　　{

　　结构体舒聚数据；

　　结构付豪符号；

　　InitOperateNum(数据);//调用数据

　　InitOperateSymbol(符号);//调用符号

　　int i，t，sum，v1，v2；

　　char c；

　　I=t=sum=0；

　　char v[100]={ 0 }；

　　char * str=(char *)malloc(sizeof(char)* 200)；

　　while((c=getchar())！=\n) //非空字符

　　{

　　str[I]=c；

　　我；

　　}

　　str[I]= \ 0 ；

　　for(I=0；str[i]！=\0;i ) {

　　if(i==0 str[i]==-) {

　　v[t]=str[I]；

　　}

　　else if(str[I]==( str[I 1]==-){

　　我；

　　v[t]=str[I]；

　　while(str[i]=0 str[i]=9) {

　　v[t]=str[I]；

　　t；

　　我；

　　}

　　Inshuju(数据，atoi(v))；

　　while(t 0) {

　　v[t]=0；

　　t-；

　　}

　　if(str[i]！=)) {

　　I-；

　　Infuhao(符号，();

　　}

　　}

　　else if(str[i]=0 str[i]=9) {

　　while(str[i]=0 str[i]=9) {

　　v[t]=str[I]；

　　t；

　　我；

　　}

　　仁寿州(数据，atoi(v))；

　　while(t 0) {

　　v[t]=0；

　　t-；

　　}

　　I-；

　　}

　　否则{

　　if(symbol.top==-1)

　　{ //如果符号栈没有元素，直接把符号放入符号栈

　　Infuhao( symbol，str[I])；

　　}

　　else if(judge(str[i])==1) { //如果此符号是(,直接放入符号栈

　　Infuhao( symbol，str[I])；

　　}

　　else if(judge(str[i])==2) { //如果此符号是 或-,判断与栈顶符号是优先级

　　if(judge(兰德付豪(symbol))==1){//如果栈顶符号是(,放入符号栈

　　Infuhao( symbol，str[I])；

　　}

　　else if(judge(兰德付豪(symbol))==2){//如果栈顶符号是 或-,则出栈运算

　　while(符号。top=0数据。top=1){//循环出栈

　　v2=Putshuju(数据);

　　v1=Putshuju(数据);

　　sum=Math(v1，v2，Putfuhao(符号));

　　仁寿州(数据，总和);//将运算结果压入数据栈

　　}

　　Infuhao( symbol，str[I])；//新符号进栈

　　}

　　else if(judge(兰德付豪(symbol))==3){//如果栈顶符号是*或/,则进符号栈

　　while(符号。top=0数据。top=1){//循环出栈

　　v2=Putshuju(数据);

　　v1=Putshuju(数据);

　　sum=Math(v1，v2，Putfuhao(符号));

　　仁寿州(数据，总和);//将运算结果压入数据栈

　　}

　　Infuhao( symbol，str[I])；//新符号进栈

　　}

　　/*栈顶符号不可能是),故不做判断*/

　　}

　　else if(judge(str[i])==3) { //如果此符号是*或/,则判断与栈顶符号是优先级

　　if(judge(兰德付豪(symbol))==1){//如果栈顶符号是(,放入符号栈

　　Infuhao( symbol，str[I])；

　　}

　　else if(judge(兰德付豪(symbol))==2){//如果栈顶符号是 或-,则进符号栈

　　Infuhao( symbol，str[I])；//新符号进栈

　　}

　　else if(judge(兰德付豪(symbol))==3){//如果栈顶符号是*或/,则出栈运算

　　while(符号。top=0数据。top=1){//循环出栈

　　v2=Putshuju(数据);

　　v1=Putshuju(数据);

　　sum=Math(v1，v2，Putfuhao(符号));

　　仁寿州(数据，总和);//将运算结果压入数据栈

　　}

　　Infuhao( symbol，str[I])；//新符号进栈

　　}

　　}

　　else if(judge(str[i])==4) { //如果此符号是),则出栈运算直到遇到(

　　do { //循环出栈直到遇到(

　　v2=Putshuju(数据);

　　v1=Putshuju(数据);

　　sum=Math(v1，v2，Putfuhao(符号));

　　仁寿州(数据，总和);//将运算结果压入数据栈

　　}while(法官(Randfuhao(符号))!=1);

　　普特富豪（符号);//括号内运算结束后使(出栈

　　}

　　}

　　}

　　免费(str)；//释放内存空间

　　while(symbol.top！=-1) {

　　v2=Putshuju(数据);

　　v1=Putshuju(数据);

　　sum=Math(v1，v2，Putfuhao(符号));

　　仁寿州(数据，总和);

　　}

　　printf(%d ，数据。数据[0])；

　　返回0;

　　}我们来看看演示结果：

　　好了，诸如类似不再演示了，代码讲解我觉得注释就够了，不关注点个赞吗？

　　(5)升级版代码补充更新，看到很多人都觉得上面的代码太简单，为此再更新一个复杂的代码，可以执行科学计算，复杂四则运算：

　　完整代码：运行即可成功

　　#include stdio.h

　　#include stdlib.h

　　#include string.h

　　#包含" windows.h "

　　#包含" math.h "

　　#包含" conio.h "

　　double string to double(char a[1000])

　　{

　　int I=0；

　　char * p=(char *)malloc(1000 * sizeof(char))；

　　int top=0；

　　double sum=0；

　　double mul=1；

　　while(a[i]！=\0 a[i]！=.)

　　{

　　p[top]=a[I]；

　　顶；

　　我；

　　}

　　而（顶！=0)

　　{

　　top-；

　　sum=sum(p[top]-48)* mul；

　　mul=mul * 10

　　}

　　if(a[i]== . )

　　{

　　我；

　　mul=0.1

　　while(a[i]！=\0)

　　{

　　sum=sum(a[I]-48)* mul；

　　mul=mul/10；

　　我；

　　}

　　}

　　返回总和；

　　}

　　结构表达式

　　{

　　双数字

　　茶符号；

　　int ifNum//标志位，1表示数字，0表示符号

　　int end//标志位，标志结构体数据末尾

　　} *表达式1,*表达式2;

　　结构数字堆栈

　　{

　　双*基；

　　} numstack1//计算后缀表达式所需的数据栈

　　结构符号堆栈

　　{

　　char * base

　　} signstack1//符号栈

　　void structExpreRead(结构表达式表达式1[1000])

　　{

　　int I=0；

　　而(表达式1[我]。结束！=1)

　　{

　　如果(表达式1[我]。ifNum==1)

　　{

　　printf(%f ，表达式1[i].num)；

　　我；

　　}

　　其他

　　{

　　printf("% c "，表达式1[i]).签字);

　　我；

　　}

　　}

　　}

　　//四则运算

　　双计算（双一，双b，字符符号)

　　{

　　如果(符号== )

　　返回a b；

　　如果(符号==-)

　　返回b-a；

　　if(sign==* )

　　返回a * b；

　　if(sign==/)

　　返回b/a；

　　}

　　//符号优先级

　　整数(字符x)

　　{

　　if(x==()

　　返回1;

　　if(x== x==-)

　　return 2；

　　if(x==*x==/)

　　返回3;

　　}

　　void stringCopy(char *a，char *b，int start，int length)

　　{

　　int I；

　　int j=0；

　　for(I=start；我开始长度；我)

　　{

　　a[j]=b[I]；

　　j；

　　}

　　a[j]= \ 0 ；

　　}

　　双com(char exp[1000])

　　{

　　int strRead=0，strWrite=0；

　　内部strStart

　　int length=0；

　　双重结构浮动

　　char strCutten[1000]；

　　int I=0；//表达式遍历索引

　　int j=0；//后缀表达式索引

　　int sign top=-1；//符号栈顶指针

　　int sign top 1=-1；//数据栈顶指针

　　int s=0；

　　int k=0；//后缀表达式遍历

　　双甲、乙；//四则运算参数

　　express 1=(struct express *)malloc(strlen(exp)* size of(struct express))；

　　while(exp[strRead]！=\0)

　　{

　　//如果是数字，存进结构体中的数字

　　if(exp[strRead]= 0 exp[strRead]= 9 exp[strRead]==，)

　　{

　　strStart=strRead

　　while(exp[strRead]= 0 exp[strRead]= 9 exp[strRead]== . )

　　{

　　strRead

　　长度；

　　}

　　//截取数字字符串，并转换成数字

　　strncpy(strCutten，exp strStart，length)；

　　str cutten[length]= \ 0 ；

　　strCuttenFloat=string to double(strCutten)；

　　表达式1。num=strCuttenFloat

　　表达式1。ifNum=1；

　　表达式1。end=0；

　　表达式1。符号= o

　　strWrite

　　长度=0;

　　}

　　//如果是符号，存进结构体中的符号

　　其他

　　{

　　表达式1。sign=exp[strRead]；

　　表达式1。ifNum=0；

　　表达式1。end=0；

　　表达式1。num=0；

　　strRead

　　strWrite

　　}

　　}

　　表达式1。end=1；

　　表达式1。ifNum=1；

　　表达式1。符号= o

　　表达式1。num=0；

　　/*下面将表达式转换成后缀表达式*/

　　//符号栈初始化

　　标志堆栈1。base=(char *)malloc(strlen(exp)* sizeof(char))；

　　//后缀表达式初始化

　　express 2=(struct express *)malloc(strlen(exp)* sizeof(struct express))；

　　而(表达式1[我]。结束！=1)

　　{

　　如果(表达式1[我]。ifNum==1)

　　{

　　表达式2[j].num=express 1[I].数字

　　表达式2[j].ifNum=1；

　　j；

　　我；

　　}

　　else if(表达式1[i]).符号==()

　　{

　　信号顶部

　　标志堆栈1。base[sign top]=express 1[I].签字；

　　我；

　　}

　　else if(signum(express 1[I].符号)==2)

　　{

　　if(signtop==-1)

　　{

　　信号顶部

　　标志堆栈1。base[sign top]=express 1[I].签字；

　　我；

　　}

　　其他

　　{

　　while(符号编号(符号堆栈1。base[sign top])==2 sign num(sign stack 1。base[sign top])==3)

　　{

　　表达式2[j].符号=符号堆栈1。base[sign top]；

　　表达式2[j].ifNum=0；

　　j；

　　签名顶部-；

　　if(signtop==-1)

　　打破；

　　}

　　信号顶部

　　标志堆栈1。base[sign top]=express 1[I].签字；

　　我；

　　}

　　}

　　else if(表达式1[i]).sign== * express 1[I].sign==/)

　　{

　　if(signtop==-1)

　　{

　　信号顶部

　　标志堆栈1。base[sign top]=express 1[I].签字；

　　我；

　　}

　　其他

　　{

　　while(符号编号(符号堆栈1。base[sign top]==3))

　　{

　　表达式2[j].符号=符号堆栈1。base[sign top]；

　　表达式2[j].ifNum=0；

　　j；

　　签名顶部-；

　　if(signtop==-1)

　　打破；

　　}

　　信号顶部

　　标志堆栈1。base[sign top]=express 1[I].签字；

　　我；

　　}

　　}

　　其他

　　{

　　如果(表达式1[我]。sign==))

　　{

　　while(signstack1.base[signtop]！=()

　　{

　　表达式2[j].符号=符号堆栈1。base[sign top]；

　　表达式2[j].ifNum=0；

　　j；

　　签名顶部-；

　　}

　　我；

　　签名顶部-；

　　}

　　else if(表达式1[i]).sign==s )

　　{

　　}

　　其他

　　{

　　printf(输入表达式格式不规范！\ n’)；

　　睡眠(2000);

　　出口(1);

　　}

　　}

　　}

　　while(signtop！=-1)

　　{

　　表达式2[j].符号=符号堆栈1。base[sign top]；

　　表达式2[j].ifNum=0；

　　j；

　　签名顶部-；

　　}

　　表达式2[j].end=1；

　　numstack 1。base=(double *)malloc(100 * sizeof(double))；

　　if(numstack1.base==NULL)

　　{

　　printf(\n动态内存分配失败\ n’)；

　　睡眠(2000);

　　出口(1);

　　}

　　而(表达式2[k]。结束！=1)

　　{

　　如果(表达式2[k]).ifNum==1)/*数字直接入栈*/

　　{

　　信号1

　　numstack 1。base[sign top 1]=express 2[k].数字

　　k；

　　}

　　else/*如果是符号*/

　　{

　　a=堆栈1的数量。base[sign top 1]；

　　标志顶1-；

　　b=数量堆栈1。base[sign top 1]；

　　numstack 1。base[sign top 1]=compute(a，b，express 2[k]).签字);

　　k；

　　}

　　}

　　返回num堆栈1。base[sign top 1]；

　　}

　　//结构体用来分别存储表达式中的数字和符号

　　//表达式转换成标准的中缀表达式

　　//操作符分为单目和双目

　　/*

　　*s:罪；徐：反正辛

　　* c:cos；d:arccos

　　*t:谭；g:arctan

　　*问：平方根

　　*左：lg

　　*e:ln

　　*/

　　//检测表达式是否需要化简

　　int ifNeedSimplify(char * express)

　　{

　　int I=0；

　　while(express[I]！=\0)

　　{

　　if(express[I]！= express[I]！=- express[I]！= * express[I]！=/ express[I]！=( express[I]！=))

　　返回1;

　　我；

　　}

　　返回0;

　　}

　　void HideCursor() /*隐藏光标*/

　　{

　　控制台_光标_信息光标_信息={1,0}。

　　SetConsoleCursorInfo(GetStdHandle(STD _ OUTPUT _ HANDLE)，cursor _ info)；

　　}

　　void gotoxy(int x，int y)

　　{

　　坐标c；

　　c . x=x-1；

　　c . y=y-1；

　　SetConsoleCursorPosition(GetStdHandle(STD _ OUTPUT _ HANDLE)，c)；

　　}

　　void setxy(int x，int y)/*列，行*/

　　{ COORD coord={x，y }；

　　SetConsoleCursorPosition(GetStdHandle(STD _ OUTPUT _ HANDLE)，coord)；

　　}

　　void Horizontalline(int x1，int y1，int length)

　　{

　　int I；

　　setxy(x1，y1)；

　　for(I=0；我长度* 2;我)

　　putchar( _ )；

　　}

　　void Verticalline(int x1，int y1，int length)

　　{

　　int I；

　　setxy(x1，y1)；

　　for(I=0；我长度；我)

　　{

　　putchar( )；

　　y1；

　　setxy(x1，y1)；

　　}

　　}

　　void initialSet()

　　{

　　水平线(0,4,18);

　　水平线(0,8,18);

　　水平线(0,12,18);

　　水平线(0,16,18);

　　Verticalline(0，4，14)；

　　垂直的(8,4,14);

　　垂直的(16,4,14);

　　垂直的(24,4,14);

　　垂直的(32,4,14);

　　setxy(3，6)；

　　printf( sin:s )；

　　setxy(1，10)；

　　printf( arcsin:x )；

　　setxy(3，14)；

　　printf( sqrt:q )；

　　setxy(11，6)；

　　printf( cos:c )；

　　setxy(10，10)；

　　printf( arccos:d )；

　　setxy(11.14)；

　　printf(/)；

　　setxy(19.6)；

　　printf( tan:t )；

　　setxy(19.10)；

　　printf( atan:g )；

　　setxy(19.14)；

　　printf(" */")；

　　setxy(27.6)；

　　printf( LG:l )；

　　setxy(27.10)；

　　printf( ln:e )；

　　setxy(27.14)；

　　printf(())；

　　setxy(0.0)；

　　}

　　请参阅clearIn()

　　{

　　setxy(0.1)；

　　printf(“”)；

　　setxy(2.0)；

　　printf(“”)；

　　setxy(0.0)；

　　}

　　请参阅清除()

　　{

　　setxy(0.20)；

　　printf(“”)；

　　}

　　int main()

　　{

　　while(1)}

　　茶表示[1000];

　　内部i=0，j=1

　　内部启动；

　　char str1[1000]，编号Str[1000]，str 2[1000]；//将表达出来分成三个部分

　　int bracketsnum=1

　　double sinValue、cosValue、tanValue、qValue、logValue、lnValue、arcsinValue、arccosValue、arctanvalue

　　char num char[1000]；

　　内部s=0

　　坦克暂停；

　　initialSet():

　　printf(请输入表达式：\ n)；

　　获取(表示式);

　　而(表示[我]！=\0)//缺陷：无里面不能实现函数的嵌套。犯罪函数必须带括号。

　　{

　　如果(表示[I]= s )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　sin value=sin(com(num str))；

　　gcvt(sinValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= c )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　cos value=cos(com(num str))；

　　gcvt(cosValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= t )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　tan value=tan(com(num str))；

　　gcvt(tanValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= q )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　q值=sqrt(com(num str))；

　　gcvt(qValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= l )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　logValue=log10(com(编号str))；

　　gcvt(logValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]==e])

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　ln value=log(com(num str))；

　　gcvt(lnValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= x )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　arcsinvalue=asin(com(num str))；

　　gcvt(arcsinValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= d )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　arccos value=acos(com(num str))；

　　gcvt(arccosValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　else if(表示[I]= g )

　　{

　　开始=I；

　　//截取表达出来的第一个片段

　　stringCopy(str1、express、0、starti

　　//读取不要函数中的表达式

　　I=I2

　　而(支架！=0)

　　{

　　如果(表示[i]==()

　　支架；支架；

　　如果(表示[i]=)

　　支架-;

　　(i)；

　　}

　　bracketsnum=1

　　//截取表达出来的第二个片段

　　字符串拷贝(编号str、express、starti 2、I-start ti-3)；

　　//数字片段进行计算

　　arctan value=atan(com(num str))；

　　gcvt(arctanValue，I-start ti-2，num char)；

　　//截取表达出来的第三个片段

　　stringCopy(str2、expre、I、strlen(expre)-3)；

　　//三个片段重新拼接成表达出来

　　strcat(str1，num char)；

　　strcat(str1、str 2)；

　　strcpy(表示str 1)；

　　}

　　其他语句

　　{

　　(i)；

　　}

　　}

　　setxy(0.20)；

　　printf("% f \ n，com(表示));

　　pause=get har()；

　　清除()；

　　setxy(0.0)；

　　clear in()；

　　}

　　系统("暂停");

　　}欢迎你加群与我一起交流：813269919

　　来自51吨重博客作者wx62a0461bcb0eb的原创作品，

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。