Classe allocator

O modelo de classe descreve um objeto que gerencia a alocação de armazenamento e a liberação de matrizes de objetos do tipo Type. Um objeto da classe allocator é o objeto alocador padrão especificado nos construtores para várias modelos de classe de contêiner na Biblioteca Padrão C++.

Sintaxe

template <class Type>
class allocator

Parâmetros

Tipo
O tipo de objeto para o qual o armazenamento está sendo alocado ou desalocado.

Comentários

Todos os contêineres da Biblioteca Padrão C++ têm um parâmetro de modelo cujo padrão é allocator. Construir um contêiner com um alocador personalizado fornece controle sobre a alocação e a liberação dos elementos desse contêiner.

Por exemplo, um objeto alocador pode alocar armazenamento em um heap privado ou na memória compartilhada ou pode otimizar para tamanhos de objeto grandes ou pequenos. Ele também pode especificar, por meio das definições de tipo que fornece, que os elementos sejam acessados por meio de objetos acessadores especiais que gerenciam a memória compartilhada ou executam coleta de lixo automática. Portanto, uma classe que aloca armazenamento usando um objeto alocador deve usar esses tipos para declarar um ponteiro e referenciar objetos, como os contêineres na Biblioteca Padrão do C++.

(Somente C_++98/03) Ao derivar da classe allocator, você precisa fornecer um struct rebind, cujo typedef _Other referencie a classe recém-derivada.

Portanto, um alocador define os seguintes tipos:

• pointer comporta-se como um ponteiro para Type.

• const_pointer comporta-se como um ponteiro const para Type.

• reference comporta-se como uma referência para Type.

• const_reference comporta-se como uma referência const para Type.

Esses Types especificam a forma que os ponteiros e as referências devem usar para elementos alocados. (allocator::pointer não é necessariamente o mesmo que Type* para todos os objetos do alocador, mesmo tendo essa definição óbvia para a classe allocator.)

C++11 e posterior: para permitir operações de movimentação no alocador, use a interface de alocador mínimo e implemente o construtor de cópia, os operadores == e !=, allocate e deallocate. Para obter mais informações e um exemplo, consulte Alocadores

Membros

Construtores

Nome	Descrição
allocator	Construtores usados para criar objetos allocator.

Typedefs

Nome	Descrição
const_pointer	Um tipo que fornece um ponteiro constante para o tipo de objeto gerenciado pelo alocador.
const_reference	Um tipo que fornece uma referência constante ao tipo de objeto gerenciado pelo alocador.
difference_type	Um tipo integral com sinal que pode representar a diferença entre os valores de ponteiros para o tipo de objeto gerenciado pelo alocador.
pointer	Um tipo que fornece um ponteiro para o tipo de objeto gerenciado pelo alocador.
referência	Um tipo que fornece uma referência ao tipo de objeto gerenciado pelo alocador.
size_type	Um tipo integral sem sinal que pode representar o comprimento de qualquer sequência que um objeto do tipo allocator possa alocar.
value_type	Um tipo que é gerenciado pelo alocador.

Funções

Nome	Descrição
address	Localiza o endereço de um objeto cujo valor é especificado.
allocate	Aloca um bloco de memória grande o suficiente para armazenar pelo menos um número especificado de elementos.
construct	Constrói um tipo específico de objeto em um endereço especificado que é inicializado com um valor especificado.
deallocate	Libera um número especificado de objetos do armazenamento começando em uma posição especificada.
destroy	Chama um destruidor de objetos sem desalocar a memória na qual o objeto foi armazenado.
max_size	Retorna o número de elementos do tipo Type que podem ser alocados por um objeto da classe allocator antes que a memória livre seja totalmente usada.
rebind	Uma estrutura que habilita um alocador para que objetos de um tipo aloquem armazenamento para objetos de outro tipo.

Operadores

Nome	Descrição
operator=	Atribui um objeto allocator a outro objeto allocator.

address

Localiza o endereço de um objeto cujo valor é especificado.

pointer address(reference val) const;
const_pointer address(const_reference val) const;

Parâmetros

val
O valor const ou não const do objeto cujo endereço está sendo pesquisado.

Valor de retorno

Um ponteiro const ou não const para o objeto localizado, de valor const ou não const, respectivamente.

Comentários

As funções de membro retornam o endereço de val, na forma que os ponteiros devem usar para os elementos alocados.

Exemplo

// allocator_address.cpp
// compile with: /EHsc
#include <memory>
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( 2 * i );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::const_pointer v1Ptr;
   const int k = 8;
   v1Ptr = v1Alloc.address( *find(v1.begin( ), v1.end( ), k) );
   // v1Ptr = v1Alloc.address( k );
   cout << "The integer addressed by v1Ptr has a value of: "
        << "*v1Ptr = " << *v1Ptr << "." << endl;
}

The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The integer addressed by v1Ptr has a value of: *v1Ptr = 8.

allocate

Aloca um bloco de memória grande o suficiente para armazenar pelo menos um número especificado de elementos.

pointer allocate(size_type count, const void* _Hint);

Parâmetros

count
O número de elementos para os quais um armazenamento suficiente deve ser alocado.

_Hint
Um ponteiro const que pode ajudar o objeto alocador a atender à solicitação de armazenamento, localizando o endereço de um objeto alocado antes da solicitação.

Valor de retorno

Um ponteiro para o objeto alocado ou nulo se a memória não foi alocada.

Comentários

A função membro aloca armazenamento para uma matriz de elementos de contagem do tipo Type, chamando o operador new(count). Ela retorna um ponteiro para o objeto alocado. O argumento de dica ajuda alguns alocadores a melhorarem a localização da referência. Uma opção válida é o endereço de um objeto alocado anteriormente pelo mesmo objeto alocador, que ainda não foi desalocado. Para não fornecer nenhuma dica, use um argumento de ponteiro nulo.

Exemplo

// allocator_allocate.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   allocator<int> v1Alloc;
   allocator<int>::pointer v1aPtr;
   v1aPtr = v1Alloc.allocate ( 10 );

   int i;
   for ( i = 0 ; i < 10 ; i++ )
   {
      v1aPtr[ i ] = i;
   }

   for ( i = 0 ; i < 10 ; i++ )
   {
      cout << v1aPtr[ i ] << " ";
   }
   cout << endl;
   v1Alloc.deallocate( v1aPtr, 10 );
}

0 1 2 3 4 5 6 7 8 9

allocator

Construtores usados para criar objetos do alocador.

allocator();
allocator(const allocator<Type>& right);
template <class Other>
    allocator(const allocator<Other>& right);

Parâmetros

direita
O objeto alocador a ser copiado.

Comentários

O construtor não fará nada. Em geral, no entanto, um objeto alocador construído usando outro objeto alocador deve ser comparado como igual a ele e permitir a mescla de alocação e liberação de objeto entre os dois objetos alocadores.

Exemplo

// allocator_allocator.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

class Int {
public:
   Int( int i )
   {
      cout << "Constructing " << ( void* )this  << endl;
      x = i;
      bIsConstructed = true;
   };
   ~Int( )
   {
      cout << "Destructing " << ( void* )this << endl;
      bIsConstructed = false;
   };
   Int &operator++( )
   {
      x++;
      return *this;
   };
   int x;
private:
   bool bIsConstructed;
};

int main( )
{
   allocator<double> Alloc;
   vector <Int>:: allocator_type v1Alloc;

   allocator<double> cAlloc(Alloc);
   allocator<Int> cv1Alloc(v1Alloc);

   if ( cv1Alloc == v1Alloc )
      cout << "The allocator objects cv1Alloc & v1Alloc are equal."
           << endl;
   else
      cout << "The allocator objects cv1Alloc & v1Alloc are not equal."
           << endl;

   if ( cAlloc == Alloc )
      cout << "The allocator objects cAlloc & Alloc are equal."
           << endl;
   else
      cout << "The allocator objects cAlloc & Alloc are not equal."
           << endl;
}

The allocator objects cv1Alloc & v1Alloc are equal.
The allocator objects cAlloc & Alloc are equal.

const_pointer

Um tipo que fornece um ponteiro constante para o tipo de objeto gerenciado pelo alocador.

typedef const value_type *const_pointer;

Comentários

O tipo de ponteiro descreve um objeto ptr que pode designar, usando a expressão *ptr, qualquer objeto const que um objeto do tipo allocator possa alocar.

Exemplo

// allocator_const_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( i * 2 );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::const_pointer v1Ptr;
   const int k = 10;
   v1Ptr = v1Alloc.address( k );

   cout << "The integer's address found has a value of: "
        << *v1Ptr << "." << endl;
}

The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The integer's address found has a value of: 10.

const_reference

Um tipo que fornece uma referência constante ao tipo de objeto gerenciado pelo alocador.

typedef const value_type& const_reference;

Comentários

O tipo de referência descreve um objeto que pode designar qualquer objeto const que um objeto do tipo allocator possa alocar.

Exemplo

// allocator_const_ref.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <double> v;
   vector <double> ::iterator vIter, vfIter;
   vector <double> :: allocator_type vAlloc;

   int j;
   for ( j = 1 ; j <= 7 ; j++ )
   {
      v.push_back( 100.0 * j );
   }

   cout << "The original vector v is:\n ( " ;
   for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;

   vfIter = v.begin( );
   allocator<double>::const_reference vcref =*vfIter;
   cout << "The value of the element referred to by vref is: "
        << vcref << ",\n the first element in the vector." << endl;

   // const references can have their elements modified,
   // so the following would generate an error:
   // vcref = 150;
   // but the value of the first element could be modified through
   // its nonconst iterator and the const reference would remain valid
*vfIter = 175;
   cout << "The value of the element referred to by vcref,"
        <<"\n after nofication through its nonconst iterator, is: "
        << vcref << "." << endl;
}

The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element referred to by vref is: 100,
the first element in the vector.
The value of the element referred to by vcref,
after nofication through its nonconst iterator, is: 175.

constructo

Constrói um tipo específico de objeto em um endereço especificado que é inicializado com um valor especificado.

void construct(pointer ptr, const Type& val);
void construct(pointer ptr, Type&& val);
template <class _Other>
    void construct(pointer ptr, _Other&&... val);

Parâmetros

ptr
Um ponteiro para o local no qual o objeto deve ser construído.

val
O valor com o qual o objeto que está sendo construído deve ser inicializado.

Comentários

A primeira função membro é equivalente a new ((void *) ptr) Type(val).

Exemplo

// allocator_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( 3 * i );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::pointer v1PtrA;
   int kA = 6, kB = 7;
   v1PtrA = v1Alloc.address( *find( v1.begin( ), v1.end( ), kA ) );
   v1Alloc.destroy ( v1PtrA );
   v1Alloc.construct ( v1PtrA , kB );

   cout << "The modified vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;
}

The original vector v1 is:
( 3 6 9 12 15 18 21 ).
The modified vector v1 is:
( 3 7 9 12 15 18 21 ).

deallocate

Libera um número especificado de objetos do armazenamento começando em uma posição especificada.

void deallocate(pointer ptr, size_type count);

Parâmetros

ptr
Um ponteiro para o primeiro objeto a ser desalocado do armazenamento.

count
O número de objetos a serem desalocados do armazenamento.

Comentários

A função membro libera armazenamento para a matriz de objetos de contagem do tipo Type, começando em ptr, chamando operator delete(ptr). O ponteiro ptr deve ter sido retornado anteriormente por uma chamada para allocate de um objeto alocador que compara como igual a *this, alocando um objeto de matriz do mesmo tipo e tamanho. deallocate nunca gera uma exceção.

Exemplo

Para obter um exemplo que usa a função de membro, consulte allocator::allocate.

destroy

Chama um destruidor de objetos sem desalocar a memória na qual o objeto foi armazenado.

void destroy(pointer ptr);

Parâmetros

ptr
Um ponteiro que designa o endereço do objeto a ser destruído.

Comentários

A função membro destrói o objeto designado por ptr, chamando o destruidor ptr->Type::~Type.

Exemplo

// allocator_destroy.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( 2 * i );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::pointer v1PtrA;
   int kA = 12, kB = -99;
   v1PtrA = v1Alloc.address( *find(v1.begin( ), v1.end( ), kA) );
   v1Alloc.destroy ( v1PtrA );
   v1Alloc.construct ( v1PtrA , kB );

   cout << "The modified vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;
}

The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The modified vector v1 is:
( 2 4 6 8 10 -99 14 ).

difference_type

Um tipo integral com sinal que pode representar a diferença entre os valores de ponteiros para o tipo de objeto gerenciado pelo alocador.

typedef ptrdiff_t difference_type;

Comentários

O tipo de inteiro com sinal descreve um objeto que pode representar a diferença entre os endereços de quaisquer dois elementos em uma sequência, que um objeto do tipo allocator possa alocar.

Exemplo

// allocator_diff_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 0 ; i <= 7 ; i++ )
   {
      v1.push_back( i * 2 );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::const_pointer v1PtrA, v1PtrB;
   const int kA = 4, kB =12;
   v1PtrA = v1Alloc.address( kA );
   v1PtrB = v1Alloc.address( kB );
   allocator<int>::difference_type v1diff = *v1PtrB - *v1PtrA;

   cout << "Pointer v1PtrA addresses " << *v1PtrA << "." << endl;
   cout << "Pointer v1PtrB addresses " << *v1PtrB <<  "." << endl;
   cout << "The difference between the integer's addresses is: "
        << v1diff << "." << endl;
}

The original vector v1 is:
( 0 2 4 6 8 10 12 14 ).
Pointer v1PtrA addresses 4.
Pointer v1PtrB addresses 12.
The difference between the integer's addresses is: 8.

max_size

Retorna o número de elementos do tipo Type que podem ser alocados por um objeto da classe allocator antes que a memória livre seja totalmente usada.

size_type max_size() const;

Valor de retorno

O número de elementos que podem ser alocados.

Exemplo

// allocator_max_size.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( i );
   }

   cout << "The original vector v1 is:\n ( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   vector <double> v2;
   vector <double> ::iterator v2Iter;
   vector <double> :: allocator_type v2Alloc;
   allocator<int>::size_type v1size;
   v1size = v1Alloc.max_size( );

   cout << "The number of integers that can be allocated before\n"
        << " the free memory in the vector v1 is used up is: "
        << v1size << "." << endl;

   int ii;
   for ( ii = 1 ; ii <= 7 ; ii++ )
   {
      v2.push_back( ii * 10.0 );
   }

   cout << "The original vector v2 is:\n ( " ;
   for ( v2Iter = v2.begin( ) ; v2Iter != v2.end( ) ; v2Iter++ )
      cout << *v2Iter << " ";
   cout << ")." << endl;
   allocator<double>::size_type v2size;
   v2size = v2Alloc.max_size( );

   cout << "The number of doubles that can be allocated before\n"
        << " the free memory in the vector v2 is used up is: "
        << v2size << "." << endl;
}

operator=

Atribui um objeto alocador a outro objeto alocador.

template <class Other>
    allocator<Type>& operator=(const allocator<Other>& right);

Parâmetros

direita
Um objeto alocador a ser atribuído a outro objeto desse.

Valor de retorno

Uma referência ao objeto alocador

Comentários

O operador de atribuição de modelo não faz nada. Em geral, no entanto, um objeto alocador atribuído a outro objeto alocador deve ser comparado como igual a ele e permitir a mescla de alocação e liberação de objeto entre os dois objetos alocadores.

Exemplo

// allocator_op_assign.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

class Int {
public:
   Int(int i)
   {
      cout << "Constructing " << ( void* )this  << endl;
      x = i;
      bIsConstructed = true;
   };
   ~Int( ) {
      cout << "Destructing " << ( void* )this << endl;
      bIsConstructed = false;
   };
   Int &operator++( )
   {
      x++;
      return *this;
   };
   int x;
private:
   bool bIsConstructed;
};

int main( )
{
   allocator<Int> Alloc;
   allocator<Int> cAlloc ;
   cAlloc = Alloc;
}

pointer

Um tipo que fornece um ponteiro para o tipo de objeto gerenciado pelo alocador.

typedef value_type *pointer;

Comentários

O tipo de ponteiro descreve um objeto ptr que pode designar, usando a expressão *ptr, qualquer objeto que um objeto do tipo allocator possa alocar.

Exemplo

// allocator_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <int> v1;
   vector <int>::iterator v1Iter;
   vector <int>:: allocator_type v1Alloc;

   int i;
   for ( i = 1 ; i <= 7 ; i++ )
   {
      v1.push_back( 3 * i );
   }

   cout << "The original vector v1 is:\n( " ;
   for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
      cout << *v1Iter << " ";
   cout << ")." << endl;

   allocator<int>::const_pointer v1Ptr;
   const int k = 12;
   v1Ptr = v1Alloc.address( k );

   cout << "The integer addressed by v1Ptr has a value of: "
        << "*v1Ptr = " << *v1Ptr << "." << endl;
}

The original vector v1 is:
( 3 6 9 12 15 18 21 ).
The integer addressed by v1Ptr has a value of: *v1Ptr = 12.

rebind

Uma estrutura que habilita um alocador para que objetos de um tipo aloquem armazenamento para objetos de outro tipo.

struct rebind { typedef allocator<_Other> other; };

Parâmetros

other
O tipo de elemento para o qual a memória está sendo alocada.

Comentários

Essa estrutura é útil para alocar memória para um tipo diferente do tipo de elemento do contêiner que está sendo implementado.

O modelo de classe de membro define o tipo other. Sua única finalidade é fornecer o nome do tipo allocator<_Other>, dado o nome do tipo allocator<Type>.

Por exemplo, dado um objeto alocador al do tipo A, é possível alocar um objeto do tipo _Other com a expressão:

A::rebind<Other>::other(al).allocate(1, (Other *)0)

Ou, você pode nomear o tipo de ponteiro dele, escrevendo o tipo:

A::rebind<Other>::other::pointer

Exemplo

// allocator_rebind.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

typedef vector<int>::allocator_type IntAlloc;
int main( )
{
   IntAlloc v1Iter;
   vector<int> v1;

   IntAlloc::rebind<char>::other::pointer pszC =
      IntAlloc::rebind<char>::other(v1.get_allocator()).allocate(1, (void *)0);

   int * pInt = v1Iter.allocate(10);
}

reference

Um tipo que fornece uma referência ao tipo de objeto gerenciado pelo alocador.

typedef value_type& reference;

Comentários

O tipo de referência descreve um objeto que pode designar qualquer objeto que um objeto do tipo allocator possa alocar.

Exemplo

// allocator_reference.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <double> v;
   vector <double> ::iterator vIter, vfIter;
   vector <double> :: allocator_type vAlloc;

   int j;
   for ( j = 1 ; j <= 7 ; j++ )
   {
      v.push_back( 100.0 * j );
   }

   cout << "The original vector v is:\n ( " ;
   for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;

   vfIter = v.begin( );
   allocator<double>::reference vref =*vfIter;
   cout << "The value of the element referred to by vref is: "
        << vref << ",\n the first element in the vector." << endl;

   // nonconst references can have their elements modified
   vref = 150;
   cout << "The element referred to by vref after being modified is: "
        << vref << "." << endl;
}

The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element referred to by vref is: 100,
the first element in the vector.
The element referred to by vref after being modified is: 150.

size_type

Um tipo integral sem sinal que pode representar o comprimento de qualquer sequência que um objeto do tipo allocator possa alocar.

typedef size_t size_type;

Exemplo

// allocator_size_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

int main( )
{
   vector <double> v;
   vector <double> ::iterator vIter;
   vector <double> :: allocator_type vAlloc;

   int j;
   for ( j = 1 ; j <= 7 ; j++ )
   {
      v.push_back( 100.0 * j );
   }

   cout << "The original vector v is:\n ( " ;
   for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;

   allocator<double>::size_type vsize;
   vsize = vAlloc.max_size( );

   cout << "The number of doubles that can be allocated before\n"
        << " the free memory in the vector v is used up is: "
        << vsize << "." << endl;
}

value_type

Um tipo que é gerenciado pelo alocador.

typedef Type value_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloType.

Exemplo

// allocator_value_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;

int main( )
{
   vector <double> v;
   vector <double> ::iterator vIter, vfIter;
   vector <double> :: allocator_type vAlloc;

   int j;
   for ( j = 1 ; j <= 7 ; j++ )
   {
      v.push_back( 100.0 * j );
   }

   cout << "The original vector v is:\n ( " ;
   for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;

   vfIter = v.begin( );
   allocator<double>::value_type vecVal = 150.0;
*vfIter = vecVal;
   cout << "The value of the element addressed by vfIter is: "
        << *vfIter << ",\n the first element in the vector." << endl;

   cout << "The modified vector v is:\n ( " ;
   for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
      cout << *vIter << " ";
   cout << ")." << endl;
}

The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element addressed by vfIter is: 150,
the first element in the vector.
The modified vector v is:
( 150 200 300 400 500 600 700 ).

Auxiliares

allocator_arg_t

struct allocator_arg_t { explicit allocator_arg_t() = default; };
inline constexpr allocator_arg_t allocator_arg{};

uses_allocator

template <class T, class Alloc> struct uses_allocator;