⑴ 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;
}