Unions and type-punning

by

To re-iterate, type-punning through unions is perfectly fine in C (but not in C++). In contrast, using pointer casts to do so violates C99 strict aliasing and is problematic because different types may have different alignment requirements and you could raise a SIGBUS if you do it wrong. With unions, this is never a problem.

The relevant quotes from the C standards are:

C89 section 3.3.2.3 §5:

if a member of a union object is accessed after a value has been stored in a different member of the object, the behavior is implementation-defined

C11 section 6.5.2.3 §3:

A postfix expression followed by the . operator and an identifier designates a member of a structure or union object. The value is that of the named member

with the following footnote 95:

If the member used to read the contents of a union object is not the same as the member last used to store a value in the object, the appropriate part of the object representation of the value is reinterpreted as an object representation in the new type as described in 6.2.6 (a process sometimes called ‘‘type punning’’). This might be a trap representation.

This should be perfectly clear.

James is confused because C11 section 6.7.2.1 §16 reads

The value of at most one of the members can be stored in a union object at any time.

This seems contradictory, but it is not: In contrast to C++, in C, there is no concept of active member and it’s perfectly fine to access the single stored value through an expression of an incompatible type.

See also C11 annex J.1 §1:

The values of bytes that correspond to union members other than the one last stored into [are unspecified].

In C99, this used to read

The value of a union member other than the last one stored into [is unspecified]

This was incorrect. As the annex isn’t normative, it did not rate its own TC and had to wait until the next standard revision to get fixed.

GNU extensions to standard C++ (and to C90) do explicitly allow type-punning with unions. Other compilers that don’t support GNU extensions may also support union type-punning, but it’s not part of the base language standard.

More Related Contents:

  1. Purpose of Unions in C and C++
  2. union ‘punning’ structs w/ “common initial sequence”: Why does C (99+), but not C++, stipulate a ‘visible declaration of the union type’?
  3. union for uint32_t and uint8_t[4] undefined behavior? [duplicate]
  4. What is the strict aliasing rule?
  5. Accessing inactive union member and undefined behavior?
  6. Is type-punning through a union unspecified in C99, and has it become specified in C11?
  7. Why does C++ disallow anonymous structs?
  8. What’s a proper way of type-punning a float to an int and vice-versa?
  9. sizeof a union in C/C++
  10. How to compile C code with anonymous structs / unions?
  11. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  12. Is a Union Member’s Destructor Called
  13. When would anyone use a union? Is it a remnant from the C-only days?
  14. Is reinterpret_cast type punning actually undefined behavior?
  15. C++11 anonymous union with non-trivial members
  16. How do boost::variant and boost::any work?
  17. Questions regarding C++ non-POD unions
  18. What is the modern, correct way to do type punning in C++?
  19. memcpy/memmove to a union member, does this set the ‘active’ member?
  20. Pointers with c++ [duplicate]
  21. Calculate the factorial of an arbitrarily large number, showing all the digits
  22. Using -1 as a flag value for unsigned (size_t) types
  23. Discards qualifiers error
  24. Why does -INT_MIN = INT_MIN in a signed, two’s complement representation?
  25. Function declaration inside or outside the class
  26. std::put_time implementation status in GCC?
  27. Where can I learn more about C++0x? [closed]
  28. scanf on an istream object
  29. Printing all environment variables in C / C++
  30. Creating N nested for-loops

Leave a Comment