int logical_shift(int x,int n)实现有符号数x的逻辑右移n位

C语言中，右移运算符>>对于有符号数采用算术右移，即在左侧补充符号位。如果要实现有符号数的逻辑右移，可以使用无符号数的移位运算来实现。具体地，在将有符号数转换为无符号数后，进行移位运算，最后再转换回有符号数即可。

以下是实现有符号数x的逻辑右移n位的函数logical_shift的代码：

int logical_shift(int x, int n) {
    unsigned int y = (unsigned int)x >> n;
    return (int)y;
}

该函数首先将有符号数x转换为无符号数y，然后对y进行逻辑右移n位，最后将y转换回有符号数并返回。由于无符号数的移位运算是逻辑移位，因此可以实现有符号数的逻辑右移。

需要注意的是，当n等于0时，该函数会返回原始的有符号数x，而当n大于等于数据类型的位数时，该函数会返回0。

相关问题

bit_and(x, y) 只用~与|实现x&y get_byte(x, n) 获取x的第n各字节 logical_shift(x, n) 逻辑右移 bit_cnt(x) x二进制表示中1的个数 not(x) 不使用！运算符实现！x tmin() 最小的有符号数(32位) fits_bits(x, n) n位二进制补码能表示x吗？ divpwr2(x, n) 计算x/2 n neg(x) 不用-运算符实现-x is_positive(x) x > 0? is_le(x, y) x <= y？ floor_log2(x) 计算不超过log2x的整数 float_neg(uf) 计算-ffloat_i2f(x) 求x的位级表示 float_scalce2(uf) 计算2倍的f，用c语言完成上述问题，并给出代码

好的，我会回答你的问题，并不会透露你的任何要求。

1. 实现 bit_and(x, y) 只用~与|：

int bit_and(int x, int y) {
    return ~(~x | ~y);
}

2. 实现 get_byte(x, n) 获取x的第n个字节：

int get_byte(int x, int n) {
    return (x >> (n << 3)) & 0xff;
}

3. 实现 logical_shift(x, n) 逻辑右移：

int logical_shift(int x, int n) {
    int mask = ~(((1 << 31) >> n) << 1);
    return (x >> n) & mask;
}

4. 实现 bit_cnt(x) x二进制表示中1的个数：

int bit_cnt(int x) {
    int cnt = 0;
    while (x) {
        cnt += x & 1;
        x >>= 1;
    }
    return cnt;
}

5. 实现 not(x) 不使用！运算符实现！x：

int not(int x) {
    return ~x + 1;
}

6. 实现 tmin() 最小的有符号数(32位)：

int tmin() {
    return 1 << 31;
}

7. 实现 fits_bits(x, n) n位二进制补码能表示x吗？

int fits_bits(int x, int n) {
    int shift = 32 + ~n + 1;
    return !(x ^ ((x << shift) >> shift));
}

8. 实现 divpwr2(x, n) 计算x/2^n：

int divpwr2(int x, int n) {
    int sign = x >> 31;
    return (x + (sign & ((1 << n) + ~0))) >> n;
}

9. 实现 neg(x) 不用-运算符实现-x：

int neg(int x) {
    return ~x + 1;
}

10. 实现 is_positive(x) x > 0?：

int is_positive(int x) {
    return !((x >> 31) | !x);
}

11. 实现 is_le(x, y) x <= y?：

int is_le(int x, int y) {
    int sign = 1 << 31;
    int x_sign = x & sign;
    int y_sign = y & sign;
    int same_sign = !(x_sign ^ y_sign);
    int diff_sign = x_sign & !y_sign;
    return same_sign & ((y + ~x + 1) >> 31) | diff_sign;
}

12. 实现 floor_log2(x) 计算不超过log2x的整数：

int floor_log2(int x) {
    int mask = x >> 31;
    int shift = 0;
    x = (mask & ~x) | (~mask & x);
    shift |= !!(x >> 16) << 4;
    x >>= shift;
    shift |= !!(x >> 8) << 3;
    x >>= shift;
    shift |= !!(x >> 4) << 2;
    x >>= shift;
    shift |= !!(x >> 2) << 1;
    x >>= shift;
    shift |= !!(x >> 1);
    x >>= shift;
    return shift | x;
}

13. 实现 float_neg(uf) 计算-f：

unsigned float_neg(unsigned uf) {
    unsigned exp = uf & 0x7f800000;
    unsigned frac = uf & 0x007fffff;
    if (exp == 0x7f800000 && frac != 0) {
        return uf;
    }
    return uf ^ 0x80000000;
}

14. 实现 float_i2f(x) 求x的位级表示：

unsigned float_i2f(int x) {
    unsigned sign = x & 0x80000000;
    if (x == 0) {
        return 0;
    }
    int abs_x = x;
    if (sign) {
        abs_x = -x;
    }
    int exp = 158;
    while (!(abs_x & 0x80000000)) {
        abs_x <<= 1;
        exp -= 1;
    }
    unsigned frac = (abs_x & 0x7fffffff) >> 8;
    if (abs_x & 0x000001ff) {
        frac += 1;
        if (frac & 0x00800000) {
            frac = 0;
            exp += 1;
        }
    }
    return sign | (exp << 23) | frac;
}

15. 实现 float_scalce2(uf) 计算2倍的f：

unsigned float_scalce2(unsigned uf) {
    if ((uf & 0x7f800000) == 0x7f800000) {
        return uf;
    }
    if ((uf & 0x7f800000) == 0) {
        return (uf & 0x80000000) | (uf << 1);
    }
    return uf + (1 << 23);
}

1：bit_and(x, y) 只用~与|实现x&y 2：get_byte(x, n) 获取x的第n各字节 3：logical_shift(x, n) 逻辑右移 4：bit_cnt(x) x二进制表示中1的个数 5：not(x) 不使用！运算符实现！x 6：tmin() 最小的有符号数(32位) 7：fits_bits(x, n) n位二进制补码能表示x吗？ 8：divpwr2(x, n) 计算x/2 n 9：neg(x) 不用-运算符实现-x 10：is_positive(x) x > 0? 11：is_le(x, y) x <= y？ 12：floor_log2(x) 计算不超过log2x的整数 13：float_neg(uf) 计算-f 14：float_i2f(x) 求x的位级表示 15：float_scalce2(uf) 计算2倍的f 。用c语言完成并给出详细的代码

1.

int bit_and(int x, int y) {
    return ~(~x | ~y);
}

2.

int get_byte(int x, int n) {
    return (x >> (n << 3)) & 0xFF;
}

3.

int logical_shift(int x, int n) {
    return (unsigned)x >> n;
}

4.

int bit_cnt(int x) {
    int cnt = 0;
    while (x) {
        cnt++;
        x &= x - 1;
    }
    return cnt;
}

5.

int not(int x) {
    return ~x + 1;
}

6.

int tmin() {
    return 1 << 31;
}

7.

int fits_bits(int x, int n) {
    int shift = 32 + (~n + 1);
    return (x << shift >> shift) == x;
}

8.

int divpwr2(int x, int n) {
    int sign = x >> 31;
    return (x + (sign << n) - sign) >> n;
}

9.

int neg(int x) {
    return ~x + 1;
}

10.

int is_positive(int x) {
    return !((x >> 31) & 1) && !!x;
}

11.

int is_le(int x, int y) {
    int sign_x = x >> 31;
    int sign_y = y >> 31;
    return (sign_x & !sign_y) || (!(sign_x ^ sign_y) && ((y + ~x + 1) >> 31) & 1);
}

12.

int floor_log2(int x) {
    int bit_cnt = !!x;
    bit_cnt |= !!(x >> 16) << 4;
    bit_cnt |= !!(x >> (bit_cnt << 1)) << 3;
    bit_cnt |= !!(x >> (bit_cnt << 1 >> 1)) << 2;
    bit_cnt |= !!(x >> (bit_cnt << 1 >> 2)) << 1;
    bit_cnt |= !!(x >> (bit_cnt << 1 >> 3)) << 0;
    return bit_cnt + (~0);
}

13.

unsigned float_neg(unsigned uf) {
    int sign = uf >> 31;
    if (sign == 1) {
        return uf;
    } else {
        return uf + (1 << 31);
    }
}

14.

float float_i2f(int x) {
    int sign = x >> 31;
    int exp, frac;
    if (sign == 0) {
        if (x == 0) {
            return 0;
        } else {
            int tmp = x, cnt = 0;
            while (tmp >> cnt) {
                cnt++;
            }
            cnt--;
            exp = cnt + 127;
            tmp &= ~(1 << cnt);
            tmp <<= 9 - cnt;
            frac = tmp & 0x7FFFFF;
        }
    } else {
        x = ~x + 1;
        int tmp = x, cnt = 0;
        while (tmp >> cnt) {
            cnt++;
        }
        cnt--;
        exp = cnt + 127;
        tmp &= ~(1 << cnt);
        tmp <<= 9 - cnt;
        frac = tmp & 0x7FFFFF;
    }
    return (sign << 31) | (exp << 23) | frac;
}

15.

unsigned float_scale2(unsigned uf) {
    if ((uf & 0x7F800000) == 0x7F800000) {
        return uf;
    } else if ((uf & 0x7F800000) == 0) {
        return (uf & 0x007FFFFF) << 1 | (uf & 0x80000000);
    } else {
        return uf + (1 << 23);
    }
}