Does this really break strict-aliasing rules?

by

The warning is absolutely justified. The decayed pointer to data does not point to an object of type int, and casting it doesn’t change that. See [basic.life]/7:

If, after the lifetime of an object has ended and before the storage
which the object occupied is reused or released, a new object is
created at the storage location which the original object occupied, a
pointer that pointed to the original object, a reference that referred
to the original object, or the name of the original object will
automatically refer to the new object and, once the lifetime of the
new object has started, can be used to manipulate the new object, if:
(7.1) — [..]
(7.2) — the new object is of the same type as the
original object (ignoring the top-level cv-qualifiers),

The new object is not an array of char, but an int. P0137, which formalizes the notion of pointing, adds launder:

[ Note: If these conditions are not met, a pointer to the new object
can be obtained from a pointer that represents the address of its
storage by calling std::launder (18.6 [support.dynamic]). — end note
]

I.e. your snippet can be corrected thusly:

std::cout << *std::launder(reinterpret_cast<int*>(data));

.. or just initialize a new pointer from the result of placement new, which also removes the warning.

More Related Contents:

  1. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  2. Is there a (semantic) difference between the return value of placement new and the casted value of its operand?
  3. Does accessing the first field of a struct via a C cast violate strict aliasing?
  4. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  5. reinterpret_cast between char* and std::uint8_t* – safe?
  6. Is it a strict aliasing violation to alias a struct as its first member?
  7. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  8. Order of evaluation of arguments using std::cout
  9. Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?
  10. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  11. What is the size of void?
  12. Do distinct functions have distinct addresses?
  13. Why class data members can’t be initialized by direct initialization syntax?
  14. Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?
  15. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  16. Is a pointer with the right address and type still always a valid pointer since C++17?
  17. What does the standard say about how calling clear on a vector changes the capacity?
  18. Is it safe to push_back an element from the same vector?
  19. Floating point comparison revisited
  20. Pure virtual functions may not have an inline definition. Why?
  21. Class type non-type template parameter initialization does not compile
  22. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  23. When instantiating a template, should members of its incomplete argument types be visible?
  24. Can C++ code be valid in both C++03 and C++11 but do different things?
  25. How can an incomplete type be used as a template parameter to vector here?
  26. Why was the space character not chosen for C++14 digit separators?
  27. Erasing vector::end from vector
  28. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  29. Will I be able to declare a constexpr lambda inside a template parameter?
  30. Directly write into char* buffer of std::string

Leave a Comment