Check value of least significant bit (LSB) and most significant bit (MSB) in C/C++

Question

I need to check the value of the least significant bit (LSB) and most significant bit (MSB) of an integer in C/C++. How would I do this?

Answer 1

LSB is easy. Just x & 1.

MSSB is a bit trickier, as bytes may not be 8 bits and sizeof(int) may not be 4, and there might be padding bits to the right.

Also, with a signed integer, do you mean the sign bit of the MS value bit.

If you mean the sign bit, life is easy. It's just x < 0

If you mean the most significant value bit, to be completely portable.

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

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

 return x & mask;

That's a long-winded way of doing it. In reality

x & (1 << (sizeof(int) * CHAR_BIT) - 2); will be quite portable enough and your ints won't have padding bits.

Answer 2

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

Answer 3

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

Alternatively (which is not theoretically portable, but practically it is - see Steve's comment)

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

Details: The second formula is simpler. The % operator is the remainder operator. A number's LSB is 1 iff it is an odd number and 0 otherwise. So we check the remainder of dividing with 2. The logic of the first formula is this: number 1 in binary is this:

0000...0001

If you binary-AND this with an arbitrary number, all the bits of the result will be 0 except the last one because 0 AND anything else is 0. The last bit of the result will be 1 iff the last bit of your number was 1 because 1 & 1 == 1 and 1 & 0 == 0

This is a good tutorial for bitwise operations.

HTH.

Answer 4

Others have already mentioned:

int LSB = value & 1;

for getting the least significant bit. But there is a cheatier way to get the MSB than has been mentioned. If the value is a signed type already, just do:

int MSB = value < 0;

If it's an unsigned quantity, cast it to the signed type of the same size, e.g. if value was declared as unsigned, do:

int MSB = (int)value < 0;

Yes, officially, not portable, undefined behavior, whatever. But on every two's complement system and every compiler for them that I'm aware of, it happens to work; after all, the high bit is the sign bit, so if the signed form is negative, then the MSB is 1, if it's non-negative, the MSB is 0. So conveniently, a signed test for negative numbers is equivalent to retrieving the MSB.

Answer 5

You can do something like this:

#include <iostream>

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

This way you AND your variable with the LSB, because

3: 011
1: 001

in 3-bit representation. So being AND:

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

You will be able to know if LSB is 1 or not.

edit: find MSB.

First of all read Endianess article to agree on what MSB means. In the following lines we suppose to handle with big-endian notation.

To find the MSB, in the following snippet we will focus applying a right shift until the MSB will be ANDed with 1. Consider the following code:

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

If you print MSB outside of the cycle you will get 0. If you change the value of a:

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

MSB will be 1, because its 32-bit representation is:

UINT_MAX: 11111111111111111111111111111111

However, if you do the same thing with a signed integer things will be different.

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

As I said in the comment below, the MSB of a positive integer is always 0, while the MSB of a negative integer is always 1.

You can check INT_MAX 32-bit representation:

INT_MAX: 01111111111111111111111111111111

---

Now. Why the cycle uses sizeof()? If you simply do the cycle as I wrote in the comment: (sorry for the = missing in comment)

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

you will get 1 always, because C++ won't consider the 'zero-pad bits' (because you specified a != 0 as exit statement) higher than the highest 1. For example for 32-bit integers we have:

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

int 16: 00000000000000000000000000010000
                                   ^ fake MSB