Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?

by

Why would the behavior of std::memcpy itself be undefined when used with non-TriviallyCopyable objects?

It’s not! However, once you copy the underlying bytes of one object of a non-trivially copyable type into another object of that type, the target object is not alive. We destroyed it by reusing its storage, and haven’t revitalized it by a constructor call.

Using the target object – calling its member functions, accessing its data members – is clearly undefined[basic.life]/6, and so is a subsequent, implicit destructor call[basic.life]/4 for target objects having automatic storage duration. Note how undefined behavior is retrospective. [intro.execution]/5:

However, if any such execution contains an undefined operation, this
International Standard places no requirement on the implementation
executing that program with that input (not even with regard to
operations preceding the first undefined operation).

If an implementation spots how an object is dead and necessarily subject to further operations that are undefined, … it may react by altering your programs semantics. From the memcpy call onward. And this consideration gets very practical once we think of optimizers and certain assumptions that they make.

It should be noted that standard libraries are able and allowed to optimize certain standard library algorithms for trivially copyable types, though. std::copy on pointers to trivially copyable types usually calls memcpy on the underlying bytes. So does swap.
So simply stick to using normal generic algorithms and let the compiler do any appropriate low-level optimizations – this is partly what the idea of a trivially copyable type was invented for in the first place: Determining the legality of certain optimizations. Also, this avoids hurting your brain by having to worry about contradictory and underspecified parts of the language.

More Related Contents:

  1. memcpy/memmove to a union member, does this set the ‘active’ member?
  2. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  3. reinterpret_cast creating a trivially default-constructible object
  4. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  5. Is the size of std::array defined by standard
  6. Capturing a reference by reference in a C++11 lambda
  7. Do I really need to implement user-provided constructor for const objects?
  8. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  9. Is std::abs(0u) ill-formed?
  10. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  11. What does the void() in decltype(void()) mean exactly?
  12. Lifetime of lambda objects in relation to function pointer conversion
  13. Can the point-of-instantiation be delayed until the end of the translation unit?
  14. How can an incomplete type be used as a template parameter to vector here?
  15. Is a constexpr array necessarily odr-used when subscripted?
  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. Classes with both template and non-template conversion operators in the condition of switch statement
  20. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  21. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  22. Calling an explicit constructor with a braced-init list: ambiguous or not?
  23. Spurious warning about binding temporary to reference member in constructor
  24. Can we apply content not explicitly cited from the normative references to the C++ standard?
  25. Calling delete on NULL pointers – C++03 vs C++11
  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