Namespaces
Variants

std::scoped_allocator_adaptor<OuterAlloc,InnerAlloc...>:: construct

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
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)
std::scoped_allocator_adaptor
Défini dans l'en-tête <scoped_allocator>
template < class T, class ... Args >
void construct ( T * p, Args && ... args ) ;
(1)
template < class T1, class T2, class ... Args1 , class ... Args2 >

void construct ( std:: pair < T1, T2 > * p, std:: piecewise_construct_t ,

std:: tuple < Args1... > x, std:: tuple < Args2... > y ) ;
(2) (jusqu'au C++20)
template < class T1, class T2 >
void construct ( std:: pair < T1, T2 > * p ) ;
(3) (jusqu'à C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ;
(4) (jusqu'au C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, const std:: pair < U, V > & xy ) ;
(5) (jusqu'en C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ;
(6) (jusqu'au C++20)
Modèles de fonctions d'assistance
template < class T, class ... Args >
std:: tuple < /* voir ci-dessous */ > /*concat-args*/ ( std:: tuple < Args... > && tup ) ;
(7) ( exposition uniquement* )
(jusqu'à C++20)

Construit un objet dans un stockage alloué mais non initialisé pointé par p en utilisant l'allocateur externe et les arguments de construction fournis. Si l'objet est d'un type qui utilise lui-même des allocateurs , ou s'il s'agit de std::pair (jusqu'à C++20) , transmet l'allocateur interne à l'objet construit.

1) Constructs an object of type T by construction par uses-allocator at the uninitialized memory location indicated by p using the outermost allocator.

Soit std:: uses_allocator < T, inner_allocator_type > :: value défini comme uses_inner :

Cette surcharge participe à la résolution de surcharge seulement si T n'est pas une spécialisation de std::pair .

(jusqu'à C++20)

Équivalent à std:: apply
(
[ p, this ] ( auto && ... newargs )
{
outermost-construct
( p, std:: forward < decltype ( newargs ) > ( newargs ) ... ) ;
} ,
std:: uses_allocator_construction_args
( inner_allocator ( ) , std:: forward < Args > ( args ) ... )
) ; .

(depuis C++20)
2-6) Construit un objet std::pair par construction uses-allocator à l'emplacement mémoire non initialisé indiqué par p en utilisant l'allocateur le plus externe.
2) Soit xprime égal à concat-args  < T1 > ( std :: move ( x ) ) , yprime égal à concat-args  < T2 > ( std :: move ( y ) ) , appelle outermost-construct  ( p, std:: piecewise_construct , std :: move ( xprime ) , std :: move ( yprime ) ) .
3) Équivalent à construct ( p, std:: piecewise_construct , std:: tuple <> ( ) , std:: tuple <> ( ) ) ; .
4-6) Équivalent à construct ( p, std:: piecewise_construct ,
std:: forward_as_tuple ( xarg ) , std:: forward_as_tuple ( yarg ) ) ; , où xarg et yarg sont définis comme suit :
Surcharge xarg yarg
(4) std:: forward < U > ( x ) std:: forward < V > ( y )
(5) xy. first xy. second
(6) std:: forward < U > ( xy. first ) std:: forward < V > ( xy. second )
7) Fusionne les arguments contenus dans tup et les arguments supplémentaires requis par la construction uses-allocator d'un objet de type T .
Soit std:: uses_allocator < T, inner_allocator_type > :: value défini comme uses_inner :

Table des matières

Paramètres

p - pointeur vers une zone mémoire allouée mais non initialisée
args - les arguments du constructeur à passer au constructeur de T
x - les arguments du constructeur à passer au constructeur de T1
y - les arguments du constructeur à passer au constructeur de T2
xy - la paire dont les deux membres sont les arguments du constructeur pour T1 et T2
tup - les arguments à fusionner

Notes

Cette fonction est appelée (via std::allocator_traits ) par tout objet sensible aux allocateurs, tel que std::vector , auquel on a fourni un std::scoped_allocator_adaptor comme allocateur à utiliser. Puisque inner_allocator_type est lui-même une spécialisation de std::scoped_allocator_adaptor , cette fonction sera également appelée lorsque les objets sensibles aux allocateurs construits via cette fonction commencent à construire leurs propres membres.

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2203 C++11 les allocateurs internes étaient obtenus par initialisation à la valeur
d'un objet inner_allocator_type 		obtenus en appelant inner_allocator()
LWG 2511
( P0475R1 ) 		C++11 concat-args pouvait copier des éléments de std::tuple a éliminé toutes les opérations de copie d'éléments
LWG 2586 C++11 seules les constructions à partir de
inner_allocator_type rvalues étaient vérifiées 		vérifie les constructions à partir de
inner_allocator_type lvalues non constantes à la place
LWG 2975 C++11 la surcharge (1) n'était pas contrainte contrainte pour refuser std::pair

Voir aussi

[static]
construit un objet dans le stockage alloué
(fonction template)
(jusqu'à C++20)
construit un objet dans le stockage alloué
(fonction membre publique de std::allocator<T> )