c语言表达式括号运算符

⑴ c语言逗号表达式的运算规则

1、当顺序点用，结合顺序是从左至右，用来顺序求值，完毕之后整个表达式的值是最后一个表达式的值。
main(）
{int a,s,d;
s=2;
d=3;
a=12+(s+2,d+4);
}
先算括号内的值：s+2=4，d+4=7；括号内应为（4,7），括号内取值只取最后一个，如果没有括号则取第一个；a=12+7=19。
x=(y=3,(z = ++y+2) +5);
是首先把y赋值为3,把y递增为4,然后把4加上2,把结果6赋值给z,接下来把z加5最后把x赋为结果值11。
2、注意事项：逗号运算符( , )是C语言运算符中优先级最低的一种运算符。

⑵ C语言里圆括号算作运算符吗

是运算符 单目 优先级是1
[ ]数组下标 ( )圆括号 .成员选择 ->成员选择 ++ --（后自增 自减）都是优先级为1的单目运算符

⑶ C语言中括号运算符的问题

哈哈，你这是一个逗号表达式。
它将以逗号为界，从左到右依次计算每个表达式的值，最后返回最右边的表达式的值。
阿明白？？

⑷ 在C语言中，if括号后面的语句可以是表达式吗

运算符的优先级：*的优先级最高，其次是<，最后是==，在if语句中先计算两组2*2得出4，变成if(4==5<4==4),然后计算5<4得出0，变成if(4==0==4),0和4明显不相等，if语句输出结果为0，也就是假。
当if输出为1时，输出T
当if输出为0时，输出F
所以结果是F

⑸ c语言运算符

该命令执行时，首先运算括号里面的，运算表达式（b++)时，等于运算表达式b++,该表达式的值为3，然后b=b+1,再运算表达式（++c)，等价于c=c+1,然后取表达式的值为5。最后从左到右运算，得到答案。

⑹ 用c语言写带括号表达式求值的程序

//参考代码
#include<stdio.h>
#include<string.h>

typedefintSElemType;	//栈的元素类型

#defineSTACK_INIT_SIZE10	//存储空间初始分配量
#defineSTACKINCREMENT2	//存储空间分配增量

/*
*顺序栈的结构体
**/
typedefstructSqStack
{
SElemType*base;	//在栈构造之前和销毁之后，base的值为NULL
SElemType*top;	//栈顶指针
intstacksize;	//当前已分配的存储空间，以元素为单位
}SqStack;

/*
*构造一个栈
**/
intInitStack(SqStack*S)
{
//为栈底分配一个指定大小的存储空间
(*S).base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!(*S).base)
exit(0);	//存储分配失败
(*S).top=(*S).base;	//栈底与栈顶相同表示一个空栈
(*S).stacksize=STACK_INIT_SIZE;
return1;
}

/*
*获取栈顶元素
**/
intGetTop(SqStackS,SElemType*e)
{
if(S.top>S.base)
{
*e=*(S.top-1);	//栈顶指针的下一个位置为栈顶元素
return1;
}
else
return0;
}

/*
*入栈（压栈）
**/
intPush(SqStack*S,SElemTypee)
{
if((*S).top-(*S).base>=(*S).stacksize)	//栈满，追加存储空间
{
(*S).base=(SElemType*)realloc((*S).base,
((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!(*S).base)
exit(0);//存储分配失败
(*S).top=(*S).base+(*S).stacksize;
(*S).stacksize+=STACKINCREMENT;
}
*((*S).top)++=e;
//这个等式的++*优先级相同，但是它们的运算方式，是自右向左
return1;
}

/*
*出栈
**/
intPop(SqStack*S,SElemType*e)
{
if((*S).top==(*S).base)
return0;
*e=*--(*S).top;
//这个等式的++*优先级相同，但是它们的运算方式，是自右向左
return1;
}

/*
*判断优先级
**/
SElemTypePrecede(SElemTypet1,SElemTypet2)
{
SElemTypef;
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
);
exit(0);
}
else
f='<';
break;
case')':
switch(t1)
{
case'(':
f='=';
break;
case'#':
printf(ERROR2
);
exit(0);
default:
f='>';
}
break;
case'#':
switch(t1)
{
case'#':
f='=';
break;
case'(':
printf(ERROR3
);
exit(0);
default:
f='>';
}
}
returnf;
}

/*
*搜索运算符
**/
intIn(SElemTypec)
{
switch(c)
{
case'+':
case'-':
case'*':
case'/':
case'(':
case')':
case'#':return1;
default:return0;
}
}

/*
*运算
**/
SElemTypeOperate(SElemTypea,SElemTypetheta,SElemTypeb)
{
SElemTypec;
a=a-48;	//ASCII值转化为对应的十进制值
b=b-48;	//ASCII值转化为对应的十进制值

switch(theta)
{
case'+':
c=a+b+48;
break;
case'-':
c=a-b+48;
break;
case'*':
c=a*b+48;
break;
case'/':c=a/b+48;
}
returnc;
}

/*
*比较运算符优先级
**/
SElemTypeEvaluateExpression()
{
SqStackOPTR,OPND;
SElemTypea,b,c,x,theta;
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;
case'=':
Pop(&OPTR,&x);//脱括号并接收下一字符
c=getchar();
break;
case'>':
Pop(&OPTR,&theta);//退栈并将运算结果入栈
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND,Operate(a,theta,b));
break;
}
elseif(c>='0'&&c<='9')//c是操作数
{
Push(&OPND,c);
c=getchar();
}
else	//c是非法字符
{
printf(非法字符！！
);
exit(0);
}

GetTop(OPTR,&x);
}
GetTop(OPND,&x);
returnx;
}

intmain()
{
printf(请输入算术表达式,并以#结束);
printf("%d",EvaluateExpression());
return0;
}

⑺ c语言中运算符有哪几种，优先级顺序是怎样

C语言中，运算符除了常见的三大类，算术运算符、关系运算符与逻辑运算符之外，还有一些用于完成特殊任务的运算符。

运算符的运算优先级共分为15 级，1 级最高，15 级最低。 在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符 优先级相同时，则按运算符的结合性所规定的结合方向处理。

一级运算符：标识，常量，字符串文字量，优先级提升表达式最优先执行。

二级运算符：数组下标运算（expression）、函数调用（argument-expression-list）、成员访问（identifier、-> identifier）、后缀自增（i++）、后缀自减（i--）、复合初始化（initializer-list）。

三级运算符：前缀自增（++i）、前缀自减（--i）、单目转型表式式（取地址& ，提领 * ， 正号+ ，负号-、位反~ 逻辑否!）、求类型长度（sizeof unary-expression）。

四级运算符：强制表达式成为type-name指定的类型( type-name ) cast-expression。

五级运算符：“ * ” 乘法运算符。

六级运算符：“ + ”加法运算符。

七级运算符：<< 左移运算符；>> 右移运算符。

八级运算符：<、<=、>、>=关系运算符。

九级运算符：“ == ”等于运算符；“ != ”不等于运算符。

十级运算符：“ & ”按位与运算符。

十一级运算符：“ ∧ ”按位异或运算符。

十二级运算符：“ | ”按位或运算符。

十三级运算符：“&&”逻辑与运算符。

十四级运算符：“ || ”逻辑或运算符。

十五级运算符：? :条件运算符。

(7)c语言表达式括号运算符扩展阅读

C语言中各运算符的结合性：

1、左结合性(自左至右)：

例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合方向就称为“左结合性”。

2、右结合性(自右至左)

自右至左的结合方向称为“右结合性”。最典型的右结合 性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。

⑻ c语言里逻辑运算符与括号的结合到底是怎样的比如:(c>='a'&&c<='z')||(c>='A

当然要判断，这是或运算，前者为非并不能判定表达式的值。如果是与运算，后者就不会判断。

⑼ C语言.运算符和表达式

1.BD
2.BCD
3.ACD
4.C
5.B
6.A
7.A
8.BC
9.D
10.ACD

⑽ c语言表达式求值括号匹配

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#defineMaxSize50


typedefstruct
{
floatdata[MaxSize];
inttop;
}OpStack;


typedefstruct
{
chardata[MaxSize];
inttop;
}SeqStack;


voidInitStack(SeqStack*S);//初始化栈
intStackEmpty(SeqStackS);//判断栈是否为空
intPushStack(SeqStack*S,chare);//进栈
intPopStack(SeqStack*S,char*e);//删除栈顶元素
intGetTop(SeqStackS,char*e);//取栈顶元素
voidTranslateExpress(chars1[],chars2[]);//将中缀表达式转化为后缀表达式
floatComputeExpress(chars[]);//计算后缀表达式的值


voidmain()
{
chara[MaxSize],b[MaxSize];
floatf;
printf("请输入一个算术表达式:
");
gets(a);
printf("中缀表达式为：%s
",a);
TranslateExpress(a,b);
printf("后缀表达式为：%s
",b);
f=ComputeExpress(b);
printf("计算结果：%f
",f);
}


voidInitStack(SeqStack*S)//初始化栈
{
S->top=0;
}


intStackEmpty(SeqStackS)//判断栈是否为空
{
if(S.top==0)
return1;
else
return0;
}


intPushStack(SeqStack*S,chare)//进栈
{
if(S->top>=MaxSize)
{
printf("栈已满，不能进栈!");
return0;
}
else
{
S->data[S->top]=e;
S->top++;
return1;
}
}


intPopStack(SeqStack*S,char*e)//删除栈顶元素
{
if(S->top==0)
{
printf("栈已空
");
return0;
}
else
{
S->top--;
*e=S->data[S->top];
return1;
}
}


intGetTop(SeqStackS,char*e)//取栈顶元素
{
if(S.top<=0)


{


printf("栈已空");
return0;
}
else
{
*e=S.data[S.top-1];
return1;
}
}


voidTranslateExpress(charstr[],charexp[])//把中缀表达式转换为后缀表达式
{
SeqStackS;
charch;
chare;
inti=0,j=0;
InitStack(&S);
ch=str[i];
i++;
while(ch!='')//依次扫描中缀表达式
{
switch(ch)
{
case'(':
PushStack(&S,ch);
break;
case')':
while(GetTop(S,&e)&&e!='(')
{
PopStack(&S,&e);
exp[j]=e;
j++;
}
PopStack(&S,&e);
break;
case'+':
case'-':
while(!StackEmpty(S)&&GetTop(S,&e)&&e!='(')
{
PopStack(&S,&e);
exp[j]=e;
j++;
}
PushStack(&S,ch);
break;
case'*':
case'/':
while(!StackEmpty(S)&&GetTop(S,&e)&&e=='/'||e=='*')
{
PopStack(&S,&e);
exp[j]=e;
j++;
}
PushStack(&S,ch);
break;//是空格就忽略
case'':
break;
default:
while(ch>='0'&&ch<='9')
{
exp[j]=ch;
j++;
ch=str[i];
i++;
}
i--;
exp[j]='';
j++;
}
ch=str[i];
i++;
}
while(!StackEmpty(S))//将栈中剩余运算符出栈
{
PopStack(&S,&e);
exp[j]=e;
j++;
}
exp[j]='';
}


floatComputeExpress(chara[])//计算后缀表达式的值
{
OpStackS;
inti=0;
floatx1,x2,value;
floatresult;
S.top=-1;
while(a[i]!='')//依次扫描后缀表达式
{
if(a[i]!=''&&a[i]>='0'&&a[i]<='9')//如果是数字
{
value=0;
while(a[i]!='')//如果不是空格
{
value=10*value+a[i]-'0';
i++;
}
S.top++;
S.data[S.top]=value;//处理后进栈
}
else//如果是运算符
{
switch(a[i])
{
case'+':
x1=S.data[S.top];
S.top--;
x2=S.data[S.top];
S.top--;
result=x1+x2;
S.top++;
S.data[S.top]=result;
break;
case'-':
x1=S.data[S.top];
S.top--;
x2=S.data[S.top];
S.top--;
result=x2-x1;
S.top++;
S.data[S.top]=result;
break;
case'*':
x1=S.data[S.top];
S.top--;
x2=S.data[S.top];
S.top--;
result=x1*x2;
S.top++;
S.data[S.top]=result;
break;
case'/':
x1=S.data[S.top];
S.top--;
x2=S.data[S.top];
S.top--;
result=x2/x1;
S.top++;
S.data[S.top]=result;
break;
}
i++;
}
}
if(!S.top!=-1)//如果栈不空，将结果出栈并返回
{
result=S.data[S.top];
S.top--;
if(S.top==-1)
returnresult;
else
{
printf("表达式错误");
exit(-1);
}
}
return0;
}