allocator – třída

Šablona třídy popisuje objekt, který spravuje přidělení úložiště a uvolní pole objektů typu Type. Objekt třídy allocator je výchozí objekt alokátoru zadaný v konstruktorech pro několik šablon tříd kontejneru ve standardní knihovně jazyka C++.

Syntaxe

template <class Type>
class allocator

Parametry

Typ
Typ objektu, pro který se přiděluje nebo uvolní úložiště.

Poznámky

Všechny kontejnery standardní knihovny C++ mají parametr šablony allocator, který má výchozí hodnotu . Vytvoření kontejneru pomocí vlastního alokátoru poskytuje kontrolu nad přidělením a uvolněním prvků tohoto kontejneru.

Například objekt alokátoru může přidělit úložiště na privátní haldě nebo ve sdílené paměti, nebo může optimalizovat pro malé nebo velké velikosti objektů. Může také určit, prostřednictvím definic typů, které poskytuje, že prvky budou přístupné prostřednictvím speciálních objektů příslušenství, které spravují sdílenou paměť, nebo provádět automatické uvolňování paměti. Proto by třída, která přiděluje úložiště pomocí objektu alokátoru, měla použít tyto typy pro deklarování ukazatelů a referenčních objektů, jako kontejnery ve standardní knihovně jazyka C++.

(jenom C++98/03) Při odvození z třídy alokátoru musíte zadat rebind strukturu, jejíž _Other typedef odkazuje na nově odvozenou třídu.

Alokátor tedy definuje následující typy:

• ukazatel se chová jako ukazatel na Type.

• const_pointer se chová jako ukazatel const na Type.

• odkaz se chová jako odkaz na Type.

• const_reference se chová jako const odkaz na Type.

Tyto Typeprvky určují formulář, který musí odkazy a ukazatele převzít pro přidělené prvky. ( alokátor::p ointer není nutně stejný jako Type* pro všechny objekty alokátoru, i když má tuto jasnou definici třídy allocator.)

C++11 a novější: Pokud chcete povolit operace přesunu v alokátoru, použijte minimální rozhraní alokátoru a implementujte konstruktor kopírování, == a != operátory, přidělte a uvolněte. Další informace a příklad najdete v tématu Alokátory

Členové

Konstruktory

Název	Popis
allocator	Konstruktory používané k vytváření allocator objektů.

Typedefs

Název	Popis
const_pointer	Typ, který poskytuje konstantní ukazatel na typ objektu spravovaného alokátorem.
const_reference	Typ, který poskytuje konstantní odkaz na typ objektu spravovaného alokátorem.
difference_type	Celočíselný typ se signedm, který může představovat rozdíl mezi hodnotami ukazatelů na typ objektu spravovaného alokátorem.
ukazatel	Typ, který poskytuje ukazatel na typ objektu spravovaného alokátorem.
odkaz	Typ, který poskytuje odkaz na typ objektu spravovaného alokátorem.
size_type	Celočíselný typ bez znaménka, který může představovat délku jakékoli sekvence, kterou může objekt typu allocator přidělit.
value_type	Typ spravovaný alokátorem.

Funkce

Název	Popis
adresa	Vyhledá adresu objektu, jehož hodnota je zadána.
allocate	Přidělí blok paměti dostatečně velký, aby ukládaly alespoň určitý zadaný počet prvků.
konstruovat	Vytvoří konkrétní typ objektu na zadané adrese, která je inicializována se zadanou hodnotou.
uvolnit	Uvolní zadaný počet objektů od úložiště počínaje zadanou pozicí.
zničit	Volá destruktor objektů bez uvolnění paměti, ve které byl objekt uložen.
max_size	Vrátí počet prvků typu Type , které mohou být přiděleny objektem třídy allocator před uvolněním paměti.
znovu svázat	Struktura, která umožňuje alokátor pro objekty jednoho typu přidělit úložiště pro objekty jiného typu.

Operátory

Název	Popis
operator=	Přiřadí jeden allocator objekt jinému allocator objektu.

adresa

Vyhledá adresu objektu, jehož hodnota je zadána.

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

Parametry

Val
Hodnota const nebo nonconst objektu, jehož adresa je hledána.

Návratová hodnota

Const nebo nonconst ukazatel na objekt nalezen, v uvedeném pořadí, const nebo nonconst hodnota.

Poznámky

Členské funkce vrací adresu val, ve tvaru, který musí ukazatele přijmout pro přidělené prvky.

Příklad

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

Přidělí blok paměti dostatečně velký, aby ukládaly alespoň určitý zadaný počet prvků.

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

Parametry

count
Počet prvků, pro které je třeba přidělit dostatečné úložiště.

_Náznak
Ukazatel const, který může pomoct objektu alokátoru splnit požadavek na úložiště vyhledáním adresy objektu přiděleného před požadavkem.

Návratová hodnota

Ukazatel na přidělený objekt nebo hodnotu null, pokud nebyla přidělena paměť.

Poznámky

Členová funkce přiděluje úložiště pro pole prvků počtu typu Type, voláním operátoru new(count). Vrátí ukazatel na přidělený objekt. Argument nápovědy pomáhá některým alokátorům zlepšit lokalitu odkazu; Platná volba je adresa objektu, který byl dříve přidělen stejným objektem alokátoru, a ještě není uvolněn. Pokud chcete zadat žádný tip, použijte místo toho argument ukazatele null.

Příklad

// 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 používané k vytváření objektů alokátoru

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

Parametry

Vpravo
Objekt alokátoru, který se má zkopírovat.

Poznámky

Konstruktor nic nedělá. Obecně platí, že objekt alokátoru vytvořený z jiného objektu alokátoru by se měl porovnat s ním a umožnit vzájemné kombinování přidělení objektů a uvolnění mezi těmito dvěma objekty alokátoru.

Příklad

// 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, který poskytuje konstantní ukazatel na typ objektu spravovaného alokátorem.

typedef const value_type *const_pointer;

Poznámky

Typ ukazatele popisuje objekt ptr , který může prostřednictvím výrazu *ptrurčit libovolný objekt const, který objekt typu allocator může přidělit.

Příklad

// 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, který poskytuje konstantní odkaz na typ objektu spravovaného alokátorem.

typedef const value_type& const_reference;

Poznámky

Typ odkazu popisuje objekt, který může určit libovolný objekt const, který může objekt typu allocator přidělit.

Příklad

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

konstruovat

Vytvoří konkrétní typ objektu na zadané adrese, která je inicializována se zadanou hodnotou.

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

Parametry

ptr
Ukazatel na umístění, kde má být objekt vytvořen.

Val
Hodnota, pomocí které má být objekt vytvořen, má být inicializován.

Poznámky

První členová funkce je ekvivalentní new ((void *) ptr) Type(val).

Příklad

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

uvolnit

Uvolní zadaný počet objektů od úložiště počínaje zadanou pozicí.

void deallocate(pointer ptr, size_type count);

Parametry

ptr
Ukazatel na první objekt, který se má uvolnit z úložiště.

count
Počet objektů, které se mají uvolnit z úložiště.

Poznámky

Členské funkce uvolní úložiště pro pole objektů počtu typů Type začínajících na ptr voláním operator delete(ptr). Ukazatel ptr musí být vrácen dříve voláním přidělení objektu alokátoru , který porovnává rovnající se *, přidělení objektu pole se stejnou velikostí a typem. deallocate nikdy nevyvolá výjimku.

Příklad

Příklad použití členské funkce, viz alokátor::allocate.

zničit

Volá destruktor objektů bez uvolnění paměti, ve které byl objekt uložen.

void destroy(pointer ptr);

Parametry

ptr
Ukazatel označující adresu objektu, který má být zničen.

Poznámky

Člen funkce zničí objekt určený ptr voláním destruktoru ptr->Type::~Type.

Příklad

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

Celočíselný typ se signedm, který může představovat rozdíl mezi hodnotami ukazatelů na typ objektu spravovaného alokátorem.

typedef ptrdiff_t difference_type;

Poznámky

Typ signed integer popisuje objekt, který může představovat rozdíl mezi adresami libovolných dvou prvků v posloupnosti, kterou objekt typu allocator může přidělit.

Příklad

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

Vrátí počet prvků typu Type , které mohou být přiděleny objektem alokátoru třídy před uvolněním paměti.

size_type max_size() const;

Návratová hodnota

Počet prvků, které je možné přidělit.

Příklad

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

Přiřadí jeden objekt alokátoru jinému objektu alokátoru.

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

Parametry

Vpravo
Objekt alokátoru, který má být přiřazen jinému takovému objektu.

Návratová hodnota

Odkaz na objekt alokátoru

Poznámky

Operátor přiřazení šablony nedělá nic. Obecně platí, že objekt alokátoru přiřazený jinému objektu alokátoru by se měl porovnat s ním a umožnit vzájemné kombinování přidělení objektů a uvolnění mezi těmito dvěma objekty alokátoru.

Příklad

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

ukazatel

Typ, který poskytuje ukazatel na typ objektu spravovaného alokátorem.

typedef value_type *pointer;

Poznámky

Typ ukazatele popisuje objekt ptr , který lze určit pomocí výrazu *ptr, libovolný objekt, který může objekt typu allocator přidělit.

Příklad

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

znovu svázat

Struktura, která umožňuje alokátor pro objekty jednoho typu přidělit úložiště pro objekty jiného typu.

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

Parametry

jiný
Typ prvku, pro který je přidělena paměť.

Poznámky

Tato struktura je užitečná pro přidělování paměti pro typ, který se liší od typu prvku implementovaného kontejneru.

Šablona třídy člena definuje typ jiný. Jediným účelem je zadat název allocator<_Other>typu s názvem typu allocator<Type>.

Například vzhledem k objektu al alokátoru typu Amůžete přidělit objekt typu _Other pomocí výrazu:

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

Nebo můžete typ ukazatele pojmenovat zadáním tohoto typu:

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

Příklad

// 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, který poskytuje odkaz na typ objektu spravovaného alokátorem.

typedef value_type& reference;

Poznámky

Typ odkazu popisuje objekt, který může určit libovolný objekt, který může objekt typu allocator přidělit.

Příklad

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

Celočíselný typ bez znaménka, který může představovat délku jakékoli sekvence, kterou může objekt typu allocator přidělit.

typedef size_t size_type;

Příklad

// 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 spravovaný alokátorem.

typedef Type value_type;

Poznámky

Typ je synonymem pro parametr Typešablony .

Příklad

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

Pomocníci

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;