std:: uses_allocator_construction_args

From cppreference.net

Défini dans l'en-tête `<memory>`
`T` n'est pas une spécialisation de std::pair
template < class T, class Alloc, class ... Args > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, Args && ... args ) noexcept ;	(1)	(depuis C++20)
`T` est une spécialisation de std::pair
template < class T, class Alloc, class Tuple1, class Tuple2 > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, std:: piecewise_construct_t , Tuple1 && x, Tuple2 && y ) noexcept ;	(2)	(depuis C++20)
template < class T, class Alloc > constexpr auto uses_allocator_construction_args ( const Alloc & alloc ) noexcept ;	(3)	(depuis C++20)
template < class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, U && u, V && v ) noexcept ;	(4)	(depuis C++20)
template < class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, std:: pair < U, V > & pr ) noexcept ;	(5)	(depuis C++23)
template < class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, const std:: pair < U, V > & pr ) noexcept ;	(6)	(depuis C++20)
template < class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, std:: pair < U, V > && pr ) noexcept ;	(7)	(depuis C++20)
template < class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, const std:: pair < U, V > && pr ) noexcept ;	(8)	(depuis C++23)
template < class T, class Alloc, class NonPair > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, NonPair && non_pair ) noexcept ;	(9)	(depuis C++20)

Prépare la liste d'arguments nécessaire pour créer un objet du type donné T au moyen de la construction uses-allocator .

1) Cette surcharge participe à la résolution de surcharge seulement si

n'est pas une spécialisation de std::pair . Retourne std::tuple déterminé comme suit :

Si std:: uses_allocator_v < T, Alloc > est false et std:: is_constructible_v < T, Args... > est true , retourne std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) .
Sinon, si std:: uses_allocator_v < T, Alloc > est true et std:: is_constructible_v < T, std:: allocator_arg_t , const Alloc & , Args... > est true , retourne
std:: tuple < std:: allocator_arg_t , const Alloc & , Args && ... > ( std:: allocator_arg , alloc,
std:: forward < Args > ( args ) ... ) .
Sinon, si std:: uses_allocator_v < T, Alloc > est true et std:: is_constructible_v < T, Args..., const Alloc & > est true , retourne std:: forward_as_tuple ( std:: forward < Args > ( args ) ..., alloc ) .
Sinon, le programme est mal formé.

2) Cette surcharge participe à la résolution de surcharge seulement si

est une spécialisation de std::pair . Pour

qui est std:: pair < T1, T2 > , équivalent à

return std::make_tuple(std::piecewise_construct,
    std::apply([&alloc](auto&&... args1)
        {
            return std::uses_allocator_construction_args<T1>(alloc,
                       std::forward<decltype(args1)>(args1)...);
        }, std::forward<Tuple1>(x)
    ),
    std::apply([&alloc](auto&&... args2)
        {
            return std::uses_allocator_construction_args<T2>(alloc,
                       std::forward<decltype(args2)>(args2)...);
        }, std::forward<Tuple2>(y)
    )
);

3) Cette surcharge participe à la résolution de surcharge uniquement si

est une spécialisation de std::pair . Équivalent à

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct, std::tuple<>{}, std::tuple<>{}
);

4) Cette surcharge participe à la résolution de surcharge uniquement si

est une spécialisation de std::pair . Équivalent à

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::forward<U>(u)),
    std::forward_as_tuple(std::forward<V>(v))
);

5,6) Cette surcharge participe à la résolution de surcharge uniquement si

est une spécialisation de std::pair . Équivalent à

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct,
    std::forward_as_tuple(pr.first),
    std::forward_as_tuple(pr.second)
);

7,8) Cette surcharge participe à la résolution de surcharge uniquement si

est une spécialisation de std::pair . Équivalent à

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::get<0>(std::move(pr))),
    std::forward_as_tuple(std::get<1>(std::move(pr)))
);

9) Cette surcharge participe à la résolution de surcharge seulement si

est une spécialisation de std::pair , et étant donné le modèle de fonction d'exposition uniquement

template<class A, class B>
void /*deduce-as-pair*/(const std::pair<A, B>&);

, /*deduce-as-pair*/ ( non_pair ) est mal formé lorsqu'il est considéré comme un opérande non évalué.
Soit la classe d'exposition uniquement pair-constructor définie comme

class /*pair-constructor*/
{
    const Alloc& alloc_; // exposition only
    NonPair&     u_;     // exposition only
    constexpr reconstruct(const std::remove_cv<T>& p) const // exposition only
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, p);
    }
    constexpr reconstruct(std::remove_cv<T>&& p) const // exposition only
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, std::move(p));
    }
public:
    constexpr operator std::remove_cv<T>() const
    {
        return reconstruct(std::forward<NonPair>(u_));
    }
};

Cette surcharge est équivalente à return std:: make_tuple ( pair_construction ) ; , où


        pair_construction

est une valeur de type


        
         pair-constructor

dont les membres


        
         alloc_

u_

sont respectivement


        alloc


        non_pair

Table des matières

Paramètres

alloc	-	l'allocateur à utiliser
args	-	les arguments à passer au constructeur de `T`
x	-	tuple d'arguments à passer aux constructeurs du `first` membre de données de `T`
y	-	tuple d'arguments à passer aux constructeurs du `second` membre de données de `T`
u	-	argument unique à passer au constructeur du `first` membre de données de `T`
v	-	argument unique à passer au constructeur du `second` membre de données de `T`
pr	-	une paire dont le membre de données `first` sera passé au constructeur du `first` membre de données de `T` et le membre de données `second` sera passé au constructeur du `second` membre de données de `T`
non_pair	-	argument unique à convertir en std::pair pour une construction ultérieure

Valeur de retour

std::tuple d'arguments appropriés pour être passés au constructeur de T .

Notes

Les surcharges (2-9) fournissent la propagation de l'allocateur dans std::pair , qui ne prend en charge ni les conventions d'appel d'allocateur en tête ni en queue (contrairement, par exemple, à std::tuple , qui utilise la convention d'allocateur en tête).

Lorsqu'il est utilisé dans la construction uses-allocator, la fonction de conversion de pair-constructor convertit d'abord l'argument fourni en std::pair , puis construit le résultat à partir de cette std::pair par construction uses-allocator.

Exemple

Cette section est incomplète
Raison : aucun exemple

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 3525	C++20	aucune surcharge ne pouvait gérer les types non- `pair` convertibles en `pair`	surcharge de reconstruction ajoutée

Voir aussi

uses_allocator (C++11)	vérifie si le type spécifié prend en charge la construction par allocateur (modèle de classe)
make_obj_using_allocator (C++20)	crée un objet du type donné au moyen de la construction par allocateur (modèle de fonction)
uninitialized_construct_using_allocator (C++20)	crée un objet du type donné à un emplacement mémoire spécifié au moyen de la construction par allocateur (modèle de fonction)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

std:: uses_allocator_construction_args

Table des matières

Paramètres

Valeur de retour

Notes

Exemple

Rapports de défauts

Voir aussi