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)
Défini dans l'en-tête <memory>
std::start_lifetime_as
template < class T >
T * start_lifetime_as ( void * p ) noexcept ;
(1) (depuis C++23)
template < class T >
const T * start_lifetime_as ( const void * p ) noexcept ;
(2) (depuis C++23)
template < class T >
volatile T * start_lifetime_as ( volatile void * p ) noexcept ;
(3) (depuis C++23)
template < class T >
const volatile T * start_lifetime_as ( const volatile void * p ) noexcept ;
(4) (depuis C++23)
std::start_lifetime_as_array
template < class T >
T * start_lifetime_as_array ( void * p, std:: size_t n ) noexcept ;
(5) (depuis C++23)
template < class T >

const T * start_lifetime_as_array ( const void * p,

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

volatile T * start_lifetime_as_array ( volatile void * p,

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

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

std:: size_t n ) noexcept ;
(8) (depuis C++23)
1-4) Crée implicitement un objet complet de type T (dont l'adresse est p ) et les objets imbriqués à l'intérieur. La valeur de chaque objet créé obj de type TriviallyCopyable U est déterminée de la même manière que pour un appel à std:: bit_cast < U > ( E ) sauf que le stockage n'est pas réellement accédé, où E est la lvalue de type U désignant obj . Sinon, les valeurs de ces objets créés sont non spécifiées.
  • [ p , ( char * ) p + sizeof ( T ) ) ne désigne pas une région de stockage alloué qui est un sous-ensemble de la région de stockage accessible via p , ou
  • la région n'est pas correctement alignée pour T .
  • Notez que la valeur non spécifiée peut être indéterminée.
5-8) Crée implicitement un tableau avec le type d'élément T et la longueur n . Plus précisément, si n > 0 est true , cela équivaut à std :: start_lifetime_as < U > ( p ) où U est le type "tableau de n T ". Sinon, la fonction n'a aucun effet.
  • T doit être un type complet . Sinon, le programme est mal formé.
  • Le comportement est indéfini si :
  • Un pointeur non nul p n'est pas correctement aligné pour un tableau de T , ou
  • n <= std:: size_t ( - 1 ) / sizeof ( T ) est false , ou
  • n > 0 et [ ( char * ) p , ( char * ) p + ( n * sizeof ( T ) ) ) ne désigne pas une région de stockage alloué qui est un sous-ensemble de la région de stockage accessible via p .

Table des matières

Paramètres

p - l'adresse de la région contenant les objets
n - le nombre d'éléments du tableau à créer

Valeur de retour

1-4) Un pointeur vers l'objet complet tel que décrit ci-dessus.
5-8) Un pointeur vers le premier élément du tableau créé, le cas échéant ; sinon, un pointeur qui compare égal à p .

Notes

new ( void_ptr ) unsigned char [ size ] ou new ( void_ptr ) std:: byte [ size ] fonctionne comme une version non typée de std::start_lifetime_as , mais ne conserve pas la représentation de l'objet.

std :: start_lifetime_as gère les types non-tableaux ainsi que les tableaux à limite connue, tandis que std :: start_lifetime_as_array gère les tableaux à limite inconnue.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_start_lifetime_as 202207L (C++23) Gestion explicite de la durée de vie

Exemple

Exécuter ce code 
#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
}

Sortie possible : 

(0.1,0.2)

Références

  • Norme C++23 (ISO/CEI 14882:2024) :
  • 20.2.6 Gestion explicite de la durée de vie [obj.lifetime]

Voir aussi

(C++20)
réinterprète la représentation objet d'un type comme celle d'un autre
(modèle de fonction)
(C++20)
convertit un span en une vue de ses octets sous-jacents
(modèle de fonction)