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

From cppreference.com
C++
Dynamic memory management
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Allocators
Garbage collection support
(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
Defined in header <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) (until C++20)
template < class T1, class T2 >
void construct ( std:: pair < T1, T2 > * p ) ;
(3) (until C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ;
(4) (until 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) (until C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ;
(6) (until C++20)
Helper function templates
template < class T, class ... Args >
std:: tuple < /* see below */ > /*concat-args*/ ( std:: tuple < Args... > && tup ) ;
(7) ( exposition only* )
(until C++20)

Constructs an object in allocated, but not initialized storage pointed to by p using the outer allocator and the provided constructor arguments. If the object is of a type that itself uses allocators , or if it is std::pair (until C++20) , passes the inner allocator down to the constructed object.

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

Given std:: uses_allocator < T, inner_allocator_type > :: value as uses_inner :

This overload participates in overload resolution only if T is not a specialization of std::pair .

(until C++20)

Equivalent to 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 ) ... )
) ; .

(since C++20)
2-6) Constructs a std::pair object by uses-allocator construction at the uninitialized memory location indicated by p using the outermost allocator.
2) Let xprime be concat-args  < T1 > ( std :: move ( x ) ) , yprime be concat-args  < T2 > ( std :: move ( y ) ) , calls outermost-construct  ( p, std:: piecewise_construct , std :: move ( xprime ) , std :: move ( yprime ) ) .
3) Equivalent to construct ( p, std:: piecewise_construct , std:: tuple <> ( ) , std:: tuple <> ( ) ) ; .
4-6) Equivalent to construct ( p, std:: piecewise_construct ,
std:: forward_as_tuple ( xarg ) , std:: forward_as_tuple ( yarg ) ) ; , where xarg and yarg are defined as follows:
Overload 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) Merges the arguments contained in tup and additional arguments required by uses-allocator construction of an object of type T .
Given std:: uses_allocator < T, inner_allocator_type > :: value as uses_inner :

Parameters

p - pointer to allocated, but not initialized storage
args - the constructor arguments to pass to the constructor of T
x - the constructor arguments to pass to the constructor of T1
y - the constructor arguments to pass to the constructor of T2
xy - the pair whose two members are the constructor arguments for T1 and T2
tup - the arguments to be merged

Notes

This function is called (through std::allocator_traits ) by any allocator-aware object, such as std::vector , that was given a std::scoped_allocator_adaptor as the allocator to use. Since inner_allocator_type is itself a specialization of std::scoped_allocator_adaptor , this function will also be called when the allocator-aware objects constructed through this function start constructing their own members.

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2203 C++11 inner allocators were obtained by value-initializing
an inner_allocator_type object 		obtained by calling inner_allocator()
LWG 2511
( P0475R1 ) 		C++11 concat-args might copy elements of std::tuple s eliminated all element copy operations
LWG 2586 C++11 only constructions from
inner_allocator_type rvalues were checked 		checks constructions from non-const
inner_allocator_type lvalues instead
LWG 2975 C++11 overload (1) was not constrained constrained to refuse std::pair

See also

[static]
constructs an object in the allocated storage
(function template)
(until C++20)
constructs an object in allocated storage
(public member function of std::allocator<T> )
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/memory/scoped_allocator_adaptor/construct&oldid=177662 "