Language: C++ · Versions: C++20 / C++23 (GCC 14.2 -O3)
The problem
I'm implementing a small-buffer-optimized container using alignas(T) std::byte storage[sizeof(T)]. When I placement-new a Slot struct that contains a const int id member into storage, destroy it, and placement-new a second Slot into the same storage, reading reinterpret_cast<Slot*>(storage)->id without std::launder causes -O3 to constant-fold the first object's const int id value!
Minimal example
#include <cstddef>
#include <iostream>
#include <new>
struct Slot {
const int id;
int payload;
};
int main() {
alignas(Slot) std::byte buf[sizeof(Slot)];
Slot* p1 = new (buf) Slot{1, 100};
int first = p1->id;
p1->~Slot();
new (buf) Slot{2, 200};
// Bug: reusing p1 (or casting buf without std::launder when const member was invariant)
std::cout << first << " -> " << p1->id << "\n";
}
Expected
Prints 1 -> 2.
What happens instead
Because Slot::id is const, the compiler is allowed to assume p1->id never changes during p1's lifetime, and since Slot has a const subobject, a new Slot created in the same storage is not transparently replaceable under [basic.life]/8. Accessing the new object through p1 (without saving the pointer returned by the second placement new or calling std::launder(reinterpret_cast<Slot*>(buf))) is Undefined Behavior and can print 1 -> 1 under optimization.
In C++20/23, when is std::launder still strictly required after P0532 / transparent replacement rules, and why does saving the pointer returned by new (buf) Slot{2, 200} differ from reinterpret_cast<Slot*>(buf)?
The question's premise is wrong for C++20/23, and the example has a different problem from the one described. I'm reasoning from the standard's text and haven't run anything, so I can't confirm what GCC 14.2 -O3 prints.
Fix
Slot* p2 = new (buf) Slot{2, 200}; // the new-expression's result points to the new object
std::cout << first << " -> " << p2->id << "\n"; // OK in every standard
// If you only have the storage later (typical SBO container):
std::cout << std::launder(reinterpret_cast<Slot*>(buf))->id; // OK
Why the two pointers differ
- The
newresult is a prvalue pointing to the object just created. No rule needs to be invoked. reinterpret_cast<Slot*>(buf)only reinterprets the pointer value.bufis astd::bytearray that provides storage for theSlot, and theSlotis not pointer-interconvertible with it. The result still points atbuf[0], so using it to readidis UB.std::launder([ptr.launder]) returns a pointer to the object of typeSlotlocated at that address. That is a different thing from reusing an old pointer.- A stale
p1is the third case. It is usable for the new object only if the newSlottransparently replaces the old one ([basic.life]/8).
Is const int id an obstacle?
Not in C++20/23, as far as I recall. Before C++20, [basic.life]/8 excluded objects with const-qualified or reference non-static data members from transparent replacement. I believe that restriction was removed in C++20 by the CWG 1776 resolution (P1971R0). Today the conditions are roughly these:
- the storage exactly overlays the old object;
- the types are the same;
- the old object is not a const complete object (yours is a non-const
Slotin a byte array); - the old object is not a potentially-overlapping subobject.
If I have that right, p1->id is arguably well-defined in C++20/23 and p1 refers to the new object. In C++17 and earlier, p1->id is UB, and that is where std::launder is mandatory. Please check the current [basic.life] wording and the CWG 1776 resolution yourself, because I'm going from memory.
If you still see 1 -> 1
- Check
-std=. With-std=c++17the old rule applies and the fold is permitted. - Check whether GCC treats
constmembers as invariant in your build. A concrete test is to compile with-std=c++23and comparep1->idagainstp2->idin the assembly. If they differ only underc++17, it's the standard version. Ifc++23still folds, it's a candidate GCC bug worth filing.
For portable library code, don't rely on the C++20 relaxation. Store the pointer returned by new, or std::launder when you rebuild it from the buffer. That works in C++17 through C++23, and it matches what std::optional and std::vector implementations do.