`deque` Klasa

Artykuł
10/12/2023

Rozmieszcza elementy danego typu w układzie liniowym i, podobnie jak wektor, umożliwia szybki losowy dostęp do dowolnego elementu oraz wydajne wstawianie i usuwanie z tyłu kontenera. Jednak w przeciwieństwie do wektora deque klasa obsługuje również wydajne wstawianie i usuwanie z przodu kontenera.

Składnia

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

Parametry

Type
Typ danych elementu, który ma być przechowywany w obiekcie deque.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące dequealokacji i cofania przydziału pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<Type>.

Uwagi

Wybór typu kontenera powinien ogólnie być oparty o typ wyszukiwania i wstawiania wymagany przez aplikację. Vectors powinien być preferowanym kontenerem do zarządzania sekwencją, gdy losowy dostęp do dowolnego elementu znajduje się w warstwie Premium, a operacje wstawiania lub usuwania elementów są wymagane tylko na końcu sekwencji. Wydajność kontenera listy jest lepsza, gdy wydajne wstawiania i usuwania (w stałym czasie) w dowolnej lokalizacji w sekwencji są w warstwie Premium. Takie operacje w środku sekwencji wymagają kopiowania elementów i przypisań proporcjonalnych do liczby elementów w sekwencji (czas liniowy).

Deque reallocation występuje, gdy funkcja składowa musi wstawić lub wymazać elementy sekwencji:

Jeśli element zostanie wstawiony do pustej sekwencji lub jeśli element zostanie wymazany, aby pozostawić pustą sekwencję, iteratory wcześniej zwrócone przez begin i end staną się nieprawidłowe.
Jeśli element zostanie wstawiony na pierwszym miejscu dequeelementu , wszystkie iteratory, ale nie odwołania, które wyznaczają istniejące elementy, stają się nieprawidłowe.
Jeśli element zostanie wstawiony na końcu dequeelementu , i end wszystkie iteratory, ale bez odwołań, oznacza to, że istniejące elementy staną się nieprawidłowe.
Jeśli element jest wymazany z przodu dequeelementu , tylko iterator i odwołania do wymazanego elementu stają się nieprawidłowe.
Jeśli ostatni element zostanie wymazany z końca dequeelementu , tylko iterator do ostatniego elementu i odwołania do wymazanego elementu staną się nieprawidłowe.

W przeciwnym razie wstawianie lub wymazywanie elementu powoduje unieważnienie wszystkich iteratorów i odwołań.

Elementy członkowskie

Konstruktory

Nazwa/nazwisko opis

deque Tworzy element deque. Kilka konstruktorów jest dostępnych do skonfigurowania zawartości nowego deque na różne sposoby: puste; załadowane z określoną liczbą pustych elementów; zawartość przeniesiona lub skopiowana z innego deque; zawartość skopiowana lub przeniesiona przy użyciu iteratora; i jeden element skopiowany do dequecount czasów. Niektóre konstruktory umożliwiają tworzenie elementów przy użyciu niestandardowego allocator elementu.

Nazwa/nazwisko	opis
`deque`	Tworzy element `deque`. Kilka konstruktorów jest dostępnych do skonfigurowania zawartości nowego `deque` na różne sposoby: puste; załadowane z określoną liczbą pustych elementów; zawartość przeniesiona lub skopiowana z innego `deque`; zawartość skopiowana lub przeniesiona przy użyciu iteratora; i jeden element skopiowany do `dequecount` czasów. Niektóre konstruktory umożliwiają tworzenie elementów przy użyciu niestandardowego `allocator` elementu.

Typedefs

Nazwa/nazwisko	opis
`allocator_type`	Typ reprezentujący klasę `allocatordeque` dla obiektu.
`const_iterator`	Typ, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementów i odczytywać je jako `deque``const`
`const_pointer`	Typ, który dostarcza wskaźnik do elementu w `deque` obiekcie jako `const`.
`const_reference`	Typ, który zawiera odwołanie do elementu w `deque` elemencie do odczytu i innych operacji jako `const`.
`const_reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementów i odczytywać je w `deque` formacie `const`. Element `deque` jest wyświetlany odwrotnie. Aby uzyskać więcej informacji, zobacz `reverse_iterator` Klasa
`difference_type`	Typ, który zapewnia różnicę między dwoma iteratorami dostępu losowego, które odwołują się do elementów w tym samym obiekcie `deque`.
`iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w obiekcie `deque`.
`pointer`	Typ, który dostarcza wskaźnik do elementu w elemecie `deque`.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie `deque`.
`reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować element w obiekcie `deque`. Element `deque` jest wyświetlany w odwrotnej kolejności.
`size_type`	Typ, który zlicza liczbę elementów w obiekcie `deque`.
`value_type`	Typ reprezentujący typ danych przechowywany w obiekcie `deque`.

Funkcje

Nazwa/nazwisko	opis
`assign`	Usuwa elementy z elementu `deque` i kopiuje nową sekwencję elementów do elementu docelowego `deque`.
`at`	Zwraca odwołanie do elementu w określonej lokalizacji w elemencie `deque`.
`back`	Zwraca odwołanie do ostatniego elementu elementu .`deque`
`begin`	Zwraca iterator dostępu losowego odnoszący się do pierwszego elementu w elemecie `deque`.
`cbegin`	`const` Zwraca iterator do pierwszego elementu w obiekcie `deque`.
`cend`	Zwraca iterator dostępu losowego `const` , który wskazuje tuż poza końcem obiektu `deque`.
`clear`	Usuwa wszystkie elementy elementu `deque`.
`crbegin`	Zwraca iterator dostępu losowego `const` do pierwszego elementu w widoku w odwrotnej `deque` kolejności.
`crend`	Zwraca iterator dostępu losowego `const` do pierwszego elementu w widoku w odwrotnej `deque` kolejności.
`emplace`	Wstawia element skonstruowany w miejscu do `deque` obiektu w określonej pozycji.
`emplace_back`	Dodaje element skonstruowany na końcu elementu `deque`.
`emplace_front`	Dodaje element skonstruowany na początku elementu `deque`.
`empty`	Zwraca wartość `true` , jeśli `deque` element zawiera zero elementów, a `false` jeśli zawiera co najmniej jeden element.
`end`	Zwraca iterator dostępu losowego, który wskazuje tuż poza końcem obiektu `deque`.
`erase`	Usuwa element lub zakres elementów z `deque` określonych pozycji.
`front`	Zwraca odwołanie do pierwszego elementu w elemencie `deque`.
`get_allocator`	Zwraca kopię `allocator` obiektu, który jest używany do konstruowania obiektu `deque`.
`insert`	Wstawia element, kilka elementów lub zakres elementów do `deque` elementu w określonej pozycji.
`max_size`	Zwraca maksymalną możliwą długość obiektu `deque`.
`pop_back`	Usuwa element na końcu elementu `deque`.
`pop_front`	Usuwa element na początku elementu `deque`.
`push_back`	Dodaje element na końcu elementu `deque`.
`push_front`	Dodaje element na początku elementu `deque`.
`rbegin`	Zwraca iterator dostępu losowego do pierwszego elementu w odwróconym `deque`obiekcie .
`rend`	Zwraca iterator dostępu losowego, który wskazuje tuż poza ostatnim elementem odwróconego `deque`elementu .
`resize`	Określa nowy rozmiar elementu `deque`.
`shrink_to_fit`	Odrzuca nadmiarową pojemność.
`size`	Zwraca liczbę elementów w elem.`deque`
`swap`	Wymienia elementy dwóch `deque`s.

Operatory

Nazwa/nazwisko	opis
`operator[]`	Zwraca odwołanie do `deque` elementu w określonej pozycji.
`operator=`	Zastępuje elementy elementu `deque` kopią innego `deque`elementu .

`allocator_type`

Typ reprezentujący klasę alokatora deque dla obiektu.

typedef Allocator allocator_type;

Uwagi

allocator_type jest synonimem parametru Allocatorszablonu .

Przykład

Zobacz przykład dla elementu get_allocator.

`assign`

Usuwa elementy z elementu deque i kopiuje nowy zestaw elementów do elementu docelowego deque.

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

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

void assign(initializer_list<Type> IList);

Parametry

First
Pozycja pierwszego elementu w zakresie elementów do skopiowania z argumentu deque.

Last
Pozycja pierwszego elementu poza zakresem elementów do skopiowania z argumentu deque.

Count
Liczba kopii elementu wstawionego do elementu deque.

Val
Wartość elementu wstawionego do elementu deque.

IList
Wstawiany initializer_list element do pliku deque.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie docelowym deque wstawia określony zakres elementów z oryginalnego deque lub z innego deque elementu do elementu docelowego lub wstawia kopie nowego elementu określonej wartości do elementu docelowego dequedeque. assign

Przykład

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

Zwraca odwołanie do elementu w określonej lokalizacji w elemencie deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parametry

pos
Indeks dolny (lub numer położenia) elementu do odwołania w elemencie deque.

Wartość zwracana

Jeśli pos wartość jest większa niż rozmiar obiektu deque, at zgłasza wyjątek.

Uwagi

Jeśli zwracana wartość at elementu jest przypisana do const_referenceobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana at obiektu jest przypisana do referenceobiektu , deque można go zmodyfikować.

Przykład

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

Zwraca odwołanie do ostatniego elementu elementu .deque

reference back();
const_reference back() const;

Wartość zwracana

Ostatni element elementu .deque deque Jeśli wartość jest pusta, wartość zwracana jest niezdefiniowana.

Uwagi

Jeśli zwracana wartość back elementu jest przypisana do const_referenceobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana back obiektu jest przypisana do referenceobiektu , deque można go zmodyfikować.

Podczas kompilowania przy użyciu _ITERATOR_DEBUG_LEVEL wartości zdefiniowanej jako 1 lub 2 wystąpi błąd środowiska uruchomieniowego, jeśli spróbujesz uzyskać dostęp do elementu w pustym dequeelemecie . Aby uzyskać więcej informacji, zobacz Sprawdzone iteratory .

Przykład

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

Zwraca iterator odnoszący się do pierwszego elementu w elemecie deque.

const_iterator begin() const;
iterator begin();

Wartość zwracana

Iterator dostępu losowego odnoszący się do pierwszego elementu w deque lokalizacji lub kończy się powodzeniem pustego dequeelementu .

Uwagi

Jeśli zwracana wartość begin elementu jest przypisana do const_iteratorobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana begin elementu jest przypisana do iteratorobiektu , deque można go zmodyfikować.

Przykład

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

const Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

Iterator dostępu swobodnego, który wskazuje tuż za koniec zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

`clear`

Usuwa wszystkie elementy elementu deque.

void clear();

Przykład

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

Typ, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementu i odczytywać go const w elemecie deque.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Przykład

Zobacz przykład dla elementu back.

`const_pointer`

Dostarcza wskaźnik do const elementu w elemecie deque.

typedef typename Allocator::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu. Element iterator jest częściej używany do uzyskiwania deque dostępu do elementu.

`const_reference`

Typ, który zawiera odwołanie do elementu przechowywanego const w deque obiekcie do odczytu i wykonywania const operacji.

typedef typename Allocator::const_reference const_reference;

Uwagi

Nie można użyć typu const_reference do modyfikowania wartości elementu.

Przykład

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

Typ, który udostępnia iterator dostępu losowego, który może odczytywać dowolny const element w obiekcie deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania w odwrotnej deque części.

Przykład

Zapoznaj się z przykładem rbegin sposobu deklarowania i używania iteratora.

`crbegin`

const Zwraca iterator do pierwszego elementu w odwróconym dequeobiekcie .

const_reverse_iterator crbegin() const;

Wartość zwracana

Odwrotny const iterator dostępu losowego odnoszący się do pierwszego elementu w odwróconym deque lub odnoszącym się do tego, co było ostatnim elementem w niewróceniu deque.

Uwagi

Przy użyciu wartości zwracanej crbegindeque obiektu nie można modyfikować.

Przykład

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

const Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie deque.

const_reverse_iterator crend() const;

Wartość zwracana

const Iterator odwrotnego dostępu losowego, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym deque elemecie (lokalizacja, która poprzedzała pierwszy element w niewróconym elemecie deque).

Uwagi

crend jest używany z odwróconym deque elementem, tak jak array::cend jest używany z elementem deque.

Przy użyciu wartości zwracanej crend (odpowiednio zdekrementowanej) deque nie można zmodyfikować obiektu.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego deque.

Wartość zwracana przez crend nie powinna być wyłuszczone.

Przykład

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

Konstruuje deque określony rozmiar lub elementy określonej wartości albo z określonym alokatorem albo kopią wszystkich lub części innych dequeelementów .

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);

Parametry

Al
Klasa alokatora do wykorzystania z tym obiektem.

Count
Liczba elementów w skonstruowanym dequeobiekcie .

Val
Wartość elementów w skonstruowanym dequeobiekcie .

Right
Element deque , którego konstrukcja deque ma być kopią.

First
Pozycja pierwszego elementu w zakresie elementów do skopiowania.

Last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

IList
Element initializer_list do skopiowania.

Uwagi

Wszystkie konstruktory przechowują obiekt alokatora (Al) i inicjują obiekt deque.

Pierwsze dwa konstruktory określają pusty początkowy ; dequedrugi określa również typ alokatora (_Al) do użycia.

Trzeci konstruktor określa powtórzenie określonej liczby (count) elementów wartości domyślnej dla klasy Type.

Czwarte i piąte konstruktory określają powtórzenieCount () elementów wartości val.

Szósty konstruktor określa kopię elementu dequeRight.

Siódme i ósme konstruktory kopiują zakres [First, Last)dequewartości .

Siódmy konstruktor przenosi element dequeRight.

Ósmy konstruktor kopiuje zawartość obiektu initializer_list.

Żaden z konstruktorów nie wykonuje żadnych tymczasowych reallocations.

Przykład

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

Typ, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów w ramach tego samego dequeelementu .

typedef typename Allocator::difference_type difference_type;

Uwagi

Element difference_type można również opisać jako liczbę elementów między dwoma wskaźnikami.

Przykład

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

Wstawia element skonstruowany w miejscu do deque obiektu w określonej pozycji.

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

Parametry

_Where
Położenie w miejscu, w deque którym jest wstawiany pierwszy element.

val
Wartość elementu wstawionego do elementu deque.

Wartość zwracana

Funkcja zwraca iterator wskazujący położenie, w którym nowy element został wstawiony do elementu deque.

Uwagi

Każda operacja wstawiania może być kosztowna, zobacz deque omówienie deque wydajności.

Przykład

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

Dodaje element skonstruowany na końcu elementu deque.

void emplace_back(Type&& val);

Parametry

val
Element dodany na końcu elementu deque.

Przykład

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

Dodaje element skonstruowany na końcu elementu deque.

void emplace_front(Type&& val);

Parametry

val
Element dodany na początku elementu deque.

Przykład

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

Sprawdza, czy element deque jest pusty.

bool empty() const;

Wartość zwracana

true jeśli wartość deque jest pusta; false jeśli element deque nie jest pusty.

Przykład

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

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie deque.

const_iterator end() const;

iterator end();

Wartość zwracana

Iterator dostępu losowego, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie deque. Jeśli wartość jest pusta deque , to deque::end == deque::begin.

Uwagi

end służy do testowania, czy iterator osiągnął koniec jego deque.

Przykład

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

Usuwa element lub zakres elementów z deque określonych pozycji.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parametry

_Where
Pozycja elementu, który ma zostać usunięty z elementu deque.

first
Pozycja pierwszego elementu usuniętego z elementu deque.

last
Pozycja tuż poza ostatnim elementem usuniętym z elementu deque.

Wartość zwracana

Iterator dostępu losowego, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub wskaźnik na końcu deque elementu , jeśli taki element nie istnieje.

Uwagi

erase nigdy nie zgłasza wyjątku.

Przykład

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

Zwraca odwołanie do pierwszego elementu w elemencie deque.

reference front();

const_reference front() const;

Wartość zwracana

deque Jeśli element jest pusty, zwracanie jest niezdefiniowane.

Uwagi

Jeśli zwracana wartość front elementu jest przypisana do const_referenceobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana front obiektu jest przypisana do referenceobiektu , deque można go zmodyfikować.

Przykład

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

Zwraca kopię obiektu alokatora używanego do konstruowania obiektu deque.

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez element deque.

Uwagi

Alokatory dla deque klasy określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora jest zaawansowanym tematem języka C++.

Przykład

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

Wstawia element lub kilka elementów lub zakres elementów do deque określonego położenia.

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);

Parametry

Where
Pozycja w miejscu docelowym deque , w którym wstawiono pierwszy element.

Val
Wartość elementu wstawionego do elementu deque.

Count
Liczba elementów wstawionych do elementu deque.

First
Pozycja pierwszego elementu w zakresie elementów w argumencie deque do skopiowania.

Last
Pozycja pierwszego elementu poza zakresem elementów w argumencie deque do skopiowania.

IList
initializer_list Elementy do wstawienia.

Wartość zwracana

Pierwsze dwie funkcje wstawiania zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do elementu deque.

Uwagi

Każda operacja wstawiania może być kosztowna.

`iterator`

Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w obiekcie deque.

typedef implementation-defined iterator;

Uwagi

iterator Typ może służyć do modyfikowania wartości elementu.

Przykład

Zobacz przykład dla elementu begin.

`max_size`

Zwraca maksymalną długość obiektu deque.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość obiektu deque.

Przykład

// 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[]`

Zwraca odwołanie do deque elementu w określonej pozycji.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parametry

pos
Położenie deque elementu do przywołowania.

Wartość zwracana

Odwołanie do elementu, którego pozycja jest określona w argumencie. Jeśli określona pozycja jest większa niż rozmiar dequeelementu , wynik jest niezdefiniowany.

Uwagi

Jeśli zwracana wartość operator[] elementu jest przypisana do const_referenceobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana operator[] obiektu jest przypisana do referenceobiektu , deque można go zmodyfikować.

Podczas kompilacji przy użyciu _ITERATOR_DEBUG_LEVEL zdefiniowanej jako 1 lub 2 wystąpi błąd środowiska uruchomieniowego, jeśli spróbujesz uzyskać dostęp do elementu poza granicami deque. Aby uzyskać więcej informacji, zobacz Sprawdzone iteratory .

Przykład

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

Zastępuje elementy tego deque elementu przy użyciu elementów z innego dequeelementu .

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parametry

right
Element deque , który udostępnia nową zawartość.

Uwagi

Pierwsza przesłonięć elementy do tej deque wartości z right, źródła przypisania. Drugie zastąpienie przenosi elementy do tego deque elementu z right.

Elementy zawarte w tym deque przed wykonaniem operatora zostaną usunięte.

Przykład

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

Dostarcza wskaźnik do elementu w elemecie deque.

typedef typename Allocator::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu. Element iterator jest częściej używany do uzyskiwania deque dostępu do elementu.

`pop_back`

Usuwa element na końcu elementu deque.

void pop_back();

Uwagi

Ostatni element nie może być pusty. pop_back nigdy nie zgłasza wyjątku.

Przykład

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

Usuwa element na początku elementu deque.

void pop_front();

Uwagi

Pierwszy element nie może być pusty. pop_front nigdy nie zgłasza wyjątku.

Przykład

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

Dodaje element na końcu elementu deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parametry

val
Element dodany na końcu elementu deque.

Uwagi

Jeśli zgłaszany jest wyjątek, deque pozostaje pozostawiony bez myślenia, a wyjątek zostanie ponownie zwrócony.

`push_front`

Dodaje element na początku elementu deque.

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

Parametry

val
Element dodany na początku elementu deque.

Uwagi

Jeśli zgłaszany jest wyjątek, deque pozostaje pozostawiony bez myślenia, a wyjątek zostanie ponownie zwrócony.

Przykład

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

Zwraca iterator do pierwszego elementu w odwróconym dequeobiekcie .

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dostępu losowego odnoszący się do pierwszego elementu w odwróconym deque lub odnoszącym się do tego, co było ostatnim elementem w niewróceniu deque.

Uwagi

rbegin jest używany z odwróconym deque elementem, tak jak begin jest używany z elementem deque.

Jeśli zwracana wartość rbegin elementu jest przypisana do const_reverse_iteratorobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana rbegin obiektu jest przypisana do reverse_iteratorobiektu , deque można go zmodyfikować.

rbegin może służyć do iterowania przez deque tyły.

Przykład

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

Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie deque.

typedef typename Allocator::reference reference;

Przykład

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

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie deque.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Iterator odwrotnego dostępu losowego, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym deque elemecie (lokalizacja, która poprzedzała pierwszy element w niewróconym elemecie deque).

Uwagi

rend jest używany z odwróconym deque elementem, tak jak end jest używany z elementem deque.

Jeśli zwracana wartość rend elementu jest przypisana do const_reverse_iteratorobiektu , deque nie można zmodyfikować obiektu. Jeśli wartość zwracana rend obiektu jest przypisana do reverse_iteratorobiektu , deque można go zmodyfikować.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego deque.

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

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

Określa nowy rozmiar elementu deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parametry

_Newsize
Nowy rozmiar obiektu deque.

val
Wartość nowych elementów, które mają zostać dodane do deque elementu , jeśli nowy rozmiar jest większy niż rozmiar oryginalny. Jeśli wartość zostanie pominięta, nowe elementy zostaną przypisane do wartości domyślnej klasy.

Uwagi

Jeśli wartość parametru jest mniejsza niż _Newsize, elementy są dodawane do deque elementu , dopóki nie osiągnie rozmiaru _Newsize.dequesize

Jeśli wartość parametru dequesize jest większa niż _Newsize, elementy znajdujące się najbliżej końca deque obiektu zostaną usunięte deque do momentu osiągnięcia rozmiaru _Newsize.

Jeśli obecny rozmiar obiektu deque jest taki sam jak _Newsize, nie zostanie podjęta żadna akcja.

size odzwierciedla bieżący rozmiar elementu deque.

Przykład

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

Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować element w odwróconym dequeobiekcie .

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator jest używany do iterowania przez element deque.

Przykład

Zobacz przykład rbegin.

`shrink_to_fit`

Odrzuca nadmiarową pojemność.

void shrink_to_fit();

Uwagi

Nie ma przenośnego sposobu określenia, czy shrink_to_fit zmniejsza ilość miejsca używanego przez program deque.

Przykład

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

Zwraca liczbę elementów w elem.deque

size_type size() const;

Wartość zwracana

Bieżąca długość obiektu deque.

Przykład

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

Typ, który zlicza liczbę elementów w obiekcie deque.

typedef typename Allocator::size_type size_type;

Przykład

Zobacz przykład dla elementu size.

`swap`

Wymienia elementy dwóch deques.

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);

Parametry

right
Podanie deque elementów do zamiany lub deque elementów, których elementy mają być wymieniane z elementami dequeleft.

left
Element, deque którego elementy mają być wymieniane z elementami dequeright.

Przykład

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

Typ reprezentujący typ danych przechowywany w obiekcie deque.

typedef typename Allocator::value_type value_type;

Uwagi

value_type jest synonimem parametru Typeszablonu .

Przykład

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

Zobacz też

Bezpieczeństwo wątku w standardowej bibliotece C++
Dokumentacja standardowej biblioteki C++

Share via

deque Klasa

Składnia

Parametry

Uwagi

Elementy członkowskie

Konstruktory

Typedefs

Funkcje

Operatory

allocator_type

Uwagi

Przykład

assign

Parametry

Uwagi

Przykład

at

Parametry

Wartość zwracana

Uwagi

Przykład

back

Wartość zwracana

Uwagi

Przykład

begin

Wartość zwracana

Uwagi

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

clear

Przykład

const_iterator

Uwagi

Przykład

const_pointer

Uwagi

const_reference

Uwagi

Przykład

const_reverse_iterator

Uwagi

Przykład

crbegin

Wartość zwracana

Uwagi

Przykład

crend

Wartość zwracana

Uwagi

Przykład

deque

Parametry

Uwagi

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Wartość zwracana

Uwagi

Przykład

emplace_back

Parametry

Przykład

emplace_front

Parametry

Przykład

empty

Wartość zwracana

Przykład

end

Wartość zwracana

`deque` Klasa

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