memcpy/memmove to a union member, does this set the ‘active’ member?

by

My reading of the standard is that std::memcpy is safe whenever the type is trivially copyable.

From 9 Classes, we can see that unions are class types and so trivially copyable applies to them.

A union is a class defined with the class-key union; it holds only one data member at a time (9.5).

A trivially copyable class is a class that:

  • has no non-trivial copy constructors (12.8),
  • has no non-trivial move constructors (12.8),
  • has no non-trivial copy assignment operators (13.5.3, 12.8),
  • has no non-trivial move assignment operators (13.5.3, 12.8), and
  • has a trivial destructor (12.4).

The exact meaning of trivially copyable is given in 3.9 Types:

For any object (other than a base-class subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes (1.7) making up the object can be copied into an array of char or unsigned char. If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value.

For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2, where neither obj1 nor obj2 is a base-class subobject, if the underlying bytes (1.7) making up obj1 are copied into obj2, obj2 shall subsequently hold the same value as obj1.

The standard also gives an explicit example of both.

So, if you were copying the entire union, the answer would be unequivocally yes, the active member will be “copied” along with the data. (This is relevant because it indicates that std::memcpy must be regarded as a valid means of changing the active element of a union, since using it is explicitly allowed for whole union copying.)

Now, you are instead copying into a member of the union. The standard doesn’t appear to require any particular method of assigning to a union member (and hence making it active). All it does is specify (9.5) that

[ Note: In general, one must use explicit destructor class and placement new operators to change the active member of a union. — end note]

which it says, of course, because C++11 allows objects of non-trivial type in unions. Note the “in general” on the front, which quite clearly indicates that other methods of changing the active member are permissible in specific cases; we already know this to be the case because assignment is clearly permitted. Certainly there is no prohibition on using std::memcpy, where its use would otherwise be valid.

So my answer is yes, this is safe, and yes, it changes the active member.

More Related Contents:

  1. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  2. Accessing inactive union member and undefined behavior?
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Is the size of std::array defined by standard
  5. Capturing a reference by reference in a C++11 lambda
  6. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  7. Why is modifying a string through a retrieved pointer to its data not allowed?
  8. Is a Union Member’s Destructor Called
  9. Are notes and examples in the core language specification of the C++ Standard non-normative?
  10. What does the void() in decltype(void()) mean exactly?
  11. Lifetime of lambda objects in relation to function pointer conversion
  12. Can the point-of-instantiation be delayed until the end of the translation unit?
  13. Can C++ code be valid in both C++03 and C++11 but do different things?
  14. What is the value category of the operands of C++ operators when unspecified?
  15. How can an incomplete type be used as a template parameter to vector here?
  16. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  17. Is left-shifting (
  18. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  19. C++11 anonymous union with non-trivial members
  20. Classes with both template and non-template conversion operators in the condition of switch statement
  21. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  22. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  23. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  24. Calling an explicit constructor with a braced-init list: ambiguous or not?
  25. Spurious warning about binding temporary to reference member in constructor
  26. std::tuple memory alignment
  27. Rvalues, lvalues and formal definitions
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. What is use of the ref-qualifier `const &&`?
  30. Overload resolution with ref-qualifiers

Leave a Comment