程序的生命力体现在它千变万化的行为，而再复杂的系统都是由最基本的语句组成的。C语句形式简单*，但功能强大。从规范的角度学习C语法，一切显得简单而透彻，无需困扰于各种奇怪的语法。
1. 表达式（expression）
1.1 简单表达式
一个表达式最重要的属性是它的值，可以定位其对象的值叫左值（l-value，locator value），其它叫右值（r-value）。右值只是临时值，使用完即不存在，不可把它当对象操作。
本小节先介绍原子表达式和单个的操作符（operand）用法，基本是按优先级排序的。原子表达式（primary expression）是最简单的表达式，包括标识（identifier）、常量、括号和泛选操作（generic slection）。能做原子表达式的标识只有变量名和函数名，变量名一般是左值，但数组名被转换为指针时是右值，函数名单独使用时也转换为指针。
int a[], b[];
void fun(void); a[] = ; // 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) = ; // l = 1
后缀操作符（postfix operator）包括数组下标[]、函数调用()、成员引用.和->、后缀++（--）、组合常量。a[i]被转化为a+i，因此也可以写作i[a]，a[i]返回左值。函数调用的操作数是函数指针，所以也可以直接放在函数名后面，函数返回值为右值。成员引用返回左值，组合常量也返回左值。后缀++（--）操作数必须为左值，返回原始值（右值）。
int a[], x, y;
int fun(int i) {return i;}
int (*fp)(int);
struct S {int i;} s, *ps; a[] = ; // *(a + 1) = 1
[a] = ; // *(1 + a) = 2
x+++++y; // illegal, ((x++)++) + y, not (x++) + (++y) fp = &fun; // the same as fp = fun
fun(); // the same as fp(1)
(*fp)(); // the same as fp(1)
&fun(); // illegal ps = &s;
s.i = ;
ps->i = ;
(struct S){}.i = ; // ok
一元操作符（unary operator）也可以叫前缀操作符，包括前缀++（--）、前缀+（-）、地址操作&和*、运算!和~、强制转换()、sizeof和_Alignof。前缀++（--）操作数必须为左值，返新值（左值），等同于+= 1（-=1）。取址操作&得到操作数的指针，操作数必须为左值（但不能作用于位域和register变量），结果为右值。解址操作*（dereference）获取对象，结果为左值。!作用于度量型，操作数非零则结果为0，否则结果为1。强制类型转换的结果为右值，不可继续操作。sizeof和_Alignof的结果为整型，具体类型基于实现，由宏size_t定义。
int a = ;
struct S {int bits:} s, *ps; ++a++; // illegal, ++(a++)
++++a; // ok, ++(++a)
&s.bits; // illegal
ps = &s;
(*ps).bits = ; // ok
!NaN; //
((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[];
struct S {int i;} s1, s2; (-) / ; // -2
/ (-); // -2
(-) % (-); // -1 p = &n;
pv = (void*)p;
pv++; // illegal
+ p; // ok
p - &n; // 1U << ; // 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 >> ) & 0x55555555);
n = (n & 0x33333333) + ((n >> ) & 0x33333333);
n = (n & 0x0f0f0f0f) + ((n >> ) & 0x0f0f0f0f);
n = (n & 0x00ff00ff) + ((n >> ) & 0x00ff00ff);
n = (n & 0x0000ffff) + ((n >> ) & 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) {} ? : 2.0; // 1.0
? a : b; // const volatile int
? pi : NULL; // int*, although NULL is (void*)0
? pi : pv; // void*
( ? a : b) = ; // illegal
( ? 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[], a2[];
struct S {int i;} s1, s2; a = b = ; // ok, a = (b = 1);
(a = b) = ; // 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 = {, };
enum E {FALSE, TRUE};
void f(int m, int n) {}
f(, ); // operator
, ; //
f((1 , ) , ); // f(2, 2)
for (a = , b = ; ; );
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[]; // ++(p[0])
&fun(); // &(fun())
(struct S*)p->i; // illegal
sizeof p ++; // sizeof(p++) 3 * / 2 * ; // (((3 * 4) / 2) * 1)
>> + ; // 100 >> (1 + 1)
n & 0xFFFF + 1U; // n & (0xFFFF + 1U)
0xFFFF ^ n == 0x3333; // 0xFFFF ^ (n == 0x3333)
1 | 2 ^ 3 & ; // 1 | (2 ^ (3 & 4))
|| && ; // 1 || (2 && 3) 1 == 2 ? 3 : ; // (1 == 2) ? 3 : 4
n = 1 ? 2 : ; // n = (1 ? 2 : 3)
1 ? 2 ? 3 : 4 : ; // ok, 1 ? (2 ? 3 : 4) : 5
1 ? n = 2 : ; // ok, 1 ? (n = 2) : 3
1 ? , 3 : ; // ok, 1 ? (2, 3) : 4
1 ? 2 : 3 ? 4 : ; // ok, 1 ? 2 :(3 ? 4 : 5)
1 ? 2 : 3 == ; // 1 ? 2 : (3 == 4) 1 ? 2 : n = ; // illegal, not (1 ? 2 : n) = 3 or 1 ? 2 : (n = 3)
1 ? 2 : , ; // ok, (1 ? 2 : 3), 4
1 + 2 = ; // illegal, not (1 + 2) = 3 or 1 + (2 = 3)
, , ; // (1, 2), 3
1.3 时序点（sequnce point）
表达式有时会改变对象的值（主要发生在++（--）、赋值和函数调用时），一般叫表达式的副作用（side effect）。表达式可以看成是一系列求值和副作用的序列，但即使确定了优先级和结合律，该序列的顺序仍然可能是不确定的。原因有两点：（1）双目运算两个操作数的求值顺序不确定；（2）发生的副作用并不要求立刻产生作用。但即便如此，副作用的时序还是受到一些限制的。前置++（--）的副作用在操作返回前发生，赋值操作的副作用发生在两边求值之后。一个表达式是确定的是指每一个对象的取值都发生在修改之前，且修改最多只有一次。
int a = , b, *p = &a; * + % ; // * or % first is not defined
b = a++; // a = 1 or b = 0 first is not defined
(++p)[] = ; // p = &b, then b = 1
a = a - ; // 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 = , b = a + ; // a = 0, then b = 1 b = ; // b = 0, then to if
if ( == a++) b = ; // a = 1, then b = 0 // (1) b = 1, (2) a = 2, (3) b = 0, (4) a = 3
for (b++; a++ < ; b = );
return a = ; // a = 1, then return
} int m = ;
fun(m++); // m = 1, then fun(0)
if ( == m++ && (m = )); // m = 2, then &&, no m = 0
if ( == m-- || (m = )); // m = 1, then ||, no m= 0
== m++ ? m-- : (m = ); // m = 2, then m = 1, no m = 0
还有一个关于表达式值的问题是：常量表达式会在编译时完成操作。但编译器不会改变表达式来拼凑常量，而且逗号表达式不做常量运算。另外，sizeof和_Alignof的操作数不被处理，复合常量中子表达式仍会被执行。
int a = , *p; 1 + 2 + a; // the same as 3 + a
a + 1 + ; // (a + 1) + 2, not a + 3
, ; // not 2
sizeof(a++); // 4, a = 0
_Alignof(a++); // 4, a = 0
while (a < )
{
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 = ;
if ( != a); // empty statement
a = ; // always do
goto LABEL0;
int b = ; // ok in C99
while() {} // the same as while(1);
while()
{
static int s = ; // not executed
int m; // m = rand each time
int n = ; // 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 = -;
if () if (); else; // if (1) { if (2); else; }
if () elseif (); // illegal
if (); else while (); // ok
switch (c); // ok, do nothing
switch (c) // promote to int
{
default: break; // ok
case -: 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 ( == n) break; \
} while () int n = ;
goto LABEL;
while (n > ) {LABEL: n--;} // n = 0 FUN();
for ( ; ; ); // the same as while (1);
while () {} // illegal
while {} // illegal for (static int s; ; ); // illegal
for (n = , int s; ; ); // illegal
for (int s, n = ; ; ); // ok, cover outer n
for (int i = ; 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 = ;
int vb[b];
LABEL: // can get by goto
a = ; // illegal from goto
b = ; // ok from goto
}
{
int a = ;
int va[a];
goto LABEL; // ok for a b va, illegal for vb
}
for (int i; ; i++)
{
while () {break;} // to next while
while () {goto END;} // good use of goto
continue; // no i = 0, but do i++
i = ;
}
END:;
}