Reversing the bits of an integer in C

Question

I am trying to reverse the bits of an integer in the C program. Even though I have looked at the same question by another user, I was unable to understand most of the code that was written. I have noticed that the code I have is similar to the answer by Eregrith but I cannot identify the problem with my code below:

#include <stdio.h>
#include <stdlib.h>

unsigned int reverse_bits(unsigned int num)
{
unsigned int reverse_num = 0; /* initialize the result*/
unsigned int count = sizeof(unsigned int) * 8 - 1; /* counter to track the number of bits in the integer*/

while (num != 0)
{
    unsigned int last_bit = num & 1; /* get the right-most bit*/
    reverse_num = reverse_num | last_bit; /* add that bit to the right-most bit of the desired reversed bits*/
    reverse_num = reverse_num << 1; /* shift the reversed bits left*/
    num = num >> 1; /* shift the original bits right*/
    count--;
}
reverse_num = reverse_num << count; /* If the original bits have only 0
s then shift the remaining bits left*/

return reverse_num;
}

int main()
{

reverse_bits(1);
}

If I enter reverse_bits(1), the code returns -2147483648, which clearly did not reverse the bits of the integer 1. I am new to code and I am having difficulty locating the source of this error. Without having to change the entire code, how can I modify my existing code to return the correct output?

Answer 1

How do you observed that it returns a negative value? unsigned ints only are used in your code... I supposed that you tried to print the returned value as an int with %d, but that is undefined behavior. To print an unsigned you must use %u or %x.

But your reversal is wrong. You shift the result after adding the last bit, which should be the converse. You also miss the count of bits in an unsigned int (less by one). The following should work:

#include <stdio.h>
#include <stdlib.h>

unsigned int reverse_bits(unsigned int num) {
  unsigned int reverse_num = 0; /* initialize the result*/
  unsigned int count = sizeof(unsigned int) * 8; /* counter to track the number of bits in the integer*/

  while (num != 0) {
      unsigned int last_bit = num & 1; /* get the right-most bit*/
      reverse_num <<= 1; /* add one place for the next bit */
      reverse_num |= last_bit; /* add that bit to the right-most bit of the desired reversed bits*/
      num >>= 1; /* remove one bit from the original */
      count--;
    }
  reverse_num <<= count; /* If the original bits have only 0 s then shift the remaining bits left*/
  return reverse_num;
}

int main() {
  printf("%08x\n",reverse_bits(1));
  printf("%08x\n",reverse_bits(3));
  printf("%08x\n",reverse_bits(0x0F0FFFFF));
}

---- EDIT ----

As comments mentioned the possible? UB in the case of num begin null, I suggest to add a test to eliminate that problem:

  if (count!=sizeof(reverse_num)) {
      reverse_num <<= count; /* If the original bits have only 0 s then shift the remaining bits left*/
  } else {
      reverse_num = 0;
  }
  return reverse_num;

Answer 2

Although you didn't provide the part of code that does the printing, it is somehow obvious that you are mixing int and unsigned int.

For printf() function family the specifier for unsigned int is %u so if you want to print your output, you should use:

printf("%u\n", reverse_bits(1));

Other than that your code is OK and besides, note that if a machine uses 2's complement and 32 bits for an int, -2147483648 = 10000000000000000000000000000000 which is a bit reversal of 1 = 00000000000000000000000000000001.