`deque`-klass

Ordnar element av en viss typ i ett linjärt arrangemang och möjliggör, precis som en vektor, snabb slumpmässig åtkomst till alla element samt effektiv infogning och borttagning på baksidan av containern. Men till skillnad från en vektor stöder klassen deque också effektiv infogning och borttagning längst fram i containern.

Syntax

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

Parametrar

Type
Den elementdatatyp som ska lagras i deque.

Allocator
Den typ som representerar det lagrade allokeringsobjektet som kapslar in information om dequeallokering och frigör minne. Det här argumentet är valfritt och standardvärdet är allocator<Type>.

Anmärkningar

Valet av containertyp bör i allmänhet baseras på vilken typ av sökning och infogning som krävs av programmet. Vectors bör vara den föredragna containern för att hantera en sekvens när slumpmässig åtkomst till ett element är premium och infogningar eller borttagningar av element endast krävs i slutet av en sekvens. Prestandan för listcontainern är överlägsen när effektiva infogningar och borttagningar (i konstant tid) på valfri plats i sekvensen är premium. Sådana åtgärder i mitten av sekvensen kräver elementkopior och tilldelningar som är proportionella mot antalet element i sekvensen (linjär tid).

Deque omfördelning sker när en medlemsfunktion måste infoga eller radera element i sekvensen:

Om ett element infogas i en tom sekvens, eller om ett element raderas för att lämna en tom sekvens, returneras iteratorerna tidigare av begin och end bli ogiltiga.
Om ett element infogas vid den första positionen för dequeblir alla iteratorer, men inga referenser, som anger befintliga element ogiltiga.
Om ett element infogas i slutet av dequeblir end och alla iteratorer, men inga referenser, som anger befintliga element ogiltiga.
Om ett element raderas längst fram i dequeblir bara iteratorn och referenserna till det borttagna elementet ogiltiga.
Om det sista elementet raderas från slutet av dequeblir bara iteratorn till det sista elementet och referenser till det borttagna elementet ogiltiga.

Annars ogiltigförklaras alla iteratorer och referenser om du infogar eller raderar ett element.

Medlemmar

Konstruktörer

Namn Beskrivning

deque Konstruerar en deque. Flera konstruktorer tillhandahålls för att konfigurera innehållet i den nya deque på olika sätt: tom; läses in med ett angivet antal tomma element. innehåll som flyttats eller kopierats från en annan deque; innehåll som kopierats eller flyttats med hjälp av en iterator. och ett element som kopierats till dequecount gånger. Vissa konstruktorer aktiverar med hjälp av en anpassad allocator för att skapa element.

Namn	Beskrivning
`deque`	Konstruerar en `deque`. Flera konstruktorer tillhandahålls för att konfigurera innehållet i den nya `deque` på olika sätt: tom; läses in med ett angivet antal tomma element. innehåll som flyttats eller kopierats från en annan `deque`; innehåll som kopierats eller flyttats med hjälp av en iterator. och ett element som kopierats till `dequecount` gånger. Vissa konstruktorer aktiverar med hjälp av en anpassad `allocator` för att skapa element.

Typedefs

Namn	Beskrivning
`allocator_type`	En typ som representerar klassen `allocator` för objektet `deque`.
`const_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan komma åt och läsa element i `deque` som `const`
`const_pointer`	En typ som ger en pekare till ett element i en `deque` som `const`.
`const_reference`	En typ som ger en referens till ett element i en `deque` för läsning och andra åtgärder som `const`.
`const_reverse_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan komma åt och läsa element i `deque` som `const`. `deque` visas i omvänd ordning. Mer information finns i `reverse_iterator` Class
`difference_type`	En typ som ger skillnaden mellan två iteratorer med slumpmässig åtkomst som refererar till element i samma `deque`.
`iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en `deque`.
`pointer`	En typ som ger en pekare till ett element i en `deque`.
`reference`	En typ som innehåller en referens till ett element som lagras i en `deque`.
`reverse_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra ett element i en `deque`. `deque` visas i omvänd ordning.
`size_type`	En typ som räknar antalet element i en `deque`.
`value_type`	En typ som representerar datatypen som lagras i en `deque`.

Funktioner

Namn	Beskrivning
`assign`	Raderar element från en `deque` och kopierar en ny sekvens med element till målet `deque`.
`at`	Returnerar en referens till elementet på en angiven plats i `deque`.
`back`	Returnerar en referens till det sista elementet i `deque`.
`begin`	Returnerar en iterator med slumpmässig åtkomst som adresserar det första elementet i `deque`.
`cbegin`	Returnerar en `const` iterator till det första elementet i `deque`.
`cend`	Returnerar en `const` iterator med slumpmässig åtkomst som pekar precis utanför slutet av `deque`.
`clear`	Raderar alla element i en `deque`.
`crbegin`	Returnerar en `const` iterator för slumpmässig åtkomst till det första elementet i en `deque` visas i omvänd ordning.
`crend`	Returnerar en `const` iterator för slumpmässig åtkomst till det första elementet i en `deque` visas i omvänd ordning.
`emplace`	Infogar ett element som är konstruerat på plats i `deque` vid en angiven position.
`emplace_back`	Lägger till ett element som är konstruerat på plats i slutet av `deque`.
`emplace_front`	Lägger till ett element som är konstruerat på plats i början av `deque`.
`empty`	Returnerar `true` om `deque` innehåller noll element och `false` om den innehåller ett eller flera element.
`end`	Returnerar en iterator för slumpmässig åtkomst som pekar precis utanför slutet av `deque`.
`erase`	Tar bort ett element eller ett område med element i en `deque` från angivna positioner.
`front`	Returnerar en referens till det första elementet i en `deque`.
`get_allocator`	Returnerar en kopia av det `allocator` objekt som används för att konstruera `deque`.
`insert`	Infogar ett element, flera element eller ett område med element i `deque` på en angiven position.
`max_size`	Returnerar den maximala möjliga längden på `deque`.
`pop_back`	Tar bort elementet i slutet av `deque`.
`pop_front`	Tar bort elementet i början av `deque`.
`push_back`	Lägger till ett element i slutet av `deque`.
`push_front`	Lägger till ett element i början av `deque`.
`rbegin`	Returnerar en iterator med slumpmässig åtkomst till det första elementet i en omvänd `deque`.
`rend`	Returnerar en iterator för slumpmässig åtkomst som pekar precis utanför det sista elementet i en omvänd `deque`.
`resize`	Anger en ny storlek för en `deque`.
`shrink_to_fit`	Tar bort överkapacitet.
`size`	Returnerar antalet element i `deque`.
`swap`	Utbyter elementen i två `deque`s.

Operatörer

Namn	Beskrivning
`operator[]`	Returnerar en referens till elementet `deque` på en angiven position.
`operator=`	Ersätter elementen i `deque` med en kopia av en annan `deque`.

`allocator_type`

En typ som representerar allokeringsklassen för deque-objektet.

typedef Allocator allocator_type;

Anmärkningar

allocator_type är synonymt med mallparametern Allocator.

Exempel

Se exemplet för get_allocator.

`assign`

Raderar element från en deque och kopierar en ny uppsättning element till målet deque.

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

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

void assign(initializer_list<Type> IList);

Parametrar

First
Positionen för det första elementet i området med element som ska kopieras från argumentet deque.

Last
Positionen för det första elementet utanför intervallet för element som ska kopieras från argumentet deque.

Count
Antalet kopior av ett element som infogas i deque.

Val
Värdet för elementet som infogas i deque.

IList
Den initializer_list infogas i deque.

Anmärkningar

När befintliga element i målet deque har raderats infogar assign antingen ett angivet område med element från den ursprungliga deque eller från någon annan deque i mål dequeeller infogar kopior av ett nytt element av ett angivet värde i mål deque.

Exempel

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

Returnerar en referens till elementet på en angiven plats i deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parametrar

pos
Det nedsänkta (eller positionsnummer) för elementet som ska refereras till i deque.

Returvärde

Om pos är större än storleken på dequegenererar at ett undantag.

Anmärkningar

Om returvärdet för at har tilldelats till en const_referencekan deque-objektet inte ändras. Om returvärdet för at tilldelas till en referencekan deque-objektet ändras.

Exempel

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

Returnerar en referens till det sista elementet i deque.

reference back();
const_reference back() const;

Returvärde

Det sista elementet i deque. Om deque är tom är returvärdet odefinierat.

Anmärkningar

Om returvärdet för back har tilldelats till en const_referencekan deque-objektet inte ändras. Om returvärdet för back tilldelas till en referencekan deque-objektet ändras.

När du kompileras med hjälp av _ITERATOR_DEBUG_LEVEL definierat som 1 eller 2 uppstår ett körningsfel om du försöker komma åt ett element i en tom deque. Mer information finns i Kontrollerade iteratorer.

Exempel

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

Returnerar en iterator som adresserar det första elementet i deque.

const_iterator begin() const;
iterator begin();

Returvärde

En iterator med slumpmässig åtkomst som adresserar det första elementet i deque eller till platsen som lyckas med en tom deque.

Anmärkningar

Om returvärdet för begin har tilldelats till en const_iteratorkan deque-objektet inte ändras. Om returvärdet för begin har tilldelats till en iteratorkan deque-objektet ändras.

Exempel

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

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const iterator för slumpmässig åtkomst som pekar på det första elementet i intervallet eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En iterator med slumpmässig åtkomst som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

// i2 is Container<T>::const_iterator

Värdet som returneras av cend ska inte derefereras.

`clear`

Raderar alla element i en deque.

void clear();

Exempel

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

En typ som ger en iterator med slumpmässig åtkomst som kan komma åt och läsa ett const-element i deque.

typedef implementation-defined const_iterator;

Anmärkningar

En typ const_iterator kan inte användas för att ändra värdet för ett element.

Exempel

Se exemplet för back.

`const_pointer`

Ger en pekare till ett const-element i en deque.

typedef typename Allocator::const_pointer const_pointer;

Anmärkningar

En typ const_pointer kan inte användas för att ändra värdet för ett element. En iterator används oftare för att komma åt ett deque element.

`const_reference`

En typ som innehåller en referens till ett const element som lagras i en deque för att läsa och utföra const åtgärder.

typedef typename Allocator::const_reference const_reference;

Anmärkningar

En typ const_reference kan inte användas för att ändra värdet för ett element.

Exempel

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

En typ som ger en iterator med slumpmässig åtkomst som kan läsa alla const element i deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Anmärkningar

En typ const_reverse_iterator inte kan ändra värdet för ett element och används för att iterera genom deque i omvänd ordning.

Exempel

Se exemplet för rbegin för ett exempel på hur du deklarerar och använder en iterator.

`crbegin`

Returnerar en const iterator till det första elementet i en omvänd deque.

const_reverse_iterator crbegin() const;

Returvärde

En const omvänd iterator för slumpmässig åtkomst som hanterar det första elementet i en omvänd deque eller som tar upp vad som hade varit det sista elementet i den oreverserade deque.

Anmärkningar

Med returvärdet för crbeginkan deque-objektet inte ändras.

Exempel

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

Returnerar en const iterator som adresserar platsen som lyckades med det sista elementet i en omvänd deque.

const_reverse_iterator crend() const;

Returvärde

En const omvänd iterator för slumpmässig åtkomst som adresserar platsen som lyckades med det sista elementet i en omvänd deque (platsen som hade föregått det första elementet i den oreverserade deque).

Anmärkningar

crend används med omvända deque precis som array::cend används med en deque.

Med returvärdet för crend (lämpligt minskas) kan deque-objektet inte ändras.

crend kan användas för att testa om en omvänd iterator har nått slutet av sin deque.

Värdet som returneras av crend ska inte derefereras.

Exempel

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

Konstruerar en deque av en viss storlek, eller med element av ett visst värde, eller med en specifik allokerare, eller som en kopia av hela eller delar av någon annan deque.

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

Parametrar

Al
Allokeringsklassen som ska användas med det här objektet.

Count
Antalet element i den konstruerade deque.

Val
Värdet för elementen i den konstruerade deque.

Right
Den deque som den konstruerade deque ska vara en kopia av.

First
Positionen för det första elementet i området med element som ska kopieras.

Last
Positionen för det första elementet utanför det område med element som ska kopieras.

IList
Den initializer_list som ska kopieras.

Anmärkningar

Alla konstruktorer lagrar ett allokeringsobjekt (Al) och initierar deque.

De två första konstruktorerna anger en tom inledande deque; den andra anger också den allokeringstyp (_Al) som ska användas.

Den tredje konstruktorn anger en upprepning av ett angivet tal (count) av element i standardvärdet för klassen Type.

Den fjärde och femte konstruktorn anger en upprepning av (Count) element av värdet val.

Den sjätte konstruktorn anger en kopia av dequeRight.

De sjunde och åttonde konstruktorerna kopierar intervallet [First, Last) för en deque.

Den sjunde konstruktorn flyttar dequeRight.

Den åttonde konstruktorn kopierar innehållet i en initializer_list.

Ingen av konstruktorerna utför några interimistiska omfördelningar.

Exempel

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

En typ som ger skillnaden mellan två iteratorer som refererar till element inom samma deque.

typedef typename Allocator::difference_type difference_type;

Anmärkningar

En difference_type kan också beskrivas som antalet element mellan två pekare.

Exempel

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

Infogar ett element som är konstruerat på plats i deque vid en angiven position.

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

Parametrar

_Where
Positionen i deque där det första elementet infogas.

val
Värdet för elementet som infogas i deque.

Returvärde

Funktionen returnerar en iterator som pekar på positionen där det nya elementet infogades i deque.

Anmärkningar

Alla infogningsåtgärder kan vara dyra, se deque för en diskussion om deque prestanda.

Exempel

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

Lägger till ett element som är konstruerat på plats i slutet av deque.

void emplace_back(Type&& val);

Parametrar

val
Elementet som har lagts till i slutet av deque.

Exempel

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

Lägger till ett element som är konstruerat på plats i slutet av deque.

void emplace_front(Type&& val);

Parametrar

val
Elementet som lades till i början av deque.

Exempel

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

Testar om en deque är tom.

bool empty() const;

Returvärde

true om deque är tom. false om deque inte är tom.

Exempel

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

Returnerar en iterator som adresserar platsen som lyckades med det sista elementet i en deque.

const_iterator end() const;

iterator end();

Returvärde

En iterator med slumpmässig åtkomst som adresserar platsen som lyckades med det sista elementet i en deque. Om deque är tom deque::end == deque::begin.

Anmärkningar

end används för att testa om en iterator har nått slutet av sin deque.

Exempel

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

Tar bort ett element eller ett område med element i en deque från angivna positioner.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parametrar

_Where
Positionen för elementet som ska tas bort från deque.

first
Positionen för det första elementet som tagits bort från deque.

last
Placera precis utanför det sista elementet som togs bort från deque.

Returvärde

En iterator med slumpmässig åtkomst som anger det första elementet som finns kvar utöver alla element som tas bort, eller en pekare till slutet av deque om det inte finns något sådant element.

Anmärkningar

erase utlöser aldrig ett undantag.

Exempel

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

Returnerar en referens till det första elementet i en deque.

reference front();

const_reference front() const;

Returvärde

Om deque är tom är returen odefinierad.

Anmärkningar

Om returvärdet för front har tilldelats till en const_referencekan deque-objektet inte ändras. Om returvärdet för front tilldelas till en referencekan deque-objektet ändras.

Exempel

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

Returnerar en kopia av allokeringsobjektet som används för att konstruera deque.

Allocator get_allocator() const;

Returvärde

Allokeraren som används av deque.

Anmärkningar

Allokerare för klassen deque anger hur klassen hanterar lagring. Standardallokeringsprogrammen som levereras med C++ Standard Library-containerklasser räcker för de flesta programmeringsbehov. Att skriva och använda din egen allokeringsklass är ett avancerat C++-ämne.

Exempel

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

Infogar ett element eller ett antal element eller ett område med element i deque på en angiven position.

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

Parametrar

Where
Positionen i målet deque där det första elementet infogas.

Val
Värdet för elementet som infogas i deque.

Count
Antalet element som infogas i deque.

First
Positionen för det första elementet i elementområdet i argumentet deque kopieras.

Last
Positionen för det första elementet utöver elementintervallet i argumentet deque kopieras.

IList
initializer_list av element som ska infogas.

Returvärde

De två första infogningsfunktionerna returnerar en iterator som pekar på den position där det nya elementet infogades i deque.

Anmärkningar

Alla infogningsåtgärder kan vara dyra.

`iterator`

En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en deque.

typedef implementation-defined iterator;

Anmärkningar

En typ iterator kan användas för att ändra värdet för ett element.

Exempel

Se exemplet för begin.

`max_size`

Returnerar den maximala längden på deque.

size_type max_size() const;

Returvärde

Den maximala möjliga längden på deque.

Exempel

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

Returnerar en referens till elementet deque på en angiven position.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parametrar

pos
Positionen för det deque element som ska refereras till.

Returvärde

En referens till elementet vars position anges i argumentet. Om den angivna positionen är större än storleken på dequeär resultatet odefinierat.

Anmärkningar

Om returvärdet för operator[] har tilldelats till en const_referencekan deque-objektet inte ändras. Om returvärdet för operator[] tilldelas till en referencekan deque-objektet ändras.

När du kompileras med hjälp av _ITERATOR_DEBUG_LEVEL definierat som 1 eller 2 uppstår ett körningsfel om du försöker komma åt ett element utanför gränserna för deque. Mer information finns i Kontrollerade iteratorer.

Exempel

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

Ersätter elementen i den här deque med hjälp av elementen från en annan deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parametrar

right
Den deque som innehåller det nya innehållet.

Anmärkningar

Den första åsidosättningen kopierar element till den här deque från right, tilldelningens källa. Den andra åsidosättningen flyttar element till den här deque från right.

Element som finns i den här deque innan operatorn körs tas bort.

Exempel

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

Ger en pekare till ett element i en deque.

typedef typename Allocator::pointer pointer;

Anmärkningar

En typ pointer kan användas för att ändra värdet för ett element. En iterator används oftare för att komma åt ett deque element.

`pop_back`

Tar bort elementet i slutet av deque.

void pop_back();

Anmärkningar

Det sista elementet får inte vara tomt. pop_back utlöser aldrig ett undantag.

Exempel

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

Tar bort elementet i början av deque.

void pop_front();

Anmärkningar

Det första elementet får inte vara tomt. pop_front utlöser aldrig ett undantag.

Exempel

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

Lägger till ett element i slutet av deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parametrar

val
Elementet som har lagts till i slutet av deque.

Anmärkningar

Om ett undantag utlöses lämnas deque oförändrad och undantaget ändras.

`push_front`

Lägger till ett element i början av deque.

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

Parametrar

val
Elementet som lades till i början av deque.

Anmärkningar

Om ett undantag utlöses lämnas deque oförändrad och undantaget ändras.

Exempel

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

Returnerar en iterator till det första elementet i en omvänd deque.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Returvärde

En omvänd iterator med slumpmässig åtkomst som adresserar det första elementet i en omvänd deque eller som tar itu med vad som hade varit det sista elementet i den oreverserade deque.

Anmärkningar

rbegin används med omvända deque precis som begin används med en deque.

Om returvärdet för rbegin har tilldelats till en const_reverse_iteratorkan deque-objektet inte ändras. Om returvärdet för rbegin tilldelas till en reverse_iteratorkan deque-objektet ändras.

rbegin kan användas för att iterera genom en deque bakåt.

Exempel

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

En typ som innehåller en referens till ett element som lagras i en deque.

typedef typename Allocator::reference reference;

Exempel

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

Returnerar en iterator som adresserar platsen som lyckades det sista elementet i en omvänd deque.

const_reverse_iterator rend() const;

reverse_iterator rend();

Returvärde

En omvänd iterator för slumpmässig åtkomst som adresserar platsen som lyckades med det sista elementet i en omvänd deque (platsen som hade föregått det första elementet i det oreverserade deque).

Anmärkningar

rend används med omvända deque precis som end används med en deque.

Om returvärdet för rend har tilldelats till en const_reverse_iteratorkan deque-objektet inte ändras. Om returvärdet för rend tilldelas till en reverse_iteratorkan deque-objektet ändras.

rend kan användas för att testa om en omvänd iterator har nått slutet av sin deque.

Värdet som returneras av rend ska inte derefereras.

Exempel

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

Anger en ny storlek för en deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parametrar

_Newsize
Den nya storleken på deque.

val
Värdet för de nya element som ska läggas till i deque om den nya storleken är större än den ursprungliga storleken. Om värdet utelämnas tilldelas de nya elementen standardvärdet för klassen.

Anmärkningar

Om dequesize är mindre än _Newsizeläggs elementen till i deque tills den når storleken _Newsize.

Om dequesize är större än _Newsizetas elementen närmast slutet av deque bort tills deque når storleken _Newsize.

Om den nuvarande storleken på deque är samma som _Newsizevidtas ingen åtgärd.

size visar den aktuella storleken på deque.

Exempel

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

En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra ett element i en omvänd deque.

typedef std::reverse_iterator<iterator> reverse_iterator;

Anmärkningar

En typ reverse_iterator används för att iterera via deque.

Exempel

Se exemplet för rbegin.

`shrink_to_fit`

Tar bort överkapacitet.

void shrink_to_fit();

Anmärkningar

Det finns inget bärbart sätt att avgöra om shrink_to_fit minskar lagringen som används av en deque.

Exempel

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

Returnerar antalet element i deque.

size_type size() const;

Returvärde

Den aktuella längden på deque.

Exempel

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

En typ som räknar antalet element i en deque.

typedef typename Allocator::size_type size_type;

Exempel

Se exemplet för size.

`swap`

Utbyter elementen i två 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);

Parametrar

right
Den deque som tillhandahåller de element som ska bytas ut, eller deque vars element ska bytas ut mot elementen i dequeleft.

left
En deque vars element ska utbytas med elementen i dequeright.

Exempel

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

En typ som representerar datatypen som lagras i en deque.

typedef typename Allocator::value_type value_type;

Anmärkningar

value_type är synonymt med mallparametern Type.

Exempel

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

Se även

Trådsäkerhet i C++ Standard Library
C++ standardbiblioteksreferens

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-11-07

Dela via

deque-klass

Syntax

Parametrar

Anmärkningar

Medlemmar

Konstruktörer

Typedefs

Funktioner

Operatörer

allocator_type

Anmärkningar

Exempel

assign

Parametrar

Anmärkningar

Exempel

at

Parametrar

Returvärde

Anmärkningar

Exempel

back

Returvärde

Anmärkningar

Exempel

begin

Returvärde

Anmärkningar

Exempel

cbegin

Returvärde

Anmärkningar

cend

Returvärde

Anmärkningar

clear

Exempel

const_iterator

Anmärkningar

Exempel

const_pointer

Anmärkningar

const_reference

Anmärkningar

Exempel

const_reverse_iterator

Anmärkningar

Exempel

crbegin

Returvärde

Anmärkningar

Exempel

crend

Returvärde

Anmärkningar

Exempel

deque

Parametrar

Anmärkningar

Exempel

difference_type

Anmärkningar

Exempel

emplace

Parametrar

Returvärde

Anmärkningar

Exempel

emplace_back

Parametrar

Exempel

emplace_front

Parametrar

Exempel

empty

Returvärde

Exempel

end

Returvärde

`deque`-klass

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