std::launder
From cppreference.com
| Defined in header <new>
|
||
| template <class T> constexpr T* launder(T* p) |
(since C++17) | |
Obtains a pointer to an object created in storage occupied by an existing object of the same type, even if it has const or reference members.
Formally, given
- the pointer
prepresents the addressAof a byte in memory - an object
Xis located at the addressA -
Xis within its lifetime - the type of
Xis the same asT, ignoring cv-qualifiers at every level - Every byte that would be reachable through the result is reachable through p (bytes are reachable through a pointer that points to an object if those bytes are within that object's storage, or within the immediately enclosing array of which the object is an element)
Then std::launder(p) returns a value of type T* that points to the object X.
The program is ill-formed if T is a function type or (possibly cv-qualified) void.
std::launder may be used in a core constant expression if the value of its argument may be used in a core constant expression
[edit] Exceptions
noexcept specification:
noexcept
[edit] Notes
For objects that do not have const or reference members, std::launder is not necessary; pointers and references can be reused
[edit] Example
Run this code
#include <new> struct X { const int n; // note: X has a const member int m; }; int main() { X *p = new X{3}; const int a = p->n; new (p) X{5}; // p does not point to new object because X::n is const const int b = p->n; // undefined behavior const int x = p->m; // undefined behavior (even though m is non-const, p can't be used) const int c = std::launder(p)->n; // OK, std::launder(p) points to new object }