首页 > 代码库 > 【C】 04 - 表达式和语句
【C】 04 - 表达式和语句
程序的生命力体现在它千变万化的行为,而再复杂的系统都是由最基本的语句组成的。C语句形式简单自由,但功能强大。从规范的角度学习C语法,一切显得简单而透彻,无需困扰于各种奇怪的语法。
1. 表达式(expression)
1.1 简单表达式
一个表达式最重要的属性是它的值,可以定位其对象的值叫左值(l-value,locator value),其它叫右值(r-value)。右值只是临时值,使用完即不存在,不可把它当对象操作。
本小节先介绍原子表达式和单个的操作符(operand)用法,基本是按优先级排序的。原子表达式(primary expression)是最简单的表达式,包括标识(identifier)、常量、括号和泛选操作(generic slection)。能做原子表达式的标识只有变量名和函数名,变量名一般是左值,但数组名被转换为指针时是右值,函数名单独使用时也转换为指针。
int a[2], b[2];void fun(void);a[0] = 1; // l-valuea = b; // illegalfun; // ok, but not call fun
泛型是新规范中提供的一种生成表达式的表达式,泛型的结果是表达式本身,而非表达式的值(不同于?:操作)。泛型开始于关键字_Generic,后面跟括号,括号里第一个为任意表达式,后面是多个“类型:表达式”对。类型必须是完整的且互相不相容的,可以有一个可选的default类型。表达式只能是左值、函数名或空,空表达式类型为void。泛型的结果是与第一个表达式相容的类型对应的表达式,它仍为左值、函数名或空。泛型被库用于根据参数类型选择函数,也可以用于选择变量。
#define cbrt(X) _Generic((X), long double: cbrtl, default: cbrt, float: cbrtf )(X)int i;long l;float f;cbrt(f); // cbrtf(f)_Generic(f, double: i, float: l) = 1; // l = 1
后缀操作符(postfix operator)包括数组下标[]、函数调用()、成员引用.和->、后缀++(--)、组合常量。a[i]被转化为a+i,因此也可以写作i[a],a[i]返回左值。函数调用的操作数是函数指针,所以也可以直接放在函数名后面,函数返回值为右值。成员引用返回左值,组合常量也返回左值。后缀++(--)操作数必须为左值,返回原始值(右值)。
int a[2], x, y;int fun(int i) {return i;}int (*fp)(int);struct S {int i;} s, *ps;a[0] = 1; // *(a + 1) = 11[a] = 2; // *(1 + a) = 2x+++++y; // illegal, ((x++)++) + y, not (x++) + (++y)fp = &fun; // the same as fp = funfun(1); // the same as fp(1)(*fp)(1); // the same as fp(1)&fun(1); // illegalps = &s;s.i = 1;ps->i = 1;(struct S){1}.i = 2; // ok
一元操作符(unary operator)也可以叫前缀操作符,包括前缀++(--)、前缀+(-)、地址操作&和*、运算!和~、强制转换()、sizeof和_Alignof。前缀++(--)操作数必须为左值,返新值(左值),等同于+= 1(-=1)。取址操作&得到操作数的指针,操作数必须为左值(但不能作用于位域和register变量),结果为右值。解址操作*(dereference)获取对象,结果为左值。!作用于度量型,操作数非零则结果为0,否则结果为1。强制类型转换的结果为右值,不可继续操作。sizeof和_Alignof的结果为整型,具体类型基于实现,由宏size_t定义。
int a = 1;struct S {int bits:10} s, *ps;++a++; // illegal, ++(a++)++++a; // ok, ++(++a)&s.bits; // illegalps = &s;(*ps).bits = 1; // ok!NaN; // 0((int*)ps).bits; // illegal
代数运算符包括算术运算符(*、/、%、+、-)、位运算符(>>、<<、&、|、^)、比较运算符(==、!=、>、<、>=、<=)和逻辑运算符(&&、||)。除法的操作符为整数时,商向0舍入(truncation toward 0),也可以说余数与被除数同号。指针与整型的加减表示指针的偏移(加法中顺序任意),以类型长度为单位,所以void指针不可偏移。两个指针相减的结果是以byte为单位的整型,具体类型基于实现,由宏ptrdiff_t定义。位运算只作用于整型,对有符号数的操作未定义,移位运算超出范围未定义,位操作可以实现一些快速算法。比较和逻辑运算符的值为0或1,一般用作条件表达式,==不作用于组合类型。条件表达式必须是度量型,它(X)的结果相当于(X != 0),逻辑运算的操作数必须是条件表达式。
unsigned int n, *p;void *pv;int a[2];struct S {int i;} s1, s2;(-5) / 2; // -25 / (-2); // -2(-5) % (-2); // -1p = &n;pv = (void*)p;pv++; // illegal1 + p; // okp - &n; // 41U << 40; // undefinedn & 0x000000FF; // maskn | 0x00000001; // setn & ~0x00000001; // clearn ^ 0xFFFFFFFF; // flipeax ^ eax; // fast 0// count 1 in a binary numbern = (n & 0x55555555) + ((n >> 1) & 0x55555555); n = (n & 0x33333333) + ((n >> 2) & 0x33333333); n = (n & 0x0f0f0f0f) + ((n >> 4) & 0x0f0f0f0f); n = (n & 0x00ff00ff) + ((n >> 8) & 0x00ff00ff); n = (n & 0x0000ffff) + ((n >> 16) & 0x0000ffff);if (a == a); // okif (s1 == s2); // illegalif (pv); // the same as if (0 != pv)
条件(conditional)操作符(?:)是C中唯一的3目操作符,除代码相对紧凑外与if else并无不同(包括性能)。第一个操作数为条件表达式,后两个操作数同为数、同类复合类型、同类型指针或同为void,结果是右值。若同为数,需要做一般代数转换,结果也是转换后的类型。若同为指针,则结果的的限定符为所有限定符的合并。若一个为空指针,返回另一个指针类型。若一个为void指针,返回类型是void指针。
const int a;volatile int b;int *pi;void *pvvoid f1(void) {}void f2(void) {}1 ? 1 : 2.0; // 1.01 ? a : b; // const volatile int1 ? pi : NULL; // int*, although NULL is (void*)01 ? pi : pv; // void*(1 ? a : b) = 1; // illegal(1 ? f1 : f2)(); // ok, pointer
赋值(assignment)操作符包括一般赋值操作符(=)和复合赋值操作符(x=),其中x为上段中的算术和位运算符。a x= y一般等价于a = a x b,但前者表达式a仅解析一次,在有些平台效率更高。赋值操作的左操作数必须为左值,结果为左操作数的新值(右值)。同类型的指针可相互赋值(void指针可赋值给其它指针),但要求右操作数的限定符不少于左边的。结构、联合可相互赋值,但数组不可以(数组名转化为指针),可考虑将数组放在结构中。
int a, b;int *pi;const int *pc;void *pv;int a1[2], a2[2];struct S {int i;} s1, s2;a = b = 1; // ok, a = (b = 1);(a = b) = 1; // illegalpc = pi; // okpi = pc; // illegalpi = pv; // oks1 = s2; // oka1 = a2; // illegal
逗号操作符返回第二个操作数,为右值。C中有很多的符号复用,需根据语境区决定其意义。逗号在声明列表、初始化列表、函数参数列表、枚举定义中都是分隔符,而非操作符。
// separatorint a, b;struct S {int a, b;} s = {1, 2};enum E {FALSE, TRUE};void f(int m, int n) {}f(1, 2);// operator1, 2; // 2f((1 , 2) , 2); // f(2, 2)for (a = 1, b = 2; ; );
1.2 优先级和结合律
当表达式中的操作数也是表达式时,逻辑会变得复杂,需要一定的规则决定操作的执行顺序。C教材上一般会列出一张优先级和结合律的表,但如果企图从算法角度解释优先级,你会发现是困难和含糊的。C规范也没有这两个概念,有的只是对各操作符的语法定义,简单说就是符合语法的解释才是正确的结果。比如算术运算的语法可以定义成如下表,其中清晰地定义了乘除的优先级高于加减,且结合律是从左向右。本节所有的语法定义都是简化的,甚至是故意写错的,细节请参考规范。
multiplicative_exp: unary_exp multiplicative_exp * unary_exp multiplicative_exp / unary_exp multiplicative_exp % unary_expadditive_exp: multiplicative_exp additive_exp + multiplicative_exp additive_exp - multiplicative_exp
优先级最高的当然是原子表达式,然后依次是后缀、前缀、代数、条件、赋值和逗号。同类单目操作无优先级和结合律问题,可以简单定义如下。代数运算符都是像算术运算那样累加定义的,且结合律都是从左向右。条件操作结合律是从右向左,从如下语法中看得更清楚。赋值操作的左表达式只能是单目的,就是说a + b = c这样的式子连优先级都谈不上。逗号操作符优先级最低,结合律是从左向右的。
postfix_exp: primary_exp postfix_exp postfix_opunary_exp: postfix_exp prefix_op unary_expconditional_exp: arithmatical_exp arithmatical_exp ? exp : conditional_expassignment_exp: conditional_exp unary_exp assignment_op assignment_expexp: assignment_exp exp, assignment_exp
代数运算的优先级如下表所示(从左向右递减),该表还是需要记住的。
* / % | + - | >> << | > >= < <= | == != | & | ^ | | | && | || |
有了这些语法和优先级,一些复杂的表达式就可以弄清楚了,以下列举了一些容易混淆的用法。对表达式的精确理解不仅有助于提高代码质量,而且还帮助正确理解别人的代码。
int n, *p;void fun(void) {}struct S {int i;} s;*p++; // *(p++)++p[0]; // ++(p[0])&fun(); // &(fun())(struct S*)p->i; // illegalsizeof p ++; // sizeof(p++)3 * 4 / 2 * 1; // (((3 * 4) / 2) * 1)100 >> 1 + 1; // 100 >> (1 + 1)n & 0xFFFF + 1U; // n & (0xFFFF + 1U)0xFFFF ^ n == 0x3333; // 0xFFFF ^ (n == 0x3333)1 | 2 ^ 3 & 4; // 1 | (2 ^ (3 & 4))1 || 2 && 3; // 1 || (2 && 3)1 == 2 ? 3 : 4; // (1 == 2) ? 3 : 4 n = 1 ? 2 : 3; // n = (1 ? 2 : 3)1 ? 2 ? 3 : 4 : 5; // ok, 1 ? (2 ? 3 : 4) : 51 ? n = 2 : 3; // ok, 1 ? (n = 2) : 31 ? 2, 3 : 4; // ok, 1 ? (2, 3) : 41 ? 2 : 3 ? 4 : 5; // ok, 1 ? 2 :(3 ? 4 : 5)1 ? 2 : 3 == 4; // 1 ? 2 : (3 == 4)1 ? 2 : n = 3; // illegal, not (1 ? 2 : n) = 3 or 1 ? 2 : (n = 3)1 ? 2 : 3, 4; // ok, (1 ? 2 : 3), 41 + 2 = 3; // illegal, not (1 + 2) = 3 or 1 + (2 = 3)1, 2, 3; // (1, 2), 3
1.3 时序点(sequnce point)
表达式有时会改变对象的值(主要发生在++(--)、赋值和函数调用时),一般叫表达式的副作用(side effect)。表达式可以看成是一系列求值和副作用的序列,但即使确定了优先级和结合律,该序列的顺序仍然可能是不确定的。原因有两点:(1)双目运算两个操作数的求值顺序不确定;(2)发生的副作用并不要求立刻产生作用。但即便如此,副作用的时序还是受到一些限制的。前置++(--)的副作用在操作返回前发生,赋值操作的副作用发生在两边求值之后。一个表达式是确定的是指每一个对象的取值都发生在修改之前,且修改最多只有一次。
int a = 0, b, *p = &a;1 * 2 + 3 % 4; // * or % first is not definedb = a++; // a = 1 or b = 0 first is not defined(++p)[0] = 1; // p = &b, then b = 1a = a - 1; // get a, then a = 0b = a + a++; // b = 0 or 1a = a++; // a = 1 or 2
另外,C中还规定了一些时序点,要求到达该点时,发生的副作用全部产生作用。时序点发生在完整表达式(full expression)结束、分支表达式中和函数调用前。一个完整的表达式结束时自然要求副作用全部产生作用,这类表达式包含在表达式语句、局部变量定义、分支和循环语句、for语句开头、return语句中。分支表达式是指&&、||和?:,&&和||先求值第一个表达式,如果不满足则不处理第二个表达式,两个表达式之间有一个时序点。?:的条件表达式结束有一个时序点,后面两个表达式只有一个会被处理。函数调用时,参数全部进栈完毕和执行函数之间有一个时序点。
int fun(int n){ int a = 0, b = a + 1; // a = 0, then b = 1 b = 0; // b = 0, then to if if (0 == a++) b = 0; // a = 1, then b = 0 // (1) b = 1, (2) a = 2, (3) b = 0, (4) a = 3 for (b++; a++ < 2; b = 0); return a = 1; // a = 1, then return}int m = 0;fun(m++); // m = 1, then fun(0)if (0 == m++ && (m = 0)); // m = 2, then &&, no m = 0if (2 == m-- || (m = 0)); // m = 1, then ||, no m= 0 1 == m++ ? m-- : (m = 0); // m = 2, then m = 1, no m = 0
还有一个关于表达式值的问题是:常量表达式会在编译时完成操作。但编译器不会改变表达式来拼凑常量,而且逗号表达式不做常量运算。另外,sizeof和_Alignof的操作数不被处理,复合常量中子表达式仍会被执行。
int a = 0, *p;1 + 2 + a; // the same as 3 + aa + 1 + 2; // (a + 1) + 2, not a + 31, 2; // not 2sizeof(a++); // 4, a = 0_Alignof(a++); // 4, a = 0while (a < 2){ p = (int[]){a, a++};} // a = 2, p[0] = 0
2. 语句(statement)
2.1 一般语句
这里讨论的语句是指要执行的代码,不包括全局的声明和定义,最大的语句就是函数定义的语句块(block)。以下是语句的语法定义,方括号表示可选。
stt: [exp]; labeled_stt compound_stt selection_stt iteration_stt jump_sttlabeled_stt: label: stt case int_const: stt default: sttcompound_stt: {[declaration_stt_list]}
空语句是一个表达式语句,表达式返回void,注意使用中容易造成的误解。标签语句是一个完整的语句,label可以累加,但尾部必须有语句,label语句不阻挡程序的继续执行。语句块可以为空,也可以包含多个声明和语句。函数体必须为一个语句块,否则空语句无法与声明中分号区分。auto变量的定义语句可以看作分配空间和赋值两步(即使没有初始化),在进入块时分配空间,在执行到时进行赋值。旧规范中要求定义必须在block头部,但新规不作限制。
void f(void); // declaration, not void f(void) {}void f(void) return; // illegal, should be blockvoid f(void){ int a = 0; if (0 != a); // empty statement a = 1; // always do goto LABEL0; int b = 1; // ok in C99 while(1) {} // the same as while(1); while(1) { static int s = 0; // not executed int m; // m = rand each time int n = 1; // n = 1 each time n++; }LABEL0: a = b; // randLABEL1: // ok, many lablesLABEL2: ; // ok, empty statementLABEL3: // illegle}
2.2 分支语句
selection_stt: if (exp) stt if (exp) stt else stt switch (exp) stt
分支和循环语句中的控制表达式必须是条件表达式,switch语句中的控制表达式还要求是整型。像括号匹配一样,if语句中的else总是和它之前第一个未匹配的if匹配。else后面可以跟任何语句,包括另一个if语句或其它,但没有elseif关键字。switch语句的控制表达式需要做整型提升,case中的中的值也会转换成相应的类型。case和default的顺序任意,default是可选的。匹配不上case则执行default,没有default则不执行。swtich语句中要习惯使用break语句结束分支,否则会继续执行下去。
signed char c = -1;if (1) if (2); else; // if (1) { if (2); else; }if (1) elseif (2); // illegalif (1); else while (2); // okswitch (c); // ok, do nothingswitch (c) // promote to int{ default: break; // ok case -1: break; // can be negtive case 1LL: break; // convert to int}
2.3 循环语句
iteration_stt: while (exp) stt do stt while (exp); for ([declaration or exp]; [exp]; [exp]) stt
循环语句会持续执行,直至条件不满足。当从循环外跳进循环内时,也会执行循环逻辑。do while语句比较适合为语句块定义宏:(1)有{}打包;(2)可自由跳出;(3)可作为语句添加分号。for语句中的符号是分隔符,三个表达式皆可省略。中间的控制表达式省略时,替换为非零常量。但其它控制表达式(while、if)不可省略,因为没有空表达式返回void,控制表达式外的括号也是不能省的。新规范中,for语句的第一个表达式可以为局部变量定义,但不可以同时有定义和表达式。为表达式时,其中的逗号是操作符,而为定义时则为分隔符。可以把整个for语句看成一个语句块,循环体是子语句。
#define FUN() do { n++; if (0 == n) break; } while (0)int n = 2;goto LABEL;while (n > 0) {LABEL: n--;} // n = 0FUN();for ( ; ; ); // the same as while (1);while () {} // illegalwhile 1 {} // illegalfor (static int s; ; ); // illegalfor (n = 2, int s; ; ); // illegalfor (int s, n = 2; ; ); // ok, cover outer nfor (int i = 0; i; i) {int i;} // ok
2.4 跳转语句
jump_stt: goto label; continue; break; return [exp];
跳转语句可以随意跳进跳出一般变量作用域,跳进时先分配变量空间,跳出时先释放变量空间。但可变长数组却是要动态生成的,所以不可以从外部跳进它的作用域(但可以跳出)。goto语句可以跳转到函数中任何一个label语句,包括其前面的语句。goto的使用应当以自然为准,不宜强制不用或多用。continue语句结束本轮循环体,break结束当前循环或switch语句。返回值不是void的函数必须return非空表达式,返回值为void的函数只能return空表达式或没有return语句。
void f(void) {} // okint f(void) {} // illegalint f(void) {return;} // illegalint main(void)
{
{ int b = 2; int vb[b]; LABEL: // can get by goto a = 1; // illegal from goto b = 1; // ok from goto } { int a = 2; int va[a]; goto LABEL; // ok for a b va, illegal for vb } for (int i; ; i++) { while (1) {break;} // to next while while (1) {goto END;} // good use of goto continue; // no i = 0, but do i++ i = 0; } END:;
}
【C】 04 - 表达式和语句