<allocators>

Définit plusieurs modèles qui permettent d’allouer et de libérer des blocs de mémoire pour les conteneurs basés sur des nœuds.

Syntaxe

#include <allocators>

Remarque

<allocators> est déconseillé, à compter de Visual Studio 2019 version 16.3.

Notes

L’en-tête <allocators> fournit six modèles d’allocator qui peuvent être utilisés pour sélectionner des stratégies de gestion de la mémoire pour les conteneurs basés sur des nœuds. En complément de ces modèles, il fournit également plusieurs filtres de synchronisation pour adapter la stratégie de gestion de mémoire à différents schémas de multithreading (y compris aucun). Vous pouvez accélérer votre application, ou réduire ses besoins en mémoire, en correspondant à une stratégie de gestion de la mémoire à ses modèles d’utilisation de la mémoire et à ses exigences de synchronisation.

Les modèles d’allocation sont implémentés avec des composants réutilisables qui peuvent être personnalisés ou remplacés pour fournir des stratégies de gestion de mémoire supplémentaires.

Les conteneurs basés sur des nœuds dans la bibliothèque standard C++ (std ::list, std ::set, std ::multiset, std ::map et std ::multimap) stockent leurs éléments dans des nœuds individuels. Tous les nœuds d’un type de conteneur particulier ont la même taille, il n’est donc pas nécessaire d’avoir recourt à la flexibilité d’un gestionnaire de mémoire à usage général. Comme la taille de chaque bloc de mémoire est connue au moment de la compilation, le gestionnaire de mémoire peut être beaucoup plus simple et plus rapide.

Lorsqu’ils sont utilisés avec des conteneurs qui ne sont pas basés sur un nœud (tels que les conteneurs de bibliothèque standard C++ std ::vector std ::d eque et std ::basic_string), les modèles d’allocator fonctionnent correctement, mais ne sont probablement pas susceptibles d’apporter une amélioration des performances sur l’allocateur par défaut.

Un allocator est un modèle de classe qui décrit un objet qui gère l’allocation de stockage et la libération pour les objets et les tableaux d’objets d’un type désigné. Les objets allocator sont utilisés par plusieurs modèles de classe de conteneur dans la bibliothèque C++ Standard.

Les allocateurs sont tous des modèles de ce type :

template<class Type>
class allocator;

où l’argument de modèle Type est le type géré par l’instance d’allocateur. La bibliothèque standard C++ fournit un allocateur par défaut, un allocateur de modèle de classe, qui est défini en< mémoire>. L’en-tête <allocators fournit les allocators> suivants :

• allocator_newdel

• allocator_unbounded

• allocator_fixed_size

• allocator_variable_size

• allocator_suballoc

• allocator_chunklist

Utilisez une instanciation d’allocateur appropriée comme deuxième argument de type quand vous créez un conteneur, comme dans l’exemple de code suivant.

#include <list>
#include <allocators>
std::list<int, stdext::allocators::allocator_chunklist<int> > _List0;

_List0 alloue des nœuds avec allocator_chunklist et le filtre de synchronisation par défaut.

Utilisez la macro ALLOCATOR_DECL pour créer des modèles d’allocateur avec des filtres de synchronisation autre que celui par défaut :

#include <list>
#include <allocators>
ALLOCATOR_DECL(CACHE_CHUNKLIST, stdext::allocators::sync_per_thread, Alloc);
std::list<int, alloc<int> > _List1;

_Lst1 alloue des nœuds avec allocator_chunklist et le filtre de synchronisation sync_per_thread.

Un allocateur de blocs est un cache ou un filtre. Un cache est un modèle de classe qui accepte un argument de type std ::size_t. Il définit un allocateur de blocs qui alloue et désalloue des blocs de mémoire de taille unique. Il doit obtenir de la mémoire à l’aide de l’opérateur new, mais il n’a pas besoin d’effectuer un appel distinct à l’opérateur new pour chaque bloc. Il peut, par exemple, sous-allouer la mémoire d’un bloc plus grand ou mettre en cache des blocs désalloués en vue d’une réallocation ultérieure.

Avec un compilateur qui ne peut pas rebiner la valeur de l’argument std ::size_t utilisé lorsque le modèle a été instancié n’est pas nécessairement la valeur de l’argument _Sz passé aux fonctions membres d’un cache allouent et libèrent.

<les allocators> fournissent les modèles de cache suivants :

• cache_freelist

• cache_suballoc

• cache_chunklist

Un filtre est un allocateur de bloc qui implémente ses fonctions membres à l’aide d’un autre allocateur de bloc, qui est passé à celui-ci en tant qu’argument de modèle. La forme de filtre la plus courante est le filtre de synchronisation, qui applique une stratégie de synchronisation pour contrôler l’accès aux fonctions membres d’une instance d’un autre allocateur de blocs. <les allocators fournissent les filtres> de synchronisation suivants :

• sync_none

• sync_per_container

• sync_per_thread

• sync_shared

<les allocateurs> fournissent également le filtre rts_alloc, qui contient plusieurs instances d’allocator de bloc et détermine l’instance à utiliser pour l’allocation ou la désallocation au moment de l’exécution au lieu du moment de la compilation. Elle est utilisée avec les compilateurs qui ne peuvent pas compiler la reliaison.

Une stratégie de synchronisation détermine comment une instance d’allocateur gère des demandes d’allocation et de désallocation simultanées à partir de plusieurs threads. La stratégie la plus simple consiste à passer toutes les demandes directement à l’objet cache sous-jacent, laissant à l’utilisateur la gestion de la synchronisation. Une stratégie plus complexe consiste à utiliser un mutex pour sérialiser l’accès à l’objet cache sous-jacent.

Si un compilateur prend en charge la compilation d’applications monothread et multithread, le filtre de synchronisation pour les applications monothread est sync_none ; et pour tous les autres cas sync_shared.

Le modèle cache_freelist de cache prend un argument de classe maximal, qui détermine le nombre maximal d’éléments à stocker dans la liste libre.

<allocators fournit les classes maximales> suivantes :

• max_none

• max_unbounded

• max_fixed_size

• max_variable_size

Macros

Macro	Description
ALLOCATOR_DECL	Génère un modèle de classe d’allocator.
CACHE_CHUNKLIST	Génère stdext::allocators::cache_chunklist<sizeof(Type)>.
CACHE_FREELIST	Génère stdext::allocators::cache_freelist<sizeof(Type), max>.
CACHE_SUBALLOC	Génère stdext::allocators::cache_suballoc<sizeof(Type)>.
SYNC_DEFAULT	Génère un filtre de synchronisation.

Opérateurs

Opérateur	Description
operator != (<allocators>)	Vérifie l'inégalité entre les objets allocateurs d'une classe spécifiée.
operator== (<allocators>)	Vérifie l'égalité entre les objets allocateurs d'une classe spécifiée.

Classes

Classe	Description
allocator_base	Définit la classe de base et les fonctions communes nécessaires à la création d’un allocateur défini par l’utilisateur à partir d’un filtre de synchronisation.
allocator_chunklist	Décrit un objet qui gère l’allocation et la libération de stockage pour des objets à l’aide d’un cache de type cache_chunklist.
allocator_fixed_size	Décrit un objet qui gère l’allocation et la libération de stockage pour des objets de type Type à l’aide d’un cache de type cache_freelist avec une longueur gérée par max_fixed_size.
allocator_newdel	Implémente un allocateur qui utilise la suppression d’opérateur pour libérer un bloc de mémoire et un opérateur nouveau pour allouer un bloc de mémoire.
allocator_suballoc	Décrit un objet qui gère l’allocation et la libération de stockage pour des objets de type Type à l’aide d’un cache de type cache_suballoc.
allocator_unbounded	Décrit un objet qui gère l’allocation et la libération de stockage pour des objets de type Type à l’aide d’un cache de type cache_freelist avec une longueur gérée par max_unbounded.
allocator_variable_size	Décrit un objet qui gère l’allocation et la libération de stockage pour des objets de type Type à l’aide d’un cache de type cache_freelist avec une longueur gérée par max_variable_size.
cache_chunklist	Définit un allocateur de blocs qui alloue et désalloue des blocs de mémoire de taille unique.
cache_freelist	Définit un allocateur de blocs qui alloue et désalloue des blocs de mémoire de taille unique.
cache_suballoc	Définit un allocateur de blocs qui alloue et désalloue des blocs de mémoire de taille unique.
freelist	Gère une liste de blocs de mémoire.
max_fixed_size	Décrit un objet de classe max qui limite un objet freelist à une longueur maximale fixe.
max_none	Décrit un objet de classe max qui limite un objet freelist à une longueur maximale de zéro.
max_unbounded	Décrit un objet de classe max qui ne limite pas la longueur maximale d’un objet freelist.
max_variable_size	Décrit un objet de classe max qui limite un objet freelist à une longueur maximale qui est à peu près proportionnelle au nombre de blocs de mémoire alloués.
rts_alloc	Le modèle de classe rts_alloc décrit un filtre qui contient un tableau d’instances de cache et détermine l’instance à utiliser pour l’allocation et la désallocation au moment de l’exécution au lieu du moment de la compilation.
sync_none	Décrit un filtre de synchronisation qui ne fournit aucune synchronisation.
sync_per_container	Décrit un filtre de synchronisation qui fournit un objet cache distinct pour chaque objet allocateur.
sync_per_thread	Décrit un filtre de synchronisation qui fournit un objet cache distinct pour chaque thread.
sync_shared	Décrit un filtre de synchronisation qui utilise un mutex pour contrôler l’accès à un objet cache partagé par tous les allocateurs.

Spécifications

Header :<allocators>

Espace de noms : stdext

Voir aussi

Informations de référence sur les fichiers d’en-tête