What are 0x01 and 0x80 representative of in C bitwise operations?

Question

I'm trying to reverse the order of bits in C (homework question, subject: bitwise operators). I found this solution, but I'm a little confused by the hex values used -- 0x01 and 0x80.

  unsigned char reverse(unsigned char c) {
     int shift;
     unsigned char result = 0;

     for (shift = 0; shift < CHAR_BITS; shift++) {
        if (c & (0x01 << shift))
            result |= (0x80 >> shift);
     }
     return result;
  }

The book I'm working out of hasn't discussed these kinds of values, so I'm not really sure what to make of them. Can somebody shed some light on this solution? Thank you!

Answer 1

0x01 is the least significant bit set, hence the decimal value is 1.

0x80 is the most significant bit of an 8-bit byte set. If it is stored in a signed char (on a machine that uses 2's-complement notation - as most machines you are likely to come across will), it is the most negative value (decimal -128); in an unsigned char, it is decimal +128.

The other pattern that becomes second nature is 0xFF with all bits set; this is decimal -1 for signed characters and 255 for unsigned characters. And, of course, there's 0x00 or zero with no bits set.

What the loop does on the first cycle is to check if the LSB (least significant bit) is set, and if it is, sets the MSB (most significant bit) in the result. On the next cycle, it checks the next to LSB and sets the next to MSB, etc.

| MSB |     |     |     |     |     |     | LSB |
|  1  |  0  |  1  |  1  |  0  |  0  |  1  |  1  |   Input
|  1  |  1  |  0  |  0  |  1  |  1  |  0  |  1  |   Output
|  1  |  0  |  0  |  0  |  0  |  0  |  0  |  0  |   0x80
|  0  |  0  |  0  |  0  |  0  |  0  |  0  |  1  |   0x01
|  0  |  1  |  0  |  0  |  0  |  0  |  0  |  0  |   (0x80 >> 1)
|  0  |  0  |  0  |  0  |  0  |  0  |  1  |  0  |   (0x01 << 1)

Answer 2

Each hex digit represents 4bits, so

• 0x01 is just a long way of writing 1.
• 0x80 is a short way of writing in binary [1000][0000], or 128.

The solution is using bitwise operators to test and set values.

The expression:

if (a & b) { ... }

executes '...' if the same bit is 1 in both 'a' and 'b'.

The expression

c |= b

sets the bits in 'c' to 1, if they are 1 in 'b'.

The loop moves the test & set bit down the line.

Good luck!

Answer 3

The values 0x01 and 0x80 are purposely written in hexadecimal notation to underscore their significance as the least significant and the most significant bits of the type unsigned char.

Yet the author made several mistakes:

• the macro CHAR_BITS is misspelled: it should be CHAR_BIT.
• using CHAR_BIT instead of hard-coding the almost universal value 8 is a valuable effort for complete portability, yet this effort is nullified by the use of 0x80 which is only valid if CHAR_BIT == 8.
• there is another subtle portability problem: 0x01 << shift would have undefined behavior for shift = CHAR_BIT-1 on a platform where sizeof(unsigned char) == sizeof(int) because 0x01 has type int (and not unsigned int, counter-intuitive is it not?).

Here is a corrected version that works on all conformant platforms:

#include <limits.h>

unsigned char reverse(unsigned char c) {
    int shift;
    unsigned char result = 0;

    for (shift = 0; shift < CHAR_BIT; shift++) {
        result <<= 1;
        result |= c & 1;
        c >>= 1;
    }
    return result;
}