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)
Definiert im Header <memory>
std::start_lifetime_as
template < class T >
T * start_lifetime_as ( void * p ) noexcept ;
(1) (seit C++23)
template < class T >
const T * start_lifetime_as ( const void * p ) noexcept ;
(2) (seit C++23)
template < class T >
volatile T * start_lifetime_as ( volatile void * p ) noexcept ;
(3) (seit C++23)
template < class T >
const volatile T * start_lifetime_as ( const volatile void * p ) noexcept ;
(4) (seit C++23)
std::start_lifetime_as_array
template < class T >
T * start_lifetime_as_array ( void * p, std:: size_t n ) noexcept ;
(5) (seit C++23)
template < class T >

const T * start_lifetime_as_array ( const void * p,

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

volatile T * start_lifetime_as_array ( volatile void * p,

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

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

std:: size_t n ) noexcept ;
(8) (seit C++23)
1-4) Erzeugt implizit ein vollständiges Objekt vom Typ T (dessen Adresse p ist) und darin verschachtelte Objekte. Der Wert jedes erzeugten Objekts obj vom TriviallyCopyable -Typ U wird auf dieselbe Weise bestimmt wie bei einem Aufruf von std:: bit_cast < U > ( E ) , mit der Ausnahme, dass nicht tatsächlich auf den Speicher zugegriffen wird, wobei E der Lvalue vom Typ U ist, der obj bezeichnet. Andernfalls sind die Werte solcher erzeugten Objekte nicht spezifiziert.
  • [ p , ( char * ) p + sizeof ( T ) ) keinen Bereich allokierten Speichers bezeichnet, der eine Teilmenge des durch p erreichbaren Speicherbereichs ist, oder
  • der Bereich nicht geeignet für T ausgerichtet ist.
  • Beachten Sie, dass der nicht spezifizierte Wert indeterminiert sein kann.
5-8) Erzeugt implizit ein Array mit Elementtyp T und Länge n . Genauer gesagt, wenn n > 0 true ist, entspricht dies std :: start_lifetime_as < U > ( p ) , wobei U der Typ "Array von n T s" ist. Andernfalls hat die Funktion keine Auswirkungen.
  • T muss ein vollständiger Typ sein. Andernfalls ist das Programm fehlerhaft.
  • Das Verhalten ist undefiniert, wenn:
  • Nicht-null p nicht geeignet für ein Array von T ausgerichtet ist, oder
  • n <= std:: size_t ( - 1 ) / sizeof ( T ) false ist, oder
  • n > 0 und [ ( char * ) p , ( char * ) p + ( n * sizeof ( T ) ) ) keinen Bereich von allokiertem Speicher bezeichnet, der eine Teilmenge des durch p erreichbaren Speicherbereichs ist.

Inhaltsverzeichnis

Parameter

p - die Adresse des Bereichs, der Objekte enthält
n - die Anzahl der Elemente des zu erstellenden Arrays

Rückgabewert

1-4) Ein Zeiger auf das vollständige Objekt wie oben beschrieben.
5-8) Ein Zeiger auf das erste Element des erstellten Arrays, falls vorhanden; andernfalls ein Zeiger, der gleich verglichen wird mit p .

Hinweise

new ( void_ptr ) unsigned char [ size ] oder new ( void_ptr ) std:: byte [ size ] funktioniert als untypisierte Version von std::start_lifetime_as , bewahrt jedoch die Objektdarstellung nicht.

std :: start_lifetime_as behandelt sowohl Nicht-Array-Typen als auch Arrays mit bekannter Grenze, während std :: start_lifetime_as_array Arrays mit unbekannter Grenze behandelt.

Feature-Test Makro Wert Std Funktion
__cpp_lib_start_lifetime_as 202207L (C++23) Explizite Lebensdauerverwaltung

Beispiel

Diesen Code ausführen 
#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
}

Mögliche Ausgabe: 

(0.1,0.2)

Referenzen

  • C++23-Standard (ISO/IEC 14882:2024):
  • 20.2.6 Explizite Lebensdauerverwaltung [obj.lifetime]

Siehe auch

(C++20)
interpretiert die Objektdarstellung eines Typs als die eines anderen
(Funktionsschablone)
(C++20)
konvertiert einen span in eine Ansicht seiner zugrundeliegenden Bytes
(Funktionsschablone)