std:: uses_allocator

Défini dans l'en-tête <memory>
template < class T, class Alloc > struct uses_allocator ;		(depuis C++11)

Si T a un type imbriqué allocator_type qui est convertible depuis Alloc , la constante membre value vaut true . Sinon value vaut false .

Table des matières 1 Modèle de variable d'assistance 2 Hérité de std:: integral_constant 2.1 Constantes membres 2.2 Fonctions membres 2.3 Types membres 2.4 Construction avec allocateur 2.5 Spécialisations 2.6 Notes 2.7 Voir aussi

Modèle de variable d'assistance

template < class T, class Alloc > constexpr bool uses_allocator_v = uses_allocator < T, Alloc > :: value ;		(depuis C++17)

Construction avec allocateur

Il existe trois conventions pour passer un allocateur alloc au constructeur d'un type T :

• Si T n'utilise pas un allocateur compatible ( std :: uses_allocator_v < T, Alloc > est false ), alors alloc est ignoré.
• Sinon, std :: uses_allocator_v < T, Alloc > est true , et

• si T utilise la convention d'allocateur en tête (est invocable comme T ( std:: allocator_arg , alloc, args... ) ), alors la construction avec allocateur utilise cette forme.
• si T utilise la convention d'allocateur en queue (est invocable comme T ( args..., alloc ) ), alors la construction avec allocateur utilise cette forme.
• Sinon, le programme est mal formé (cela signifie que std :: uses_allocator_v < T, Alloc > est true , mais le type ne suit aucune des deux conventions autorisées).

• En tant que cas particulier, std::pair est traité comme un type utilisant un allocateur même si std::uses_allocator est false pour les paires (contrairement à par exemple std::tuple ) : voir les surcharges spécifiques aux paires de std::pmr::polymorphic_allocator::construct et std::scoped_allocator_adaptor::construct (jusqu'à C++20) std::uses_allocator_construction_args (depuis C++20) .

Les fonctions utilitaires std::make_obj_using_allocator , et std::uninitialized_construct_using_allocator peuvent être utilisées pour créer explicitement un objet suivant le protocole ci-dessus, et std::uses_allocator_construction_args peut être utilisée pour préparer la liste d'arguments qui correspond au type de construction uses-allocator attendu par le type.

(depuis C++20)

Spécialisations

Étant donné un type défini par le programme T qui ne possède pas de allocator_type imbriqué, un programme peut spécialiser std::uses_allocator pour dériver de std::true_type pour T si l'une des exigences suivantes est satisfaite :

• T possède un constructeur qui prend std::allocator_arg_t comme premier argument, et Alloc comme second argument.
• T possède un constructeur qui prend Alloc comme dernier argument.

Dans ce qui précède, Alloc est un type qui satisfait Allocator ou est un type pointeur convertible en std::experimental::pmr::memory_resource* (library fundamentals TS) .

Les spécialisations suivantes sont déjà fournies par la bibliothèque standard :

std::uses_allocator <std::tuple> (C++11)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::queue> (C++11)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::priority_queue> (C++11)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::stack> (C++11)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::flat_map> (C++23)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::flat_set> (C++23)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::flat_multimap> (C++23)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::flat_multiset> (C++23)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::function> (C++11) (jusqu'à C++17)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::promise> (C++11)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)
std::uses_allocator <std::packaged_task> (C++11) (jusqu'à C++17)	spécialise le trait de type std::uses_allocator (spécialisation de modèle de classe)

Notes

Ce trait de type est utilisé par std::tuple , std::scoped_allocator_adaptor , et std::pmr::polymorphic_allocator . Il peut également être utilisé par des allocateurs personnalisés ou des types wrapper pour déterminer si l'objet ou le membre en cours de construction est lui-même capable d'utiliser un allocateur (par exemple, s'il s'agit d'un conteneur), auquel cas un allocateur doit être passé à son constructeur.

Voir aussi

allocator_arg allocator_arg_t (C++11)	une balise utilisée pour sélectionner les constructeurs prenant en compte l'allocateur (balise)
uses_allocator_construction_args (C++20)	prépare la liste d'arguments correspondant au type de construction uses-allocator requis par le type donné (modèle de fonction)
make_obj_using_allocator (C++20)	crée un objet du type donné au moyen d'une construction uses-allocator (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 d'une construction uses-allocator (modèle de fonction)
scoped_allocator_adaptor (C++11)	implémente un allocateur multi-niveaux pour les conteneurs multi-niveaux (modèle de classe)