allocator — Klasa

Szablon klasy opisuje obiekt, który zarządza alokacją magazynu i zwalnia tablice obiektów typu Type. Obiekt klasy allocator jest domyślnym obiektem alokatora określonym w konstruktorach dla kilku szablonów klas kontenerów w standardowej bibliotece C++.

Składnia

template <class Type>
class allocator

Parametry

Type
Typ obiektu, dla którego magazyn jest przydzielany lub cofany przydział.

Uwagi

Wszystkie kontenery biblioteki standardowej języka C++ mają parametr szablonu, który domyślnie ma wartość allocator. Konstruowanie kontenera za pomocą niestandardowego alokatora zapewnia kontrolę nad alokacją i zwalnianiem elementów tego kontenera.

Na przykład obiekt alokatora może przydzielić magazyn na stosie prywatnym lub w pamięci udostępnionej albo może być zoptymalizowany pod kątem małych lub dużych rozmiarów obiektów. Może również określać, za pomocą definicji typów, do których dostarcza, dostęp do elementów za pośrednictwem specjalnych obiektów dostępu, które zarządzają pamięcią udostępnioną, lub wykonywać automatyczne odzyskiwanie pamięci. W związku z tym klasa, która przydziela magazyn przy użyciu obiektu alokatora, powinna używać tych typów do deklarowania wskaźników i obiektów odwołań, ponieważ kontenery w standardowej bibliotece języka C++ są używane.

(Tylko C++98/03) Gdy pochodzisz z klasy alokatora, musisz podać strukturę rebind , której _Other definicja typów odwołuje się do nowo pochodnej klasy.

W związku z tym alokator definiuje następujące typy:

• wskaźnik zachowuje się jak wskaźnik na Type.

• const_pointer zachowuje się jak wskaźnik const na Type.

• odwołanie zachowuje się jak odwołanie do Type.

• const_reference zachowuje się jak odwołanie const do Type.

Określają one Typeformularz, który wskaźniki i odwołania muszą przyjmować dla przydzielonych elementów. ( alokator::p ointer nie musi być taki sam jak Type* w przypadku wszystkich obiektów alokatora, mimo że ma tę oczywistą definicję klasy allocator.)

C++11 i nowsze: aby włączyć operacje przenoszenia w alokatorze, użyj interfejsu minimalnej alokatora i zaimplementuj konstruktor kopiowania, == i != operatorów, przydziel i cofnij przydział. Aby uzyskać więcej informacji i przykład, zobacz Alokatory

Elementy członkowskie

Konstruktory

Nazwa/nazwisko	opis
allocator	Konstruktory używane do tworzenia allocator obiektów.

Typedefs

Nazwa/nazwisko	opis
const_pointer	Typ, który zapewnia stały wskaźnik do typu obiektu zarządzanego przez alokator.
const_reference	Typ, który zapewnia stałe odwołanie do typu obiektu zarządzanego przez alokator.
difference_type	Podpisany typ całkowity, który może reprezentować różnicę między wartościami wskaźników do typu obiektu zarządzanego przez alokator.
wskaźnik	Typ, który dostarcza wskaźnik do typu obiektu zarządzanego przez alokator.
odniesienie	Typ, który zawiera odwołanie do typu obiektu zarządzanego przez alokator.
size_type	Niepodpisany typ całkowity, który może reprezentować długość dowolnej sekwencji, którą może przydzielić obiekt typu allocator .
value_type	Typ zarządzany przez alokator.

Funkcje

Nazwa/nazwisko	opis
adres	Znajduje adres obiektu, którego wartość jest określona.
allocate	Przydziela blok pamięci wystarczająco duży, aby przechowywać co najmniej określoną liczbę elementów.
konstruować	Konstruuje określony typ obiektu pod określonym adresem zainicjowanym przy użyciu określonej wartości.
Deallocate	Zwalnia określoną liczbę obiektów z magazynu rozpoczynającego się na określonej pozycji.
niszczyć	Wywołuje destruktor obiektów bez cofnięcia przydziału pamięci, w której był przechowywany obiekt.
max_size	Zwraca liczbę elementów typu Type , które mogą być przydzielone przez obiekt klasy allocator przed użyciem wolnej pamięci.
ponawianie powiązania	Struktura, która umożliwia alokator obiektów jednego typu do przydzielania magazynu dla obiektów innego typu.

Operatory

Nazwa/nazwisko	opis
operator =	Przypisuje jeden allocator obiekt do innego allocator obiektu.

adres

Znajduje adres obiektu, którego wartość jest określona.

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

Parametry

Val
Wartość const lub nonconst obiektu, którego adres jest wyszukiwany.

Wartość zwracana

Wskaźnik const lub nonconst do obiektu znalezionego odpowiednio, const lub nonconst wartości.

Uwagi

Funkcje składowe zwracają adres val w postaci, która wskaźniki muszą przyjmować dla przydzielonych elementów.

Przykład

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

Przydziela blok pamięci wystarczająco duży, aby przechowywać co najmniej określoną liczbę elementów.

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

Parametry

count
Liczba elementów, dla których należy przydzielić wystarczającą ilość miejsca do magazynowania.

_Aluzja
Wskaźnik const, który może pomóc obiekt alokatora spełnić żądanie magazynu, lokalizując adres obiektu przydzielonego przed żądaniem.

Wartość zwracana

Wskaźnik do przydzielonego obiektu lub wartości null, jeśli pamięć nie została przydzielona.

Uwagi

Funkcja składowa przydziela magazyn dla tablicy elementów liczbowych typu Type, wywołując operator new(count). Zwraca wskaźnik do przydzielonego obiektu. Argument wskazówki pomaga niektórym alokatorom poprawić lokalność odwołania; prawidłowym wyborem jest adres obiektu wcześniej przydzielonego przez ten sam obiekt alokatora, a nie został jeszcze cofnięty przydział. Aby nie podać żadnej wskazówki, zamiast tego użyj argumentu wskaźnika o wartości null.

Przykład

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

Konstruktory używane do tworzenia obiektów alokatora.

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

Parametry

Prawy
Obiekt alokatora do skopiowania.

Uwagi

Konstruktor nic nie robi. Ogólnie rzecz biorąc, obiekt alokatora skonstruowany z innego obiektu alokatora powinien być porównywany z nim i zezwalać na przeplatanie alokacji obiektów i zwalnianie między dwoma obiektami alokatora.

Przykład

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

Typ, który zapewnia stały wskaźnik do typu obiektu zarządzanego przez alokator.

typedef const value_type *const_pointer;

Uwagi

Typ wskaźnika opisuje obiekt ptr , który może wyznaczyć, za pomocą wyrażenia *ptr, dowolny obiekt const, który może przydzielić obiekt typu allocator .

Przykład

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

Typ, który zapewnia stałe odwołanie do typu obiektu zarządzanego przez alokator.

typedef const value_type& const_reference;

Uwagi

Typ odwołania opisuje obiekt, który może wyznaczyć dowolny obiekt const, który może przydzielić obiekt typu allocator .

Przykład

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

konstruować

Konstruuje określony typ obiektu pod określonym adresem zainicjowanym przy użyciu określonej wartości.

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

Parametry

ptr
Wskaźnik do lokalizacji, w której ma zostać skonstruowany obiekt.

Val
Wartość, za pomocą której tworzony obiekt ma zostać zainicjowany.

Uwagi

Pierwsza funkcja składowa jest równoważna funkcji new ((void *) ptr) Type(val).

Przykład

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

Zwalnia określoną liczbę obiektów z magazynu rozpoczynającego się na określonej pozycji.

void deallocate(pointer ptr, size_type count);

Parametry

ptr
Wskaźnik do pierwszego obiektu, który ma zostać cofnięty z magazynu.

count
Liczba obiektów do cofnięcia przydziału z magazynu.

Uwagi

Funkcja składowa zwalnia magazyn dla tablicy obiektów zliczanych typu Type rozpoczynających się od ptr przez wywołanie metody operator delete(ptr). Wskaźnik ptr musi zostać zwrócony wcześniej przez wywołanie, aby przydzielić dla obiektu alokatora , który porównuje wartość równą *temu, przydzielając obiekt tablicy o tym samym rozmiarze i typie. deallocate nigdy nie zgłasza wyjątku.

Przykład

Aby zapoznać się z przykładem użycia funkcji składowej, zobacz alokator::przydziel.

niszczyć

Wywołuje destruktor obiektów bez cofnięcia przydziału pamięci, w której był przechowywany obiekt.

void destroy(pointer ptr);

Parametry

ptr
Wskaźnik wyznaczający adres obiektu do zniszczenia.

Uwagi

Funkcja składowa niszczy obiekt wyznaczony przez ptr, wywołując destruktor ptr->Type::~Type.

Przykład

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

Podpisany typ całkowity, który może reprezentować różnicę między wartościami wskaźników do typu obiektu zarządzanego przez alokator.

typedef ptrdiff_t difference_type;

Uwagi

Typ liczby całkowitej ze znakiem opisuje obiekt, który może reprezentować różnicę między adresami dowolnych dwóch elementów w sekwencji, którą obiekt typu allocator może przydzielić.

Przykład

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

Zwraca liczbę elementów typu Type , które mogą być przydzielane przez obiekt alokatora klas przed użyciem wolnej pamięci.

size_type max_size() const;

Wartość zwracana

Liczba elementów, które można przydzielić.

Przykład

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

Przypisuje jeden obiekt alokatora do innego obiektu alokatora.

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

Parametry

Prawy
Obiekt alokatora, który ma zostać przypisany do innego takiego obiektu.

Wartość zwracana

Odwołanie do obiektu alokatora

Uwagi

Operator przypisania szablonu nic nie robi. Ogólnie rzecz biorąc, jednak obiekt alokatora przypisany do innego obiektu alokatora powinien być porównywany z nim i zezwalać na przeplatanie alokacji obiektów i zwalnianie między dwoma obiektami alokatora.

Przykład

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

Typ, który dostarcza wskaźnik do typu obiektu zarządzanego przez alokator.

typedef value_type *pointer;

Uwagi

Typ wskaźnika opisuje obiekt ptr , który może wyznaczyć, za pomocą wyrażenia *ptr, dowolny obiekt, który może przydzielić obiekt typu allocator .

Przykład

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

ponawianie powiązania

Struktura, która umożliwia alokator obiektów jednego typu do przydzielania magazynu dla obiektów innego typu.

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

Parametry

inny
Typ elementu, dla którego jest przydzielana pamięć.

Uwagi

Ta struktura jest przydatna do przydzielania pamięci dla typu, który różni się od typu elementu implementowanych kontenerów.

Szablon klasy składowej definiuje inny typ. Jedynym celem jest podanie nazwy allocator<_Other>typu , przy użyciu nazwy allocator<Type>typu .

Na przykład, biorąc pod uwagę obiekt al alokatora typu A, można przydzielić obiekt typu _Other za pomocą wyrażenia:

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

Możesz też nazwać jego typ wskaźnika, zapisując typ:

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

Przykład

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

Typ, który zawiera odwołanie do typu obiektu zarządzanego przez alokator.

typedef value_type& reference;

Uwagi

Typ odwołania opisuje obiekt, który może wyznaczyć dowolny obiekt, który może przydzielić obiekt typu allocator .

Przykład

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

Niepodpisany typ całkowity, który może reprezentować długość dowolnej sekwencji, którą może przydzielić obiekt typu allocator .

typedef size_t size_type;

Przykład

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

Typ zarządzany przez alokator.

typedef Type value_type;

Uwagi

Typ jest synonimem parametru Typeszablonu .

Przykład

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

Pomocników

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;