K&R 练习 2.6 位操作

Question

“编写一个函数 setbits(x, p, n, y) 返回 x，其中从位置 p 开始的 n 位设置为 y 的最右边 n 位，其他位保持不变。”

我很难弄清楚我做错了什么。

#include <stdio.h>
unsigned setbits(unsigned int x, int p, int n, unsigned y);

int main()
{
    unsigned x = 213;
    unsigned y = 121;
    int p = 4;
    int n = 4;

    x = setbits(x, p, n, y);
    printf("%u\n", x);

    getch();
    return 0;
}
unsigned setbits(unsigned x, int p, int n, unsigned y)
{
    return ((~(~0 << n) & y) << (p + 1 - n) | (~(~(~0 << n)) << (p + 1 - n) & x));
}

结果我在纸上得到 211，但我的代码生成 210。K&R 答案簿算法也返回 210。我不知道我在这里做错了什么。

编辑：这是答案簿中的代码：

unsigned setbits(unsigned x, int p, int n, unsigned y)
{
    return x & ~(~(~0 << n) << (p + 1 - n)) | (y & ~(~0 << n)) << (p + 1 - n);
}

重新编辑。我在将代码分成单独的行时发现了这一点。问题是最后一个 x 旁边的括号放错了：

//original
{
    return ((~(~0 << n) & y) << (p + 1 - n) | (~(~(~0 << n)) << (p + 1 - n) & x));
}

//fixed
{
    return ((~(~0 << n) & y) << (p + 1 - n)) | (~(~(~0 << n) << (p + 1 - n)) & x);
}

这是分解的代码。这看起来还是很糟糕吗？我应该使用这样的变量吗：

int setbits(unsigned x, int p, int n, unsigned y)
{
    unsigned z, k;

    z = y & ~(~0 << n);
    z = z << (p + 1 - n);
    k = ~((~(~0 << n)) << (p + 1 - n));
    k = k & x;

    return z | k;
}

Answer 1

措辞有点难以理解，但我认为这就是它所要求的：

罢工>

unsigned setbits(unsigned int x, int p, int n, unsigned y){
  return x | ((y&((1<<n)-1))<<(p-n));
}

unsigned setbits(unsigned int x, int p, int n, unsigned y){
  return (x & ~(((1<<n)-1)<<(p-n))) | ((y&((1<<n)-1))<<(p-n));
}

细分：

• |的左半部分

  • ((1<<n)-1) 将向左移动 1 n 位，减去 1 使所有位向右移动 1。
  • <<(p-n) 将它们向左移动 p-n
  • ~ 反转它们，将这些位保留为 0，其他所有位为 1
  • x & 和 x 将这些位变为 0。

• |的右半部分

  • ((1<<n)-1)同上
  • y & 只会屏蔽这些位
  • <<(p-n) 会将这些位 p-n 向左移动
  • left | right 会将这些值组合在一起，以便：
    • 从p 位置开始的n 位被设置为y 的最右边的n 位，而x 的其他位保持不变

Answer 2

书中的解决方案

unsigned setbits(unsigned x, int p, int n, unsigned y)
{
    return x & ~(~(~0 << n) << (p + 1 - n)) | (y & ~(~0 << n)) << (p + 1 - n);
}

当p=4

x 组件

l1 = ~0 => 1111_1111_1111_1111_1111_1111_1111_1111
l2 = l1 << n => 1111_1111_1111_1111_1111_1111_1111_0000
l3 = ~(l2) => 0000_0000_0000_0000_0000_0000_0000_1111
l4 = (p + 1 - n) => 1
l5 = (l3) << (l4) => 0000_0000_0000_0000_0000_0000_0001_1110
l6 = ~l5 => 1111_1111_1111_1111_1111_1111_1110_0001
l7 = x & l6 => xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxx0_000x

y 组件

s1 = ~0 => 1111_1111_1111_1111_1111_1111_1111_1111
s2 = s1 << n => 1111_1111_1111_1111_1111_1111_1111_0000
s3 = ~s2 => 0000_0000_0000_0000_0000_0000_0000_1111
s4 = (p + 1 - n) => 1
s5 = s3 << s4 => 0000_0000_0000_0000_0000_0000_0001_1110
s6 = y & s5 => 0000_0000_0000_0000_0000_0000_000y_yyy0

o = l7 | s6

输出

xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxy_yyyx
^all these uncounted bits!!!^ .

编写一个函数 setbits(x, p, n, y) 返回 x，其中 从位置 p 开始的 n 位设置为 最右边 y 的 n 位，其他位保持不变。

我们是否从零开始从右侧开始计数，然后一旦到达位置p 就开始向右计数n 位？

unsigned 属于 int 类型，可以使用验证

$ gcc -o ansi-c_2-6 *.c -std=c89
$ ansi-c_2-6

#include <stdio.h>
int main() {
  printf("%s", (sizeof(unsigned) == sizeof(int)) ? "TRUE" : "FALSE");
  return 0;
}

结论

解决方案有误。

解决方案

注意事项

• bits = CHAR_BIT * sizeof(数据类型))
• 右移携带最高有效位。 INT_MIN >> 31 == ~0
• if p + n > 32，你可以施放，但很快就会失控

x东西

左侧

left_mask = INT_MIN >> (p - 1)

右侧

right_mask = INT_MAX >> (p - 1 + n)

x = x & (left_mask | right_mask)

y 东西

中间

mid_mask = ~(left_mask | right_mask)

y = (y << (bits - p - n)) & mid_mask

return 东西

x | y

TL;DR

书错了

改为这样做

unsigned setbits(unsigned x, unsigned char p, unsigned char n, unsigned y)
{
  char bits = CHAR_BIT * sizeof(unsigned);
  unsigned left_mask, right_mask, mid_mask;
  left_mask = p > 0 ? INT_MIN >> (p-1) : 0;
  right_mask = INT_MAX >> (p - 1 + n);
  mid_mask = (left_mask | right_mask) & x;
  x = (left_mask | right_mask) & x;
  y = y << (bits - p - n) & mid_mask;
  return x | y;
}

限制：

• n > 0
• p + n < sizeof(unsigned) * CHAR_BIT

Answer 3

unsigned setbits(unsigned x, int p, int n, int y) {
   return x | (~(~0 << n) << p);
}