Namensräume
Varianten
Aktionen

std::start_lifetime_as, std::start_lifetime_as_array

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
start_lifetime_asstart_lifetime_as_array
(C++23)(C++23)
 
Definiert in 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), außer dass der Speicher nicht tatsächlich zugegriffen wird, wobei E der L-Wert vom Typ U ist, der obj bezeichnet. Andernfalls sind die Werte solcher erzeugter Objekte nicht spezifiziert.
  • [p, (char*)p + sizeof(T)) keine Region von zugewiesenem Speicher bezeichnet, die eine Teilmenge der durch p erreichbaren Speicherregion ist, oder
  • die Region für T nicht geeignet ausgerichtet ist.
  • Beachten Sie, dass der nicht spezifizierte Wert unbestimmt sein kann.
5-8) Erzeugt implizit ein Array mit dem Elementtyp T und der Länge n. Genauer gesagt, wenn n > 0 true ist, ist dies äquivalent zu std::start_lifetime_as<U>(p), wobei U der Typ "Array von n Ts" ist. Andernfalls hat die Funktion keine Auswirkungen.
  • T muss ein vollständiger Typ sein. Andernfalls ist das Programm schlecht geformt.
  • Das Verhalten ist undefiniert, wenn
  • Nicht-null p ist für ein Array von T nicht geeignet ausgerichtet, oder
  • n <= std::size_t(-1) / sizeof(T) ist false, oder
  • n > 0 und [(char*)p, (char*)p + (n * sizeof(T))) bezeichnet keine Region von zugewiesenem Speicher, die eine Teilmenge der durch p erreichbaren Speicherregion ist.

Inhalt

[edit] Parameter

p - die Adresse der Region, die Objekte umfasst
n - die Anzahl der Elemente des zu erzeugenden Arrays

[edit] Rückgabewert

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

[edit] Hinweise

new (void_ptr) unsigned char[size] oder new (void_ptr) std::byte[size] funktioniert als typlose Version von std::start_lifetime_as, behält aber nicht die Objekt-Repräsentation bei.

std::start_lifetime_as behandelt Nicht-Array-Typen sowie Arrays mit bekannter Bindung, während std::start_lifetime_as_array Arrays mit unbekannter Bindung behandelt.

Feature-Test-Makro Wert Std Feature
__cpp_lib_start_lifetime_as 202207L (C++23) Explizites Lebenszeitmanagement

[edit] Beispiel

Führen Sie diesen Code aus
#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)

[edit] Referenzen

  • C++23 Standard (ISO/IEC 14882:2024)
  • 20.2.6 Explizites Lebenszeitmanagement [obj.lifetime]

[edit] Siehe auch

(C++20)
 interpretiert die Objekt-Repräsentation eines Typs als die eines anderen Typs neu
(Funktion-Template) [bearbeiten]
(C++20)
 konvertiert einen span in eine Ansicht seiner zugrunde liegenden Bytes
(Funktionsschablone) [edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/start_lifetime_as&oldid=179469"