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
Definido en el encabezado <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) (hasta C++20)
template < class T1, class T2 >
void construct ( std:: pair < T1, T2 > * p ) ;
(3) (hasta C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ;
(4) (hasta 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) (hasta C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ;
(6) (hasta C++20)
Plantillas de funciones auxiliares
template < class T, class ... Args >
std:: tuple < /* ver abajo */ > /*concat-args*/ ( std:: tuple < Args... > && tup ) ;
(7) ( solo para exposición* )
(hasta C++20)

Construye un objeto en almacenamiento asignado pero no inicializado apuntado por p usando el asignador externo y los argumentos de constructor proporcionados. Si el objeto es de un tipo que a su vez usa asignadores , o si es std::pair (until C++20) , pasa el asignador interno al objeto construido.

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

Dado std:: uses_allocator < T, inner_allocator_type > :: value como uses_inner :

Esta sobrecarga participa en la resolución de sobrecarga solo si T no es una especialización de std::pair .

(hasta C++20)

Equivalente a 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 ) ... )
) ; .

(desde C++20)
2-6) Construye un objeto std::pair mediante construcción uses-allocator en la ubicación de memoria no inicializada indicada por p usando el asignador más externo.
2) Sea xprime igual a concat-args  < T1 > ( std :: move ( x ) ) , yprime igual a concat-args  < T2 > ( std :: move ( y ) ) , llama a outermost-construct  ( p, std:: piecewise_construct , std :: move ( xprime ) , std :: move ( yprime ) ) .
3) Equivalente a construct ( p, std:: piecewise_construct , std:: tuple <> ( ) , std:: tuple <> ( ) ) ; .
4-6) Equivalente a construct ( p, std:: piecewise_construct ,
std:: forward_as_tuple ( xarg ) , std:: forward_as_tuple ( yarg ) ) ; , donde xarg y yarg se definen de la siguiente manera:
Sobrecarga 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) Combina los argumentos contenidos en tup y los argumentos adicionales requeridos para la construcción uses-allocator de un objeto de tipo T .
Dado std:: uses_allocator < T, inner_allocator_type > :: value como uses_inner :

Contenidos

Parámetros

p - puntero a almacenamiento asignado pero no inicializado
args - los argumentos del constructor que se pasarán al constructor de T
x - los argumentos del constructor que se pasarán al constructor de T1
y - los argumentos del constructor que se pasarán al constructor de T2
xy - el par cuyos dos miembros son los argumentos del constructor para T1 y T2
tup - los argumentos que se van a combinar

Notas

Esta función es llamada (a través de std::allocator_traits ) por cualquier objeto consciente del asignador, como std::vector , al que se le haya proporcionado un std::scoped_allocator_adaptor como asignador a utilizar. Dado que inner_allocator_type es en sí mismo una especialización de std::scoped_allocator_adaptor , esta función también será llamada cuando los objetos conscientes del asignador construidos a través de esta función comiencen a construir sus propios miembros.

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2203 C++11 los asignadores internos se obtenían mediante inicialización por valor
de un objeto inner_allocator_type 		obtenidos llamando a inner_allocator()
LWG 2511
( P0475R1 ) 		C++11 concat-args podría copiar elementos de std::tuple s eliminó todas las operaciones de copia de elementos
LWG 2586 C++11 solo se verificaban las construcciones desde
inner_allocator_type rvalues 		verifica construcciones desde
inner_allocator_type lvalues no constantes en su lugar
LWG 2975 C++11 la sobrecarga (1) no estaba restringida restringida para rechazar std::pair

Véase también

[static]
construye un objeto en el almacenamiento asignado
(plantilla de función)
(until C++20)
construye un objeto en almacenamiento asignado
(función miembro pública de std::allocator<T> )