In C C what s the simplest way to reverse the order of bits in a byte

Question

While there are multiple ways to reverse bit order in a byte  I m curious as to what is the  simplest  for a developer to implement   And by reversing I mean   1110 - gt  0111 0010 - gt  0100   This is similar to  but not a duplicate of this PHP question   This is similar to  but not a duplicate of this C question  This question is asking for the easiest method to implement by a developer  The  Best Algorithm  is concerned with memory and cpu performance

User · Answer

For the very limited case of constant  8-bit input  this method costs no memory or CPU at run-time    define MSB2LSB b     b  amp 1 128 0    b  amp 2 64 0    b  amp 4 32 0    b  amp 8 16 0    b  amp 16 8 0    b  amp 32 4 0    b  amp 64 2 0    b  amp 128 1 0     I used this for ARINC-429 where the bit order  endianness  of the label is opposite the rest of the word  The label is often a constant  and conventionally in octal     Here s how I used it to define a constant  because the spec defines this label as big-endian 205 octal     define LABEL HF COMM MSB2LSB 0205    More examples   assert 0b00000000    MSB2LSB 0b00000000    assert 0b10000000    MSB2LSB 0b00000001    assert 0b11000000    MSB2LSB 0b00000011    assert 0b11100000    MSB2LSB 0b00000111    assert 0b11110000    MSB2LSB 0b00001111    assert 0b11111000    MSB2LSB 0b00011111    assert 0b11111100    MSB2LSB 0b00111111    assert 0b11111110    MSB2LSB 0b01111111    assert 0b11111111    MSB2LSB 0b11111111    assert 0b10101010    MSB2LSB 0b01010101

User · Answer

typedef struct       uint8 t b0 1      uint8 t b1 1      uint8 t b2 1      uint8 t b3 1      uint8 t b4 1      uint8 t b5 1      uint8 t b6 1      uint8 t b7 1    bits t   uint8 t reverse bits uint8 t src        uint8 t dst   0x0      bits t  src bits    bits t    amp src      bits t  dst bits    bits t    amp dst       dst bits- gt b0   src bits- gt b7      dst bits- gt b1   src bits- gt b6      dst bits- gt b2   src bits- gt b5      dst bits- gt b3   src bits- gt b4      dst bits- gt b4   src bits- gt b3      dst bits- gt b5   src bits- gt b2      dst bits- gt b6   src bits- gt b1      dst bits- gt b7   src bits- gt b0       return dst

User · Answer

This simple function uses a mask to test each bit in the input byte and transfer it into a shifting output   char Reverse Bits char input            char output   0       for  unsigned char mask   1  mask  gt  0  mask  lt  lt   1                output  lt  lt   1           if  input  amp  mask              output    1             return output

User · Answer

The simplest way is probably to iterate over the bit positions in a loop   unsigned char reverse unsigned char c       int shift     unsigned char result   0     for  shift   0  shift  lt  CHAR BIT  shift            if  c  amp   0x01  lt  lt  shift            result     0x80  gt  gt  shift           return result

User · Answer

Assuming that your compiler allows unsigned long long   unsigned char reverse unsigned char b      return  b   0x0202020202ULL  amp  0x010884422010ULL    1023      Discovered here

User · Answer

Can this be fast solution   int byte to be reversed          byte to be reversed gt  gt 7  amp 0x01    byte to be reversed gt  gt 5  amp 0x02               byte to be reversed gt  gt 3  amp 0x04    byte to be reversed gt  gt 1  amp 0x08          byte to be reversed lt  lt 7  amp 0x80    byte to be reversed lt  lt 5  amp 0x40         byte to be reversed lt  lt 3  amp 0x20    byte to be reversed lt  lt 1  amp 0x10     Gets rid of the hustle of using a for loop  but experts please tell me if this is efficient and faster

User · Answer

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   gt  0b1000   Index 7  0b0111   gt  0b1110   etc static 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 amp 0b1111   lt  lt  4    lookup n gt  gt 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 amp 0b1111   lt  lt  4    lookup n gt  gt 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

User · Answer

If you using small microcontroller and need high speed solution with small footprint  this could be solutions  It is possible to use it for C project  but you need to add this file as assembler file   asm  to your C project  Instructions  In C project add this declaration   extern uint8 t byte mirror uint8 t     Call this function from C  byteOutput  byte mirror byteInput     This is the code  it is only suitable for 8051 core  In the CPU register r0 is data from byteInput  Code rotate right r0 cross carry and then rotate carry left to r1  Repeat this procedure 8 times  for every bit  Then the register r1 is returned to c function as byteOutput  In 8051 core is only posibble to rotate acumulator a   NAME     BYTE MIRROR RSEG     RCODE PUBLIC   byte mirror                8051 core          byte mirror     mov r3  8  loop         mov a r0      rrc a      mov r0 a          mov a r1      rlc a         mov r1 a      djnz r3 loop     mov r0 a     ret   PROS  It is small footprint  it is high speed CONS  It is not reusable code  it is only for 8051  011101101- carry  101101110 lt -carry

User · Answer

Since nobody posted a complete table lookup solution  here is mine   unsigned char reverse byte unsigned char x        static const unsigned char table               0x00  0x80  0x40  0xc0  0x20  0xa0  0x60  0xe0          0x10  0x90  0x50  0xd0  0x30  0xb0  0x70  0xf0          0x08  0x88  0x48  0xc8  0x28  0xa8  0x68  0xe8          0x18  0x98  0x58  0xd8  0x38  0xb8  0x78  0xf8          0x04  0x84  0x44  0xc4  0x24  0xa4  0x64  0xe4          0x14  0x94  0x54  0xd4  0x34  0xb4  0x74  0xf4          0x0c  0x8c  0x4c  0xcc  0x2c  0xac  0x6c  0xec          0x1c  0x9c  0x5c  0xdc  0x3c  0xbc  0x7c  0xfc          0x02  0x82  0x42  0xc2  0x22  0xa2  0x62  0xe2          0x12  0x92  0x52  0xd2  0x32  0xb2  0x72  0xf2          0x0a  0x8a  0x4a  0xca  0x2a  0xaa  0x6a  0xea          0x1a  0x9a  0x5a  0xda  0x3a  0xba  0x7a  0xfa          0x06  0x86  0x46  0xc6  0x26  0xa6  0x66  0xe6          0x16  0x96  0x56  0xd6  0x36  0xb6  0x76  0xf6          0x0e  0x8e  0x4e  0xce  0x2e  0xae  0x6e  0xee          0x1e  0x9e  0x5e  0xde  0x3e  0xbe  0x7e  0xfe          0x01  0x81  0x41  0xc1  0x21  0xa1  0x61  0xe1          0x11  0x91  0x51  0xd1  0x31  0xb1  0x71  0xf1          0x09  0x89  0x49  0xc9  0x29  0xa9  0x69  0xe9          0x19  0x99  0x59  0xd9  0x39  0xb9  0x79  0xf9          0x05  0x85  0x45  0xc5  0x25  0xa5  0x65  0xe5          0x15  0x95  0x55  0xd5  0x35  0xb5  0x75  0xf5          0x0d  0x8d  0x4d  0xcd  0x2d  0xad  0x6d  0xed          0x1d  0x9d  0x5d  0xdd  0x3d  0xbd  0x7d  0xfd          0x03  0x83  0x43  0xc3  0x23  0xa3  0x63  0xe3          0x13  0x93  0x53  0xd3  0x33  0xb3  0x73  0xf3          0x0b  0x8b  0x4b  0xcb  0x2b  0xab  0x6b  0xeb          0x1b  0x9b  0x5b  0xdb  0x3b  0xbb  0x7b  0xfb          0x07  0x87  0x47  0xc7  0x27  0xa7  0x67  0xe7          0x17  0x97  0x57  0xd7  0x37  0xb7  0x77  0xf7          0x0f  0x8f  0x4f  0xcf  0x2f  0xaf  0x6f  0xef          0x1f  0x9f  0x5f  0xdf  0x3f  0xbf  0x7f  0xff             return table x

User · Answer

Although probably not portable  I would use assembly language  Many assembly languages have instructions to rotate a bit into the carry flag and to rotate the carry flag into the word  or byte    The algorithm is   for each bit in the data type    rotate bit into carry flag   rotate carry flag into destination  end-for   The high level language code for this is much more complicated  because C and C   do not support rotating to carry and rotating from carry   The carry flag has to modeled   Edit   Assembly language for example     Enter with value to reverse in R0     Assume 8 bits per byte and byte is the native processor type     LODI  R2  8         Set up the bit counter Loop     RRC  R0             Rotate R0 right into the carry bit     RLC  R1             Rotate R1 left  then append carry bit     DJNZ  R2  Loop      Decrement R2 and jump if non-zero to  loop     LODR  R0  R1        Move result into R0

User · Answer

I know that this question is dated but I still think that the topic is relevant for some purposes  and here is a version that works very well and is readable  I can not say that it is the fastest or the most efficient  but it ought to be one of the cleanest  I have also included a helper function for easily displaying the bit patterns  This function uses some of the standard library functions instead of writing your own bit manipulator    include  lt algorithm gt   include  lt bitset gt   include  lt exception gt   include  lt iostream gt   include  lt limits gt   include  lt string gt      helper lambda function template template lt typename T gt  auto getBits      T value        return std  bitset lt sizeof T    CHAR BIT gt  value          Function template to flip the bits    This will work on integral types such as int  unsigned int     std  uint8 t  16 t etc  I did not test this with floating    point types  I chose to use the  bitset  here to convert    from T to string as I find it easier to use than some of the    string to type or type to string conversion functions     especially when the bitset has a function to return a string   template lt typename T gt  T reverseBits T amp  value        static constexpr std  uint16 t bit count   sizeof T    CHAR BIT          Do not use the helper function in this function      auto bits   std  bitset lt bit count gt  value       auto str   bits to string        std  reverse str begin    str end         bits   std  bitset lt bit count gt  str       return static cast lt T gt   bits to ullong            main program int main         try           std  uint8 t value   0xE0     1110 0000          std  cout  lt  lt   value  lt  lt    n      don t forget to promote unsigned char            Here is where I use the helper function to display the bit pattern         auto bits   getBits lt std  uint8 t gt  value           std  cout  lt  lt  bits to string    lt  lt    n            value   reverseBits value           std  cout  lt  lt   value  lt  lt    n        for integer promotion             using helper function again            bits   getBits lt std  uint8 t gt  value           std  cout  lt  lt  bits to string    lt  lt    n          catch const std  exception amp  e              std  cerr  lt  lt  e what            return EXIT FAILURE            return EXIT SUCCESS      And it gives the following output   224 11100000 7 00000111

User · Answer

a slower but simpler implementation   static int swap bit unsigned char unit                  swap bit 7  and bit 0              unit        unit  amp  0x80   gt  gt  7     unit  amp  0x01    lt  lt  7     unit  amp  0x7f        unit        unit  amp  0x80   gt  gt  7     unit  amp  0x01       unit  amp  0xfe        unit        unit  amp  0x80   gt  gt  7     unit  amp  0x01    lt  lt  7     unit  amp  0x7f                   swap bit 6  and bit 1              unit        unit  amp  0x40   gt  gt  5     unit  amp  0x02    lt  lt  5     unit  amp  0xbf        unit        unit  amp  0x40   gt  gt  5     unit  amp  0x02       unit  amp  0xfd        unit        unit  amp  0x40   gt  gt  5     unit  amp  0x02    lt  lt  5     unit  amp  0xbf                   swap bit 5  and bit 2              unit        unit  amp  0x20   gt  gt  3     unit  amp  0x04    lt  lt  3     unit  amp  0xdf        unit        unit  amp  0x20   gt  gt  3     unit  amp  0x04       unit  amp  0xfb        unit        unit  amp  0x20   gt  gt  3     unit  amp  0x04    lt  lt  3     unit  amp  0xdf                   swap bit 4  and bit 3              unit        unit  amp  0x10   gt  gt  1     unit  amp  0x08    lt  lt  1     unit  amp  0xef        unit        unit  amp  0x10   gt  gt  1     unit  amp  0x08       unit  amp  0xf7        unit        unit  amp  0x10   gt  gt  1     unit  amp  0x08    lt  lt  1     unit  amp  0xef         return unit

User · Answer

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

User · Answer

xor ax ax   xor bx bx   mov cx 8   mov al original byte  cycle    shr al 1   jnc not inc   inc bl not inc  test cx cx   jz end cycle   shl bl 1   loop cycle end cycle    reversed byte will be at bl register

User · Answer

unsigned char c      the original unsigned char u      the reversed c gt  gt 7 amp 0b00000001   c lt  lt 7 amp 0b10000000   c gt  gt 5 amp 0b00000010   c lt  lt 5 amp 0b01000000   c gt  gt 3 amp 0b00000100   c lt  lt 3 amp 0b00100000   c gt  gt 1 amp 0b00001000   c lt  lt 1 amp 0b00010000    Explanation  exchanged bits as per the arrows below  01234567  lt ------ gt    lt ---- gt      lt -- gt        lt  gt

User · Answer

How about this one     int value   0xFACE   value     0xFF  amp  value  lt  lt  8     val  gt  gt  8

User · Answer

This one is based on the one BobStein-VisiBone provided   define reverse 1byte b         uint8 t b  amp  0b00000001    0b10000000   0                                       uint8 t b  amp  0b00000010    0b01000000   0                                       uint8 t b  amp  0b00000100    0b00100000   0                                       uint8 t b  amp  0b00001000    0b00010000   0                                       uint8 t b  amp  0b00010000    0b00001000   0                                       uint8 t b  amp  0b00100000    0b00000100   0                                       uint8 t b  amp  0b01000000    0b00000010   0                                       uint8 t b  amp  0b10000000    0b00000001   0      I really like this one a lot because the compiler automatically handle the work for you  thus require no further resources   this can also be extended to 16-Bits      define reverse 2byte b         uint16 t b  amp  0b0000000000000001    0b1000000000000000   0                                       uint16 t b  amp  0b0000000000000010    0b0100000000000000   0                                       uint16 t b  amp  0b0000000000000100    0b0010000000000000   0                                       uint16 t b  amp  0b0000000000001000    0b0001000000000000   0                                       uint16 t b  amp  0b0000000000010000    0b0000100000000000   0                                       uint16 t b  amp  0b0000000000100000    0b0000010000000000   0                                       uint16 t b  amp  0b0000000001000000    0b0000001000000000   0                                       uint16 t b  amp  0b0000000010000000    0b0000000100000000   0                                       uint16 t b  amp  0b0000000100000000    0b0000000010000000   0                                       uint16 t b  amp  0b0000001000000000    0b0000000001000000   0                                       uint16 t b  amp  0b0000010000000000    0b0000000000100000   0                                       uint16 t b  amp  0b0000100000000000    0b0000000000010000   0                                       uint16 t b  amp  0b0001000000000000    0b0000000000001000   0                                       uint16 t b  amp  0b0010000000000000    0b0000000000000100   0                                       uint16 t b  amp  0b0100000000000000    0b0000000000000010   0                                       uint16 t b  amp  0b1000000000000000    0b0000000000000001   0

User · Answer

include  lt stdio h gt   include  lt stdlib h gt   int main         int i      unsigned char rev   0x70      0b01110000     unsigned char tmp   0       for i 0 i lt 8 i              tmp        rev  amp   1 lt  lt i   1 0   lt  lt   7-i              rev   tmp       printf   x   rev           0b00001110 binary value of given number     return 0

User · Answer

Here is a simple and readable solution  portable to all conformant platforms  including those with sizeof char     sizeof int     include  lt limits h gt   unsigned char reverse unsigned char c        int shift      unsigned char result   0       for  shift   0  shift  lt  CHAR BIT  shift              result  lt  lt   1          result    c  amp  1          c  gt  gt   1            return result

User · Answer

Two lines   for i 0 i lt 8 i         reversed      original gt  gt i   amp  0b1  lt  lt  7-i     or in case you have issues with the  0b1  part   for i 0 i lt 8 i         reversed      original gt  gt i   amp  1  lt  lt  7-i      original  is the byte you want to reverse   reversed  is the result  initialized to 0

User · Answer

define BITS SIZE 8  int reverseBits   int a       int rev   0    int i        scans each bit of the input number     for   i   0  i  lt  BITS SIZE - 1  i                checks if the bit is 1        if   a  amp    1  lt  lt  i                    shifts the bit 1  starting from the MSB to LSB          to build the reverse number                 rev    1  lt  lt    BITS SIZE - 1   - i               return rev

User · Answer

How about just XOR the byte with 0xFF   unsigned char reverse unsigned char b       b    0xFF     return b

User · Answer

Before implementing any algorithmic solution  check the assembly language for whatever CPU architecture you are using   Your architecture may include instructions which handle bitwise manipulations like this  and what could be simpler than a single assembly instruction     If such an instruction is not available  then I would suggest going with the lookup table route   You can write a script program to generate the table for you  and the lookup operations would be faster than any of the bit-reversing algorithms here  at the cost of having to store the lookup table somewhere

User · Answer

Table lookup or  uint8 t rev byte uint8 t x        uint8 t y      uint8 t m   1      while  m           y  gt  gt   1         if  m amp x              y    0x80                  m  lt  lt  1            return y      edit  Look here for other solutions that might work better for you

User · Answer

See the bit twiddling hacks for many solutions  Copypasting from there is obviously simple to implement      For example  on a 32-bit CPU    uint8 t b   byte to reverse  b     b   0x0802LU  amp  0x22110LU     b   0x8020LU  amp  0x88440LU     0x10101LU  gt  gt  16    If by    simple to implement    one means something that can be done without a reference in an exam or job interview  then the safest bet is probably the inefficient copying of bits one by one into another variable in reverse order  already shown in other answers

User · Answer

include  lt stdio h gt   include  lt stdlib h gt    define BIT0  0x01   define BIT1  0x02   define BIT2  0x04   define BIT3  0x08   define BIT4  0x10   define BIT5  0x20   define BIT6  0x40   define BIT7  0x80    define BYTE TO BINARY PATTERN   c c c c c c c c n    define BITETOBINARY byte     byte  amp  BIT7    1     0       byte  amp  BIT6    1     0       byte  amp  BIT5    1     0       byte  amp  BIT4    1     0       byte  amp  BIT3    1     0       byte  amp  BIT2    1     0       byte  amp  BIT1    1     0       byte  amp  BIT0    1     0       define BITETOBINARYREVERSE byte     byte  amp  BIT0    1     0       byte  amp  BIT1    1     0       byte  amp  BIT2    1     0       byte  amp  BIT3    1     0       byte  amp  BIT4    1     0       byte  amp  BIT5    1     0       byte  amp  BIT6    1     0       byte  amp  BIT7    1     0        int main          int i j c       i    BIT2 BIT7       printf  0x 02X n  i            printf BYTE TO BINARY PATTERN BITETOBINARY i         printf  Reverse         printf BYTE TO BINARY PATTERN BITETOBINARYREVERSE i        return 0

User · Answer

template  lt typename T gt  T reverse T n  size t b   sizeof T    CHAR BIT        assert b  lt   std  numeric limits lt T gt   digits        T rv   0       for  size t i   0  i  lt  b    i  n  gt  gt   1            rv    rv  lt  lt  1     n  amp  0x01              return rv      EDIT   Converted it to a template with the optional bitcount

User · Answer

I think this is simple enough  uint8 t reverse uint8 t a      unsigned w     a  lt  lt  7   amp  0x0880      a  lt  lt  5   amp  0x0440      a  lt  lt  3   amp  0x0220      a  lt  lt  1   amp  0x0110     return static cast lt uint8 t gt  w    w gt  gt 8        or  uint8 t reverse uint8 t a      unsigned w     a  amp  0x11   lt  lt  7      a  amp  0x22   lt  lt  5      a  amp  0x44   lt  lt  3      a  amp  0x88   lt  lt  1     return static cast lt uint8 t gt  w    w gt  gt 8

User · Answer

I find the following solution simpler than the other bit fiddling algorithms I ve seen in here   unsigned char reverse byte char a       return   a  amp  0x1    lt  lt  7      a  amp  0x2    lt  lt  5               a  amp  0x4    lt  lt  3      a  amp  0x8    lt  lt  1               a  amp  0x10   gt  gt  1      a  amp  0x20   gt  gt  3               a  amp  0x40   gt  gt  5      a  amp  0x80   gt  gt  7       It gets every bit in the byte  and shifts it accordingly  starting from the first to the last   Explanation        a  amp  0x1   lt  lt  7    get first bit on the right and shift it into the first left position       a  amp  0x2   lt  lt  5    add it to the second bit and shift it into the second left position     and so on

User · Answer

This is an old question  but nobody seems to have shown the clear easy way  the closest was edW    I used C  to test this  but there s nothing in this example that couldn t be done easily in C   void PrintBinary string prompt  int num  int pad   8        Debug WriteLine    prompt    Convert ToString num  2  PadLeft pad   0          int ReverseBits int num        int result   0      int saveBits   num      for  int i   1  i  lt   8  i                     Move the result one bit to the left         result   result  lt  lt  1             PrintBinary  saveBits   saveBits               Extract the right-most bit         var nextBit   saveBits  amp  1             PrintBinary  nextBit   nextBit  1               Add our extracted bit to the result         result   result   nextBit             PrintBinary  result   result               We re done with that bit  rotate it off the right         saveBits   saveBits  gt  gt  1             Debug WriteLine                 return result     void PrintTest int nextNumber        var result   ReverseBits nextNumber        Debug WriteLine  ---------------------------------------        PrintBinary  Original   nextNumber       PrintBinary  Reverse   result      void Main            Calculate the reverse for each number between 1 and 255     for  int x   250  x  lt  256  x            PrintTest x

User · Answer

This should work  unsigned char reverse unsigned char b       b    b  amp  0xF0   gt  gt  4    b  amp  0x0F   lt  lt  4     b    b  amp  0xCC   gt  gt  2    b  amp  0x33   lt  lt  2     b    b  amp  0xAA   gt  gt  1    b  amp  0x55   lt  lt  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

User · Answer

You may be interested in std  vector lt bool gt   that is bit-packed  and std  bitset  It should be the simplest as requested    include  lt iostream gt   include  lt bitset gt  using namespace std  int main       bitset lt 8 gt  bs   5    bitset lt 8 gt  rev    for int ii 0  ii   bs size      ii      rev bs size  -ii-1    bs ii     cerr  lt  lt  bs  lt  lt       lt  lt  rev  lt  lt  endl      Other options may be faster   EDIT  I owe you a solution using std  vector lt bool gt    include  lt algorithm gt   include  lt iterator gt   include  lt iostream gt   include  lt vector gt  using namespace std  int main       vector lt bool gt  b 0 0 0 0 0 1 0 1     reverse b begin    b end       copy b begin    b end    ostream iterator lt int gt  cerr      cerr  lt  lt  endl      The second example requires c  0x extension  to initialize the array with         The advantage of using a bitset or a std  vector lt bool gt   or a boost  dynamic bitset  is that you are not limited to bytes or words but can reverse an arbitrary number of bits   HTH

User · Answer

There are many ways to reverse bits depending on what you mean the  quot simplest way quot    Reverse by Rotation Probably the most logical  consists in rotating the byte while applying a mask on the first bit  n  amp  1   unsigned char reverse bits unsigned char b        unsigned char   r   0      unsigned        byte len   8       while  byte len--            r    r  lt  lt  1     b  amp  1           b  gt  gt   1            return r      As the length of an unsigner char is 1 byte  which is equal to 8 bits  it means we will scan each bit while  byte len--   We first check if b as a bit on the extreme right with  b  amp  1   if so we set bit 1 on r with   and move it just 1 bit to the left by multiplying r by 2 with  r  lt  lt  1   Then we divide our unsigned char b by 2 with b  gt  gt  1 to erase the bit located at the extreme right of variable b  As a reminder  b  gt  gt   1  is equivalent to b    2     Reverse in One Line This solution is attributed to Rich Schroeppel in the Programming Hacks section unsigned char reverse bits3 unsigned char b        return  b   0x0202020202ULL  amp  0x010884422010ULL    0x3ff      The multiply operation  b   0x0202020202ULL  creates five separate copies of the 8-bit byte pattern to fan-out into a 64-bit value   The AND operation   amp  0x010884422010ULL  selects the bits that are in the correct  reversed  positions  relative to each 10-bit groups of bits   Together the multiply and the AND operations copy the bits from the original byte so they each appear in only one of the 10-bit sets  The reversed positions of the bits from the original byte coincide with their relative positions within any 10-bit set   The last step    0x3ff   which involves modulus division by 2 10 - 1 has the effect of merging together each set of 10 bits  from positions 0-9  10-19  20-29       in the 64-bit value  They do not overlap  so the addition steps underlying the modulus division behave like OR operations     Divide and Conquer Solution unsigned char reverse unsigned char b       b    b  amp  0xF0   gt  gt  4    b  amp  0x0F   lt  lt  4     b    b  amp  0xCC   gt  gt  2    b  amp  0x33   lt  lt  2     b    b  amp  0xAA   gt  gt  1    b  amp  0x55   lt  lt  1     return b     This is the most upvoted answer and despite some explanations  I think that for most people it feels difficult to visualize whats 0xF0  0xCC  0xAA  0x0F  0x33 and 0x55 truly means  It does not take advantage of  0b  which is a GCC extension and is included since the C  14 standard  release in December 2014  so a while after this answer dating from April 2010  Integer constants can be written as binary constants  consisting of a sequence of    0    and    1    digits  prefixed by    0b    or    0B     This is particularly useful in environments that operate a lot on the bit level  like microcontrollers    Please check below code snippets to remember and understand even better this solution where we move half by half  unsigned char reverse unsigned char b       b    b  amp  0b11110000   gt  gt  4    b  amp  0b00001111   lt  lt  4     b    b  amp  0b11001100   gt  gt  2    b  amp  0b00110011   lt  lt  2     b    b  amp  0b10101010   gt  gt  1    b  amp  0b01010101   lt  lt  1     return b     NB  The  gt  gt  4 is because there are 8 bits in 1 byte  which is an unsigned char so we want to take the other half  and so on  We could easily apply this solution to 4 bytes with only two additional lines and following the same logic  Since both mask complement each other we can even use   in order to switch bits and saving some ink  uint32 t reverse integer bits uint32 t b       uint32 t mask   0b11111111111111110000000000000000     b    b  amp  mask   gt  gt  16    b  amp   mask   lt  lt  16     mask   0b11111111000000001111111100000000     b    b  amp  mask   gt  gt  8    b  amp   mask   lt  lt  8     mask   0b11110000111100001111000011110000     b    b  amp  mask   gt  gt  4    b  amp   mask   lt  lt  4     mask   0b11001100110011001100110011001100     b    b  amp  mask   gt  gt  2    b  amp   mask   lt  lt  2     mask   0b10101010101010101010101010101010     b    b  amp  mask   gt  gt  1    b  amp   mask   lt  lt  1     return b       C   Only  Reverse Any Unsigned  Template  The above logic can be summarized with a loop that would work on any type of unsigned  template  lt class T gt  T reverse bits T n        short bits   sizeof n    8       T mask    T 0      equivalent to uint32 t mask   0b11111111111111111111111111111111           while  bits  gt  gt   1            mask    mask  lt  lt   bits      will convert mask to 0b00000000000000001111111111111111          n    n  amp   mask   gt  gt  bits    n  amp  mask   lt  lt  bits     divide and conquer            return n      C   17 only You may use a table that store the reverse value of each byte with  i   0x0202020202ULL  amp  0x010884422010ULL    0x3ff  initialized through a lambda  you will need to compile it with g   -std c  1z since it only works since C  17   and then return the value in the table will give you the accordingly reversed bit   include  lt cstdint gt   include  lt array gt   uint8 t reverse bits uint8 t n            static constexpr array lt uint8 t  256 gt  table      constexpr                  constexpr size t SIZE   256                  array lt uint8 t  SIZE gt  result                     for  size t i   0  i  lt  SIZE    i                      result i     i   0x0202020202ULL  amp  0x010884422010ULL    0x3ff                  return result                     return table n       main cpp Try it yourself with inclusion of above function   include  lt stdint h gt   include  lt stdio h gt   include  lt stdlib h gt   template  lt class T gt  void print binary T n      T mask   1ULL  lt  lt    sizeof n    8  - 1       will set the most significant bit     for   mask    0  mask  gt  gt   1  putchar  0       n  amp  mask        putchar   n       int main         uint32 t n   12      print binary n       n   reverse bits n        print binary n       unsigned char c    a       print binary c       c   reverse bits c       print binary c       uint16 t s   12      print binary s       s   reverse bits s       print binary s       uint64 t l   12      print binary l       l   reverse bits l       print binary l       return 0      Reverse with asm volatile Last but not least  if simplest means fewer lines  why not give a try to inline assembly  You can test below code snippet by adding -masm intel  when compiling  unsigned char reverse bits unsigned char c          asm     volatile    R quot           mov cx  8            daloop                             ror di                   adc ax  ax               dec cx                   jnz short daloop          quot       Explanations line by line          mov cx  8         we will reverse the 8 bits contained in one byte     daloop                while loop         shr di            Shift Register  di   containing value of the first argument of callee function  to the Right         rcl ax            Rotate Carry Left  rotate ax left and add the carry from shr di  the carry is equal to 1 if one bit was  quot lost quot  from previous operation          dec cl            Decrement cx         jnz short daloop  Jump if cx register is Not equal to Zero  else end loop and return value contained in ax register

User · Answer

I ll chip in my solution  since i can t find anything like this in the answers so far  It is a bit overengineered maybe  but it generates the lookup table using C  14 std  index sequence in compile time    include  lt array gt   include  lt utility gt   constexpr unsigned long reverse uint8 t value        uint8 t result   0      for  std  size t i   0  j   7  i  lt  8    i  --j            result      value  amp   1  lt  lt  j    gt  gt  j   lt  lt  i            return result     template lt size t    I gt  constexpr auto make lookup table std  index sequence lt I    gt         return std  array lt uint8 t  sizeof    I  gt  reverse I             template lt typename Indices   std  make index sequence lt 256 gt  gt  constexpr auto bit reverse lookup table         return make lookup table Indices        constexpr auto lookup   bit reverse lookup table     int main int argc        return lookup argc       https   godbolt org z cSuWhF

User · Answer

This one helped me with 8x8 dot matrix set of arrays   uint8 t mirror bits uint8 t var        uint8 t temp   0      if   var  amp  0x01  temp    0x80      if   var  amp  0x02  temp    0x40      if   var  amp  0x04  temp    0x20      if   var  amp  0x08  temp    0x10       if   var  amp  0x10  temp    0x08      if   var  amp  0x20  temp    0x04      if   var  amp  0x40  temp    0x02      if   var  amp  0x80  temp    0x01       return temp

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

Examples related to c++

Examples related to c

Examples related to bit-manipulation