scoped_allocator_adaptor Classe

Representa um ninho de alocadores.

Sintaxe

template <class Outer, class... Inner>
class scoped_allocator_adaptor;

Observações

O modelo de classe encapsula um ninho de um ou mais alocadores. Cada classe tem um alocador externo do tipo outer_allocator_type, um sinônimo de Outer, que é uma base pública do scoped_allocator_adaptor objeto. Outer é usado para alocar memória a ser usada por um contêiner. Você pode obter uma referência a esse objeto base do alocador chamando outer_allocator.

O restante do ninho tem tipo inner_allocator_type. Um alocador interno é usado para alocar memória para elementos dentro de um contêiner. Você pode obter uma referência ao objeto armazenado desse tipo chamando inner_allocator. Se Inner... não estiver vazio, inner_allocator_type tem tipo scoped_allocator_adaptor<Inner...>e inner_allocator designa um objeto membro. Caso contrário, inner_allocator_type tem tipo scoped_allocator_adaptor<Outer>, e inner_allocator designa o objeto inteiro.

O ninho se comporta como se tivesse profundidade arbitrária, replicando seu alocador encapsulado mais interno conforme necessário.

Vários conceitos que não fazem parte da interface visível ajudam a descrever o comportamento desse modelo de classe. Um alocador externo medeia todas as chamadas para os métodos de construção e destruição. É efetivamente definido pela função OUTERMOST(X)recursiva, onde OUTERMOST(X) é um dos seguintes.

• Se X.outer_allocator() está bem formado, então OUTERMOST(X) é OUTERMOST(X.outer_allocator()).

• Caso contrário, OUTERMOST(X) é X.

Para efeitos de exposição, definem-se três tipos:

Construtores

Typedefs (definições de tipos)

Estruturas

Metodologia

Operadores

Requerimentos

Cabeçalho:<scoped_allocator>

Espaço de nomes: std

scoped_allocator_adaptor::alocar

Aloca memória usando o Outer alocador.

pointer allocate(size_type count);pointer allocate(size_type count, const_void_pointer hint);

Parâmetros

contagem
O número de elementos para os quais deve ser atribuído armazenamento suficiente.

Dica
Um ponteiro que pode ajudar o objeto alocador localizando o endereço de um objeto alocado antes da solicitação.

Valor de retorno

A primeira função de membro retorna Outer_traits::allocate(outer_allocator(), count). A segunda função de membro retorna Outer_traits::allocate(outer_allocator(), count, hint).

scoped_allocator_adaptor::construct

Constrói um objeto.

template <class Ty, class... Atypes>
void construct(Ty* ptr, Atypes&&... args);

template <class Ty1, class Ty2, class... Atypes1, class... Atypes2>
void construct(pair<Ty1, Ty2>* ptr, piecewise_construct_t,
    tuple<Atypes1&&...>
first, tuple<Atypes1&&...> second);

template <class Ty1, class Ty2>
void construct(pair<Ty1, Ty2>* ptr);

template <class Ty1, class Ty2, class Uy1, class Uy2>
void construct(pair<Ty1, Ty2>* ptr,
    class Uy1&& first, class Uy2&& second);

template <class Ty1, class Ty2, class Uy1, class Uy2>
void construct(pair<Ty1, Ty2>* ptr, const pair<Uy1, Uy2>& right);

template <class Ty1, class Ty2, class Uy1, class Uy2>
void construct(pair<Ty1, Ty2>* ptr, pair<Uy1, Uy2>&& right);

Parâmetros

ptr
Um ponteiro para o local da memória onde o objeto deve ser construído.

Args
Uma lista de argumentos.

primeira
Um objeto do primeiro tipo em um par.

segunda
Um objeto do segundo tipo em um par.

direito
Um objeto existente a ser movido ou copiado.

Observações

O primeiro método constrói o objeto em ptr chamando Outermost_traits::construct(OUTERMOST(*this), ptr, xargs...), onde xargs... é um dos seguintes.

• Se uses_allocator<Ty, inner_allocator_type> mantém falso, então xargs... é args....

• Se uses_allocator<Ty, inner_allocator_type> é verdadeiro, e is_constructible<Ty, allocator_arg_t, inner_allocator_type, args...> se mantém verdadeiro, então xargs... é allocator_arg, inner_allocator(), args....

• Se uses_allocator<Ty, inner_allocator_type> é verdadeiro, e is_constructible<Ty, args..., inner_allocator()> se mantém verdadeiro, então xargs... é args..., inner_allocator().

O segundo método constrói o objeto par em ptr chamando Outermost_traits::construct(OUTERMOST(*this), &ptr->first, xargs...), onde xargs... é first... modificado como na lista acima, e Outermost_traits::construct(OUTERMOST(*this), &ptr->second, xargs...), onde xargs... é second... modificado como na lista acima.

O terceiro método comporta-se da mesma forma que this->construct(ptr, piecewise_construct, tuple<>, tuple<>).

O quarto método comporta-se da mesma forma que this->construct(ptr, piecewise_construct, forward_as_tuple(std::forward<Uy1>(first), forward_as_tuple(std::forward<Uy2>(second)).

O quinto método comporta-se da mesma forma que this->construct(ptr, piecewise_construct, forward_as_tuple(right.first), forward_as_tuple(right.second)).

O sexto método comporta-se da mesma forma que this->construct(ptr, piecewise_construct, forward_as_tuple(std::forward<Uy1>(right.first), forward_as_tuple(std::forward<Uy2>(right.second)).

scoped_allocator_adaptor::d eallocate

Deslocaliza objetos usando o alocador externo.

void deallocate(pointer ptr, size_type count);

Parâmetros

ptr
Um ponteiro para o local inicial dos objetos a serem deslocalizados.

contagem
O número de objetos a serem negociados.

scoped_allocator_adaptor::d estroy

Destrói um objeto especificado.

template <class Ty>
void destroy(Ty* ptr)

Parâmetros

ptr
Um ponteiro para o objeto a ser destruído.

Valor de retorno

Outermost_traits::destroy(OUTERMOST(*this), ptr)

scoped_allocator_adaptor::inner_allocator

Recupera uma referência ao objeto armazenado do tipo inner_allocator_type.

inner_allocator_type& inner_allocator() noexcept;
const inner_allocator_type& inner_allocator() const noexcept;

Valor de retorno

Uma referência ao objeto armazenado do tipo inner_allocator_type.

scoped_allocator_adaptor::max_size

Determina o número máximo de objetos que podem ser alocados pelo alocador externo.

size_type max_size();

Valor de retorno

Outer_traits::max_size(outer_allocator())

scoped_allocator_adaptor::operador=

scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;

scoped_allocator_adaptor::operador==

template <class OuterA1, class OuterA2, class... InnerAllocs>
bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;

scoped_allocator_adaptor::operador!=

template <class OuterA1, class OuterA2, class... InnerAllocs>
bool operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;

scoped_allocator_adaptor::outer_allocator

Recupera uma referência ao objeto armazenado do tipo outer_allocator_type.

outer_allocator_type& outer_allocator() noexcept;
const outer_allocator_type& outer_allocator() const noexcept;

Valor de retorno

Uma referência ao objeto armazenado do tipo outer_allocator_type.

scoped_allocator_adaptor::rebind Struct

Define o tipo Outer::rebind<Other>::other como sinônimo de scoped_allocator_adaptor<Other, Inner...>.

struct rebind{ typedef Other_traits::rebind<Outros> Other_alloc; typedef scoped_allocator_adaptor<Other_alloc, Inner...> outros; };

scoped_allocator_adaptor::scoped_allocator_adaptor Construtor

Constrói um objeto scoped_allocator_adaptor. Também inclui um destruidor.

scoped_allocator_adaptor();

scoped_allocator_adaptor(const scoped_allocator_adaptor& right) noexcept;
template <class Outer2>
scoped_allocator_adaptor(
const scoped_allocator_adaptor<Outer2, Inner...>& right) noexcept;
template <class Outer2>
scoped_allocator_adaptor(
scoped_allocator_adaptor<Outer2, Inner...>&& right) noexcept;
template <class Outer2>
scoped_allocator_adaptor(Outer2&& al,
    const Inner&... rest) noexcept;

~scoped_allocator_adaptor();

Parâmetros

direito
Uma scoped_allocator_adaptorexistente .

al
Um alocador existente para ser usado como alocador externo.

resto
Uma lista de alocadores a serem usados como alocadores internos.

Observações

O primeiro construtor padrão constrói seus objetos de alocador armazenados. Cada um dos próximos três construtores constrói seus objetos de alocador armazenados a partir dos objetos correspondentes à direita. O último construtor constrói seus objetos de alocador armazenados a partir dos argumentos correspondentes na lista de argumentos.

scoped_allocator_adaptor::select_on_container_copy_construction

Cria um novo scoped_allocator_adaptor objeto com cada objeto de alocador armazenado inicializado chamando select_on_container_copy_construction cada alocador correspondente.

scoped_allocator_adaptor select_on_container_copy_construction();

Valor de retorno

Esse método efetivamente retorna scoped_allocator_adaptor(Outer_traits::select_on_container_copy_construction(*this), inner_allocator().select_on_container_copy_construction()). O resultado é um novo scoped_allocator_adaptor objeto com cada objeto alocador armazenado inicializado chamando al.select_on_container_copy_construction() o alocador correspondente al.

Ver também

de referência de arquivos de cabeçalho