`deque` Sınıf

Makale
10/12/2023

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 deque count kopyalanan bir öğe. Oluşturuculardan bazıları, öğeleri oluşturmak için özel allocator kullanmayı etkinleştirir.

Veri Akışı Adı	Açıklama
`deque`	bir `deque`oluş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 `deque`bir öğeden taşınan veya kopyalanan içerik; yineleyici kullanılarak kopyalanan veya taşınan içerik ve zamanlara `deque` `count` 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ı `allocator` `deque` 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 `deque` `const`tür.
`const_reference`	gibi okuma ve diğer işlemler `const`için içindeki bir `deque` öğeye başvuru sağlayan tür.
`const_reverse_iterator`	içindeki öğelere olarak erişebilen ve bu öğeleri `deque` `const`okuyabilen 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ı `deque`iç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 `deque`tü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 `deque`tür. `deque` ters sırada görüntülenir.
`size_type`	içindeki öğe sayısını sayan bir `deque`tür.
`value_type`	içinde depolanan veri türünü temsil eden bir `deque`tür.

İşlevler

Veri Akışı Adı	Açıklama
`assign`	öğesinden `deque` öğeleri siler ve hedef öğesine `deque`yeni bir öğe dizisi kopyalar.
`at`	öğesinde belirtilen bir konumda `deque`öğesine başvuru döndürür.
`back`	öğesinin son öğesine `deque`başvuru döndürür.
`begin`	içindeki ilk öğeyi ele alan rastgele erişim yineleyicisi `deque`döndürür.
`cbegin`	içindeki ilk öğeye `deque`bir `const` yineleyici döndürür.
`cend`	öğesinin sonunun hemen ötesine işaret eden rastgele erişim `const` yineleyicisi `deque`döndürür.
`clear`	öğesinin `deque`tü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 `deque`yerinde bir öğe ekler.
`emplace_front`	öğesinin başlangıcına `deque`yerinde bir öğe ekler.
`empty`	`deque` sıfır öğe içeriyorsa ve `false` bir veya daha fazla öğe içeriyorsa döndürür`true`.
`end`	öğesinin sonunun hemen ötesine işaret eden rastgele erişim yineleyicisi `deque`döndürür.
`erase`	Belirtilen konumlardan bir öğeyi veya öğe `deque` aralığını kaldırır.
`front`	içindeki ilk öğeye başvuru `deque`döndürür.
`get_allocator`	nesnesini oluşturmak `allocator` için kullanılan nesnesinin `deque`bir 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 `deque`döndürür.
`pop_back`	öğesinin sonundaki `deque`öğesini siler.
`pop_front`	öğesinin başındaki `deque`öğesini siler.
`push_back`	öğesinin sonuna `deque`bir öğe ekler.
`push_front`	öğesinin başlangıcına `deque`bir öğesi ekler.
`rbegin`	Ters çevrilmiş `deque`içindeki ilk öğeye rastgele erişim yineleyicisi döndürür.
`rend`	Ters çevrilmiş `deque`bir içindeki son öğenin hemen ötesine işaret eden rastgele erişim yineleyicisi döndürür.
`resize`	için yeni bir `deque`boyut 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 `deque`bir 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 const dequeiş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 deque Rightbir kopyasını belirtir.

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

Yedinci oluşturucu öğesini deque Righttaşı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.

Ö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 deque leftöğeleri.

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

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

Ayrıca bkz.

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

Aracılığıyla paylaş

deque Sınıf

Sözdizimi

Parametreler

Açıklamalar

Üyeler

Oluşturucular

Tür tanımları

İşlevler

İşleçler

allocator_type

Açıklamalar

Örnek

assign

Parametreler

Açıklamalar

Örnek

at

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

back

Dönüş Değeri

Açıklamalar

Örnek

begin

Dönüş Değeri

Açıklamalar

Örnek

cbegin

Dönüş Değeri

Açıklamalar

cend

Dönüş Değeri

Açıklamalar

clear

Örnek

const_iterator

Açıklamalar

Örnek

const_pointer

Açıklamalar

const_reference

Açıklamalar

Örnek

const_reverse_iterator

Açıklamalar

Örnek

crbegin

Dönüş Değeri

Açıklamalar

Örnek

crend

Dönüş Değeri

Açıklamalar

Örnek

deque

Parametreler

Açıklamalar

Örnek

difference_type

Açıklamalar

Örnek

emplace

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

emplace_back

Parametreler

Örnek

emplace_front

Parametreler

Örnek

empty

Dönüş Değeri

Örnek

end

Dönüş Değeri

`deque` Sınıf

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`