<allocators>

Define vários modelos que ajudam ao atribuir e liberar blocos de memória para contêiners nó- base.

#include <allocators>

Comentários

O cabeçalho de <allocators> fornece seis modelos do distribuidor que podem ser usados para selecionar estratégias de gerenciamento de memória para contêiners nó- base.Para uso com esses modelos, também fornece vários filtros diferentes de sincronização para personalizar a estratégia de gerenciamento de memória para uma variedade de diferentes esquemas de multithreading (que não incluem nenhum).Corresponder uma estratégia de gerenciamento de memória conhecidos os padrões de uso de memória, e requisitos de sincronização, um aplicativo específico geralmente pode aumentar a velocidade ou reduzir os requisitos de memória total de um aplicativo.

Os modelos do distribuidor são implementadas com componentes reutilizáveis que podem ser personalizados ou substituído para fornecer estratégias de gerenciamento de memória adicionais.

Contêiners nó- baseados na biblioteca do C++ padrão (std::list, std::set, std::multiset, std::map e std::multimap) armazenam os elementos em nós individuais.Todos os nós de um tipo específico de recipiente são o mesmo tamanho, então a flexibilidade de um gerenciador de memória de uso geral não é necessária.Porque o tamanho de cada bloco de memória é conhecido em tempo de compilação, o gerenciador de memória pode ser muito mais simples e mais rapidamente.

Quando usado com contêiner que nó- não são baseados (como o std::deque de std::vector de contêiner da biblioteca do C++ padrão, e std::basic_string), modelos de alllocator funcionarão corretamente, mas não são prováveis fornecer nenhuma melhoria de desempenho sobre o distribuidor padrão.

Um distribuidor é uma classe de modelo que descreve um objeto que gerencia a alocação de armazenamento e se objetos e para liberar matrizes de objetos de um tipo designado.Os objetos do distribuidor são usados por várias classes do modelo de recipiente na biblioteca do C++ padrão.

Os distribuidores são todos os modelos de esse tipo:

template<class Type>

class allocator;

onde o argumento Type o tipo de modelo é gerenciado pela instância do distribuidor.A biblioteca do C++ padrão fornece um distribuidor padrão, a classe distribuidordo modelo, que é definido em <memory>.O cabeçalho de <allocators> distribuidores fornece os seguintes:

• allocator_newdel

• allocator_unbounded

• allocator_fixed_size

• allocator_variable_size

• allocator_suballoc

• allocator_chunklist

Use uma instanciação apropriado de um distribuidor como o segundo argumento de tipo para criar um contêiner, como no exemplo de código.

#include <list>

#include <allocators>

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

_List0 atribui os nós com allocator_chunklist e o filtro padrão de sincronização.

Use a macro ALLOCATOR_DECL (<allocators>) para criar modelos do distribuidor com os filtros de sincronização diferentes de opção:

#include <list>

#include <allocators>

ALLOCATOR_DECL(CACHE_CHUNKLIST, stdext::allocators::sync_per_thread, Alloc);

std::list<int, alloc<int> > _List1;

_Lst1 atribui os nós com allocator_chunklist e o filtro de sincronização de synchronization_per_thread .

Um distribuidor de bloco é um cache ou um filtro.Um cache é uma classe de modelo que recebe um argumento de std::size_t do tipo.Define um distribuidor do bloco que atribui e desaloque blocos de memória de um único tamanho.Deve obter a memória usando o operador new, mas não precisa fazer uma chamada para o operador new separado para cada bloco.Pode, por exemplo, suballocate de um bloco maior ou blocos desalocados cache para a realocação subseqüente.

Com um compilador que não pode compilar reassociar o valor do argumento de std::size_t usado quando o modelo foi instanciado não é necessariamente o valor de _Sz de argumento passado às funções de membro de um cache de atributo e desalocam.

<allocators> fornece os seguintes modelos de cache:

• cache_freelist

• cache_suballoc

• cache_chunklist

Um filtro é um distribuidor do bloco que implementa as funções de membro usando outro distribuidor de pacote que ela é passada como um argumento do modelo.A forma mais comum de filtro é um filtro de sincronização, que aplica uma diretiva de sincronização para controlar o acesso às funções de membro de uma instância de outro distribuidor do bloco.<allocators> fornece os seguintes filtros de sincronização:

• synchronization_none

• synchronization_per_container

• synchronization_per_thread

• synchronization_shared

<allocators> também fornece o filtro rts_alloc, que contém vários o distribuidor do bloco ativa e determina que a instância usar para a alocação ou a desalocação em tempo de execução em vez de em tempo de compilação.É usado com compiladores que não podem criar reassociam.

Uma diretiva de sincronização determina como uma instância do distribuidor trata solicitações simultâneas de alocação e de desalocação de vários threads.A diretiva mais simples é passar diretamente todas as solicitações pelo objeto subjacente do cache, deixando o gerenciamento de sincronização ao usuário.Uma diretiva mais complexa pôde ser usar um mutex para serializar acesso ao objeto subjacente do cache.

Se um compilador oferece suporte à criação de thread única e aplicativos multissegmentados, o filtro padrão de sincronização para aplicativos de único thread é sync_none; para todos os outros casos é sync_shared.

O modelo cache_freelist de cache usa um argumento máximo da classe que determina o número máximo de elementos a serem armazenados na lista livre.

<allocators> fornece as seguintes classes máximas:

• max_none

• max_unbounded

• max_fixed_size

• max_variable_size

Macros

Operadores

Classes

Requisitos

Cabeçalho: <allocators>

Stdext denamespace:

Consulte também

Outros recursos

Arquivos de cabeçalho