表达式的求值（c语言）

编写程序对表达式求值C语言~

#include "stdio.h"
#include "malloc.h"

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
//构造一个空栈
Status InitStack(SqStack *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 StackEmpty(SqStack S){
if(S.top == S.base)
return TRUE;
else
return FALSE;
}
//用e返回S的顶元素
Status GetTop(SqStack S, SElemType *e){
if(S.top == S.base)
return ERROR;
*e = *(S.top-1);
return OK;
}
//插入e为新的顶元素
Status Push(SqStack *S, SElemType e){
if((S->top - S->base) >= S->stacksize){
S->base = (
SElemType*)realloc(S->base,
(S->stacksize+STACKINCREMENT)*sizeof(SElemType)
);
if(!S->base)
exit(OVERFLOW);
S->top = S->base +S->stacksize;
S->stacksize += STACKINCREMENT;
}
*(S->top)=e;
S->top++;
return OK;
}
//删除S的顶元素，并用e返回其值
Status Pop(SqStack *S, SElemType *e){
if(S->top == S->base)
return ERROR;
S->top--;
*e = *(S->top);
return OK;
}
//从栈底到栈顶依次对S的每个元素调用函数Visit（），一旦失败操作无效
Status ListTraverse(SqStack S,Status (*visit)(SElemType)){
SElemType *p;
p=S.base;
for(p=S.base;p<S.top;p++)
(*visit)(*p);

return OK;
}
//输出元素e
Status output(SElemType e){
printf("%d ",e);

return OK;
}

实现表达式求值的代码：
/*计算整数表达式的值
*表达式必须以#结束
*表达式中可以出现多位数字，
*表达式中可以出现空格
*运算符包括+,-,*,/,(,)
*运算结果可以是多位整数，并以整数的形式返回
*/
typedef int SElemType; /*放入堆栈的元素的类型*/
#include
#include "stack_s.c"
/*判断输入的某个字符是否是运算符
*c表示输入的字符
*op数组中存放系统能识别的运算符
*/
Status in(char c,char op[]){
char *p;
p=op;
while(*p != '\0'){
if(c == *p)
return TRUE;
p++;
}
return FALSE;
}
/*比较两个运算符的优先级
*a，b中存放待比较的运算符
*'>'表示a>b
*'0'表示不可能出现的比较
*/
char Precede(char a, char b){
int i,j;
char pre[][7]={
/*运算符之间的优先级制作成一张表格*/
{'>','>','','>'},
{'>','>','','>'},
{'>','>','>','>','','>'},
{'>','>','>','>','','>'},
{'<','<','<','<','<','=','0'},
{'>','>','>','>','0','>','>'},
{'<','<','<','<','<','0','='}};
switch(a){
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(b){
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;
}
return pre[i][j];
}
/*进行实际的运算
*a，b中分别以整数的形式存放两个待运算的操作数
*theta中存放代表操作符的字符
*结果以整数的形式返回
*/
int Operate(int a, char theta, int b){
int i,j,result;
i=a;
j=b;

switch(theta) {
case '+': result = i + j; break;
case '-': result = i - j; break;
case '*': result = i * j; break;
case '/': result = i / j; break;
}
return result;
}
/*从输入缓冲区中获得下一个整数或运算符，并通过n带回到主调函数
*返回值为1表示获得的是运算符
*返回值为0表示获得的是整形操作数
*/
int getNext(int *n){
char c;
*n=0;
while((c=getchar())==' '); /*跳过一个或多个空格*/
if(!isdigit(c)){ /*通过函数判断如果字符不是数字，那么只能是运算符*/
*n=c;
return 1;
}
do { /*能执行到该条语句，说明字符是数字，此处用循环获得连续的数字*/
*n=*n*10+(c-'0'); /*把连续的数字字符转换成相对应的整数*/
c=getchar();
} while(isdigit(c)); /*如果下一个字符是数字，进入下一轮循环*/
ungetc(c,stdin); /*新读入的字符不是数字，可能是运算符,为了不影响下次读入，把该字符放回到输入缓冲区*/
return 0;
}

int EvaluateExpression(){

int n;
int flag;
int c;
char x,theta;
int a,b;

char OP[]="+-*/()#";
SqStack OPTR;
SqStack OPND;

InitStack(&OPTR);
Push(&OPTR,'#');
InitStack(&OPND);
flag=getNext(&c);

GetTop(OPTR, &x);
while(c!='#' || x != '#')
{
if(flag == 0)
{
Push(&OPND,c);
flag = getNext(&c);
} else
{
GetTop(OPTR, &x);
switch(Precede(x, c))
{
case '<'://栈顶元素优先级低
Push(&OPTR,c);
flag = getNext(&c);
break;
case '='://脱括号并接受下一字符
Pop(&OPTR,&x);
flag = getNext(&c);
break;
case '>'：// 退栈并将运算结果入栈
Pop(&OPTR, &theta);
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND, Operate(a, theta, b));
break;
}
}
GetTop(OPTR, &x);
}
GetTop(OPND, &c);
return c;
}

void main(){
int c;
printf("Please input one expression:");
c=EvaluateExpression();
printf("Result=%d
",c);
getch();
}

//表达式求值
//By:jimly
//10/10/2009
//例如：输入2+2（4-6*3）=
//以"="结束,然后回车即出结果
#include
#include
#include
#include
typedef float ElemType;
typedef struct Stack
{
ElemType *base; // 栈基址
ElemType *top; // 栈顶
int stacksize; // 栈存储空间的尺寸
} SqStack;
/*------------------------------------------------------------
// 栈的基本操作
------------------------------------------------------------*/
bool InitStack(SqStack *S);
bool InitStack(SqStack *S);
void DestroyStack(SqStack *S);
bool StackEmpty(SqStack S);
int StackLength(SqStack S);
ElemType GetTop(SqStack S, ElemType *e);
void StackTraverse(SqStack S, void (*fp)(ElemType));
bool Push(SqStack *S, ElemType e);
bool Pop(SqStack *S, ElemType *e);
/*------------------------------------------------------------
// 表达式求值的操作函数定义
------------------------------------------------------------*/
char Precede(char A1,char A2);
ElemType Operate(ElemType a,ElemType theta,ElemType b);
bool In(char c,char op[]);
ElemType EvaluateExpression();
void Menu();//////////////////////////////////////////////
// Eval_exdivssion.cpp 表达式求值实现函数 //
//////////////////////////////////////////////
/*------------------------------------------------------------
操作目的： 判定运算符栈的栈顶运算符A1和读入的运算符A2之间优先关系的函数
初始条件： 无
操作结果： 判断出优先关系
函数参数：
char A1 运算符
char A2 运算符
返回值：
char 大小关系
------------------------------------------------------------*/
char Precede(char A1,char A2)
{
if (A1 == '+' || A1 == '-')
{
if (A2 == '+' || A2 == '-' || A2 == ')' || A2 == '=')
{
return '>';
}
else
return '<';
}
if (A1 == '*' || A1 == '/')
{
if (A2 == '(')
{
return '<';
}
else
return '>';
}
if (A1 == '(')
{
if (A2 == ')')
{
return '=';
}
if (A2 == '=')
{
return 'E';
}
else
return '<';
}
if (A1 == ')')
{
if (A2 == '(')
{
return 'E';
}
if (A2 == '=')
{
return 'E';
}
else
return '>';
}
if (A1 == '=')
{
if (A2 == '=')
{
return '=';
}
else
return '<';
}
else
return '=';
}
/*------------------------------------------------------------
操作目的： 二元运算a与b的函数
初始条件： 无
操作结果： 返回运算结果
函数参数：
ElemType a 操作数
ElemType theta 操作符
ElemType b 操作数
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType Operate(ElemType a,ElemType theta,ElemType b)
{
switch(char(theta))
{
case '+':
return a += b;
break;
case '-':
return a -= b;
break;
case '*':
return a *= b;
break;
case '/':
if(b==0)
{
printf("除数不能为0！！
");
exit(0);
}
return a /= b;
break;
} return 0;
}
/*------------------------------------------------------------
操作目的： 判断字符c是否属于运算符集合op
初始条件： 无
操作结果： 返回判断结果
函数参数：
char c 要判断的字符
char op[] 运算符集合
返回值：
bool 属于返回true 否则返回false
------------------------------------------------------------*/
bool In(char c,char op[])
{
for (int i = 0;i<7;i++)
{
if (op[i] == c)
return true;
}
return false;
}
/*------------------------------------------------------------
操作目的： 算术表达式求值的运算符优先算法
初始条件： 无
操作结果： 返回表达式的值
函数参数：
无
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType EvaluateExpression()
{
SqStack OPTR; //运算符栈
SqStack OPND; //运算数栈
char Ct = '='; //判断是否结束的标识
int i = 0,j = 1;
ElemType e = 0,t = 0,c;
char op[7] = {'+','-','*','/','(',')','='}; InitStack(&OPTR); //初始化
Push(&OPTR,Ct);
InitStack(&OPND); //初始化 c = (float)getchar();
while (c!='=' || GetTop(OPTR,&e)!='=')
{
if (!In((char)c,op)) //不是运算e符进栈
{
while(!In((char)c,op)) //可以是几位数
{
t = t*10+(c-48);
c = (float)getchar();
}
Push(&OPND,t);
t = 0;
} else
{
switch (Precede((char)GetTop(OPTR,&e),(char)c))
{
case '<'://栈顶元素优先权低
Push(&OPTR,c);
c = (float)getchar();
break;
case '='://脱括号并接受下个字符
ElemType x;
Pop(&OPTR,&x);
c = (float)getchar();
break;
case '>'://退栈并将运算结果入栈
ElemType b,theta,a;
Pop(&OPTR,&theta);
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND,Operate(a,theta,b));
break;
case 'E':
printf("括号不匹配！！
");
exit(0);
break;

}
}
}
ElemType tem = GetTop(OPND,&e);
DestroyStack(&OPND);
DestroyStack(&OPTR);
return tem;
}/***
*DynaSeqStack.cpp - 动态顺序栈，即栈的动态顺序存储实现
****/
const int STACK_INIT_SIZE = 100; // 初始分配的长度
const int STACKINCREMENT = 10; // 分配内存的增量
/*------------------------------------------------------------
操作目的： 初始化栈
初始条件： 无
操作结果： 构造一个空的栈
函数参数：
SqStack *S 待初始化的栈
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool InitStack(SqStack *S)
{
assert(S != NULL);
S->base = (ElemType *)malloc(sizeof(ElemType) * STACK_INIT_SIZE);

if(S->base == NULL) return false; S->top = S->base;
S->stacksize = STACK_INIT_SIZE; return true;
}/*------------------------------------------------------------
操作目的： 销毁栈
初始条件： 栈S已存在
操作结果： 销毁栈S
函数参数：
SqStack *S 待销毁的栈
返回值：
无
------------------------------------------------------------*/
void DestroyStack(SqStack *S)
{
assert(S != NULL); free(S->base);
S->top = S->base = NULL;
}/*------------------------------------------------------------
操作目的： 判断栈是否为空
初始条件： 栈S已存在
操作结果： 若S为空栈，则返回true，否则返回false
函数参数：
SqStack S 待判断的栈
返回值：
bool 是否为空
------------------------------------------------------------*/
bool StackEmpty(SqStack S)
{
assert((S.base != NULL) && (S.top != NULL));
return(S.base == S.top);
}/*------------------------------------------------------------
操作目的： 得到栈的长度
初始条件： 栈S已存在
操作结果： 返回S中数据元素的个数
函数参数：
SqStack S 栈S
返回值：
int 数据元素的个数
------------------------------------------------------------*/
int StackLength(SqStack S)
{
assert((S.base != NULL) && (S.top != NULL));
return(S.top-S.base);
}/*------------------------------------------------------------
操作目的： 得到栈顶元素
初始条件： 栈S已存在
操作结果： 用e返回栈顶元素
函数参数：
SqStack S 栈S
ElemType *e 栈顶元素的值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
ElemType GetTop(SqStack S, ElemType *e)
{
assert((S.base != NULL) && (S.top != NULL));
if(StackEmpty(S)) return false; *e = *(S.top-1);
return *e;
}/*------------------------------------------------------------
操作目的： 遍历栈
初始条件： 栈S已存在
操作结果： 依次对S的每个元素调用函数fp
函数参数：
SqStack S 栈S
void (*fp)() 访问每个数据元素的函数指针
返回值：
无
------------------------------------------------------------*/
void StackTraverse(SqStack S, void (*fp)(ElemType))
{
assert((S.base != NULL) && (S.top != NULL));
for(; S.base<S.top; S.base++) (*fp)(*S.base);
}/*------------------------------------------------------------
操作目的： 压栈——插入元素e为新的栈顶元素
初始条件： 栈S已存在
操作结果： 插入数据元素e作为新的栈顶
函数参数：
SqStack *S 栈S
ElemType e 待插入的数据元素
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Push(SqStack *S, ElemType e)
{
if (S->top - S->base>=S->stacksize)
{
S->base = (ElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT) * sizeof(ElemType));
if (!S->base)
exit(0);
S->top = S->base + S->stacksize;
S->stacksize += STACKINCREMENT;
}
*S->top++ = e; return true;
}/*------------------------------------------------------------
操作目的： 弹栈——删除栈顶元素
初始条件： 栈S已存在且非空
操作结果： 删除S的栈顶元素，并用e返回其值
函数参数：
SqStack *S 栈S
ElemType *e 被删除的数据元素值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Pop(SqStack *S, ElemType *e)
{
if(S == NULL) return false;
assert((S->base != NULL) && (S->top != NULL));
if(StackEmpty(*S)) return false; *e = *(--S->top);
return true;
}//////菜单///////
void Menu()
{
printf("表达式求值模拟程序

");

printf("功能菜单：
");
printf("==============
");
printf("[1] 输入表达式并求值
");
printf("[0] 退出
");
printf("==============
");
printf("请输入你的选择(0~1)（以回车结束）：");
}///////// 主函数 ///////////
//////////////////////////////
int main()
{
char ch = ' ',tp; do
{
system("cls");
Menu();
ch = getchar();
if (ch == '0')
break;
tp = getchar();
printf("请输入一个表达式（最后输入”=“,然后回车出结果）：");
printf("这个表达式结果为：%g
",EvaluateExpression());
tp = getchar();
printf("任意键继续...");
getch();
} while (true); return 0;
}//end

c语言有丰富的表达式，这是它的特点之一，表达式主要有4类，算术表达式，赋值表达式，逗号表达式，关系表达式
1.算术表达式就是包含算术运算符（如+ - / * %等）的表达式（不是语句，后面没有分号），如：a+b ，a%b，a+b-c*d，3+5等，算术表达式的值就是最后算出的结果，如3+5这个表达式的值就是8
2.赋值表达式，就是含有赋值运算符=的表达式，如a=5，b=3，c='A'等，=左边的a,b,c称为左值，必须为变量，=右边的5,3,'A'称为右值，必须为常量，赋值表达式的值为右值，如a=3的值为3，c='A'的值为字母A的ascii码65（当然也可以认为它的值就是字母A）
3.逗号表达式就是含有逗号的表达式，形式：表达式1，表达式2，表达式3.......如a,b,c 3,5,7 a=3,b=4,c=6 3,a=5,b=6等 逗号表达式的值为，最右边的表达式的值，如3,4,5的值就是5，表达式a=3,b=4,c=6的值就是表达式b=6的值，由上述分析知，表达式b=6的值就是6，所以表达式a=3,b=4,c=6的值就是6
4.关系表达式，指含有关系运算符（如> < >= == =<等）的表达式（其实也是算术表达式的一种）如a>b,a>6,6>5,3<2,4==6等，如果表达式的关系是正确的，那么表达式的值为1，否则为0
如6>5正确，表达式的值为1,3<2,和4==6错误，表达式的值为0
当然可以细分为很多种表达式，不过主要也就是这几种的变型，希望对你有所帮助

饿？无题无真相
#include <stdio.h>
void main()
{
int a,b,sum;
scanf("%d%d",&a,&b);
sum=a+b;
printf("a+b=",sum);
}

运行结果：
输入 12 15
输出 27

这个问题太深奥了

具体想问什么，表述清楚些。可以在讨论

---

临翔区19355265376： C语言 求表达式的值 - ？
商祁楷莱： 逻辑式.解释如下: x++,x的值不为0,所以(x++)为“真”.同理(++y)也为“真”. 所以x++||++y的运算结果为“真”. ++z,这个z的值也不是0,所以(++z)为真. 所以表达式:x++||++y&&++z的逻辑结果为“真”,值就是“1”.所以t=1

临翔区19355265376： c语言 表达式求值 - ？
商祁楷莱： 1、先取第一个数(遇到符号止) 2、记录当前符号 3、取下一个数(遇到符号止) 4、前两数按上次记录符号运算,结果存到第一个数上 5、重复2-4,直到取下一数时,遇到字符串结束符为止

临翔区19355265376： C语言编程(数据结构):表达式求值 - ？
商祁楷莱： /*在TC2 和 VC6下都可以顺利运行. 做了一个下午.一定要用我这个噢. 有简单的输入错误检测.有完整的说明和 注释*/#include<stdio.h> /*库文件包含*/ #include<string.h> /*用于字符串操作*/ #include<stdlib.h> /*用于exit函数*//*****************...

临翔区19355265376： 表达式的求值(c语言) - ？
商祁楷莱： c语言有丰富的表达式,这是它的特点之一,表达式主要有4类,算术表达式,赋值表达式,逗号表达式,关系表达式 1.算术表达式就是包含算术运算符(如+ - / * %等)的表达式(不是语句,后面没有分号),如:a+b ,a%b,a+b-c*d,3+5等,算...

临翔区19355265376： C语言表达式的值 - ？
商祁楷莱： a>=c+d 可以得出 && 的结果是0,然后 !c>0 等价于0>0 为假 d

临翔区19355265376： C语言用栈编写求表达式的值 - ？
商祁楷莱： //表达式输入完了之后直接回车,就出结果了,跟平时输入字符串一样./**********************************************算术表达式求值的算符优先级算法利用栈来实现括号匹配和表达式求值算法的详细说明,请查看清华大学出版社《数...

临翔区19355265376： 用C语言求算术表达式的值 - ？
商祁楷莱： C语言中,余运算(就是%)只能在2个整数间进行. 把z=(x+a%3*(int)(x+y)%2/4); 改成: z=(x+(int)a%3*(int)(x+y)%2/4); 就可以了.

临翔区19355265376： c语言,根据下列定义计算表达式的值. - ？
商祁楷莱： y+=i-=j*=++x;按规则拆开就是—— x=x+1;//x==4.5 j=j*x;//j=5*4.5==22.5 i=i-j;//i=3-22.5==(int)-19.5==-19——浮点数赋给整型变量只截取整数部分 y=y+i;//y=5.0+(-19)==-14.0——浮点数与整数运算结果是浮点数,赋给浮点变量当然还是浮点数.所以最后y=-14.0.

临翔区19355265376： c语言求表达式的值？
商祁楷莱： 运行程序的结果: (1) x*=2/3+5 75 (2)x%=(x%=4)-20 (3)x/=x+x0

临翔区19355265376： c语言键盘输入表达式求值 - ？
商祁楷莱： #includevoid main() { int a,b; char c; scanf(＂%d%c%d=＂,&a,&c,&b); switch(c) { case '+':printf(＂%d\n＂,a+b);break; case '-':printf(＂%d\n＂,a-b);break; case '*':printf(＂%d\n＂,a*b);break; case '/':printf(＂%d\n＂,a/b);break; default :printf(＂输入有误\n＂); } }