In C/C++ what's the simplest way to reverse the order of bits in a byte?

This should work:

unsigned char reverse(unsigned char b) {   b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;   b = (b & 0xCC) >> 2 | (b & 0x33) << 2;   b = (b & 0xAA) >> 1 | (b & 0x55) << 1;   return b;}

First the left four bits are swapped with the right four bits. Then all adjacent pairs are swapped and then all adjacent single bits. This results in a reversed order.

I think a lookup table has to be one of the simplest methods. However, you don't need a full lookup table.

//Index 1==0b0001 => 0b1000//Index 7==0b0111 => 0b1110//etcstatic unsigned char lookup[16] = {0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf, };uint8_t reverse(uint8_t n) {   // Reverse the top and bottom nibble then swap them.   return (lookup[n&0b1111] << 4) | lookup[n>>4];}// Detailed breakdown of the math//  + lookup reverse of bottom nibble//  |       + grab bottom nibble//  |       |        + move bottom result into top nibble//  |       |        |     + combine the bottom and top results //  |       |        |     | + lookup reverse of top nibble//  |       |        |     | |       + grab top nibble//  V       V        V     V V       V// (lookup[n&0b1111] << 4) | lookup[n>>4]

This fairly simple to code and verify visually.
Ultimately this might even be faster than a full table. The bit arith is cheap and the table easily fits on a cache line.

If you are talking about a single byte, a table-lookup is probably the best bet, unless for some reason you don't have 256 bytes available.