Thread: Struct as a Union member

Did you define LITTLE_ENDIAN or BIG_ENDIAN?

Tim S.

What are you doing? Bitfields aren't portable, and unions are generally problematic.

Some points you may find useful:

• C (in C99) and C++ (in C++11) introduced a header called <stdint.h> or, C++-style, <cstdint>. This defines uint32_t, int16_t and other types you may find very useful. Of course, you may not want to make your code C++11 dependent (although in practice most compilers will have stdint anyway to support C); in that case I suggest you define your own. For example:
  
  Code:

  #include <climits>
  #if INT_MAX == 2147483647
      typedef int uint32_t;
  #else
      #error "Unknown platform, can't determine int32_t"
  #endif
  // ...

  In many projects with more sophisticated build-systems it is the build system's job to figure out details like endianness and bit-sizes, and define types appropriately. (See e.g. cmake.)
• Although your code seems to work as it should (i.e. sizeof(WordByte) is 4), compilers are allowed to pad structures. It may not happen in this case because the struct is already a "nice" size, but certainly at higher optimization levels the compiler may well make every struct member aligned to a 16-byte boundary or whatever, and that will break your code completely. I know of one compiler that would align data structures and loops (with padding or no-ops) to 32-byte boundaries at high opt levels because of sophisticated caching requirements.
• Often you can hide endianness issues quite easily without resorting to structs. For example, in network programming you'd use htonl() to convert "host" to "network" byte order, and ntohl() to convert the other way (networks use big endian, these functions/macros are no-ops on big-endian processors and do reversing on little endian machines). Or you may be able to inline the differences -- often the only endian-dependent code in my SDL programs is this:
  
  Code:

      SDL_Surface *newImage = SDL_CreateRGBSurface(
          SDL_SWSURFACE, image->w, image->h, 32,
  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
          0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
  #else
          0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
  #endif
          );

• Since BIG_ENDIAN and LITTLE_ENDIAN are supposed to be independent but at least one should be defined, you could use #else or check for an error with something like
  
  Code:

  #if !defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
      #error "Endianness not defined! Define BIG_ENDIAN or LITTLE_ENDIAN."
  #endif

• Because you've named the members of the structure, you can't easily loop over them. You may find it more useful to inline-define shift code so you can just do something like
  
  Code:

  MyWordType word;
  for(std::size_t i = 0; i < sizeof(word); i ++) {
  #if BIG_ENDIAN
      dealWith((word & 0xff000000) >> 24);  // better be an unsigned type so we get logical right-shift
      word <<= CHAR_BIT;  // CHAR_BIT is from <climits>, it is almost always 8
  #else
      dealWith(word & 0xff);
      word >>= CHAR_BIT;
  #endif
  }

  That's probably not the best way, I just whipped it up. Also, I'm pretty sure you're not supposed to shift by negative values, otherwise that would make it simpler.