How do I convert between big-endian and little-endian values in C

Question

How do I convert between big-endian and little-endian values in C    For clarity  I have to translate binary data  double-precision floating point values and 32-bit and 64-bit integers  from one CPU architecture to another   This doesn t involve networking  so ntoh   and similar functions won t work here   Note  The answer I accepted applies directly to compilers I m targeting  which is why I chose it    However  there are other very good  more portable answers here

User · Answer

Seems like the safe way would be to use htons on each word. So, if you have...

std::vector<uint16_t> storage(n);  // where n is the number to be converted

// the following would do the trick
std::transform(word_storage.cbegin(), word_storage.cend()
  , word_storage.begin(), [](const uint16_t input)->uint16_t {
  return htons(input); });

The above would be a no-op if you were on a big-endian system, so I would look for whatever your platform uses as a compile-time condition to decide whether htons is a no-op. It is O(n) after all. On a Mac, it would be something like ...

#if (__DARWIN_BYTE_ORDER != __DARWIN_BIG_ENDIAN)
std::transform(word_storage.cbegin(), word_storage.cend()
  , word_storage.begin(), [](const uint16_t input)->uint16_t {
  return htons(input); });
#endif

User · Answer

Just thought I added my own solution here since I haven t seen it anywhere  It s a small and portable C   templated function and portable that only uses bit operations   template lt typename T gt  inline static T swapByteOrder const T amp  val        int totalBytes   sizeof val       T swapped    T  0      for  int i   0  i  lt  totalBytes    i            swapped     val  gt  gt   8  totalBytes-i-1    amp  0xFF   lt  lt   8 i             return swapped

User · Answer

On most POSIX systems  through it s not in the POSIX standard  there is the endian h  which can be used to determine what encoding your system uses  From there it s something like this   unsigned int change endian unsigned int x        unsigned char  ptr    unsigned char    amp x      return  ptr 0   lt  lt  24     ptr 1   lt  lt  16     ptr 2   lt  lt  8    ptr 3       This swaps the order  from big endian to little endian    If you have the number 0xDEADBEEF  on a little endian system stored as 0xEFBEADDE   ptr 0  will be 0xEF  ptr 1  is 0xBE  etc   But if you want to use it for networking  then htons  htonl and htonll  and their inverses ntohs  ntohl and ntohll  will be helpful for converting from host order to network order

User · Answer

Seriously    I don t understand why all solutions are that complicated  How about the simplest  most general template function that swaps any type of any size under any circumstances in any operating system      template  lt typename T gt  void SwapEnd T amp  var        static assert std  is pod lt T gt   value   Type must be POD type for safety        std  array lt char  sizeof T  gt  varArray      std  memcpy varArray data     amp var  sizeof T        for int i   0  i  lt  static cast lt int gt  sizeof var  2   i            std  swap varArray sizeof var  - 1 - i  varArray i        std  memcpy  amp var  varArray data    sizeof T        It s the magic power of C and C   together  Simply swap the original variable character by character   Point 1  No operators  Remember that I didn t use the simple assignment operator     because some objects will be messed up when the endianness is flipped and the copy constructor  or assignment operator  won t work  Therefore  it s more reliable to copy them char by char   Point 2  Be aware of alignment issues  Notice that we re copying to and from an array  which is the right thing to do because the C   compiler doesn t guarantee that we can access unaligned memory  this answer was updated from its original form for this   For example  if you allocate uint64 t  your compiler cannot guarantee that you can access the 3rd byte of that as a uint8 t  Therefore  the right thing to do is to copy this to a char array  swap it  then copy it back  so no reinterpret cast   Notice that compilers are mostly smart enough to convert what you did back to a reinterpret cast if they re capable of accessing individual bytes regardless of alignment   To use this function   double x   5  SwapEnd x     and now x is different in endianness

User · Answer

Here s how to read a double stored in IEEE 754 64 bit format  even if your host computer uses a different system        read a double from a stream in ieee754 format regardless of host    encoding     fp - the stream    bigendian - set to if big bytes first  clear for little bytes                first      double freadieee754 FILE  fp  int bigendian        unsigned char buff 8       int i      double fnorm   0 0      unsigned char temp      int sign      int exponent      double bitval      int maski  mask      int expbits   11      int significandbits   52      int shift      double answer          read the data        for  i   0  i  lt  8  i            buff i    fgetc fp          just reverse if not big-endian       if   bigendian                for  i   0  i  lt  4  i                          temp   buff i               buff i    buff 8 - i - 1               buff 8 - i - 1    temp                      sign   buff 0   amp  0x80   -1   1         exponet in raw format       exponent     buff 0   amp  0x7F   lt  lt  4      buff 1   amp  0xF0   gt  gt  4           read inthe mantissa  Top bit is 0 5  the successive bits half       bitval   0 5      maski   1      mask   0x08      for  i   0  i  lt  significandbits  i                  if  buff maski   amp  mask              fnorm    bitval           bitval    2 0          mask  gt  gt   1          if  mask    0                        mask   0x80              maski                           handle zero specially        if  exponent    0  amp  amp  fnorm    0          return 0 0       shift   exponent -   1  lt  lt   expbits - 1   - 1      exponent   shift   bias           nans have exp 1024 and non-zero mantissa        if  shift    1024  amp  amp  fnorm    0          return sqrt -1 0         infinity       if  shift    1024  amp  amp  fnorm    0          ifdef INFINITY         return sign    1   INFINITY   -INFINITY   endif         return   sign   1 0    0 0            if  shift  gt  -1023                answer   ldexp fnorm   1 0  shift           return answer   sign            else                  denormalised numbers            if  fnorm    0 0              return 0 0          shift   -1022          while  fnorm  lt  1 0                        fnorm    2              shift--                    answer   ldexp fnorm  shift           return answer   sign            For the rest of the suite of functions  including the write and the integer routines see my github project  https   github com MalcolmMcLean ieee754

User · Answer

Look up bit shifting  as this is basically all you need to do to swap from little -  big endian  Then depending on the bit size  you change how you do the bit shifting

User · Answer

Here is a basic function to swap to from little and big endian  It s basic but it doesn t require supplementary libraries  void endianness swap uint32 t amp  val        uint8 t a  b  c      a    val  amp  0xFF000000   gt  gt  24      b    val  amp  0x00FF0000   gt  gt  16      c    val  amp  0x0000FF00   gt  gt  8      val  val  amp  0x000000FF   lt  lt  24      val   val    c  lt  lt  16     b  lt  lt  8     a

User · Answer

If you re using Visual C   do the following  You include intrin h and call the following functions   For 16 bit numbers   unsigned short  byteswap ushort unsigned short value     For 32 bit numbers   unsigned long  byteswap ulong unsigned long value     For 64 bit numbers   unsigned   int64  byteswap uint64 unsigned   int64 value     8 bit numbers  chars  don t need to be converted   Also these are only defined for unsigned values they work for signed integers as well   For floats and doubles it s more difficult as with plain integers as these may or not may be in the host machines byte-order  You can get little-endian floats on big-endian machines and vice versa   Other compilers have similar intrinsics as well    In GCC for example you can directly call some builtins as documented here   uint32 t   builtin bswap32  uint32 t x  uint64 t   builtin bswap64  uint64 t x     no need to include something   Afaik bits h declares the same function in a non gcc-centric way as well   16 bit swap it s just a bit-rotate   Calling the intrinsics instead of rolling your own gives you the best performance and code density btw

User · Answer

The same way you do in C   short big   0xdead  short little      big  amp  0xff  lt  lt 8      big  amp  0xff00  gt  gt 8      You could also declare a vector of unsigned chars  memcpy the input value into it  reverse the bytes into another vector and memcpy the bytes out  but that ll take orders of magnitude longer than bit-twiddling  especially with 64-bit values

User · Answer

If you are doing this for purposes of network host compatability you should use   ntohl     Network to Host byte order  Long  htonl     Host to Network byte order  Long   ntohs     Network to Host byte order  Short  htons     Host to Network byte order  Short    If you are doing this for some other reason one of the byte swap solutions presented here would work just fine

User · Answer

Most platforms have a system header file that provides efficient byteswap functions  On Linux it is in  lt endian h gt   You can wrap it nicely in C      include  lt iostream gt    include  lt endian h gt   template lt size t N gt  struct SizeT       define BYTESWAPS bits    template lt class T gt  inline T htobe T t  SizeT lt bits   8 gt     return htobe    bits t       template lt class T gt  inline T htole T t  SizeT lt bits   8 gt     return htole    bits t       template lt class T gt  inline T betoh T t  SizeT lt bits   8 gt     return be    bits    toh t       template lt class T gt  inline T letoh T t  SizeT lt bits   8 gt     return le    bits    toh t      BYTESWAPS 16  BYTESWAPS 32  BYTESWAPS 64    undef BYTESWAPS  template lt class T gt  inline T htobe T t    return htobe t  SizeT lt sizeof t gt        template lt class T gt  inline T htole T t    return htole t  SizeT lt sizeof t gt        template lt class T gt  inline T betoh T t    return betoh t  SizeT lt sizeof t gt        template lt class T gt  inline T letoh T t    return letoh t  SizeT lt sizeof t gt         int main         std  cout  lt  lt  std  hex      std  cout  lt  lt  htobe static cast lt unsigned short gt  0xfeca    lt  lt    n       std  cout  lt  lt  htobe 0xafbeadde   lt  lt    n           Use ULL suffix to specify integer constant as unsigned long long      std  cout  lt  lt  htobe 0xfecaefbeafdeedfeULL   lt  lt    n       Output   cafe deadbeaf feeddeafbeefcafe

User · Answer

If you take the common pattern for reversing the order of bits in a word  and cull the part that reverses bits within each byte  then you re left with something which only reverses the bytes within a word   For 64-bits   x     x  amp  0x00000000ffffffff   lt  lt  32      x  gt  gt  32   amp  0x00000000ffffffff   x     x  amp  0x0000ffff0000ffff   lt  lt  16      x  gt  gt  16   amp  0x0000ffff0000ffff   x     x  amp  0x00ff00ff00ff00ff   lt  lt   8      x  gt  gt   8   amp  0x00ff00ff00ff00ff     The compiler should clean out the superfluous bit-masking operations  I left them in to highlight the pattern   but if it doesn t you can rewrite the first line this way   x     x                        lt  lt  32      x  gt  gt  32     That should normally simplify down to a single rotate instruction on most architectures  ignoring that the whole operation is probably one instruction    On a RISC processor the large  complicated constants may cause the compiler difficulties   You can trivially calculate each of the constants from the previous one  though   Like so   uint64 t k   0x00000000ffffffff     compiler should know a trick for this    x     x  amp  k   lt  lt  32      x  gt  gt  32   amp  k   k    k  lt  lt  16  x     x  amp  k   lt  lt  16      x  gt  gt  16   amp  k   k    k  lt  lt  8  x     x  amp  k   lt  lt   8      x  gt  gt   8   amp  k     If you like  you can write that as a loop   It won t be efficient  but just for fun   int i   sizeof x    CHAR BIT   2  uintmax t k    1  lt  lt  i  - 1  while  i  gt   8        x     x  amp  k   lt  lt  i      x  gt  gt  i   amp  k       i  gt  gt   1      k    k  lt  lt  i      And for completeness  here s the simplified 32-bit version of the first form   x     x                lt  lt  16      x  gt  gt  16   x     x  amp  0x00ff00ff   lt  lt   8      x  gt  gt   8   amp  0x00ff00ff

User · Answer

If you have C   17 then add this header   include  lt algorithm gt    Use this template function to swap the bytes   template  lt typename T gt  void swapEndian T amp  buffer        static assert std  is pod lt T gt   value   swapEndian support POD type only        char  startIndex   static cast lt char  gt   void  buffer data         char  endIndex   startIndex   sizeof buffer       std  reverse startIndex  endIndex       call it like   swapEndian  stlContainer

User · Answer

From The Byte Order Fallacy by Rob Pike      Let s say your data stream has a little-endian-encoded 32-bit integer  Here s how to extract it  assuming unsigned bytes     i    data 0  lt  lt 0     data 1  lt  lt 8     data 2  lt  lt 16     data 3  lt  lt 24        If it s big-endian  here s how to extract it    i    data 3  lt  lt 0     data 2  lt  lt 8     data 1  lt  lt 16     data 0  lt  lt 24     TL DR  don t worry about your platform native order  all that counts is the byte order of the stream your are reading from  and you better hope it s well defined   Note  it was remarked in the comment that absent explicit type conversion  it was important that data be an array of unsigned char or uint8 t  Using signed char or char  if signed  will result in data x  being promoted to an integer and data x   lt  lt  24 potentially shifting a 1 into the sign bit which is UB

User · Answer

Byte swapping with ye olde 3-step-xor trick around a pivot in a template function gives a flexible  quick O ln2  solution that does not require a library  the style here also rejects 1 byte types   template lt typename T gt void swap T  amp t       for uint8 t pivot   0  pivot  lt  sizeof t  2  pivot                 uint8 t    amp t   pivot        uint8 t    amp t sizeof t -1- pivot              uint8 t    amp t sizeof t -1- pivot        uint8 t    amp t   pivot              uint8 t    amp t   pivot        uint8 t    amp t sizeof t -1- pivot

User · Answer

Wow  I couldn t believe some of the answers I ve read here   There s actually an instruction in assembly which does this faster than anything else   bswap   You could simply write a function like this       declspec naked  uint32 t EndianSwap uint32 value          asm               mov eax  dword ptr esp   4          bswap eax         ret           It is MUCH faster than the intrinsics that have been suggested   I ve disassembled them and looked   The above function has no prologue epilogue so virtually has no overhead at all   unsigned long  byteswap ulong unsigned long value     Doing 16 bit is just as easy  with the exception that you d use xchg al  ah   bswap only works on 32-bit registers   64-bit is a little more tricky  but not overly so   Much better than all of the above examples with loops and templates etc   There are some caveats here     Firstly bswap is only available on 80x486 CPU s and above   Is anyone planning on running it on a 386     If so  you can still replace bswap with     mov ebx  eax shr ebx  16 xchg bl  bh xchg al  ah shl eax  16 or eax  ebx   Also inline assembly is only available in x86 code in Visual Studio   A naked function cannot be lined and also isn t available in x64 builds   I that instance  you re going to have to use the compiler intrinsics

User · Answer

The procedure for going from big-endian to little-endian is the same as going from little-endian to big-endian   Here s some example code   void swapByteOrder unsigned short amp  us        us    us  gt  gt  8              us  lt  lt  8      void swapByteOrder unsigned int amp  ui        ui    ui  gt  gt  24               ui lt  lt 8   amp  0x00FF0000               ui gt  gt 8   amp  0x0000FF00              ui  lt  lt  24      void swapByteOrder unsigned long long amp  ull        ull    ull  gt  gt  56                ull lt  lt 40   amp  0x00FF000000000000                ull lt  lt 24   amp  0x0000FF0000000000                ull lt  lt 8   amp  0x000000FF00000000                ull gt  gt 8   amp  0x00000000FF000000                ull gt  gt 24   amp  0x0000000000FF0000                ull gt  gt 40   amp  0x000000000000FF00               ull  lt  lt  56

User · Answer

I have this code that allow me to convert from HOST ENDIAN ORDER  whatever it is  to LITTLE ENDIAN ORDER or BIG ENDIAN ORDER  I use a template  so if I try to convert from HOST ENDIAN ORDER to LITTLE ENDIAN ORDER and they happen to be the same for the machine for wich I compile  no code will be generated   Here is the code with some comments      We define some constant for little  big and host endianess  Here I use     BOOST LITTLE ENDIAN BOOST BIG ENDIAN to check the host indianess  If you    don t want to use boost you will have to modify this part a bit  enum EEndian     LITTLE ENDIAN ORDER    BIG ENDIAN ORDER   if defined BOOST LITTLE ENDIAN    HOST ENDIAN ORDER   LITTLE ENDIAN ORDER  elif defined BOOST BIG ENDIAN    HOST ENDIAN ORDER   BIG ENDIAN ORDER  else  error  Impossible de determiner l indianness du systeme cible    endif        this function swap the bytes of values given it s size as a template    parameter  could sizeof be used    template  lt class T  unsigned int size gt  inline T SwapBytes T value      union          T value       char bytes size       in  out     in value   value     for  unsigned int i   0  i  lt  size   2    i           out bytes i    in bytes size - 1 - i        out bytes size - 1 - i    in bytes i          return out value        Here is the function you will use  Again there is two compile-time assertion    that use the boost librarie  You could probably comment them out  but if you    do be cautious not to use this function for anything else than integers    types  This function need to be calles like this             int x   someValue         int i   EndianSwapBytes lt HOST ENDIAN ORDER  BIG ENDIAN ORDER gt  x      template lt EEndian from  EEndian to  class T gt  inline T EndianSwapBytes T value         A   La donn  e    swapper    une taille de 2  4 ou 8 octets   BOOST STATIC ASSERT sizeof T     2    sizeof T     4    sizeof T     8         A   La donn  e    swapper est d un type arithmetic   BOOST STATIC ASSERT boost  is arithmetic lt T gt   value         Si from et to sont du m  me type on ne swap pas    if  from    to       return value     return SwapBytes lt T  sizeof T  gt  value

User · Answer

i like this one  just for style  -   long swap long i        char  c    char     amp i      return    long     char     c 3   c 2   c 1   c 0

User · Answer

I recently wrote a macro to do this in C  but it s equally valid in C     define REVERSE BYTES      do for size t REVERSE BYTES 0  REVERSE BYTES lt sizeof   VA ARGS    gt  gt 1    REVERSE BYTES         unsigned char   amp    VA ARGS     REVERSE BYTES       unsigned char   amp    VA ARGS     sizeof   VA ARGS   -1-REVERSE BYTES          unsigned char   amp    VA ARGS     sizeof   VA ARGS   -1-REVERSE BYTES       unsigned char   amp    VA ARGS     REVERSE BYTES          unsigned char   amp    VA ARGS     REVERSE BYTES       unsigned char   amp    VA ARGS     sizeof   VA ARGS   -1-REVERSE BYTES    while 0   It accepts any type and reverses the bytes in the passed argument  Example usages  int main        unsigned long long x   0xABCDEF0123456789      printf  quot Before   llX n quot  x       REVERSE BYTES x       printf  quot After    llX n quot  x        char c 7   quot nametag quot       printf  quot Before   c c c c c c c n quot  c 0  c 1  c 2  c 3  c 4  c 5  c 6        REVERSE BYTES c       printf  quot After    c c c c c c c n quot  c 0  c 1  c 2  c 3  c 4  c 5  c 6       Which prints  Before  ABCDEF0123456789 After   8967452301EFCDAB Before  nametag After   gateman  The above is perfectly copy paste-able  but there s a lot going on here  so I ll break down how it works piece by piece  The first notable thing is that the entire macro is encased in a do while 0  block  This is a common idiom to allow normal semicolon use after the macro  Next up is the use of a variable named REVERSE BYTES as the for loop s counter  The name of the macro itself is used as a variable name to ensure that it doesn t clash with any other symbols that may be in scope wherever the macro is used  Since the name is being used within the macro s expansion  it won t be expanded again when used as a variable name here  Within the for loop  there are two bytes being referenced and XOR swapped  so a temporary variable name is not required     unsigned char   amp    VA ARGS     REVERSE BYTES    unsigned char   amp    VA ARGS     sizeof   VA ARGS   -1-REVERSE BYTES     VA ARGS   represents whatever was given to the macro  and is used to increase the flexibility of what may be passed in  albeit not by much   The address of this argument is then taken and cast to an unsigned char pointer to permit the swapping of its bytes via array    subscripting  The final peculiar point is the lack of    braces  They aren t necessary because all of the steps in each swap are joined with the comma operator  making them one statement  Finally  it s worth noting that this is not the ideal approach if speed is a top priority  If this is an important factor  some of the type-specific macros or platform-specific directives referenced in other answers are likely a better option  This approach  however  is portable to all types  all major platforms  and both the C and C   languages

User · Answer

I am really surprised no one mentioned htobeXX and betohXX functions  They are defined in endian h and are very similar to network functions htonXX

User · Answer

Portable technique for implementing optimizer-friendly unaligned non-inplace endian accessors  They work on every compiler  every boundary alignment and every byte ordering  These unaligned routines are supplemented  or mooted  depending on native endian and alignment  Partial listing but you get the idea  BO  are constant values based on native byte ordering   uint32 t sw get uint32 1234 pu32  uint32 1234  pu32      union       uint32 1234 u32 1234      uint32 t u32      bou32    bou32 u32 1234 0      pu32  BO32 0     bou32 u32 1234 1      pu32  BO32 1     bou32 u32 1234 2      pu32  BO32 2     bou32 u32 1234 3      pu32  BO32 3     return bou32 u32      void sw set uint32 1234 pu32  u32  uint32 1234  pu32  uint32 t u32      union       uint32 1234 u32 1234      uint32 t u32      bou32    bou32 u32   u32      pu32  BO32 0    bou32 u32 1234 0       pu32  BO32 1    bou32 u32 1234 1       pu32  BO32 2    bou32 u32 1234 2       pu32  BO32 3    bou32 u32 1234 3       if HAS SW INT64 int64 sw get int64 12345678 pi64  int64 12345678  pi64      union       int64 12345678 i64 12345678      int64 i64      boi64    boi64 i64 12345678 0      pi64  BO64 0     boi64 i64 12345678 1      pi64  BO64 1     boi64 i64 12345678 2      pi64  BO64 2     boi64 i64 12345678 3      pi64  BO64 3     boi64 i64 12345678 4      pi64  BO64 4     boi64 i64 12345678 5      pi64  BO64 5     boi64 i64 12345678 6      pi64  BO64 6     boi64 i64 12345678 7      pi64  BO64 7     return boi64 i64      endif  int32 t sw get int32 3412 pi32  int32 3412  pi32      union       int32 3412 i32 3412      int32 t i32      boi32    boi32 i32 3412 2      pi32  BO32 0     boi32 i32 3412 3      pi32  BO32 1     boi32 i32 3412 0      pi32  BO32 2     boi32 i32 3412 1      pi32  BO32 3     return boi32 i32      void sw set int32 3412 pi32  i32  int32 3412  pi32  int32 t i32      union       int32 3412 i32 3412      int32 t i32      boi32    boi32 i32   i32      pi32  BO32 0    boi32 i32 3412 2       pi32  BO32 1    boi32 i32 3412 3       pi32  BO32 2    boi32 i32 3412 0       pi32  BO32 3    boi32 i32 3412 1      uint32 t sw get uint32 3412 pu32  uint32 3412  pu32      union       uint32 3412 u32 3412      uint32 t u32      bou32    bou32 u32 3412 2      pu32  BO32 0     bou32 u32 3412 3      pu32  BO32 1     bou32 u32 3412 0      pu32  BO32 2     bou32 u32 3412 1      pu32  BO32 3     return bou32 u32      void sw set uint32 3412 pu32  u32  uint32 3412  pu32  uint32 t u32      union       uint32 3412 u32 3412      uint32 t u32      bou32    bou32 u32   u32      pu32  BO32 0    bou32 u32 3412 2       pu32  BO32 1    bou32 u32 3412 3       pu32  BO32 2    bou32 u32 3412 0       pu32  BO32 3    bou32 u32 3412 1      float sw get float 1234 pf  float 1234  pf      union       float 1234 f 1234      float f      bof    bof f 1234 0      pf  BO32 0     bof f 1234 1      pf  BO32 1     bof f 1234 2      pf  BO32 2     bof f 1234 3      pf  BO32 3     return bof f      void sw set float 1234 pf  f  float 1234  pf  float f      union       float 1234 f 1234      float f      bof    bof f    float f      pf  BO32 0    bof f 1234 0       pf  BO32 1    bof f 1234 1       pf  BO32 2    bof f 1234 2       pf  BO32 3    bof f 1234 3      double sw get double 12345678 pd  double 12345678  pd      union       double 12345678 d 12345678      double d      bod    bod d 12345678 0      pd  BO64 0     bod d 12345678 1      pd  BO64 1     bod d 12345678 2      pd  BO64 2     bod d 12345678 3      pd  BO64 3     bod d 12345678 4      pd  BO64 4     bod d 12345678 5      pd  BO64 5     bod d 12345678 6      pd  BO64 6     bod d 12345678 7      pd  BO64 7     return bod d      void sw set double 12345678 pd  d  double 12345678  pd  double d      union       double 12345678 d 12345678      double d      bod    bod d   d      pd  BO64 0    bod d 12345678 0       pd  BO64 1    bod d 12345678 1       pd  BO64 2    bod d 12345678 2       pd  BO64 3    bod d 12345678 3       pd  BO64 4    bod d 12345678 4       pd  BO64 5    bod d 12345678 5       pd  BO64 6    bod d 12345678 6       pd  BO64 7    bod d 12345678 7       These typedefs have the benefit of raising compiler errors if not used with accessors  thus mitigating forgotten accessor bugs   typedef char int8 1 1   uint8 1 1    typedef char int16 12 2   uint16 12 2      little endian    typedef char int16 21 2   uint16 21 2      big endian     typedef char int24 321 3   uint24 321 3      Alpha Micro  PDP-11     typedef char int32 1234 4   uint32 1234 4      little endian    typedef char int32 3412 4   uint32 3412 4      Alpha Micro  PDP-11    typedef char int32 4321 4   uint32 4321 4      big endian     typedef char int64 12345678 8   uint64 12345678 8      little endian    typedef char int64 34128756 8   uint64 34128756 8      Alpha Micro  PDP-11    typedef char int64 87654321 8   uint64 87654321 8      big endian     typedef char float 1234 4      little endian    typedef char float 3412 4      Alpha Micro  PDP-11    typedef char float 4321 4      big endian     typedef char double 12345678 8      little endian    typedef char double 78563412 8      Alpha Micro     typedef char double 87654321 8      big endian

User · Answer

Here s a generalized version I came up with off the top of my head  for swapping a value in place   The other suggestions would be better if performance is a problem    template lt typename T      void ByteSwap T   p                for  int i   0   i  lt  sizeof T  2     i              std  swap   char   p  i     char   p  sizeof T -1-i            Disclaimer  I haven t tried to compile this or test it yet

User · Answer

We ve done this with templates   You could do something like this      Specialization for 2-byte types  template lt  gt  inline void endian byte swapper lt  2  gt  char  dest  char const  src           Use bit manipulations instead of accessing individual bytes from memory  much faster      ushort  p dest   reinterpret cast lt  ushort   gt  dest       ushort const  const p src   reinterpret cast lt  ushort const   gt  src        p dest     p src  gt  gt  8      p src  lt  lt  8         Specialization for 4-byte types  template lt  gt  inline void endian byte swapper lt  4  gt  char  dest  char const  src           Use bit manipulations instead of accessing individual bytes from memory  much faster      uint  p dest   reinterpret cast lt  uint   gt  dest       uint const  const p src   reinterpret cast lt  uint const   gt  src        p dest     p src  gt  gt  24       p src  amp  0x00ff0000   gt  gt  8       p src  amp  0x0000ff00   lt  lt  8      p src  lt  lt  24

User · Answer

Using the codes below  you can swap between BigEndian and LittleEndian easily    define uint32 t unsigned   define uint16 t unsigned short   define swap16 x      uint16 t  x   amp  0x00ff  lt  lt 8        uint16 t  x   amp  0xff00  gt  gt 8     define swap32 x      uint32 t  x   amp  0x000000ff  lt  lt 24        uint32 t  x   amp  0x0000ff00  lt  lt 8        uint32 t  x   amp  0x00ff0000  gt  gt 8        uint32 t  x   amp  0xff000000  gt  gt 24

User · Answer

Simply put    include  lt climits gt   template  lt typename T gt  T swap endian T u        static assert  CHAR BIT    8   CHAR BIT    8         union               T u          unsigned char u8 sizeof T          source  dest       source u   u       for  size t k   0  k  lt  sizeof T   k            dest u8 k    source u8 sizeof T  - k - 1        return dest u      usage  swap endian lt uint32 t gt  42

User · Answer

If you re doing this to transfer data between different platforms look at the ntoh and hton functions

User · Answer

Note that  at least for Windows  htonl   is much slower than their intrinsic counterpart  byteswap ulong    The former is a DLL library call into ws2 32 dll  the latter is one BSWAP assembly instruction  Therefore  if you are writing some platform-dependent code  prefer using the intrinsics for speed    define htonl x   byteswap ulong x    This may be especially important for  PNG image processing where all integers are saved in Big Endian with explanation  One can use htonl        to slow down typical Windows programs  if you are not prepared

User · Answer

If a big-endian 32-bit unsigned integer looks like 0xAABBCCDD which is equal to 2864434397  then that same 32-bit unsigned integer looks like 0xDDCCBBAA on a little-endian processor which is also equal to 2864434397   If a big-endian 16-bit unsigned short looks like 0xAABB which is equal to 43707  then that same 16-bit unsigned short looks like 0xBBAA on a little-endian processor which is also equal to 43707   Here are a couple of handy  define functions to swap bytes from little-endian to big-endian and vice-versa --      can be used for short  unsigned short  word  unsigned word  2-byte types   define BYTESWAP16 n     n amp 0xFF00  gt  gt 8    n amp 0x00FF  lt  lt 8       can be used for int or unsigned int or float  4-byte types   define BYTESWAP32 n    BYTESWAP16  n amp 0xFFFF0000  gt  gt 16     BYTESWAP16 n amp 0x0000FFFF   lt  lt 16       can be used for unsigned long long or double  8-byte types   define BYTESWAP64 n    BYTESWAP32  n amp 0xFFFFFFFF00000000  gt  gt 32     BYTESWAP32 n amp 0x00000000FFFFFFFF   lt  lt 32

User · Answer

I took a few suggestions from this post and put them together to form this   include  lt boost type traits hpp gt   include  lt boost static assert hpp gt   include  lt boost detail endian hpp gt   include  lt stdexcept gt   include  lt cstdint gt   enum endianness       little endian      big endian      network endian   big endian            if defined BOOST LITTLE ENDIAN          host endian   little endian      elif defined BOOST BIG ENDIAN          host endian   big endian      else          error  quot unable to determine system endianness quot       endif     namespace detail    template lt typename T  size t sz gt  struct swap bytes       inline T operator   T val                throw std  out of range  quot data size quot              template lt typename T gt  struct swap bytes lt T  1 gt        inline T operator   T val                return val            template lt typename T gt  struct swap bytes lt T  2 gt        inline T operator   T val                return     val   gt  gt  8   amp  0xff       val   amp  0xff   lt  lt  8              template lt typename T gt  struct swap bytes lt T  4 gt        inline T operator   T val                return     val   amp  0xff000000   gt  gt  24                       val   amp  0x00ff0000   gt  gt   8                       val   amp  0x0000ff00   lt  lt   8                       val   amp  0x000000ff   lt  lt  24              template lt  gt  struct swap bytes lt float  4 gt        inline float operator   float val                uint32 t mem  swap bytes lt uint32 t  sizeof uint32 t  gt      uint32 t   amp val           return   float   amp mem            template lt typename T gt  struct swap bytes lt T  8 gt        inline T operator   T val                return     val   amp  0xff00000000000000ull   gt  gt  56                       val   amp  0x00ff000000000000ull   gt  gt  40                       val   amp  0x0000ff0000000000ull   gt  gt  24                       val   amp  0x000000ff00000000ull   gt  gt  8                        val   amp  0x00000000ff000000ull   lt  lt  8                        val   amp  0x0000000000ff0000ull   lt  lt  24                       val   amp  0x000000000000ff00ull   lt  lt  40                       val   amp  0x00000000000000ffull   lt  lt  56              template lt  gt  struct swap bytes lt double  8 gt        inline double operator   double val                uint64 t mem  swap bytes lt uint64 t  sizeof uint64 t  gt      uint64 t   amp val           return   double   amp mem            template lt endianness from  endianness to  class T gt  struct do byte swap       inline T operator   T value                return swap bytes lt T  sizeof T  gt    value               specialisations when attempting to swap to the same endianess template lt class T gt  struct do byte swap lt little endian  little endian  T gt    inline T operator   T value    return value       template lt class T gt  struct do byte swap lt big endian     big endian     T gt    inline T operator   T value    return value             namespace detail  template lt endianness from  endianness to  class T gt  inline T byte swap T value           ensure the data is only 1  2  4 or 8 bytes     BOOST STATIC ASSERT sizeof T     1    sizeof T     2    sizeof T     4    sizeof T     8          ensure we re only swapping arithmetic types     BOOST STATIC ASSERT boost  is arithmetic lt T gt   value        return detail  do byte swap lt from  to  T gt    value      You would then use it as follows     swaps val from host-byte-order to network-byte-order auto swapped   byte swap lt host endian  network endian gt  val    and vice-versa    swap a value received from the network into host-byte-order auto val   byte swap lt network endian  host endian gt  val from network

User · Answer

There is an assembly instruction called BSWAP that will do the swap for you  extremely fast  You can read about it here   Visual Studio  or more precisely the Visual C   runtime library  has platform intrinsics for this  called  byteswap ushort     byteswap ulong    and  byteswap int64    Similar should exist for other platforms  but I m not aware of what they would be called

[c++] How do I convert between big-endian and little-endian values in C++?

Examples related to c++

Examples related to endianness