程序的生命力体现在它千变万化的行为，而再复杂的系统都是由最基本的语句组成的。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-value a = b; // illegal fun; // 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) = 1 1[a] = 2; // *(1 + a) = 2 x+++++y; // illegal, ((x++)++) + y, not (x++) + (++y) fp = &fun; // the same as fp = fun fun(1); // the same as fp(1) (*fp)(1); // the same as fp(1) &fun(1); // illegal ps = &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; // illegal ps = &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; // -2 5 / (-2); // -2 (-5) % (-2); // -1 p = &n; pv = (void*)p; pv++; // illegal 1 + p; // ok p - &n; // 4 1U << 40; // undefined n & 0x000000FF; // mask n | 0x00000001; // set n & ~0x00000001; // clear n ^ 0xFFFFFFFF; // flip eax ^ eax; // fast 0 // count 1 in a binary number n = (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); // ok if (s1 == s2); // illegal if (pv); // the same as if (0 != pv)
条件（conditional）操作符（?:）是C中唯一的3目操作符，除代码相对紧凑外与if else并无不同（包括性能）。第一个操作数为条件表达式，后两个操作数同为数、同类复合类型、同类型指针或同为void，结果是右值。若同为数，需要做一般代数转换，结果也是转换后的类型。若同为指针，则结果的的限定符为所有限定符的合并。若一个为空指针，返回另一个指针类型。若一个为void指针，返回类型是void指针。
const int a; volatile int b; int *pi; void *pv void f1(void) {} void f2(void) {} 1 ? 1 : 2.0; // 1.0 1 ? a : b; // const volatile int 1 ? pi : NULL; // int*, although NULL is (void*)0 1 ? 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; // illegal pc = pi; // ok pi = pc; // illegal pi = pv; // ok s1 = s2; // ok a1 = a2; // illegal
逗号操作符返回第二个操作数，为右值。C中有很多的符号复用，需根据语境区决定其意义。逗号在声明列表、初始化列表、函数参数列表、枚举定义中都是分隔符，而非操作符。
// separator int a, b; struct S {int a, b;} s = {1, 2}; enum E {FALSE, TRUE}; void f(int m, int n) {} f(1, 2); // operator 1, 2; // 2 f((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_exp additive_exp: multiplicative_exp additive_exp + multiplicative_exp additive_exp - multiplicative_exp
优先级最高的当然是原子表达式，然后依次是后缀、前缀、代数、条件、赋值和逗号。同类单目操作无优先级和结合律问题，可以简单定义如下。代数运算符都是像算术运算那样累加定义的，且结合律都是从左向右。条件操作结合律是从右向左，从如下语法中看得更清楚。赋值操作的左表达式只能是单目的，就是说a + b = c这样的式子连优先级都谈不上。逗号操作符优先级最低，结合律是从左向右的。
postfix_exp: primary_exp postfix_exp postfix_op unary_exp: postfix_exp prefix_op unary_exp conditional_exp: arithmatical_exp arithmatical_exp ? exp : conditional_exp assignment_exp: conditional_exp unary_exp assignment_op assignment_exp exp: 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; // illegal sizeof 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) : 5 1 ? n = 2 : 3; // ok, 1 ? (n = 2) : 3 1 ? 2, 3 : 4; // ok, 1 ? (2, 3) : 4 1 ? 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), 4 1 + 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 defined b = a++; // a = 1 or b = 0 first is not defined (++p)[0] = 1; // p = &b, then b = 1 a = a - 1; // get a, then a = 0 b = a + a++; // b = 0 or 1 a = 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 = 0 if (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 + a a + 1 + 2; // (a + 1) + 2, not a + 3 1, 2; // not 2 sizeof(a++); // 4, a = 0 _Alignof(a++); // 4, a = 0 while (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_stt labeled_stt: label: stt case int_const: stt default: stt compound_stt: {[declaration_stt_list]}
空语句是一个表达式语句，表达式返回void，注意使用中容易造成的误解。标签语句是一个完整的语句，label可以累加，但尾部必须有语句，label语句不阻挡程序的继续执行。语句块可以为空，也可以包含多个声明和语句。函数体必须为一个语句块，否则空语句无法与声明中分号区分。auto变量的定义语句可以看作分配空间和赋值两步（即使没有初始化），在进入块时分配空间，在执行到时进行赋值。旧规范中要求定义必须在block头部，但新规不作限制。
void f(void); // declaration, not void f(void) {} void f(void) return; // illegal, should be block void 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; // rand LABEL1: // ok, many lables LABEL2: ; // ok, empty statement LABEL3: // 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); // illegal if (1); else while (2); // ok switch (c); // ok, do nothing switch (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 = 0 FUN(); for ( ; ; ); // the same as while (1); while () {} // illegal while 1 {} // illegal for (static int s; ; ); // illegal for (n = 2, int s; ; ); // illegal for (int s, n = 2; ; ); // ok, cover outer n for (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) {} // ok int f(void) {} // illegal int f(void) {return;} // illegal int 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:;
}