<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 :
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 :
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 :
<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 :
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