C语言K&R圣经笔记 2.8自增和自减 2.9位运算 2.10赋值

2.8 自增和自减操作符

C提供了两个不同寻常的操作符，用于对变量进行自增和自减。自增操作符++对操作数加上1，而自减操作符 -- 对操作数减去1。我们已经频繁使用++ 对变量进行自增，如：

if (c == '\n')
    ++nl;

不寻常之处在于 ++ 和 -- 既能用作前缀操作符（在变量之前，如++n），又能用作后缀（在变量之后，如n++）。两种情况下，效果都是n递增。不过表达式 ++n 是在它的值被使用之前对n进行递增，而 n++是在它的值被使用之后对n进行递增。这意味着如果不仅要用到递增的效果，还要用到表达式的值时，++n 和 n++ 是不一样的。如果 n 为 5，则

x = n++;

将x设为5，而

x = ++n;

将x设为6。两种情况下，n都会变成6。自增和自减操作符只能用于变量；像 (i+j)++ 这样的表达式是非法的。

当只需要用到递增效果，而不需要值的时候，如

if (c == '\n')
    nl++;

前缀和后缀是一样的。不过有些情况下会专门要求使用前缀，而有些则专门使用后缀。举个例子，看看下面这个函数 squeeze(s, c) ，将字符串s中出现的所有字符c都删除：

/* squeeze: 从s中删除所有的c */
void squeeze(char s[], int c)
{
    int i, j;

    for (i = j = 0; s[i] != '\0'; i++)
        if (s[i] != c)
            s[j++] = s[i];
    s[j] = '\0'; 
}

每当非c字符出现时，它就被拷贝到当前的 j 位置，而只有这时 j 才会自增，为接收下一个字符做准备。与下面的写法是完全相同的：

if (s[i] != c) {
    s[j] = c;
    j++;
}

类似结构的另一个例子来自于我们在第一章写的 getline 函数，其中的

if (c == '\n') {
    s[i] = c;
    i++;
}

可以替换成更紧凑的形式：

if (c == '\n')
    s[i++] = c;

第三个例子可以看看标准库函数 strcat(s, t)，它将字符串 t 连接到字符串 s 的末尾。strcat 假定 s 有足够的空间来存放合并的结果。按我们下面的写法， strcat 不返回值，标准库的strcat版本返回指向结果字符串的指针。

/* strcat: 把t拼接到s的末尾；s必须足够大 */
void strcat(char s[], char t[])
{
    int i, j;

    i = j = 0;
    while (s[i] != '\0')    /* 找到s的结尾 */
        ++s;
    while ((s[i++] = t[j++]) != '\0')    /* 拷贝t */
        ;
}

由于每个字符都要从 t 拷贝到 s，++后缀同时用于 i 和 j，以保证它们在循环的下一轮时处于正确的位置。

练习2-4，写另一个版本的 squeeze(s1, s2)，把字符串s1中出现的所有字符串 s2 都删除

练习2-5，写一个函数 any(s1, s2)，返回字符串s2中任意字符在字符串s1中首次出现的位置，如果s1不包含s2的任何字符，则返回-1。（标准库函数 strpbrk 做同样的事，但返回的是位置的指针）

2.9 位运算操作符

C提供了六个位操作符；它们只能用于整型，即 char, short, int 和 long，不管有无符号均可。

&        按位与

|        按位或

^        按位异或

<<        左移

>>        右移

~        取反（一元）

按位与操作符 & 经常用于屏蔽位中的某些部分；例如

 n = n & 0177

只保留 n 的低7位，其他位都设为0。

按位或操作符 |  用于将一些位打开（设为1）

x = x | SET_ON

会将 SET_ON 中为1的位设置到 x 上对应的位。

按位异或操作符 ^ 的规则是：若两个操作数对应的位不同时，则运算结果中该位设为1，若相同则设为0。

必须把位操作符 &  |  和逻辑运算符 && || 区分开，后者隐含的是从左到右的真值计算。

例如，如果 x是1，y 是2，则 x & y 结果为0 ，而 x && y 结果是1。

移位操作符 << 和 >> 分别对它们左边的操作数进行左移或者右移，移动的位数由右边的操作数（必须为正数）指定。这样  x << 2 会将 x 的值左移两位，空出的位补0；这就等于乘以 4。对 unsigned 值进行右移，空位总是补0。对有符号的值进行右移，在有些机器上会填充符号位（算术移位），而有些机器上填充0（逻辑移位）。

一元操作符 ~ 得出整数的反码，也就是说，把每个1都转成0，每个0都转成1。例如

x = x & ~077

把 x 的低6位设为0。注意 x & ~077 不依赖于字长，这种写法比假定字长的写法好，比如 x & 0177700 假定 x 是 16位的值。可移植的写法不涉及额外的开销，因为 ~077 是常量，可以在编译期间求值。

函数 getbits(x, p, n) 可用来演示一些位操作符的用法，该函数返回 x 从位置 p 算起的 n 个位（右对齐）。我们假定第0位是最右边一位，并且 n 和 p 都是合适的正数。例如， getbits(x, 4, 3) 返回第 4，第3 和 第2 位的三个比特，右对齐。

/* getbits：返回从位置 p 开始的 n 个比特 */
unsigned getbits(int x, int p, int n)
{
    return x >> (p+1-n) & ~(~0 << n);
}

表达式 x >> (p+1-n) 把所需的比特位段移到字的最右边。~0 是所有位均为1；用 ~0 << n 把它左移 n 位，会把最右边的 n 个位变为 0；再对它取反，就得到一个最右边 n 位 都是 1 的掩码。

练习2-6、写个函数 setbits(x,p,n,y)，返回值是 x 从位置 p 开始 的 n 个位 被 y 的最右边 n 个位替换后得到的值，x 其他位都不变。

练习2-7、写个函数 invert(x,p,n) ，返回值是 x 从位置 p 开始的 n 个位被翻转（即0变1，1变0）后的结果，其他位都不变。

练习2-8、 写个函数 rightrot(x,n)，返回值是整数 x 向右旋转了 n 个位。

2.10 赋值操作符和表达式

 i = i + 2

像这种左侧的变量在右边马上重复出现的表达式，可以写成紧凑的形式：

i += 2

其中操作符 += 被称为 赋值操作符。

大部分的二元操作符（像 + 这样左右两边各有一个操作数的操作符）都有一个对应的赋值操作符 op=， 其中 op 是下列操作符之一

 + - * / % << >> & ^ |

设有表达式 expr1 和 expr2，则

expr1 op= expr2

等价于

expr1 = (expr1) op (expr2)

唯一区别是在前面一种形式中， expr1 只会被计算一次。注意 expr2 两边的括号：

x *= y + 1

意思是

x = x * (y+1)

而不是

x = x * y + 1

看看下面这个例子，函数 bitcounts 统计其整数参数中为1的比特位数量。

/* bitcounts: 计算x中为1的比特位数量 */
int bitcounts(unsigned x)
{
    int b;

    for (b = 0; x != 0; x >> 1)
        if (x & 01)
            b++;
    return b;
}

将参数 x 声明为 unsigned 可以保证，对 x 做右移时，左边填充的总是0而不是符号位，不管这个程序在什么样的机器上运行。

除了简洁之外，赋值操作符的优势在于它们与人们思考的方式更为一致。我们会说“把 i 加上 2 ”或者“ i 自增 2 ”，而不是“拿到 i 的值，加上 2， 再把结果放回 i ”。因此 表达式  i += 2 比 i = i + 2 更好。另外，对于复杂的表达式如

yyval[yypv[p3+p4] + yypv[p1]] += 2

赋值操作符使代码容易理解，因为读者不必费力地检查两个长表达式是否相等，或者疑惑它们为什么不相等。而且赋值操作符甚至能帮助编译器生成高效的代码。

我们已经知道赋值语句是有值的，可以出现在表达式中；最常见的例子是

while ((c = getchar()) != EOF)
    ...

其他赋值操作符（ +=   -= 等）也能出现在表达式中，不过出现频率会低些。

在所有这样的表达式中，赋值表达式的类型就是它左边操作数的类型，而赋值表达式的值就是赋值之后的值。

练习2-9、在2的补码系统中，x &= (x-1) 删除x最右边的一个比特位。解释为什么。并使用这个发现来写一个更快的 bitcount 版本。