allocator Sınıfı

Sınıf şablonu, türündeki Typenesne dizileri için depolama ayırma ve boşaltmayı yöneten bir nesneyi açıklar. Sınıfın allocator nesnesi, C++ Standart Kitaplığı'ndaki birkaç kapsayıcı sınıfı şablonu için oluşturucularda belirtilen varsayılan ayırıcı nesnesidir.

Sözdizimi

template <class Type>
class allocator

Parametreler

Tür
Depolamanın ayrıldığı veya serbest bırakıldığı nesnenin türü.

Açıklamalar

Tüm C++ Standart Kitaplığı kapsayıcılarında varsayılan olarak allocatorolarak ayarlanmış bir şablon parametresi vardır. Özel ayırıcı ile bir kapsayıcı oluşturmak, bu kapsayıcının öğelerini ayırma ve boşaltma üzerinde denetim sağlar.

Örneğin, ayırıcı nesnesi özel bir yığında veya paylaşılan bellekte depolama ayırabilir veya küçük veya büyük nesne boyutları için iyileştirir. Ayrıca, sağladığı tür tanımları aracılığıyla, paylaşılan belleği yöneten veya otomatik çöp toplama gerçekleştiren özel erişimci nesneleri aracılığıyla öğelere erişileceğini belirtebilir. Bu nedenle, ayırıcı nesnesi kullanarak depolamayı ayıran bir sınıf, C++ Standart Kitaplığı'ndaki kapsayıcılar gibi işaretçi ve başvuru nesneleri bildirmek için bu türleri kullanmalıdır.

(Yalnızca C++98/03) Ayırıcı sınıfından türetdiğinizde, tür tanımı yeni türetilen sınıfınıza başvuran bir yeniden bağlama yapısı _Other sağlamanız gerekir.

Bu nedenle, ayırıcı aşağıdaki türleri tanımlar:

• işaretçisi , işaretçisi Typegibi davranır.

• const_pointer, için Typesabit bir işaretçi gibi davranır.

• başvuru , başvurusu Typegibi davranır.

• const_reference, öğesine Typeconst başvurusu gibi davranır.

Bunlar Type, işaretçilerin ve başvuruların ayrılan öğeler için alması gereken formu belirtir. ( allocator::p ointer, sınıfı allocatoriçin bu belirgin tanıma sahip olsa bile, tüm ayırıcı nesnelerle aynı Type* olmayabilir.)

C++11 ve üzeri: Ayırıcınızda taşıma işlemlerini etkinleştirmek için en düşük ayırıcı arabirimini kullanın ve kopya oluşturucu, == ve != işleçlerini uygulayın, ayırın ve serbest bırakın. Daha fazla bilgi ve örnek için bkz. Ayırıcılar

Üyeler

Oluşturucular

Veri Akışı Adı	Açıklama
allocator	Nesne oluşturmak allocator için kullanılan oluşturucular.

Tür tanımları

Veri Akışı Adı	Açıklama
const_pointer	Ayırıcı tarafından yönetilen nesne türüne sabit bir işaretçi sağlayan tür.
const_reference	Ayırıcı tarafından yönetilen nesne türüne sabit başvuru sağlayan bir tür.
difference_type	ayırıcı tarafından yönetilen nesne türüne yönelik işaretçi değerleri arasındaki farkı temsil eden imzalı tam sayı türü.
Işaretçi	Ayırıcı tarafından yönetilen nesne türüne yönelik bir işaretçi sağlayan tür.
referans	Ayırıcı tarafından yönetilen nesne türüne başvuru sağlayan bir tür.
size_type	Türdeki bir nesnenin ayırabileceği herhangi bir sıranın uzunluğunu temsil eden imzasız bir tamsayı türü allocator .
value_type	Ayırıcı tarafından yönetilen bir tür.

İşlevler

Veri Akışı Adı	Açıklama
adres	Değeri belirtilen bir nesnenin adresini bulur.
allocate	En az belirli sayıda öğeyi depolayabilecek kadar büyük bir bellek bloğu ayırır.
yapmak	Belirtilen bir değerle başlatılan belirli bir adreste belirli bir nesne türü oluşturur.
Ayırması	Belirtilen sayıda nesneyi belirtilen konumdan başlayarak depolama alanından serbest bırakın.
yıkmak	Nesnenin depolandığı belleği serbest bırakmadan bir nesne yıkıcısını çağırır.
max_size	Boş bellek kullanılmadan önce sınıfın allocator bir nesnesi tarafından ayrılabilecek tür Type öğelerinin sayısını döndürür.
yeniden bağlama	Bir türdeki nesneler için ayırıcının başka türdeki nesneler için depolama ayırmasını sağlayan bir yapı.

İşleçler

Veri Akışı Adı	Açıklama
operator=	Bir allocator nesneyi başka bir allocator nesneye atar.

adres

Değeri belirtilen bir nesnenin adresini bulur.

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

Parametreler

Val
Adresi aranmakta olan nesnenin sabit veya nonconst değeri.

Dönüş Değeri

Sırasıyla const veya nonconst değerinin bulunduğu nesneye ilişkin sabit veya nonconst işaretçisi.

Açıklamalar

Üye işlevleri, işaretçilerin ayrılan öğeler için alması gereken biçimde val adresini döndürür.

Örnek

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

En az belirli sayıda öğeyi depolayabilecek kadar büyük bir bellek bloğu ayırır.

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

Parametreler

count
Yeterli depolama alanının ayrılacağı öğe sayısı.

_İma
Ayırıcı nesnenin, istek öncesinde ayrılan bir nesnenin adresini bularak depolama isteğini karşılamasına yardımcı olabilecek bir const işaretçisi.

Dönüş Değeri

Ayrılan nesnenin işaretçisi veya bellek ayrılmadıysa null.

Açıklamalar

üye işlevi, new(count) işlecini çağırarak türündeki Typebir sayı öğeleri dizisi için depolama alanı ayırır. Ayrılan nesneye bir işaretçi döndürür. İpucu bağımsız değişkeni, bazı ayırıcıların başvurunun yerelliğini geliştirmesine yardımcı olur; geçerli bir seçim, aynı ayırıcı nesne tarafından daha önce ayrılan ve henüz serbest bırakılmamış bir nesnenin adresidir. İpucu sağlamak için bunun yerine null işaretçi bağımsız değişkeni kullanın.

Örnek

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

Ayırıcı nesneleri oluşturmak için kullanılan oluşturucular.

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

Parametreler

Sağ
Kopyalanacak ayırıcı nesnesi.

Açıklamalar

Oluşturucu hiçbir şey yapmaz. Ancak genel olarak, başka bir ayırıcı nesneden oluşturulmuş bir ayırıcı nesne, buna eşit olarak karşılaştırılmalı ve iki ayırıcı nesne arasında nesne ayırma ve serbest ayırmaya izin vermelidir.

Örnek

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

Ayırıcı tarafından yönetilen nesne türüne sabit bir işaretçi sağlayan tür.

typedef const value_type *const_pointer;

Açıklamalar

İşaretçi türü, ifadesi *ptraracılığıyla, türünde allocator bir nesnenin ptr ayırabileceği herhangi bir const nesnesi belirtebilen bir nesneyi açıklar.

Örnek

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

Ayırıcı tarafından yönetilen nesne türüne sabit başvuru sağlayan bir tür.

typedef const value_type& const_reference;

Açıklamalar

Başvuru türü, türündeki bir nesnenin ayırabileceği herhangi bir sabit nesneyi belirtebilen bir nesneyi allocator açıklar.

Örnek

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

yapmak

Belirtilen bir değerle başlatılan belirli bir adreste belirli bir nesne türü oluşturur.

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

Parametreler

ptr
Nesnenin oluşturulacağı konumun işaretçisi.

Val
Oluşturulmakta olan nesnenin başlatılacağı değerdir.

Açıklamalar

İlk üye işlevi ile new ((void *) ptr) Type(val)eşdeğerdir.

Örnek

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

Ayırması

Belirtilen sayıda nesneyi belirtilen konumdan başlayarak depolama alanından serbest bırakın.

void deallocate(pointer ptr, size_type count);

Parametreler

ptr
Depolama alanından serbest bırakılacak ilk nesnenin işaretçisi.

count
Depolama alanından serbest bırakılacak nesne sayısı.

Açıklamalar

üye işlevi, ptr'den başlayarak türündeki sayı nesneleri Type dizisi için öğesini çağırarak operator delete(ptr)depolama alanını boşaltıyor. İşaretçi ptr daha önce * ile eşit olan bir ayırıcı nesnesine ayırmak için çağrı tarafından döndürülerek aynı boyutta ve türde bir dizi nesnesi ayrılmış olmalıdır. deallocate hiçbir zaman özel durum oluşturmaz.

Örnek

Üye işlevini kullanan bir örnek için bkz . allocator::allocate.

yıkmak

Nesnenin depolandığı belleği serbest bırakmadan bir nesne yıkıcısını çağırır.

void destroy(pointer ptr);

Parametreler

ptr
Yok edilecek nesnenin adresini belirleme işaretçisi.

Açıklamalar

üye işlevi, yok ediciyi ptr->Type::~Typeçağırarak ptr tarafından belirlenen nesneyi yok eder.

Örnek

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

ayırıcı tarafından yönetilen nesne türüne yönelik işaretçi değerleri arasındaki farkı temsil eden imzalı tam sayı türü.

typedef ptrdiff_t difference_type;

Açıklamalar

İmzalı tamsayı türü, bir nesnenin ayırabileceği bir dizideki iki öğe arasındaki farkı temsil eden bir nesneyi allocator açıklar.

Örnek

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

Boş bellek kullanılmadan önce sınıf ayırıcı nesnesi tarafından ayrılabilecek tür Type öğelerinin sayısını döndürür.

size_type max_size() const;

Dönüş Değeri

Ayrılabilecek öğe sayısı.

Örnek

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

Bir ayırıcı nesnesini başka bir ayırıcı nesnesine atar.

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

Parametreler

Sağ
Bu tür başka bir nesneye atanacak ayırıcı nesnesi.

Dönüş Değeri

Ayırıcı nesnesine başvuru

Açıklamalar

Şablon atama işleci hiçbir şey yapmaz. Ancak genel olarak, başka bir ayırıcı nesneye atanan bir ayırıcı nesnesi buna eşit olarak karşılaştırılmalı ve iki ayırıcı nesne arasında nesne ayırma ve serbest ayırmaya izin vermelidir.

Örnek

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

Ayırıcı tarafından yönetilen nesne türüne yönelik bir işaretçi sağlayan tür.

typedef value_type *pointer;

Açıklamalar

İşaretçi türü, *ptr ifadesi aracılığıyla, türündeki allocator bir nesnenin ptr ayırabileceği herhangi bir nesneyi belirtebilen bir nesneyi açıklar.

Örnek

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

yeniden bağlama

Bir türdeki nesneler için ayırıcının başka türdeki nesneler için depolama ayırmasını sağlayan bir yapı.

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

Parametreler

Diğer
Belleğin ayrıldığı öğenin türü.

Açıklamalar

Bu yapı, uygulanan kapsayıcının öğe türünden farklı türde bellek ayırmada kullanışlıdır.

Üye sınıf şablonu diğer türünü tanımlar. Tek amacı, tür adı verilen tür adını allocator<_Other>allocator<Type>sağlamaktır.

Örneğin, türünde Abir ayırıcı nesnesi al verüldüğünde, türünde bir nesnesini _Other şu ifadeyle ayırabilirsiniz:

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

İsterseniz, türü yazarak işaretçi türünü adlandırabilirsiniz:

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

Örnek

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

Ayırıcı tarafından yönetilen nesne türüne başvuru sağlayan bir tür.

typedef value_type& reference;

Açıklamalar

Başvuru türü, türündeki bir nesnenin ayırabileceği herhangi bir nesneyi belirtebilen bir nesneyi allocator açıklar.

Örnek

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

Türdeki bir nesnenin ayırabileceği herhangi bir sıranın uzunluğunu temsil eden imzasız bir tamsayı türü allocator .

typedef size_t size_type;

Örnek

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

Ayırıcı tarafından yönetilen bir tür.

typedef Type value_type;

Açıklamalar

türü, şablon parametresi Typeiçin bir eş anlamlıdır.

Örnek

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

Yardımcıları

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;