Namespaces
Variants

std:: start_lifetime_as, std:: start_lifetime_as_array

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Explicit lifetime management
start_lifetime_as
(C++23)
start_lifetime_as_array
(C++23)
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definido en el encabezado <memory>
std::start_lifetime_as
template < class T >
T * start_lifetime_as ( void * p ) noexcept ;
(1) (desde C++23)
template < class T >
const T * start_lifetime_as ( const void * p ) noexcept ;
(2) (desde C++23)
template < class T >
volatile T * start_lifetime_as ( volatile void * p ) noexcept ;
(3) (desde C++23)
template < class T >
const volatile T * start_lifetime_as ( const volatile void * p ) noexcept ;
(4) (desde C++23)
std::start_lifetime_as_array
template < class T >
T * start_lifetime_as_array ( void * p, std:: size_t n ) noexcept ;
(5) (desde C++23)
template < class T >

const T * start_lifetime_as_array ( const void * p,

std:: size_t n ) noexcept ;
(6) (desde C++23)
template < class T >

volatile T * start_lifetime_as_array ( volatile void * p,

std:: size_t n ) noexcept ;
(7) (desde C++23)
template < class T >

const volatile T * start_lifetime_as_array ( const volatile void * p,

std:: size_t n ) noexcept ;
(8) (desde C++23)
1-4) Crea implícitamente un objeto completo de tipo T (cuya dirección es p ) y objetos anidados dentro del mismo. El valor de cada objeto creado obj de tipo TriviallyCopyable U se determina de la misma manera que para una llamada a std:: bit_cast < U > ( E ) excepto que el almacenamiento no se accede realmente, donde E es el lvalue de tipo U que denota obj . De lo contrario, los valores de dichos objetos creados no están especificados.
  • [ p , ( char * ) p + sizeof ( T ) ) no denota una región de almacenamiento asignado que sea un subconjunto de la región de almacenamiento accesible a través de p , o
  • la región no está adecuadamente alineada para T .
  • Nótese que el valor no especificado puede ser indeterminado.
5-8) Crea implícitamente un array con tipo de elemento T y longitud n . Para ser preciso, si n > 0 es true , es equivalente a std :: start_lifetime_as < U > ( p ) donde U es el tipo "array de n T s". De lo contrario, la función no tiene efectos.
  • T debe ser un tipo completo . De lo contrario, el programa está mal formado.
  • El comportamiento es indefinido si:
  • Un p no nulo no está adecuadamente alineado para un array de T , o
  • n <= std:: size_t ( - 1 ) / sizeof ( T ) es false , o
  • n > 0 y [ ( char * ) p , ( char * ) p + ( n * sizeof ( T ) ) ) no denota una región de almacenamiento asignado que sea un subconjunto de la región de almacenamiento accesible a través de p .

Contenidos

Parámetros

p - la dirección de la región que contiene objetos
n - el número de elementos del array a crear

Valor de retorno

1-4) Un puntero al objeto completo como se describió anteriormente.
5-8) Un puntero al primer elemento del arreglo creado, si existe; de lo contrario, un puntero que compare igual a p .

Notas

new ( void_ptr ) unsigned char [ size ] o new ( void_ptr ) std:: byte [ size ] funciona como una versión sin tipo de std::start_lifetime_as , pero no conserva la representación del objeto.

std :: start_lifetime_as maneja tipos no array así como arrays de límite conocido, mientras que std :: start_lifetime_as_array maneja arrays de límite desconocido.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_start_lifetime_as 202207L (C++23) Gestión explícita del tiempo de vida

Ejemplo

Ejecutar este código 
#include <complex>
#include <iostream>
#include <memory>
int main()
{
    alignas(std::complex<float>) unsigned char 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
}

Salida posible: 

(0.1,0.2)

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 20.2.6 Gestión explícita del tiempo de vida [obj.lifetime]

Véase también

(C++20)
reinterpreta la representación de objeto de un tipo como la de otro
(plantilla de función)
(C++20)
convierte un span en una vista de sus bytes subyacentes
(plantilla de función)