<allocators>

Définit plusieurs modèles qui permettent d'allouer et les blocs de mémoire pour les conteneurs basés nœud-.

#include <allocators>

Notes

L'en-tête d' <allocators> fournit six modèles d'allocateur qui peuvent être utilisés pour sélectionner des stratégies de gestion de la mémoire pour les conteneurs basés nœud-.Pour utiliser avec ces modèles, il fournit également plusieurs filtres de synchronisation pour adapter la stratégie de gestion de la mémoire diverses modèles de multithreading (aucun).La mise en correspondance une stratégie de gestion de la mémoire à des modèles d'utilisation de la mémoire, et des spécifications de synchronisation, d'une application particulière peut souvent augmenter la vitesse ou réduire les besoins en mémoire globaux d'une application.

Les modèles d'allocateur 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 la mémoire supplémentaires.

Les conteneurs basés nœud- dans la bibliothèque C++ standard (std::list, std::set, std::multiset, std::map et std::multimap) stockent leurs éléments dans chaque nœud.Tous les nœuds d'un type particulier de conteneur sont la même taille, la souplesse d'un gestionnaire à caractère général de mémoire n'est pas nécessaire.Étant donné que 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 rapidement.

Lorsque utilisé avec des conteneurs qui nœud- ne sont pas basés sur (tel que le std::deque de std::vector de conteneurs de la bibliothèque C++ standard, et std::basic_string), les modèles d'alllocator fonctionneront correctement, mais ne sont pas susceptibles d'apporter une amélioration des performances sur l'allocateur par défaut.

Un allocateur est une classe de modèle qui décrit un objet qui gère l'allocation de mémoire et libérer des objets et des tableaux d'objets d'un type spécifié.Les objets d'allocation sont utilisés par plusieurs classes de modèle de conteneur dans la bibliothèque C++ standard.

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

template<class Type>

class allocator;

là où l'argument template Type est le type managé par l'instance de l'allocateur.La bibliothèque C++ standard fournit un allocateur par défaut, la classe de modèle allocateur, qui est définie dans <memory>.l'en-tête d' <allocators> fournit les allocateurs suivants :

Utilisez une instanciation appropriée d'un allocateur comme deuxième argument de type en créant un conteneur, tel que 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 par défaut de synchronisation.

Utilisez la macro ALLOCATOR_DECL (<allocators>) pour créer des modèles d'allocateur avec les filtres de synchronisation autres que la valeur 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 de synchronization_per_thread .

Un allocateur de bloc est un cache ou un filtre.Un cache est une classe de modèle qui prend un argument de type std::size_t.Il définit un allocateur de bloc qui alloue et libère les blocs de mémoire d'une taille unique.Il doit obtenir la mémoire à l'aide de l'opérateur new, mais il n'a pas besoin d'effectuer un appel séparé à l'opérateur new pour chaque bloc.Il peut, par exemple, suballocate d'un plus grand bloc ou des blocs libérés par cache pour la redistribution ultérieure.

Avec un compilateur qui ne peut pas être compilé interface de nouveau la valeur de l'argument de std::size_t utilisé lorsque le modèle instancié n'est pas nécessairement la valeur du _Sz d'argument passé aux fonctions membres d'un cache allouent et libèrent.

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

Un filtre est un allocateur de bloc qui implémente ses fonctions membres à l'aide d'un autre allocateur de bloc qui est passé comme argument template.La forme la plus courante du filtre est un filtre de synchronisation, qui implémente une stratégie de synchronisation pour contrôler l'accès aux fonctions membres d'une instance d'un autre allocateur de bloc.<allocators> fournit les filtres suivants de synchronisation :

<allocators> fournit également le filtre rts_alloc, qui contient plusieurs allocateur de bloc cite et détermine quel instance à utiliser pour l'allocation ou la désallocation au moment de l'exécution et non au moment de la compilation.Il est utilisé avec les compilateurs qui ne peuvent pas se compiler avec onglets de nouveau.

Une stratégie de synchronisation détermine comment les handles d'instance des demandes simultanées d'allocation d'un allocateur et de désallocation à partir de plusieurs threads.La stratégie la plus simple consiste à passer toutes les requêtes directement à l'objet de cache sous-jacent, en conservant de la gestion de synchronisation à l'utilisateur.Une stratégie plus complexe peut s'agir d'utiliser un mutex pour sérialiser l'accès à l'objet de cache sous-jacent.

Si un compilateur prend compiler des applications monothread et multithread, le filtre par défaut de synchronisation pour les applications à un seul thread est sync_none; pour tous les autres cas c'est sync_shared.

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

<allocators> fournit les classes maximale suivantes :

Macros

ALLOCATOR_DECL (<allocators>)	Donne une classe de modèle de l'allocateur.
CACHE_CHUNKLIST (<allocators>)	Référence stdext::allocators::cache_chunklist<sizeof(Type)>.
CACHE_FREELIST (<allocators>)	Référence stdext::allocators::cache_freelist<sizeof(Type), max>.
CACHE_SUBALLOC (<allocators>)	Référence stdext::allocators::cache_suballoc<sizeof(Type)>.
SYNC_DEFAULT (<allocators>)	Génère un filtre de synchronisation.

Opérateurs

operator!= (<allocators>)	Tests pour l'inégalité entre les objets d'allocation d'une classe spécifiée.
operator== (<allocators>)	Tests d'égalité entre les objets d'allocation d'une classe spécifiée.

Classes

allocator_base	Définit la classe de base et les fonctions communes nécessaires pour créer un allocateur défini par l'utilisateur d'un filtre de synchronisation.
allocator_chunklist	Décrit un objet qui gère l'allocation de mémoire et libérer des objets à l'aide d'un cache de type cache_chunklist.
allocator_fixed_size	Décrit un objet qui gère l'allocation de mémoire et libérer des objets de type Type à l'aide d'un cache de type cache_freelist d'une longueur gérée par max_fixed_size.
allocator_newdel	Implémente un allocateur qui utilise operator delete pour libérer un bloc de mémoire et operator new pour allouer un bloc de mémoire.
allocator_suballoc	Décrit un objet qui gère l'allocation de mémoire et libérer 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 de mémoire et libérer des objets de type Type à l'aide d'un cache de type cache_freelist d'une longueur gérée par max_unbounded.
allocator_variable_size	Décrit un objet qui gère l'allocation de mémoire et libérer des objets de type Type à l'aide d'un cache de type cache_freelist d'une longueur gérée par max_variable_size.
cache_chunklist	Définit un allocateur de bloc qui alloue et libère les blocs de mémoire d'une taille unique.
cache_freelist	Définit un allocateur de bloc qui alloue et libère les blocs de mémoire d'une taille unique.
cache_suballoc	Définit un allocateur de bloc qui alloue et libère les blocs de mémoire d'une taille unique.
freelist	Gère une liste de blocs de mémoire.
max_fixed_size	Décrit un objet de classe maximale qui limite un objet de freelist à une longueur maximale fixe.
max_none	Décrit un objet de classe maximale qui limite un objet de freelist à une longueur maximale de zéro.
max_unbounded	Décrit un objet de classe maximale qui ne limite pas la longueur maximale d'un objet de freelist .
max_variable_size	Décrit un objet de classe maximale qui limite un objet de freelist à une longueur maximale qui est proportionnelle à peu près au nombre de blocs de mémoire alloués.
rts_alloc	La classe de modèle de rts_alloc décrit filtre qui contient un tableau d'instances de cache et détermine qui instance à utiliser pour l'allocation et la désallocation au moment de l'exécution et non au moment de la compilation.
synchronization_none	Décrit un filtre de synchronisation qui ne fournit aucune synchronisation.
synchronization_per_container	Décrit un filtre de synchronisation qui fournit un objet cache distinct pour chaque objet d'allocation.
synchronization_per_thread	Décrit un filtre de synchronisation qui fournit un objet cache distinct pour chaque thread.
synchronization_shared	Décrit un filtre de synchronisation qui utilise un mutex pour contrôler l'accès à un objet de cache qui est partagé par tous les allocateurs.

Configuration requise

en-tête : <allocators>

stdext del'espace de noms :

Voir aussi

Autres ressources

Fichiers d'en-tête

Last updated on 2013-03-15