<allocators>
Definisce diversi modelli che consentono di allocare e liberare blocchi di memoria per contenitori basati su nodi.
Sintassi
#include <allocators>
Nota
<Allocator> è deprecato, a partire da Visual Studio 2019 versione 16.3.
Osservazioni:
L'intestazione <allocatori> fornisce sei modelli di allocatore che possono essere usati per selezionare strategie di gestione della memoria per i contenitori basati su nodi. Per l'uso con questi modelli, l'intestazione offre anche diversi filtri di sincronizzazione che consentono di personalizzare la strategia di gestione della memoria in numerosi schemi di multithreading diversi o in nessuno schema. È possibile velocizzare l'app o ridurne i requisiti di memoria, associando una strategia di gestione della memoria ai relativi modelli di utilizzo della memoria e ai requisiti di sincronizzazione.
I modelli di allocatore vengono implementati con componenti riutilizzabili che possono essere personalizzati o sostituiti per offrire ulteriori strategie di gestione della memoria.
I contenitori basati su nodi nella libreria standard C++ (std::list, std::set, std::multiset, std::map e std::multimap) archivia i relativi elementi in singoli nodi. Poiché tutti i nodi di un tipo di contenitore specifico hanno le stesse dimensioni, non è necessaria la flessibilità di un gestore di memoria di uso generale. Poiché la dimensione di ogni blocco di memoria è nota in fase di compilazione, il gestore di memoria può essere molto più semplice e veloce.
Se usata con contenitori non basati su nodi ,ad esempio i contenitori della libreria standard C++ std::vector std::d eque e std::basic_string, i modelli di allocatore funzioneranno correttamente, ma probabilmente non offrono alcun miglioramento delle prestazioni rispetto all'allocatore predefinito.
Un allocatore è un modello di classe che descrive un oggetto che gestisce l'allocazione di archiviazione e libera per oggetti e matrici di oggetti di un tipo designato. Gli oggetti allocatore vengono usati da diversi modelli di classe contenitore nella libreria standard C++.
Gli allocatori sono tutti i modelli di questo tipo:
template<class Type>
class allocator;
dove l'argomento di modello Type è il tipo gestito dall'istanza dell'allocatore. La libreria standard C++ fornisce un allocatore predefinito, un allocatore di modelli di classe, definito in <memoria>. L'intestazione <allocatori fornisce gli allocatori> seguenti:
Usare una creazione di istanza appropriata di un allocatore come secondo argomento tipo durante la creazione di un contenitore, come l'esempio di codice seguente.
#include <list>
#include <allocators>
std::list<int, stdext::allocators::allocator_chunklist<int> > _List0;
_List0 alloca nodi con allocator_chunklist e il filtro di sincronizzazione predefinito.
Usare la macro ALLOCATOR_DECL per creare modelli allocatore con filtri di sincronizzazione diversi da quello predefinito:
#include <list>
#include <allocators>
ALLOCATOR_DECL(CACHE_CHUNKLIST, stdext::allocators::sync_per_thread, Alloc);
std::list<int, alloc<int> > _List1;
_Lst1 alloca nodi con allocator_chunklist e il filtro di sincronizzazione sync_per_thread.
Un allocatore di blocco è una cache o un filtro. Una cache è un modello di classe che accetta un argomento di tipo std::size_t. Definisce un allocatore di blocco che alloca e dealloca blocchi di memoria di un'unica dimensione. Deve ottenere la memoria usando l'operatore new, ma non necessita di eseguire una chiamata all'operatore new per ogni blocco. Può, ad esempio, sottoallocare da un blocco più grande o blocchi deallocati della cache per una riallocazione successiva.
Con un compilatore che non può riassociare il valore dell'argomento std::size_t utilizzato quando è stata creata un'istanza del modello non è necessariamente il valore dell'argomento _Sz passato alle funzioni membro di una cache allocare e deallocare.
<Gli allocatori> forniscono i modelli di cache seguenti:
Un filtro è un allocatore di blocchi che implementa le funzioni membro usando un altro allocatore di blocchi, che viene passato come argomento modello. La forma più comune di filtro è il filtro di sincronizzazione che applica un criterio di sincronizzazione per controllare l'accesso alle funzioni membro di un'istanza di un altro allocatore di blocco. <Gli allocatori> forniscono i filtri di sincronizzazione seguenti:
<Gli allocatori> forniscono anche il filtro rts_alloc, che contiene più istanze di allocatore di blocchi e determina l'istanza da usare per l'allocazione o la deallocazione in fase di esecuzione anziché in fase di compilazione. Viene usata con i compilatori e non può compilare la riassociazione.
Un criterio di sincronizzazione determina la modalità di gestione delle richieste di allocazione e disallocazione simultanee da più thread di un'istanza dell'allocatore. Il criterio più semplice consiste nel passare tutte le richieste direttamente tramite l'oggetto cache sottostante, lasciando la gestione della sincronizzazione all'utente. Un criterio più complesso potrebbe essere quello di usare un mutex per serializzare l'accesso all'oggetto cache sottostante.
Se un compilatore supporta la compilazione di applicazioni a thread singolo e multithread, per le applicazioni a thread singolo il filtro di sincronizzazione predefinito è sync_none; in tutti gli altri casi, è sync_shared.
Il modello cache_freelist di cache accetta un argomento di classe max, che determina il numero massimo di elementi da archiviare nell'elenco gratuito.
<Gli allocatori> forniscono le classi massime seguenti:
Macro
| Macro | Descrizione |
|---|---|
| ALLOCATOR_DECL | Restituisce un modello di classe allocatore. |
| CACHE_CHUNKLIST | Restituisce stdext::allocators::cache_chunklist<sizeof(Type)>. |
| CACHE_FREELIST | Restituisce stdext::allocators::cache_freelist<sizeof(Type), max>. |
| CACHE_SUBALLOC | Restituisce stdext::allocators::cache_suballoc<sizeof(Type)>. |
| SYNC_DEFAULT | Restituisce un filtro di sincronizzazione. |
Operatori
| Operatore | Descrizione |
|---|---|
| operator!= (<allocatori>) | Verifica la disuguaglianza tra gli oggetti allocatore di una classe specificata. |
| operator== (<allocatori>) | Verifica l'uguaglianza tra gli oggetti allocatore di una classe specificata. |
Classi
| Classe | Descrizione |
|---|---|
| allocator_base | Definisce la classe base e le funzioni comuni necessari per creare un allocatore definito dall'utente da un filtro di sincronizzazione. |
| allocator_chunklist | Descrive un oggetto che gestisce l'allocazione e la liberazione dello spazio di archiviazione per gli oggetti usando una cache di tipo cache_chunklist. |
| allocator_fixed_size | Descrive un oggetto che gestisce l'allocazione e la liberazione dello spazio di archiviazione per gli oggetti di tipo Type usando una cache di tipo cache_freelist con lunghezza gestita da max_fixed_size. |
| allocator_newdel | Implementa un allocatore che usa l'eliminazione dell'operatore per deallocare un blocco di memoria e un nuovo operatore per allocare un blocco di memoria. |
| allocator_suballoc | Descrive un oggetto che gestisce l'allocazione e la liberazione dello spazio di archiviazione per gli oggetti di tipo Type usando una cache di tipo cache_suballoc. |
| allocator_unbounded | Descrive un oggetto che gestisce l'allocazione e la liberazione dello spazio di archiviazione per gli oggetti di tipo Type usando una cache di tipo cache_freelist con lunghezza gestita da max_unbounded. |
| allocator_variable_size | Descrive un oggetto che gestisce l'allocazione e la liberazione dello spazio di archiviazione per gli oggetti di tipo Type usando una cache di tipo cache_freelist con lunghezza gestita da max_variable_size. |
| cache_chunklist | Definisce un allocatore di blocco che alloca e dealloca blocchi di memoria di un'unica dimensione. |
| cache_freelist | Definisce un allocatore di blocco che alloca e dealloca blocchi di memoria di un'unica dimensione. |
| cache_suballoc | Definisce un allocatore di blocco che alloca e dealloca blocchi di memoria di un'unica dimensione. |
| freelist | Gestisce un elenco di blocchi di memoria. |
| max_fixed_size | Descrive un oggetto classe max che limita un oggetto freelist a una lunghezza massima fissa. |
| max_none | Descrive un oggetto classe max che limita un oggetto freelist a una lunghezza massima pari a zero. |
| max_unbounded | Descrive un oggetto classe max che non limita la lunghezza massima di un oggetto freelist. |
| max_variable_size | Descrive un oggetto classe max che limita un oggetto freelist a una lunghezza massima approssimativamente proporzionale al numero di blocchi di memoria allocati. |
| rts_alloc | Il modello di classe rts_alloc descrive un filtro che contiene una matrice di istanze della cache e determina l'istanza da usare per l'allocazione e la deallocazione in fase di esecuzione anziché in fase di compilazione. |
| sync_none | Descrive un filtro di sincronizzazione che non fornisce alcuna sincronizzazione. |
| sync_per_container | Descrive un filtro di sincronizzazione che fornisce un oggetto cache separato per ogni oggetto allocatore. |
| sync_per_thread | Descrive un filtro di sincronizzazione che fornisce un oggetto cache separato per ogni thread. |
| sync_shared | Descrive un filtro di sincronizzazione che usa un mutex per controllare l'accesso a un oggetto della cache condiviso da tutti gli allocatori. |
Requisiti
Intestazione:<allocatori>
Spazio dei nomi: stdext