operate函数C语言,假设函数operate的部分c代码如下

C语言 编程计算Y=5+7(X-6)/9

- -|| 忍不住吐槽。。二楼的童鞋写的程序好长啊。。。有必要吗

创新互联专注于企业营销型网站、网站重做改版、翼城网站定制设计、自适应品牌网站建设、H5网站设计、购物商城网站建设、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为翼城等各大城市提供网站开发制作服务。

#includestdio.h

int main()

{

double x,y; // 有除法的题要注意一下，计算机中，整数除法是不准的。。。会省掉余数

printf("please input x"); //所谓的提示句子，我做作业时一般都不写= =!

scanf("%lf",x); //这里要注意一下地是，double型的数据输入用 lf 。我经常习惯性地写 d

printf("Y=5+7(x-6)/9\n"); // 又一句提示，可有可无

y=5+7*(x-6)/9;

printf("%g\n",y);

}

其实用函数去写的话会是整段代码好看些，至少简洁一点。不过我写这么短的代码的时候除非特意练习函数，否则一般都不用的。

我注意看了一下1L，发现输出写错了- -！printf 的实数一律统一 %f 无论是单精度还是双精度

不过我一般习惯用 %g 因为这种输出会省掉后面不必要的零

如何用C语言实现多个操作数的基本四则运算

#include stdlib.h

#include math.h

#include conio.h

#include stdio.h

#include string.h

void SplitPrem(char *str);

float Combine();

char str[200],str1[200],str2[50][30],operate_c[50],sub_str[30];

int operate_2str[50];

int strnum=0,operatenum=0; /* 子字符串个数，操作符个数 */

int i,j,k,flag;

float f=0.0,str_f[50];

void main()

{

float temp;

printf("请输入一个字符串表达式:\n");

gets(str);

strcpy(str1,str);

SplitPrem(str1);

temp=Combine();

printf("%s=%g\n",str,temp);

}

/* 分解为子字符串和操作符 */

void SplitPrem(char *str1)

{

j=strlen(str1);

sub_str[0]=str1[0];

k=1;

for( i=1; ij; i++)

{

if(str1[i]=='*'||str1[i]=='/'||str1[i]=='+'||str1[i]=='-')

{

sub_str[k]=0;

strcpy(str2[strnum],sub_str);

operate_c[operatenum]=str1[i];

operate_2str[operatenum]=strnum;

strnum++;

operatenum++;

k=0;

}

else

{

sub_str[k]=str1[i];

k++;

}

}

if(k0)

{

sub_str[k]=0;

strcpy(str2[strnum],sub_str);

strnum++;

}

for( i=0; istrnum; i++)

str_f[i]=atof(str2[i]); /* 字符串转化为浮点数 */

}

/*先计算乘除，后计算加减，每计算一次，子字符串和操作符向前移动 */

float Combine()

{

while(1)

{

flag=0;

for( i=0; ioperatenum; i++)

{

if(operate_c[i]=='*'||operate_c[i]=='/')

{

if(operate_c[i]=='*')

{

f=str_f[operate_2str[i]]*str_f[operate_2str[i]+1];

str_f[operate_2str[i]]=f;

for( j=i; joperatenum-1; j++)

{

operate_c[j]=operate_c[j+1];

operate_2str[j]=operate_2str[j+1]-1;

}

for( j=operate_2str[i]+1; jstrnum-1; j++)

str_f[j]=str_f[j+1];

operatenum=operatenum-1;

strnum=strnum-1;

flag=1;

}

else

{

f=str_f[operate_2str[i]]/str_f[operate_2str[i]+1];

str_f[operate_2str[i]]=f;

for( j=i; joperatenum-1; j++)

{

operate_c[j]=operate_c[j+1];

operate_2str[j]=operate_2str[j+1]-1;

}

for( j=operate_2str[i]+1; jstrnum-1; j++)

str_f[j]=str_f[j+1];

operatenum=operatenum-1;

strnum=strnum-1;

flag=1;

}

}

}

if(flag==0)break;

}

while(1)

{

flag=0;

for( i=0; ioperatenum; i++)

{

if(operate_c[i]=='+'||operate_c[i]=='-')

{

if(operate_c[i]=='+')

{

f=str_f[operate_2str[i]]+str_f[operate_2str[i]+1];

str_f[operate_2str[i]]=f;

for( j=i; joperatenum-1; j++)

{

operate_c[j]=operate_c[j+1];

operate_2str[j]=operate_2str[j+1]-1;

}

for( j=operate_2str[i]+1; jstrnum-1; j++)

str_f[j]=str_f[j+1];

operatenum=operatenum-1;

strnum=strnum-1;

flag=1;

}

else

{

f=str_f[operate_2str[i]]-str_f[operate_2str[i]+1];

str_f[operate_2str[i]]=f;

for( j=i; joperatenum-1; j++)

{

operate_c[j]=operate_c[j+1];

operate_2str[j]=operate_2str[j+1]-1;

}

for( j=operate_2str[i]+1; jstrnum-1; j++)

str_f[j]=str_f[j+1];

operatenum=operatenum-1;

strnum=strnum-1;

flag=1;

}

}

}

if(flag==0)break;

}

return f;

}

C语言中这是什么意思

声明一个myCOperate *型指针pOperate，并用strOperateField和调用函数RUNTIME_CLASS(myCOperate)的返回值调用函数etOperate，把函数etOperate的返回值赋给指针pOperate。

一个小的C语言问题

#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */

#define STACKINCREMENT 2 /* 存储空间分配增量 */

typedef struct SqStack

{

SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */

SElemType *top; /* 栈顶指针 */

int stacksize; /* 当前已分配的存储空间，以元素为单位 */

}SqStack; /* 顺序栈 */

Status InitStack(SqStack *S)

{ /* 构造一个空栈S */

(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));

if(!(*S).base)

exit(OVERFLOW); /* 存储分配失败 */

(*S).top=(*S).base;

(*S).stacksize=STACK_INIT_SIZE;

return OK;

}

Status GetTop(SqStack S,SElemType *e)

{ /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */

if(S.topS.base)

{

*e=*(S.top-1);

return OK;

}

else

return ERROR;

}

Status Push(SqStack *S,SElemType e)

{ /* 插入元素e为新的栈顶元素 */

if((*S).top-(*S).base==(*S).stacksize) /* 栈满 */

return ERROR;

*((*S).top)++=e;

return OK;

}

Status Pop(SqStack *S,SElemType *e)

{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */

if((*S).top==(*S).base)

return ERROR;

*e=*--(*S).top;

return OK;

}

#includestdio.h

#includestdlib.h /* atoi() */

#includemath.h

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

/* 表达式求值(范围为int类型,输入负数要用(0-正数)表示) */

typedef int SElemType; /* 栈元素类型为整型,改进算法3.4 */

#include"stack.h"

SElemType Precede(SElemType t1,SElemType t2)

{ /* 根据教科书表3.1，判断两符号的优先关系 */

SElemType f;

switch(t2)

{

case '+':

case '-':if(t1=='('||t1=='=')

f='';

else

f='';

break;

case '*':

case '/':if(t1=='*'||t1=='/'||t1==')')

f='';

else

f='';

break;

case '(':if(t1==')')

{

printf("ERROR1\n");

exit(ERROR);

}

else

f='';

break;

//将此函数补充完整

//......

return f;

}

Status In(SElemType c)

{ /* 判断c是否为运算符 */

switch(c)

{

case'+':

case'-':

//将此函数补充完整

//......

}

}

SElemType Operate(SElemType a,SElemType theta,SElemType b)

{

SElemType c;

switch(theta)

{

case'+':c=a+b;

break;

//将此函数补充完整

//......

}

return c;

}

SElemType EvaluateExpression()

{ /* 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈 */

SqStack OPTR,OPND;

SElemType a,b,d,x,theta;

char c; /* 存放由键盘接收的字符串 */

char z[6]; /* 存放整数字符串 */

int i;

InitStack(OPTR); /* 初始化运算符栈 */

Push(OPTR,'='); /* =是表达式结束标志 */

InitStack(OPND); /* 初始化运算数栈 */

c=getchar();

GetTop(OPTR,x);

while(c!='='||x!='=')

{

if(In(c)) /* 是7种运算符之一 */

switch(Precede(x,c))

{

case'':Push(OPTR,c); /* 栈顶元素优先权低 */

c=getchar();

break;

//将此函数补充完整

//......

}

else if(c='0'c='9') /* c是操作数 */

{

//将此函数补充完整

//......

}

else /* c是非法字符 */

{

printf("ERROR3\n");

exit(ERROR);

}

GetTop(OPTR,x);

}

GetTop(OPND,x);

return x;

}

void main()

{

printf("请输入算术表达式,负数要用(0-正数)表示,并以=结束\n");

printf("%d\n",EvaluateExpression());

}

C语言程序

我这个程序使用了栈这个数据结构,功能是:任意输入一个数学表达式以#结束,可以包括小括号,其他括号不行,我这个程序功能挺强的,可有任意位数,你运行试一下:

//此表达式求值程序功能：运算数可以是任意位数，可以是负数，可以含任意对匹配的括号

//如，-8+3*(-8+23)-12#;另外还有简单的表达式输入错误的判断的功能，

//括号不匹配，运算符多输入或少输入；

#includemalloc.h

#includestdio.h

#define error -1

typedef struct snode1{

int data;

struct snode1*next;

}snode1,*linkstack1;

typedef struct snode2{

char c;

struct snode2*next;

}snode2,*linkstack2;

initstack1(linkstack1*s)

{

*s=(linkstack1)malloc(sizeof(snode1));

(*s)-next=NULL;

}

initstack2(linkstack2*s)

{

*s=(linkstack2)malloc(sizeof(snode2));

(*s)-next=NULL;

}

int popstack1(linkstack1 s)

{

int e;

linkstack1 p;

if(!(s-next))

{ printf("The stack is empty.");return error; }

p=s-next;

e=p-data;

s-next=p-next;

free(p);

return e;

}

pushstack1(linkstack1 s,int x)

{linkstack1 p;

p=(linkstack1)malloc(sizeof(snode1));

p-data=x;

p-next=s-next;

s-next=p;

}

char popstack2(linkstack2 s)

{char e;linkstack2 p;

if(!(s-next))

{

printf("The stack is empty.");return '\0'; }

p=s-next;

e=p-c;

s-next=p-next;

free(p);

return e;

}

pushstack2(linkstack2 s,char x)

{linkstack2 p;

p=(linkstack2)malloc(sizeof(snode2));

p-c=x;

p-next=s-next;

s-next=p;

}

Gettopstack1(linkstack1 s)

{if(!(s-next))

{printf("The stack is empty .");return error;

}

return (s-next-data);

}

char Gettopstack2(linkstack2 s)

{

if(!(s-next))

{printf("The stack is empty .");return '\0';

}

return(s-next-c);

}

char Precede(char c1,char c2)//此函数功能为：比较两运算符的优先级，定义了两个整

{int a,b; //形变量与这两运算符相对应，依据这两优先级，巧妙设置两变量的值

switch(c1) //通过这两整形变量值的大小判定两运算符的优先级

{case'+':

case'-':a=2;break;

case'*':

case'/':a=4;break;

case'#':a=-1;break;

case'(':a=0;break;

case')':a=5;break;

}

switch(c2)

{case'+':

case'-':b=1;break;

case'*':

case'/':b=3;break;

case'#':b=-1;break;

case'(':b=5;break;

case')':b=0;break;

}

if(a==b)return('=');

else if(ab)return('');

else return('');

}

int In(char c)//判定是否是运算符

{ int a;

switch(c)

{case'+':

case'-':

case'*':

case'#':

case'(':

case')':

case'/':a=1;break;

default:a=0;

}

return a;

}

operate(int a,int b,char c)//进行二元运算a@b;

{int x;

switch(c)

{case'+':x=a+b;break;

case'-':x=a-b;break;

case'*':x=a*b;break;

case'/':x=a/b;break;

}

return (x);

}

In2(char ch)//以下这三个函数是判定括号是否匹配

{ int a;

switch(ch)

{case'(':

case'[':

case'{':a=1;break;//这个函数判定是不是括号，左括号还是右括号

case')':

case']':

case'}':a=2;break;

default:a=0;

}

return a;

}

match1(char c1,char c2)//判定这两个括号是不是匹配

{int a;int b;

switch(c1)

{case'(':a=1;break;

case'[':a=2;break;

case'{':a=3;break;

}

switch(c2)

{case')':b=1;break;

case']': b=2;break;

case'}':b=3;break;

}

if(a==b)return 1;

else return 0;

}

match(char*s)

{linkstack2 p;//这是判定整个表达式括号匹配的主导函数，利用了栈这个数据结构

int a ;

initstack2(p);

while(*s)

{a=In2(*s);

if(a==1){pushstack2(p,*s);s++; }

else if(a==2)

{

if(match1(popstack2(p),*s))s++;

else return 0;

}

else s++;

}

if(!(p-next)) return 1;

else return 0;

} //到这里为止

IsRight(char ch1,char ch2)

{

if(In(ch1)In(ch2))

{if(ch2=='('ch1!=')')return 1;

else if(ch1==')'ch2!='(')return 1;

else return 0;

}

else return 1;

}

int EvaluateExpreession()

{char *s,*t,ch;int i=0, sum,a,b,total;

linkstack1 opnd;linkstack2 optr;

initstack1(opnd);

initstack2(optr);pushstack2(optr,'#');

t=(char*)malloc(20*sizeof(char));//为t分配空间

gets(t);//将输入的表达式先保存在字符窜t中

if(!match(t)){printf("syn Erroe!"); return error; }//判定输入的表达式中括号是否匹配，

//如果不的话，输入错误

s=(char*)malloc(30*sizeof(char));//对表达式中的第一个字符进行处理，如果是'－'的话

if(*t=='-')s[i++]='0';//在它前面补0，如果是＋的话，则应将其去掉：这两种不能视为错误

if(*t=='+'(t[1]=='('||!In(t[1])))t++;//应看作视冗余，我们应处理一下

ch=*t;

t++;

while(*t)//下面这个循环功能是：将这样的输入进行处理－－（－2－－－）和（+2－－－）

{ //方法是在负号前补0，将多余的+去除

if(ch=='('*t=='-')

{s[i++]=ch;s[i++]='0';}

else if(ch=='('*t=='+')

{t++;s[i++]=ch;}

else s[i++]=ch;

ch=*t;t++;

}

s[i]=ch;//到这里经过处理后的字符窜都已经存在了s中了

ch=*s++;

while(ch!='#'||Gettopstack2(optr)!='#')//以下为计算的主体部分

{

if(!In(ch))

{ sum=0;

while(!(In(ch)))//如果是数字，则将其放入整形变量sum中，并不断循环，直至

{ //不是数字为止，最后压入栈中，因此这起到了多位数的计算功能

sum=10*sum+ch-48;

if(*s=='#')ch=*s;

else ch=*s++;

}

pushstack1(opnd,sum);

}

// if(!IsRight(ch,*s)){printf("Syn Error!");return error; }

switch(Precede(Gettopstack2(optr),ch))//如果遇到运算符，则将其与栈顶的运算符

{ //进行优先级的比较

case'':pushstack2(optr,ch);ch=*s++;break;//如果栈顶中的低，则将其压入运算符栈中

case'=':popstack2(optr); ch=*s++; break;//如果相等，那么是遇到了左右括号，两都仍掉

case'': //如果栈中高，则进行计算

if(!(opnd-next)){printf("Syn Error!");return;} //如果数栈中竟然没数，则说明表达式输入错误

else b=popstack1(opnd);

if(!(opnd-next)){printf("Syn Error!");return;}

else a=popstack1(opnd);

total=operate(a,b,popstack2(optr));

pushstack1(opnd,total);break;

}

}

if(opnd-next-next){printf("Syn Error!");return;}//运算结束后，数栈中还有两个以上数，则说明表达式错误

printf("biao da shi zhi shi %d ", Gettopstack1(opnd));

}

main()

{

printf("please input the biaodashi:");

EvaluateExpreession();

}

求一个C语言算术表达式求值程序

我的能运行!!但表达式末尾加要加#

例如2+3要打2+3#

#includecstdio

#includemalloc.h

#define NULL 0

typedef struct node{

char date;

struct node *next;

}SNode;

SNode *InitStack(){

SNode *top;

top=(SNode *)malloc(sizeof(SNode));

top-next=NULL;

return top;

}

void PushOptr(SNode *top,char x){

SNode *p;

p=(SNode *)malloc(sizeof(SNode));

p-date=x;

p-next=top-next;

top-next=p;

}

char PopOptr(SNode *top){

SNode *p;

char x;

if(top==NULL)

return NULL;

p=top-next;

x=p-date;

top-next=p-next;

free(p);

return x;

}

void PushOpnd(SNode *top,char x){

SNode *p;

p=(SNode *)malloc(sizeof(SNode));

p-date=x;

p-next=top-next;

top-next=p;

}

char PopOpnd(SNode *top){

SNode *p;

char x;

if(top==NULL)

return NULL;

p=top-next;

x=p-date;

top-next=p-next;

free(p);

return x;

}

char GetTop(SNode *top){

return (top-next)-date;

}

int In(char c){

int n;

switch(c){

case '+':

case '-':

case '*':

case '/':

case '(':

case ')':

case '#':n=1;break;

default:n=0;break;

}

return n;

}

char Precede(char x,char y){

int i,j;

int form[7][7]={{1,1,-1,-1,-1,1,1},{1,1,-1,-1,-1,1,1},{1,1,1,1,-1,1,1},{1,1,1,1,-1,1,1},{-1,-1,-1,-1,-1,0,2},{1,1,1,1,2,1,1},{-1,-1,-1,-1,-1,2,0}};

switch(x){

case '+':i=0;break;

case '-':i=1;break;

case '*':i=2;break;

case '/':i=3;break;

case '(':i=4;break;

case ')':i=5;break;

case '#':i=6;break;

}

switch(y){

case '+':j=0;break;

case '-':j=1;break;

case '*':j=2;break;

case '/':j=3;break;

case '(':j=4;break;

case ')':j=5;break;

case '#':j=6;break;

}

if(form[i][j]==1)

return '';

else

if(form[i][j]==-1)

return '';

else

return '=';

}

int Operate(char x,char z,char y){

int a=x-'0',b=y-'0';

switch(z){

case '+':return a+b;

case '-':return a-b;

case '*':return a*b;

case '/':return a/b;

}

}

char Eval_Exp(){

char a,b,c,r,f,z;

int result;

SNode *top[2];

top[0]=InitStack();

PushOptr(top[0],'#');

top[1]=InitStack();

c=getchar();

while(c!='#'||(GetTop(top[0]))!='#'){

if(!In(c)){

PushOpnd(top[1],c);

c=getchar();

}

else{

r=Precede(GetTop(top[0]),c);

switch(r){

case '':PushOptr(top[0],c);

c=getchar();

break;

case '=':PopOptr(top[0]);

c=getchar();

break;

case '':b=PopOptr(top[0]);

a=PopOpnd(top[1]);

z=PopOpnd(top[1]);

result=Operate(z,b,a);

f=result+'0';

PushOpnd(top[1],f);

break;

}

}

}

return f;

}

void main(){

char result;

result=Eval_Exp();

printf("%d\n",result-'0');

}