检查 C/C++ 中最低有效位 (LSB) 和最高有效位 (MSB) 的值

Question

我需要检查 C/C++ 中整数的最低有效位 (LSB) 和最高有效位 (MSB) 的值。我该怎么做？

Answer 1

//int value;
int LSB = value & 1;

或者（理论上不可移植，但实际上可以 - 请参阅史蒂夫的评论）

//int value;
int LSB = value % 2;

详细信息：
第二个公式更简单。 % 运算符是余数运算符。当一个数字是奇数时，其 LSB 为 1，否则为 0。所以我们检查除以 2 的余数。 第一个公式的逻辑是这样的： 二进制中的数字 1 是这样的：

0000...0001

如果将它与任意数字进行二元与，则结果除了最后一位之外的所有位都将为 0因为 0 AND 其他任何值都是 0。当且仅当您的数字的最后一位为 1 时，结果的最后一位将为 1，因为 1 & 1 == 1 和 1 & 0 == 0

这是一个很好的按位运算教程。

HTH。

Answer 2

您可以执行以下操作：

#include <iostream>

int main(int argc, char **argv)
{
    int a = 3;
    std::cout << (a & 1) << std::endl;
    return 0;
}

这样您就可以将变量与 LSB 进行“与”操作，因为

3: 011
1: 001

采用的是 3 位表示形式。因此，AND：

AND
-----
0  0  | 0
0  1  | 0
1  0  | 0
1  1  | 1

您将能够知道 LSB 是否为 1。

编辑：找到MSB。

首先阅读 Endianess 文章以就 MSB 的含义达成一致。在下面的行中，我们假设使用大端表示法进行处理。

为了找到 MSB，在下面的代码片段中，我们将重点应用右移，直到 MSB 与 1< 进行 AND 运算。 /代码>。
考虑以下代码：

#include <iostream>
#include <limits.h>

int main(int argc, char **argv)
{
    unsigned int a = 128; // we want to find MSB of this 32-bit unsigned int
    int MSB = 0;   // this variable will represent the MSB we're looking for

    // sizeof(unsigned int) = 4 (in Bytes)
    // 1 Byte = 8 bits
    // So 4 Bytes are 4 * 8 = 32 bits
    // We have to perform a right shift 32 times to have the
    // MSB in the LSB position.
    for (int i = sizeof(unsigned int) * 8; i > 0; i--) {

        MSB = (a & 1); // in the last iteration this contains the MSB value

        a >>= 1; // perform the 1-bit right shift
    }

    // this prints out '0', because the 32-bit representation of
    // unsigned int 128 is:
    // 00000000000000000000000010000000
    std::cout << "MSB: " << MSB << std::endl; 

    return 0;
}

如果在循环之外打印 MSB，您将得到 0。
如果您更改 a 的值：

unsigned int a = UINT_MAX; // found in <limits.h>

MSB 将是 1，因为它的 32 位表示为：

UINT_MAX: 11111111111111111111111111111111

但是，如果您执行相同的操作使用有符号整数情况会有所不同。

#include <iostream>
#include <limits.h>

int main(int argc, char **argv)
{
    int a = -128; // we want to find MSB of this 32-bit unsigned int
    int MSB = 0; // this variable will represent the MSB we're looking for

    // sizeof(int) = 4 (in Bytes)
    // 1 Byte = 8 bits
    // So 4 Bytes are 4 * 8 = 32 bits
    // We have to perform a right shift 32 times to have the
    // MSB in the LSB position.
    for (int i = sizeof(int) * 8; i > 0; i--) {

        MSB = (a & 1); // in the last iteration this contains the MSB value

        a >>= 1; // perform the 1-bit right shift
    }

    // this prints out '1', because the 32-bit representation of
    // int -128 is:
    // 10000000000000000000000010000000
    std::cout << "MSB: " << MSB << std::endl; 

    return 0;
}

正如我在下面的评论中所说，正整数的MSB始终为0，而MSB 负整数始终为1。

您可以检查 INT_MAX 32 位表示：

INT_MAX: 01111111111111111111111111111111

---

现在。为什么循环使用sizeof()？
如果你只是按照我在评论中写的方式进行循环：（抱歉评论中缺少 =），

for (; a != 0; a >>= 1)
    MSB = a & 1;

你将始终得到 1 ，因为 C++ 不会考虑 '零填充位”（因为您指定了 a != 0 作为退出语句）高于最高的 1。例如，对于 32 位整数，我们有：

int 7 : 00000000000000000000000000000111
                                     ^ this will be your fake MSB
                                       without considering the full size 
                                       of the variable.

int 16: 00000000000000000000000000010000
                                   ^ fake MSB

Answer 3

int LSB = value & 1;
int MSB = value >> (sizeof(value)*8 - 1) & 1;

Answer 4

其他人已经提到：

int LSB = value & 1;

获取最低有效位。但还有一种比上面提到的更欺骗的方法来获取 MSB。如果该值已经是有符号类型，只需执行以下操作：

int MSB = value < 0;

如果它是无符号数量，则将其转换为相同大小的有符号类型，例如，如果 value 被声明为 unsigned , do：

int MSB = (int)value < 0;

是的，正式的，不可移植的，未定义的行为，等等。但在我所知道的每个二进制补码系统和每个编译器上，它恰好可以工作；毕竟，高位是符号位，因此如果有符号形式为负数，则 MSB 为 1，如果为非负数，则 MSB 为 0。所以方便地，负数的有符号测试相当于检索MSB。

Answer 5

LSB 很容易。只是 x & 1.

MSSB 有点棘手，因为 bytes 可能不是 8 位，sizeof(int) 可能不是 4，并且右侧可能有填充位。

另外，对于有符号整数，您的意思是MS值位的符号位。

如果你指的是符号位，那么生活就很容易了。只是 x < 0

如果您指的是最高有效值位，则完全可移植。

 int answer  = 0;
 int rack = 1;
 int mask  = 1;

 while(rack < INT_MAX)
 {
    rack << = 1;
    mask << = 1;
    rack |= 1; 
 } 

 return x & mask;

这是一种冗长的做法。实际上

x & (1 << (sizeof(int) * CHAR_BIT) - 2);
将具有足够的可移植性，并且您的整数不会有填充位。