|
|
Defined in header <memory> | ||
std::start_lifetime_as | ||
template<class T> T* start_lifetime_as(void* p)noexcept; | (1) | (since C++23) |
template<class T> const T* start_lifetime_as(constvoid* p)noexcept; | (2) | (since C++23) |
template<class T> volatile T* start_lifetime_as(volatilevoid* p)noexcept; | (3) | (since C++23) |
template<class T> constvolatile T* start_lifetime_as(constvolatilevoid* p)noexcept; | (4) | (since C++23) |
std::start_lifetime_as_array | ||
template<class T> T* start_lifetime_as_array(void* p,std::size_t n)noexcept; | (5) | (since C++23) |
template<class T> const T* start_lifetime_as_array(constvoid* p, | (6) | (since C++23) |
template<class T> volatile T* start_lifetime_as_array(volatilevoid* p, | (7) | (since C++23) |
template<class T> constvolatile T* start_lifetime_as_array(constvolatilevoid* p, | (8) | (since C++23) |
T
(whose address isp) and objects nested within it. The value of each created objectobj
ofTriviallyCopyable typeU
is determined in the same manner as for a call tostd::bit_cast<U>(E) except that the storage is not actually accessed, whereE
is the lvalue of typeU
denotingobj
. Otherwise, the values of such created objects are unspecified.T
shall be anImplicitLifetimeType and shall be acomplete type. Otherwise, the program is ill-formed.[
p,
(char*)p+ sizeof(T))
does not denote a region of allocated storage that is a subset of the region of storage reachable throughp, orT
.T
and lengthn. To be precise, ifn>0 istrue, it is equivalent tostd::start_lifetime_as<U>(p) whereU
is the type "array ofnT
s". Otherwise, the function has no effects.T
shall be acomplete type. Otherwise, the program is ill-formed.T
, or[
(char*)p,
(char*)p+(n* sizeof(T)))
does not denote a region of allocated storage that is a subset of the region of storage reachable throughp.Contents |
p | - | the address of the region consisting objects |
n | - | the number of the element of the array to be created |
new(void_ptr)unsignedchar[size] ornew(void_ptr)std::byte[size] works as an untyped version ofstd::start_lifetime_as
, but it does not keep the object representation.
std::start_lifetime_as handles non-array types as well as arrays of known bound, whilestd::start_lifetime_as_array handles arrays of unknown bound.
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_start_lifetime_as | 202207L | (C++23) | Explicit lifetime management |
#include <complex>#include <iostream>#include <memory> int main(){ alignas(std::complex<float>)unsignedchar network_data[sizeof(std::complex<float>)]{0xcd,0xcc,0xcc,0x3d,0xcd,0xcc,0x4c,0x3e}; // auto d = *reinterpret_cast<std::complex<float>*>(network_data);// std::cout << d << '\n'; // UB: network_data does not point to a complex<float> // auto d1 = *std::launder(reinterpret_cast<std::complex<float>*>(network_data));// std::cout << d1 << '\n'; // UB: implicitly created objects have dynamic storage// duration and have indeterminate value initially,// even when an array which provides storage for// them has determinate bytes.// See also CWG2721. auto d2=*std::start_lifetime_as<std::complex<float>>(network_data);std::cout<< d2<<'\n';// OK}
Possible output:
(0.1,0.2)
(C++20) | reinterpret the object representation of one type as that of another (function template)[edit] |
(C++20) | converts aspan into a view of its underlying bytes(function template)[edit] |