allocator, classe

Le modèle de classe décrit un objet qui gère l’allocation de stockage et la libération pour les tableaux d’objets de type Type. Un objet de classe allocator est l’objet d’allocateur par défaut spécifié dans les constructeurs pour plusieurs modèles de classe de conteneur dans la bibliothèque standard C++.

Syntaxe

template <class Type>
class allocator

Paramètres

Type
Type d'objet pour lequel le stockage est alloué ou libéré.

Notes

Tous les conteneurs de bibliothèque C++ Standard ont un paramètre de modèle qui est allocatordéfini par défaut sur . La construction d’un conteneur avec un allocateur personnalisé permet de contrôler l’allocation et la libération des éléments de ce conteneur.

Par exemple, un objet allocateur peut allouer du stockage sur un segment de mémoire privé ou dans la mémoire partagée, ou il peut optimiser la mémoire pour les objets de petite ou de grande taille. Il peut également spécifier, via les définitions de types qu’il fournit, que les éléments soient accessibles via des objets d’accesseur spéciaux qui gèrent la mémoire partagée, ou effectuer un nettoyage de la mémoire automatique. Ainsi, une classe qui alloue du stockage à l’aide d’un objet allocateur doit utiliser ces types pour déclarer des objets pointeur et référence, comme le font les conteneurs dans la bibliothèque C++ Standard.

(C++98/03 uniquement) Lorsque vous dérivez de la classe allocator, vous devez fournir un struct rebind , dont _Other le typedef fait référence à votre classe nouvellement dérivée.

Ainsi, un allocateur définit les types suivants :

• le pointeur se comporte comme un pointeur vers Type.

• const_pointer se comporte comme un pointeur const vers Type.

• référence se comporte comme une référence à Type.

• const_reference se comporte comme une référence const à Type.

Ces Typeéléments spécifient le formulaire que les pointeurs et les références doivent prendre pour les éléments alloués. ( allocator ::p ointer n’est pas nécessairement le même que Type* pour tous les objets allocator, même s’il a cette définition évidente pour la classe allocator.)

C++11 et versions ultérieures : Pour autoriser les opérations de déplacement dans votre allocateur, utilisez l’interface d’allocateur minimale et implémentez le constructeur de copie, les opérateurs == et !=, allocate et deallocate. Pour plus d’informations et pour obtenir un exemple, consultez Allocateurs

Membres

Constructeurs

Nom	Description
allocator	Constructeurs utilisés pour créer des objets allocator.

Typedefs

Nom	Description
const_pointer	Type qui fournit un pointeur constant vers le type d'objet géré par l'allocateur.
const_reference	Type qui fournit une référence constante au type d'objet géré par l'allocateur.
difference_type	Type intégral signé qui peut représenter la différence entre des valeurs de pointeurs vers le type d'objet géré par l'allocateur.
pointer	Type qui fournit un pointeur vers le type d'objet géré par l'allocateur.
référence	Type qui fournit une référence au type d'objet géré par l'allocateur.
size_type	Type intégral non signé qui peut représenter la longueur de n’importe quelle séquence qu’un objet de type allocator peut allouer.
value_type	Type géré par l'allocateur.

Functions

Nom	Description
address	Recherche l'adresse d'un objet dont la valeur est spécifiée.
allocate	Alloue un bloc de mémoire suffisamment grand pour stocker au moins un nombre spécifié d'éléments.
construct	Construit un type d'objet spécifique à une adresse spécifiée qui est initialisée avec une valeur spécifiée.
deallocate	Libère du stockage un nombre d'objets spécifié à partir d'une position spécifiée.
destroy	Appelle un destructeur d'objets sans libérer la mémoire où l'objet était stocké.
max_size	Retourne le nombre d'éléments de type Type qui pourraient être alloués par un objet de classe allocator avant que la mémoire libre soit complètement utilisée.
rebind	Structure qui permet à un allocateur d'objets d'un type d'allouer du stockage pour les objets d'un autre type.

Opérateurs

Nom	Description
operator=	Assigne un objet allocator à un autre objet allocator.

address

Recherche l'adresse d'un objet dont la valeur est spécifiée.

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

Paramètres

val
Valeur const ou nonconst de l’objet dont l’adresse est recherchée.

Valeur de retour

Pointeur const ou nonconst vers l’objet trouvé d’une valeur const ou nonconst, respectivement.

Notes

Les fonctions membres retournent l’adresse de val, sous la forme que les pointeurs doivent prendre pour les éléments alloués.

Exemple

// 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.

allouer

Alloue un bloc de mémoire suffisamment grand pour stocker au moins un nombre spécifié d'éléments.

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

Paramètres

count
Nombre d’éléments pour lesquels un stockage suffisant doit être alloué.

_Hint
Pointeur const pouvant aider l’objet allocateur à satisfaire la demande de stockage en recherchant l’adresse d’un objet alloué avant la demande.

Valeur de retour

Pointeur vers l’objet alloué ou null si la mémoire n’a pas été allouée.

Notes

La fonction membre alloue le stockage pour un tableau d’éléments de nombre de type Type, en appelant l’opérateur new(count). Retourne un pointeur vers l’objet alloué. L’argument hint permet d’aider certains allocateurs à améliorer la localité de référence. Un choix valide est l’adresse d’un objet précédemment alloué par le même objet allocateur et pas encore désalloué. Si vous ne voulez pas fournir d’argument hint, utilisez plutôt un argument de pointeur null.

Exemple

// 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

Constructeurs utilisés pour créer des objets allocateur.

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

Paramètres

right
Objet allocateur à copier.

Notes

Le constructeur n’effectue aucune opération. En général, toutefois, un objet allocateur construit à partir d’un autre objet allocateur doit avoir la même valeur et autoriser l’échange d’allocation et de libération d’objets entre les deux objets allocateur.

Exemple

// 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

Type qui fournit un pointeur constant vers le type d'objet géré par l'allocateur.

typedef const value_type *const_pointer;

Notes

Le type de pointeur décrit un objet ptr qui peut désigner, via l’expression *ptr, tout objet const qu’un objet de type allocator peut allouer.

Exemple

// 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

Type qui fournit une référence constante au type d'objet géré par l'allocateur.

typedef const value_type& const_reference;

Notes

Le type de référence décrit un objet qui peut désigner n’importe quel objet const qu’un objet de type allocator peut allouer.

Exemple

// 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.

construct

Construit un type d'objet spécifique à une adresse spécifiée qui est initialisée avec une valeur spécifiée.

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

Paramètres

ptr
Pointeur vers l’emplacement où l’objet doit être construit.

val
Valeur avec laquelle l’objet en cours de construction doit être initialisé.

Notes

La première fonction membre est équivalente à new ((void *) ptr) Type(val).

Exemple

// 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

Libère du stockage un nombre d'objets spécifié à partir d'une position spécifiée.

void deallocate(pointer ptr, size_type count);

Paramètres

ptr
Pointeur vers le premier objet à désallouer dans le stockage.

count
Nombre d’objets à désallouer dans le stockage.

Notes

La fonction membre libère le stockage pour le tableau d’objets de nombre de types Type commençant par ptr, en appelant operator delete(ptr). Le pointeur ptr doit avoir été retourné précédemment par un appel pour allouer pour un objet allocator qui compare à *this, en allouant un objet de tableau de la même taille et du même type. deallocate ne lève jamais d’exception.

Exemple

Pour obtenir un exemple utilisant la fonction membre, consultez allocator::allocate.

destroy

Appelle un destructeur d'objets sans libérer la mémoire où l'objet était stocké.

void destroy(pointer ptr);

Paramètres

ptr
Pointeur désignant l’adresse de l’objet à détruire.

Notes

La fonction membre détruit l’objet désigné par ptr, en appelant le destructeur ptr->Type::~Type.

Exemple

// 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

Type intégral signé qui peut représenter la différence entre des valeurs de pointeurs vers le type d'objet géré par l'allocateur.

typedef ptrdiff_t difference_type;

Notes

Le type entier signé décrit un objet qui peut représenter la différence entre les adresses des deux éléments d’une séquence qu’un objet de type allocator peut allouer.

Exemple

// 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

Retourne le nombre d'éléments de type Type qui pourraient être alloués par un objet d'allocateur de classe avant que la mémoire libre soit complètement utilisée.

size_type max_size() const;

Valeur de retour

Nombre d’éléments pouvant être alloués.

Exemple

// 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;
}

opérateur =

Assigne un objet allocateur à un autre objet allocateur.

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

Paramètres

right
Objet allocateur à assigner à un autre objet allocateur.

Valeur de retour

Référence à l’objet allocateur

Notes

L’opérateur d’assignation de modèle n’effectue aucune opération. En général, toutefois, un objet allocateur assigné à un autre objet allocateur doit avoir la même valeur et autoriser l’échange d’allocation et de libération d’objets entre les deux objets allocateur.

Exemple

// 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

Type qui fournit un pointeur vers le type d'objet géré par l'allocateur.

typedef value_type *pointer;

Notes

Le type de pointeur décrit un objet ptr qui peut désigner, via l’expression *ptr, tout objet qu’un objet de type allocator peut allouer.

Exemple

// 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

Structure qui permet à un allocateur d'objets d'un type d'allouer du stockage pour les objets d'un autre type.

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

Paramètres

other
Type d’élément pour lequel la mémoire est allouée.

Notes

Cette structure est utile pour allouer de la mémoire au type qui diffère du type d’élément du conteneur en cours d’implémentation.

Le modèle de classe membre définit l’autre type. Son seul objectif est de fournir le nom allocator<_Other>de type , en fonction du nom allocator<Type>de type .

Par exemple, en fonction d’un objet al allocator de type A, vous pouvez allouer un objet de type _Other avec l’expression :

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

Sinon, vous pouvez nommer son type pointeur en écrivant le type :

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

Exemple

// 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);
}

référence

Type qui fournit une référence au type d'objet géré par l'allocateur.

typedef value_type& reference;

Notes

Le type de référence décrit un objet qui peut désigner n’importe quel objet qu’un objet de type allocator peut allouer.

Exemple

// 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

Type intégral non signé qui peut représenter la longueur de n’importe quelle séquence qu’un objet de type allocator peut allouer.

typedef size_t size_type;

Exemple

// 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

Type géré par l'allocateur.

typedef Type value_type;

Notes

Le type est un synonyme du paramètre de modèle Type.

Exemple

// 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 ).

Programmes d’assistance

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;