检查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

如果你使用任意数字二进制和AND,结果的所有位都将为0,除了最后一位,因为0和其他任何东西都是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;
}

这样你就AND可以使用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.在以下几行中,我们假设使用big-endian表示法处理.

要查找MSB,在下面的代码片段中,我们将重点应用右移,直到MSB将AND使用1.请考虑以下代码:

#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;