Aracılığıyla paylaş


deque Sınıfı

Belirli bir türün öğelerini doğrusal bir düzende düzenler ve vektör gibi herhangi bir öğeye hızlı rastgele erişim ve kapsayıcının arkasında verimli ekleme ve silme işlemleri sağlar. Ancak, bir vektörden farklı olarak, sınıfı kapsayıcının deque önünde etkili ekleme ve silmeyi de destekler.

Sözdizimi

template <class Type, class Allocator =allocator<Type>>
class deque

Parametreler

Type
içinde dequedepolanacak öğe veri türü.

Allocator
's ayırma ve belleği serbest bırakma hakkındaki dequeayrıntıları kapsülleyen depolanan ayırıcı nesnesini temsil eden tür. Bu bağımsız değişken isteğe bağlıdır ve varsayılan değerdir allocator<Type>.

Açıklamalar

Kapsayıcı türünün seçimi genelde uygulamanın gerektirdiği arama ve ekleme türüne dayalı olmalıdır. Vectors herhangi bir öğeye rastgele erişim premium olduğunda ve öğelerin eklenmesi veya silinmesi yalnızca bir dizinin sonunda gerekli olduğunda, bir diziyi yönetmek için tercih edilen kapsayıcı olmalıdır. Sıra içindeki herhangi bir konumda verimli ekleme ve silme işlemleri (sabit zamanda) premium olduğunda liste kapsayıcısının performansı üstündür. Sıranın ortasındaki bu tür işlemler, dizideki öğe sayısıyla orantılı öğe kopyaları ve atamaları gerektirir (doğrusal süre).

Deque bir üye işlevinin dizinin öğelerini eklemesi veya silmesi gerektiğinde reallocation gerçekleşir:

  • Bir öğe boş bir diziye eklenirse veya boş bir dizi bırakmak için bir öğe silinirse, daha önce tarafından begin döndürülen ve end geçersiz hale gelen yineleyiciler.

  • öğesinin ilk konumuna dequebir öğe eklenirse, var olan öğeleri belirten tüm yineleyiciler, ancak başvuru yoksa geçersiz hale gelir.

  • öğesinin dequeend sonuna bir öğe eklenirse ve tüm yineleyiciler eklenirse, ancak başvuru yoksa, var olan öğeler geçersiz hale gelir.

  • öğesinin dequeönünde bir öğe silinirse, yalnızca bu yineleyici ve silinen öğeye başvurular geçersiz hale gelir.

  • Son öğe sonundan dequesilinirse, yalnızca son öğeye yineleyici ve silinen öğeye başvurular geçersiz olur.

Aksi takdirde, bir öğenin eklenmesi veya silinmesi tüm yineleyicileri ve başvuruları geçersiz kılmıştır.

Üyeler

Oluşturucular

Veri Akışı Adı Açıklama
deque bir dequeoluşturur. Yeni deque öğenin içeriğini farklı şekillerde ayarlamak için çeşitli oluşturucular sağlanır: boş; belirtilen sayıda boş öğeyle yüklenir; başka dequebir öğeden taşınan veya kopyalanan içerik; yineleyici kullanılarak kopyalanan veya taşınan içerik ve zamanlara dequecount kopyalanan bir öğe. Oluşturuculardan bazıları, öğeleri oluşturmak için özel allocator kullanmayı etkinleştirir.

Tür tanımları

Veri Akışı Adı Açıklama
allocator_type Nesnenin sınıfını allocatordeque temsil eden bir tür.
const_iterator gibi öğelerine erişebilen ve bu öğeleri deque okuyabilen rastgele erişim yineleyicisi sağlayan bir tür const
const_pointer gibi bir öğeye işaretçi sağlayan bir dequeconsttür.
const_reference gibi okuma ve diğer işlemler constiçin içindeki bir deque öğeye başvuru sağlayan tür.
const_reverse_iterator içindeki öğelere olarak erişebilen ve bu öğeleri dequeconstokuyabilen rastgele erişim yineleyicisi sağlayan bir tür. deque tersine görüntülenir. Daha fazla bilgi için bkz. reverse_iterator Sınıf
difference_type Aynı dequeiçindeki öğelere başvuran iki rastgele erişim yineleyicisi arasındaki farkı sağlayan bir tür.
iterator içindeki herhangi bir öğeyi okuyabilen veya değiştirebilen rastgele erişim yineleyicisi sağlayan bir dequetür.
pointer içindeki bir öğeye işaretçi sağlayan tür deque.
reference içinde depolanan bir öğeye başvuru sağlayan tür deque.
reverse_iterator içindeki bir öğeyi okuyabilen veya değiştirebilen rastgele erişim yineleyicisi sağlayan bir dequetür. deque ters sırada görüntülenir.
size_type içindeki öğe sayısını sayan bir dequetür.
value_type içinde depolanan veri türünü temsil eden bir dequetür.

İşlevler

Veri Akışı Adı Açıklama
assign öğesinden deque öğeleri siler ve hedef öğesine dequeyeni bir öğe dizisi kopyalar.
at öğesinde belirtilen bir konumda dequeöğesine başvuru döndürür.
back öğesinin son öğesine dequebaşvuru döndürür.
begin içindeki ilk öğeyi ele alan rastgele erişim yineleyicisi dequedöndürür.
cbegin içindeki ilk öğeye dequebir const yineleyici döndürür.
cend öğesinin sonunun hemen ötesine işaret eden rastgele erişim const yineleyicisi dequedöndürür.
clear öğesinin dequetüm öğelerini siler.
crbegin Ters sırada görüntülenen ilk öğeye deque rastgele erişim const yineleyicisi döndürür.
crend Ters sırada görüntülenen ilk öğeye deque rastgele erişim const yineleyicisi döndürür.
emplace Belirtilen konumda içine deque yerinde inşa edilmiş bir öğe ekler.
emplace_back öğesinin sonuna dequeyerinde bir öğe ekler.
emplace_front öğesinin başlangıcına dequeyerinde bir öğe ekler.
empty deque sıfır öğe içeriyorsa ve false bir veya daha fazla öğe içeriyorsa döndürürtrue.
end öğesinin sonunun hemen ötesine işaret eden rastgele erişim yineleyicisi dequedöndürür.
erase Belirtilen konumlardan bir öğeyi veya öğe deque aralığını kaldırır.
front içindeki ilk öğeye başvuru dequedöndürür.
get_allocator nesnesini oluşturmak allocator için kullanılan nesnesinin dequebir kopyasını döndürür.
insert Belirtilen konumda öğesine bir öğe, birkaç öğe veya bir öğe deque aralığı ekler.
max_size öğesinin mümkün olan en uzun uzunluğunu dequedöndürür.
pop_back öğesinin sonundaki dequeöğesini siler.
pop_front öğesinin başındaki dequeöğesini siler.
push_back öğesinin sonuna dequebir öğe ekler.
push_front öğesinin başlangıcına dequebir öğesi ekler.
rbegin Ters çevrilmiş dequeiçindeki ilk öğeye rastgele erişim yineleyicisi döndürür.
rend Ters çevrilmiş dequebir içindeki son öğenin hemen ötesine işaret eden rastgele erişim yineleyicisi döndürür.
resize için yeni bir dequeboyut belirtir.
shrink_to_fit Fazla kapasiteyi atar.
size içindeki dequeöğe sayısını döndürür.
swap İki dequeöğesinin öğelerini değiştirir.

İşleçler

Veri Akışı Adı Açıklama
operator[] Belirtilen konumdaki öğeye deque başvuru döndürür.
operator= öğesinin deque öğelerini başka dequebir kopyasıyla değiştirir.

allocator_type

Nesne için ayırıcı sınıfını temsil eden bir deque tür.

typedef Allocator allocator_type;

Açıklamalar

allocator_type , şablon parametresinin Allocatoreş anlamlısıdır.

Örnek

örneğine get_allocatorbakın.

assign

öğesinden deque öğeleri siler ve hedef öğesine dequeyeni bir öğe kümesi kopyalar.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

Parametreler

First
bağımsız değişkeninden dequekopyalanacak öğe aralığındaki ilk öğenin konumu.

Last
bağımsız değişkeninden dequekopyalanacak öğe aralığının ötesindeki ilk öğenin konumu.

Count
öğesine eklenen dequeöğenin kopyalarının sayısı.

Val
içine eklenen dequeöğenin değeri.

IList
initializer_list içine dequeeklenen.

Açıklamalar

Hedefteki deque mevcut öğeler silindikten sonra, assign belirtilen öğe aralığını özgün deque öğeden veya başka deque bir öğeden hedef öğesine ekler veya belirtilen dequedeğerin yeni bir öğesinin kopyalarını hedef dequeöğesine ekler.

Örnek

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}
d1 = 5678c1 =102030c1 =5060c1 =4444444

at

öğesinde belirtilen bir konumda dequeöğesine başvuru döndürür.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parametreler

pos
içinde başvurulacak dequeöğenin alt indis (veya konum numarası) .

Dönüş Değeri

boyutu değerinden dequeat büyükse pos bir özel durum oluşturur.

Açıklamalar

değerinin dönüş değeri at bir const_referencedeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri at bir referencedeque öğesine atanmışsa, nesnesi değiştirilebilir.

Örnek

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int& i = c1.at( 0 );
   int& j = c1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}
The first element is 10
The second element is 20

back

öğesinin son öğesine dequebaşvuru döndürür.

reference back();
const_reference back() const;

Dönüş Değeri

öğesinin dequeson öğesi. deque boşsa, dönüş değeri tanımlanmamış olur.

Açıklamalar

değerinin dönüş değeri back bir const_referencedeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri back bir referencedeque öğesine atanmışsa, nesnesi değiştirilebilir.

1 veya 2 olarak tanımlanan kullanılarak _ITERATOR_DEBUG_LEVEL derlendiğinde, boş dequebir içindeki bir öğeye erişmeye çalışırsanız bir çalışma zamanı hatası oluşur. Daha fazla bilgi için bkz . İşaretli Yineleyiciler .

Örnek

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.back( );
   const int& ii = c1.front( );

   cout << "The last integer of c1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of c1 is " << ii << endl;
}
The last integer of c1 is 11
The next-to-last integer of c1 is 10

begin

içindeki ilk öğeyi dequeele alan bir yineleyici döndürür.

const_iterator begin() const;
iterator begin();

Dönüş Değeri

veya içindeki deque ilk öğeyi veya boş dequebir öğesinin başarılı olduğu konumu ele alan rastgele erişim yineleyicisi.

Açıklamalar

değerinin dönüş değeri begin bir const_iteratordeque öğesine atanmışsa nesnesi değiştirilemez. dönüş değeri begin bir iteratordeque öğesine atanmışsa nesnesi değiştirilebilir.

Örnek

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::const_iterator c1_cIter;

   c1.push_back( 1 );
   c1.push_back( 2 );

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

   // The following line would be an error because iterator is const
   // *c1_cIter = 200;
}
The first element of c1 is 1
The first element of c1 is now 20

cbegin

Aralıktaki ilk öğeyi ele alan bir const yineleyici döndürür.

const_iterator cbegin() const;

Dönüş Değeri

Aralığın const ilk öğesini veya boş aralığın sonunun hemen ötesindeki konumu işaret eden rastgele erişim yineleyicisi (boş aralık için). cbegin() == cend()

Açıklamalar

değerinin cbegindönüş değeriyle, aralıktaki öğeler değiştirilemez.

Dönüş değerinin olduğunu const_iteratorgaranti etmek için üye işlevinin begin() yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve cbegin()destekleyen herhangi bir türde begin() değiştirilebilir (non- const) kapsayıcısı olduğunu düşününContainer.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

cend

Bir const aralıktaki son öğenin hemen ötesindeki konumu ele alan bir yineleyici döndürür.

const_iterator cend() const;

Dönüş Değeri

Aralığın hemen sonunu gösteren bir rastgele erişim yineleyicisi.

Açıklamalar

cend bir yineleyicinin aralığının sonunu geçip geçmediğini test etmek için kullanılır.

Dönüş değerinin olduğunu const_iteratorgaranti etmek için üye işlevinin end() yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve cend()destekleyen herhangi bir türde end() değiştirilebilir (non- const) kapsayıcısı olduğunu düşününContainer.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

tarafından cend döndürülen değer başvurulmamalıdır.

clear

öğesinin dequetüm öğelerini siler.

void clear();

Örnek

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}
The size of the deque is initially 3
The size of the deque after clearing is 0

const_iterator

içindeki bir öğeye dequeerişebilen ve öğeyi okuyabilen rastgele erişim yineleyicisi sağlayan bir const tür.

typedef implementation-defined const_iterator;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür const_iterator kullanılamaz.

Örnek

örneğine backbakın.

const_pointer

içindeki bir öğeye yönelik bir constdequeişaretçi sağlar.

typedef typename Allocator::const_pointer const_pointer;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür const_pointer kullanılamaz. daha iterator yaygın olarak bir deque öğeye erişmek için kullanılır.

const_reference

okuma ve gerçekleştirme const işlemleri için içinde deque depolanan bir const öğeye başvuru sağlayan bir tür.

typedef typename Allocator::const_reference const_reference;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür const_reference kullanılamaz.

Örnek

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as c2 is const
   // c2.push_back( 30 );
}
The first element is 10
The second element is 20

const_reverse_iterator

içindeki dequeherhangi const bir öğeyi okuyabilen rastgele erişim yineleyicisi sağlayan bir tür.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Açıklamalar

Bir tür const_reverse_iterator bir öğenin değerini değiştiremez ve öğesini tersten yinelemek deque için kullanılır.

Örnek

Yineleyici bildirme ve kullanma örneği için rbegin örneğine bakın.

crbegin

Ters çevrilmiş dequeiçindeki ilk öğeye bir const yineleyici döndürür.

const_reverse_iterator crbegin() const;

Dönüş Değeri

const Ters çevrilmiş deque bir içindeki ilk öğeyi veya ters dequeçevrilmemiş içindeki son öğeyi ele alan ters rastgele erişim yineleyicisi.

Açıklamalar

dönüş değeriyle crbegindeque nesne değiştirilemez.

Örnek

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator v1_Iter;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of deque is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed deque is "
        << *v1_rIter << "." << endl;
}
The first element of deque is 1.
The first element of the reversed deque is 2.

crend

Ters çevrilmiş dequebir const içindeki son öğeden sonra gelen konumu ele alan bir yineleyici döndürür.

const_reverse_iterator crend() const;

Dönüş Değeri

Ters const çevrilmiş deque bir öğedeki son öğeyi (ters çevrilmemiş öğedeki ilk öğeden önce gelen konum) başarılı olan konumu ele alan ters rastgele erişim yineleyicisi deque.

Açıklamalar

crend, ile kullanıldığı gibi array::cend ters çevrilmiş deque bir dequeile kullanılır.

dönüş değeri crend (uygun şekilde azalmış) deque ile nesne değiştirilemez.

crend , ters yineleyicinin sonuna dequeulaşıp ulaşmadığını test etmek için kullanılabilir.

tarafından crend döndürülen değer başvurulmamalıdır.

Örnek

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}
2
1

deque

deque Belirli bir boyutta veya belirli bir değerin öğeleriyle ya da belirli bir ayırıcıyla ya da başka dequebir öğesinin tümünün veya bir bölümünün kopyası olarak oluşturur.

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

Parametreler

Al
Bu nesneyle kullanılacak kaynak ayırıcı sınıfı.

Count
Yapısındaki dequeöğe sayısı.

Val
Yapısındaki dequeöğelerinin değeri.

Right
deque Bunun için bir deque kopya oluşturulur.

First
Kopyalanacak öğe aralığındaki ilk öğenin konumu.

Last
Kopyalanacak öğe aralığının ötesindeki ilk öğenin konumu.

IList
initializer_list Kopyalanacak.

Açıklamalar

Tüm oluşturucular bir ayırıcı nesnesi (Al) depolar ve öğesini dequebaşlatır.

İlk iki oluşturucu boş bir baş harf dequebelirtir; ikincisi de kullanılacak ayırıcı türünü (_Al) belirtir.

Üçüncü oluşturucu, sınıfı Typeiçin varsayılan değerde belirtilen sayıda (count) öğe yinelemesini belirtir.

Dördüncü ve beşinci oluşturucular değerinin val(Count) öğelerinin tekrarını belirtir.

Altıncı oluşturucu, öğesinin dequeRightbir kopyasını belirtir.

Yedinci ve sekizinci oluşturucular aralığını [First, Last) kopyalar deque.

Yedinci oluşturucu öğesini dequeRighttaşır.

Sekizinci oluşturucu bir initializer_listöğesinin içeriğini kopyalar.

Oluşturucuların hiçbiri geçici yeniden yükleme gerçekleştirmez.

Örnek

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1(3);

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2(5, 2);

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1( 3 );

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2( 5, 2 );

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

difference_type

Aynı dequeiçindeki öğelere başvuran iki yineleyici arasındaki farkı sağlayan bir tür.

typedef typename Allocator::difference_type difference_type;

Açıklamalar

A difference_type , iki işaretçi arasındaki öğe sayısı olarak da tanımlanabilir.

Örnek

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   deque <int>::difference_type df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}
The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

emplace

Belirtilen konumda içine deque yerinde inşa edilmiş bir öğe ekler.

iterator emplace(
    const_iterator _Where,
    Type&& val);

Parametreler

_Where
İlk öğenin eklendiği konum deque .

val
içine eklenen dequeöğenin değeri.

Dönüş Değeri

işlevi, yeni öğenin içine eklendiği dequekonumu gösteren bir yineleyici döndürür.

Açıklamalar

Herhangi bir ekleme işlemi pahalı olabilir. Performans tartışması deque için bkzdeque.

Örnek

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}
v1 = 10 20 30
vv1[0] = 10 20 30

emplace_back

öğesinin sonuna dequeyerinde bir öğe ekler.

void emplace_back(Type&& val);

Parametreler

val
öğesinin sonuna dequeeklendi.

Örnek

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}
Last element: 1
New last element: 2
Moved last element: 2

emplace_front

öğesinin sonuna dequeyerinde bir öğe ekler.

void emplace_front(Type&& val);

Parametreler

val
öğesinin başına dequeeklenen öğesi.

Örnek

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}
Last element: 1
New last element: 2
Moved last element: 2

empty

boş deque olup olmadığını sınar.

bool empty() const;

Dönüş Değeri

truedeque boşsa; false boş değilsedeque.

Örnek

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}
The deque is not empty.

end

içindeki son öğenin başarılı olduğu konumu ele alan bir dequeyineleyici döndürür.

const_iterator end() const;

iterator end();

Dönüş Değeri

bir içindeki son öğenin başarılı olduğu konumu ele alan rastgele erişim yineleyicisi deque. deque boşsa, öğesini seçindeque::end == deque::begin.

Açıklamalar

end , yineleyicinin sonuna dequeulaşıp ulaşmadığını test etmek için kullanılır.

Örnek

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}
The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

erase

Belirtilen konumlardan bir öğeyi veya öğe deque aralığını kaldırır.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parametreler

_Where
öğesinden dequekaldırılacak öğenin konumu.

first
öğesinden dequekaldırılan ilk öğenin konumu.

last
konumundan kaldırılan son öğenin hemen ötesindeki dequekonumu.

Dönüş Değeri

Kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten rastgele erişim yineleyicisi veya böyle bir öğe yoksa sonuna deque bir işaretçi.

Açıklamalar

erase hiçbir zaman özel durum oluşturmaz.

Örnek

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}
The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

front

içindeki ilk öğeye başvuru dequedöndürür.

reference front();

const_reference front() const;

Dönüş Değeri

deque boşsa, dönüş tanımsız olur.

Açıklamalar

değerinin dönüş değeri front bir const_referencedeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri front bir referencedeque öğesine atanmışsa, nesnesi değiştirilebilir.

1 veya 2 olarak tanımlanan kullanılarak _ITERATOR_DEBUG_LEVEL derlendiğinde, boş dequebir içindeki bir öğeye erişmeye çalışırsanız bir çalışma zamanı hatası oluşur. Daha fazla bilgi için bkz . İşaretli Yineleyiciler .

Örnek

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.front( );
   const int& ii = c1.front( );

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}
The first integer of c1 is 10
The second integer of c1 is 11

get_allocator

oluşturmak için kullanılan ayırıcı nesnesinin dequebir kopyasını döndürür.

Allocator get_allocator() const;

Dönüş Değeri

tarafından dequekullanılan ayırıcı.

Açıklamalar

sınıfı için ayırıcılar, sınıfın deque depolamayı nasıl yöneteceğini belirtir. C++ Standart Kitaplığı kapsayıcı sınıfları ile sağlanan varsayılan ayırıcılar çoğu programlama gereksinimi için yeterlidir. Kendi ayırıcı sınıfınızı yazmak ve kullanmak gelişmiş bir C++ konusudur.

Örnek

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   deque <int> c1;
   deque <int, allocator<int> > c2 = deque <int, allocator<int> >( allocator<int>( ) );

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

insert

Belirtilen konumda öğesine bir öğe veya bir dizi öğe ya da öğe deque aralığı ekler.

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

Parametreler

Where
Hedefteki deque ilk öğenin eklendiği konum.

Val
içine eklenen dequeöğenin değeri.

Count
içine dequeeklenen öğe sayısı.

First
Kopyalanacak bağımsız değişkendeki deque öğe aralığındaki ilk öğenin konumu.

Last
Kopyalanacak bağımsız değişkendeki deque öğe aralığının ötesindeki ilk öğenin konumu.

IList
initializer_list Eklenecek öğelerin sayısı.

Dönüş Değeri

İlk iki ekleme işlevi, yeni öğenin içine dequeeklendiği konumu gösteren bir yineleyici döndürür.

Açıklamalar

Herhangi bir ekleme işlemi pahalı olabilir.

iterator

içindeki herhangi bir öğeyi okuyabilen veya değiştirebilen rastgele erişim yineleyicisi sağlayan bir dequetür.

typedef implementation-defined iterator;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür iterator kullanılabilir.

Örnek

örneğine beginbakın.

max_size

değerinin uzunluk üst sınırını dequedöndürür.

size_type max_size() const;

Dönüş Değeri

mümkün olan en uzun uzunluk deque.

Örnek

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   i = c1.max_size( );
   cout << "The maximum possible length of the deque is " << i << "." << endl;
}

operator[]

Belirtilen konumdaki öğeye deque başvuru döndürür.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parametreler

pos
Başvurulacak öğenin konumu deque .

Dönüş Değeri

Bağımsız değişkende konumu belirtilen öğeye başvuru. Belirtilen konum boyutunun boyutundan dequebüyükse, sonuç tanımsız olur.

Açıklamalar

değerinin dönüş değeri operator[] bir const_referencedeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri operator[] bir referencedeque öğesine atanmışsa, nesnesi değiştirilebilir.

1 veya 2 olarak tanımlanan kullanılarak _ITERATOR_DEBUG_LEVEL derlendiğinde, sınırlarının dequedışındaki bir öğeye erişmeye çalışırsanız bir çalışma zamanı hatası oluşur. Daha fazla bilgi için bkz . İşaretli Yineleyiciler .

Örnek

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}
The first integer of c1 is 10
The second integer of c1 is 20

operator=

Bunun öğelerini deque , başka bir dequeöğesindeki öğeleri kullanarak değiştirir.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parametreler

right
deque Yeni içeriği sağlayan.

Açıklamalar

İlk geçersiz kılma, atamanın kaynağı olan öğesinden rightbu deque öğeye kopyalanır. İkinci geçersiz kılma, öğeleri öğesinden rightbu deque öğeye taşır.

İşleç yürütülmeden önce bunun deque içinde yer alan öğeler kaldırılır.

Örnek

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

   d1.push_back(10);
   d1.push_back(20);
   d1.push_back(30);
   d1.push_back(40);
   d1.push_back(50);

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

pointer

içindeki bir öğeye dequeişaretçi sağlar.

typedef typename Allocator::pointer pointer;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür pointer kullanılabilir. daha iterator yaygın olarak bir deque öğeye erişmek için kullanılır.

pop_back

öğesinin sonundaki dequeöğesini siler.

void pop_back();

Açıklamalar

Son öğe boş olmamalıdır. pop_back hiçbir zaman özel durum oluşturmaz.

Örnek

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}
The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

pop_front

öğesinin başında siler deque.

void pop_front();

Açıklamalar

İlk öğe boş olmamalıdır. pop_front hiçbir zaman özel durum oluşturmaz.

Örnek

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}
The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

push_back

öğesinin sonuna dequebir öğe ekler.

void push_back(const Type& val);

void push_back(Type&& val);

Parametreler

val
öğesinin sonuna dequeeklendi.

Açıklamalar

Bir özel durum oluşturulursa, deque unaltered bırakılır ve özel durum yeniden oluşturulur.

push_front

öğesinin başına dequebir öğe ekler.

void push_front(const Type& val);
void push_front(Type&& val);

Parametreler

val
öğesinin başına dequeeklenen öğesi.

Açıklamalar

Bir özel durum oluşturulursa, deque unaltered bırakılır ve özel durum yeniden oluşturulur.

Örnek

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}
First element: 1
New first element: 2
Moved first element: a

rbegin

Ters çevrilmiş dequeiçindeki ilk öğeye bir yineleyici döndürür.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Dönüş Değeri

Ters çevrilmiş deque bir içindeki ilk öğeyi veya ters dequeçevrilmemiş içindeki son öğeyi ele alan ters rastgele erişim yineleyicisi.

Açıklamalar

rbegin, ile kullanıldığı gibi begin ters çevrilmiş deque bir dequeile kullanılır.

değerinin dönüş değeri rbegin bir const_reverse_iteratordeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri rbegin bir reverse_iteratordeque öğesine atanmışsa, nesnesi değiştirilebilir.

rbegin geriye doğru yinelemek deque için kullanılabilir.

Örnek

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}
Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

reference

içinde depolanan bir öğeye başvuru sağlayan tür deque.

typedef typename Allocator::reference reference;

Örnek

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}
The first element is 10
The second element is 20

rend

Ters çevrilmiş dequebir içindeki son öğeyi başaran konumu ele alan bir yineleyici döndürür.

const_reverse_iterator rend() const;

reverse_iterator rend();

Dönüş Değeri

Ters çevrilmiş deque bir öğedeki son öğeyi (ters çevrilmemiş öğedeki ilk öğeden önce gelen konum) başarılı olan konumu ele alan ters rastgele erişim yineleyicisi deque.

Açıklamalar

rend, ile kullanıldığı gibi end ters çevrilmiş deque bir dequeile kullanılır.

değerinin dönüş değeri rend bir const_reverse_iteratordeque öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri rend bir reverse_iteratordeque öğesine atanmışsa, nesnesi değiştirilebilir.

rend ters yineleyicinin sonuna dequeulaşıp ulaşmadığını test etmek için kullanılabilir.

tarafından rend döndürülen değer başvurulmamalıdır.

Örnek

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}
The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

resize

için yeni bir dequeboyut belirtir.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parametreler

_Newsize
öğesinin dequeyeni boyutu.

val
Yeni boyut özgün boyuttan daha büyükse eklenecek deque yeni öğelerin değeri. Değer atlanırsa, yeni öğelere sınıfı için varsayılan değer atanır.

Açıklamalar

'sizeler değerinden deque_Newsizeküçükse, boyutuna _Newsizeulaşana deque kadar öğeleri öğesine eklenir.

'sizeler değerinden _Newsizedequebüyükse, sonuna deque en yakın öğeler boyutuna _Newsizeulaşana deque kadar silinir.

öğesinin deque mevcut boyutu ile aynıysa _Newsizehiçbir işlem yapılmaz.

size geçerli boyutunu dequeyansıtır.

Örnek

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}
The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

reverse_iterator

Ters çevrilmiş dequeiçindeki bir öğeyi okuyabilen veya değiştirebilen rastgele erişim yineleyicisi sağlayan bir tür.

typedef std::reverse_iterator<iterator> reverse_iterator;

Açıklamalar

aracılığıyla yinelemek dequeiçin bir tür reverse_iterator kullanılır.

Örnek

Rbegin örneğine bakın.

shrink_to_fit

Fazla kapasiteyi atar.

void shrink_to_fit();

Açıklamalar

tarafından kullanılan depolamanın azaltılıp azaltılamadığını shrink_to_fit saptamanın taşınabilir bir dequeyolu yoktur.

Örnek

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   //deque <int>::iterator Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}
Current size of v1 = 1
Current size of v1 = 1

size

içindeki dequeöğe sayısını döndürür.

size_type size() const;

Dönüş Değeri

geçerli uzunluğu deque.

Örnek

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}
The deque length is 1.
The deque length is now 2.

size_type

içindeki öğe sayısını sayan bir dequetür.

typedef typename Allocator::size_type size_type;

Örnek

örneğine sizebakın.

swap

İki deque öğesinin öğelerini değiştirir.

void swap(deque<Type, Allocator>& right);

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

Parametreler

right
deque Değiştirilecek öğeleri sağlayan veya deque öğeleri ile değiştirilecek dequeleftöğeleri.

left
deque öğeleri ile değiştirilecek dequerightolan.

Örnek

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}
The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

value_type

içinde depolanan veri türünü temsil eden bir dequetür.

typedef typename Allocator::value_type value_type;

Açıklamalar

value_type , şablon parametresinin Typeeş anlamlısıdır.

Örnek

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}
44

Ayrıca bkz.

C++ Standart Kitaplığında İş Parçacığı Güvenliği
C++ Standart Kitaplığı Başvurusu