Is there a (semantic) difference between the return value of placement new and the casted value of its operand?

by

Only a can safely be used to directly access the Foo object created by the placement new-expression (which we’ll call x for ease of reference). Using b requires std::launder.

The value of a is specified in [expr.new]/1:

If the entity is a non-array object, the result of the new-expression
is a pointer to the object created.

The value of a is therefore “pointer to x“. This pointer, of course, can safely be used to access x.

reinterpret_cast<Foo*>(buffer) applies the array-to-pointer conversion to buffer (see [expr.reinterpret.cast]/1). The resulting value after the conversion is applied is “pointer to the first element of buffer“.
This is a reinterpret_cast of an object pointer to an object pointer of a different type, and is defined as equivalent to static_cast<Foo*>(static_cast<void*>(buffer)) by [expr.reinterpret.cast]/7.

The inner cast to void* is actually an implicit conversion. Per [conv.ptr]/2,

The pointer value is unchanged by this conversion.

Therefore the inner cast yields a void* with the value “pointer to the first element of buffer“.

The outer cast is governed by [expr.static.cast]/13, which I’ve lightly reformatted into bullet points:

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1.

  • If the original pointer value represents the address A of a byte in memory and A does not satisfy the alignment requirement of T,
    then the resulting pointer value is unspecified.

  • Otherwise, if the original pointer value points to an object a, and there is an object b of type T (ignoring cv-qualification)
    that is pointer-interconvertible with a, the result is a pointer to
    b.

  • Otherwise, the pointer value is unchanged by the conversion.

Assuming that buffer is suitably aligned (you’d be in trouble well before this point if it’s not), the first bullet is inapplicable. The second bullet is likewise inapplicable as there’s no pointer-interconvertiblity here. It follows that we hit the third bullet – “the pointer value is unchanged by the conversion” and remains “pointer to the first element of buffer“.

Thus, b does not point to the Foo object x; it points instead to the first char element of buffer, even though its type is Foo*. It therefore cannot be used to access x; attempting to do so yields undefined behavior (for the non-static data member case, by omission from [expr.ref]; for the non-static member function case, by [class.mfct.non-static]/2).

To recover a pointer to x from b, std::launder can be used:

b = std::launder(b); // value of b is now "pointer to x"
                     // and can be used to access x

More Related Contents:

  1. Does accessing the first field of a struct via a C cast violate strict aliasing?
  2. Is it a strict aliasing violation to alias a struct as its first member?
  3. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  4. Placement new and assignment of class with const member
  5. Does this really break strict-aliasing rules?
  6. casting via void* instead of using reinterpret_cast [duplicate]
  7. treating memory returned by operator new(sizeof(T) * N) as an array
  8. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  9. Is reinterpret_cast type punning actually undefined behavior?
  10. reinterpret_cast between char* and std::uint8_t* – safe?
  11. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  12. When is a private constructor not a private constructor?
  13. When using C headers in C++, should we use functions from std:: or the global namespace?
  14. Is it still safe to delete nullptr in c++0x?
  15. Matching alias template as template argument
  16. Unsequenced value computations (a.k.a sequence points)
  17. Do I really need to implement user-provided constructor for const objects?
  18. Do all pointers have the same size in C++?
  19. Force all classes to implement / override a ‘pure virtual’ method in multi-level inheritance hierarchy
  20. Is std::abs(0u) ill-formed?
  21. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  22. What are uses of the C++ construct “placement new”?
  23. Implementing a std::vector like container without undefined behavior
  24. C++ – Why static member function can’t be created with ‘const’ qualifier
  25. Is a constexpr array necessarily odr-used when subscripted?
  26. Does C have One Definition Rule like C++?
  27. Is casting std::pair const& to std::pair const& safe?
  28. Why can’t I static_cast between char * and unsigned char *?
  29. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  30. Will I be able to declare a constexpr lambda inside a template parameter?

Leave a Comment