Classe `deque`

Articolo
10/12/2023

Organizza gli elementi di un determinato tipo in una disposizione lineare e, come un vettore, consente l'accesso casuale veloce a qualsiasi elemento e l'inserimento e l'eliminazione efficienti sul retro del contenitore. Tuttavia, a differenza di un vettore, la classe deque supporta anche l'inserimento e l'eliminazione efficiente davanti al contenitore.

Sintassi

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

Parametri

Type
Tipo di dati degli elementi da archiviare in deque.

Allocator
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli sull'allocazione dequee la deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<Type>.

Osservazioni:

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di inserimento richiesti dall'applicazione. Vectors deve essere il contenitore preferito per la gestione di una sequenza quando l'accesso casuale a qualsiasi elemento è premium e gli inserimenti o eliminazioni di elementi sono necessari solo alla fine di una sequenza. Le prestazioni del contenitore elenco sono superiori quando il numero di inserimenti ed eliminazioni efficienti (in tempo costante) in qualsiasi posizione all'interno della sequenza è limitato. Tali operazioni al centro della sequenza richiedono copie di elementi e assegnazioni proporzionali al numero di elementi della sequenza (tempo lineare).

Deque la riallocazione si verifica quando una funzione membro deve inserire o cancellare elementi della sequenza:

Se un elemento viene inserito in una sequenza vuota o se un elemento viene cancellato per lasciare una sequenza vuota, gli iteratori restituiti in precedenza da begin e end diventano non validi.
Se un elemento viene inserito alla prima posizione di deque, tutti gli iteratori, ma non i riferimenti, che designano gli elementi esistenti diventano non validi.
Se un elemento viene inserito alla fine di deque, end e tutti gli iteratori, ma nessun riferimento, che designano gli elementi esistenti diventano non validi.
Se un elemento viene cancellato nella parte anteriore di deque, solo l'iteratore e i riferimenti all'elemento cancellato diventano non validi.
Se l'ultimo elemento viene cancellato dalla fine di deque, solo l'iteratore all'elemento finale e fa riferimento all'elemento cancellato diventano non validi.

In caso contrario, l'inserimento o l'eliminazione di un elemento invalida tutti gli iteratori e i riferimenti.

Membri

Costruttori

Nome Descrizione

deque Costruisce un oggetto deque. Vengono forniti diversi costruttori per configurare il contenuto del nuovo deque in modi diversi: vuoto, caricato con un numero specificato di elementi vuoti, contenuto spostato o copiato da un altro deque; contenuto copiato o spostato usando un iteratore e un elemento copiato negli deque count orari. Alcuni costruttori consentono l'utilizzo di un allocator personalizzato per creare elementi.

Nome	Descrizione
`deque`	Costruisce un oggetto `deque`. Vengono forniti diversi costruttori per configurare il contenuto del nuovo `deque` in modi diversi: vuoto, caricato con un numero specificato di elementi vuoti, contenuto spostato o copiato da un altro `deque`; contenuto copiato o spostato usando un iteratore e un elemento copiato negli `deque` `count` orari. Alcuni costruttori consentono l'utilizzo di un `allocator` personalizzato per creare elementi.

Typedef

Nome	Descrizione
`allocator_type`	Tipo che rappresenta la classe `allocator` per l'oggetto `deque`.
`const_iterator`	Tipo che fornisce un iteratore ad accesso casuale che può avere accesso e leggere elementi nella `deque` come `const`.
`const_pointer`	Tipo che fornisce un puntatore a un elemento in un `deque` oggetto come `const`.
`const_reference`	Tipo che fornisce un riferimento a un elemento in un oggetto `deque` per la lettura e altre operazioni come `const`.
`const_reverse_iterator`	Tipo che fornisce un iteratore ad accesso casuale che può avere accesso e leggere elementi nella `deque` come `const`. L'oggetto `deque` viene visualizzato inverso. Per altre informazioni, vedere `reverse_iterator` Classe
`difference_type`	Tipo che fornisce la differenza tra due iteratori di accesso casuale che fanno riferimento agli elementi all'interno della stessa `deque`.
`iterator`	Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in una `deque`.
`pointer`	Tipo che fornisce un puntatore a un elemento in un `deque`.
`reference`	Tipo che fornisce un riferimento a un elemento archiviato in un `deque`.
`reverse_iterator`	Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare un elemento in una `deque`. L'oggetto `deque` viene visualizzato in ordine inverso.
`size_type`	Tipo che conta il numero di elementi in una `deque`.
`value_type`	Tipo che rappresenta il tipo di dati archiviati in un `deque`.

Funzioni

Nome	Descrizione
`assign`	Elimina gli elementi da una `deque` e copia una nuova sequenza di elementi nella `deque` di destinazione.
`at`	Restituisce un riferimento all'elemento in corrispondenza della posizione specificata nella `deque`.
`back`	Restituisce un riferimento all'ultimo elemento della `deque`.
`begin`	Restituisce un iteratore ad accesso casuale che punta al primo elemento nella `deque`.
`cbegin`	Restituisce un `const` iteratore al primo elemento dell'oggetto `deque`.
`cend`	Restituisce iteratore `const` ad accesso casuale che punta appena oltre la fine della `deque`.
`clear`	Cancella tutti gli elementi di un `deque`.
`crbegin`	Restituisce un iteratore ad accesso `const` casuale al primo elemento in un `deque` oggetto visualizzato in ordine inverso.
`crend`	Restituisce un iteratore ad accesso `const` casuale al primo elemento in un `deque` oggetto visualizzato in ordine inverso.
`emplace`	Inserisce un elemento costruito sul posto nella `deque` in una posizione specificata.
`emplace_back`	Aggiunge un elemento costruito sul posto alla fine della `deque`.
`emplace_front`	Aggiunge un elemento costruito sul posto all'inizio della `deque`.
`empty`	Restituisce `true` se la `deque` contiene zero elementi e `false` se contiene uno o più elementi.
`end`	Restituisce un iteratore ad accesso casuale che punta appena oltre la fine della `deque`.
`erase`	Rimuove un elemento o un intervallo di elementi in una `deque` da posizioni specificate.
`front`	Restituisce un riferimento al primo elemento in una `deque`.
`get_allocator`	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `deque`.
`insert`	Inserisce un elemento, diversi elementi, o un intervallo di elementi nella `deque` in una posizione specificata.
`max_size`	Restituisce la lunghezza massima possibile della `deque`.
`pop_back`	Cancella l'elemento alla fine della `deque`.
`pop_front`	Cancella l'elemento all'inizio della `deque`.
`push_back`	Aggiunge un elemento alla fine della `deque`.
`push_front`	Aggiunge un elemento all'inizio della `deque`.
`rbegin`	Restituisce un iteratore ad accesso casuale al primo elemento in una `deque` invertita.
`rend`	Restituisce un iteratore ad accesso casuale che punta appena oltre l'ultimo elemento di una `deque` invertita.
`resize`	Specifica una nuova dimensione per `deque`.
`shrink_to_fit`	Elimina la capacità in eccesso.
`size`	Restituisce il numero di elementi nel `deque`.
`swap`	Scambia gli elementi di due `deque`.

Operatori

Nome	Descrizione
`operator[]`	Restituisce un riferimento all'elemento `deque` in una posizione specificata.
`operator=`	Sostituisce gli elementi di una `deque` con una copia di un'altra `deque`.

`allocator_type`

Tipo che rappresenta la classe allocatore per l'oggetto deque .

typedef Allocator allocator_type;

Osservazioni:

allocator_type è un sinonimo per il parametro di modello Allocator.

Esempio

Vedere l'esempio per get_allocator.

`assign`

Cancella gli elementi da un deque oggetto e copia un nuovo set di elementi nella destinazione deque.

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

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

void assign(initializer_list<Type> IList);

Parametri

First
Posizione del primo elemento nell'intervallo di elementi da copiare dall'argomento deque.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare dall'argomento deque.

Count
Numero di copie di un elemento inserito nell'oggetto deque.

Val
Valore dell'elemento da inserire nell'oggetto deque.

IList
Oggetto initializer_list inserito nell'oggetto deque.

Osservazioni:

Dopo che tutti gli elementi esistenti nella destinazione vengono cancellati, assign inserisce un intervallo specificato di elementi dall'originale deque o da un altro deque elemento nella destinazione deque dequeoppure inserisce copie di un nuovo elemento di un valore specificato nella destinazione deque.

Esempio

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

Restituisce un riferimento all'elemento in corrispondenza della posizione specificata nella deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parametri

pos
Indice (o numero di posizione) dell'elemento a cui fare riferimento in deque.

Valore restituito

Se pos è maggiore delle dimensioni di deque, at genera un'eccezione.

Osservazioni:

Se il valore restituito di at viene assegnato a un const_referenceoggetto , l'oggetto deque non può essere modificato. Se il valore restituito di at viene assegnato a un referenceoggetto , l'oggetto deque può essere modificato.

Esempio

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

Restituisce un riferimento all'ultimo elemento della deque.

reference back();
const_reference back() const;

Valore restituito

Ultimo elemento dell'oggetto deque. Se è deque vuoto, il valore restituito non è definito.

Osservazioni:

Se il valore restituito di back viene assegnato a un const_referenceoggetto , l'oggetto deque non può essere modificato. Se il valore restituito di back viene assegnato a un referenceoggetto , l'oggetto deque può essere modificato.

Quando viene compilato usando _ITERATOR_DEBUG_LEVEL definito come 1 o 2, si verificherà un errore di runtime se si tenta di accedere a un elemento in un oggetto vuoto deque. Per altre informazioni, vedere Checked Iterators .

Esempio

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

Restituisce un iteratore che punta al primo elemento del deque.

const_iterator begin() const;
iterator begin();

Valore restituito

Iteratore ad accesso casuale che punta al primo elemento dell'oggetto deque o alla posizione successiva a un oggetto deque vuoto.

Osservazioni:

Se il valore restituito di begin viene assegnato a un const_iteratoroggetto , l'oggetto deque non può essere modificato. Se il valore restituito di begin viene assegnato a un iteratoroggetto , l'oggetto deque può essere modificato.

Esempio

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

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore ad accesso casuale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cend() const;

Valore restituito

Iteratore ad accesso casuale che punta oltre la fine dell'intervallo.

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

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

// i2 is Container<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato.

`clear`

Cancella tutti gli elementi di un deque.

void clear();

Esempio

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

Tipo che fornisce un iteratore ad accesso casuale che può accedere e leggere un const elemento in deque.

typedef implementation-defined const_iterator;

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per back.

`const_pointer`

Fornisce un puntatore a un const elemento in un oggetto deque.

typedef typename Allocator::const_pointer const_pointer;

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento. Un iterator oggetto viene usato più comunemente per accedere a un deque elemento .

`const_reference`

Tipo che fornisce un riferimento a un elemento const archiviato in un deque per la lettura e l'esecuzione di operazioni const.

typedef typename Allocator::const_reference const_reference;

Osservazioni:

Non è possibile usare un tipo const_reference per modificare il valore di un elemento.

Esempio

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

Tipo che fornisce un iteratore ad accesso casuale in grado di leggere qualsiasi const elemento in deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere l'oggetto deque inverso.

Esempio

Vedere l'esempio per rbegin un esempio di come dichiarare e usare un iteratore.

`crbegin`

Restituisce un const iteratore al primo elemento di un oggetto invertito deque.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore const ad accesso casuale inverso che punta al primo elemento in un oggetto deque invertito o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito deque.

Osservazioni:

Con il valore restituito di crbegin, l'oggetto deque non può essere modificato.

Esempio

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

Restituisce un const iteratore che punta alla posizione successiva all'ultimo elemento di un oggetto invertito deque.

const_reverse_iterator crend() const;

Valore restituito

Iteratore const ad accesso casuale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto deque il primo elemento nell'oggetto non invertito deque).

Osservazioni:

crend viene usato con un oggetto invertito deque esattamente come array::cend viene usato con un oggetto deque.

Con il valore restituito di crend (adeguato decrementato), l'oggetto deque non può essere modificato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine dell'oggetto deque.

Il valore restituito da crend non deve essere dereferenziato.

Esempio

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

Costruisce un deque oggetto di una dimensione specifica o con elementi di un valore specifico o con un allocatore specifico oppure come copia di tutti o parte di un altro dequeoggetto .

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

Parametri

Al
Classe Allocator da usare con questo oggetto.

Count
Numero di elementi nell'oggetto costruito deque.

Val
Valore degli elementi nell'oggetto costruito deque.

Right
Oggetto deque di cui l'oggetto deque costruito deve essere una copia.

First
Posizione del primo elemento nell'intervallo di elementi da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

IList
initializer_list da copiare.

Osservazioni:

Tutti i costruttori archiviano un oggetto allocatore (Al) e inizializzano .deque

I primi due costruttori specificano un oggetto iniziale dequevuoto. Il secondo specifica anche il tipo di allocatore (_Al) da usare.

Tramite il terzo costruttore viene specificata una ripetizione di un numero indicato (count) di elementi del valore predefinito per la classe Type.

Il quarto e il quinto costruttore specificano una ripetizione di elementi (Count) di valore val.

Il sesto costruttore specifica una copia dell'oggetto deque Right.

Il settimo e l'ottavo costruttore copiano l'intervallo [First, Last) di un oggetto deque.

Il settimo costruttore sposta .deque Right

L'ottavo costruttore copia il contenuto di un oggetto initializer_list.

Nessuno dei costruttori esegue riallocazioni provvisorie.

Esempio

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

Tipo che fornisce la differenza tra due iteratori che fanno riferimento agli elementi all'interno dello stesso deque.

typedef typename Allocator::difference_type difference_type;

Osservazioni:

Un oggetto difference_type può anche essere descritto come il numero di elementi tra due puntatori.

Esempio

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

Inserisce un elemento costruito sul posto nella deque in una posizione specificata.

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

Parametri

_Where
Posizione nell'oggetto in deque cui viene inserito il primo elemento.

val
Valore dell'elemento da inserire nell'oggetto deque.

Valore restituito

La funzione restituisce un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto deque.

Osservazioni:

Un'operazione di inserimento può essere dispendiosa. Vedere deque per informazioni sulle prestazioni dell'oggetto deque.

Esempio

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

Aggiunge un elemento costruito sul posto alla fine della deque.

void emplace_back(Type&& val);

Parametri

val
Elemento aggiunto alla fine dell'oggetto deque.

Esempio

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

Aggiunge un elemento costruito sul posto alla fine della deque.

void emplace_front(Type&& val);

Parametri

val
Elemento aggiunto all'inizio dell'oggetto deque.

Esempio

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

Verifica se un deque è vuoto.

bool empty() const;

Valore restituito

true se è deque vuoto; false se l'oggetto deque non è vuoto.

Esempio

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

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un deque.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore ad accesso casuale che punta alla posizione successiva all'ultimo elemento in un oggetto deque. Se l'oggetto deque è vuoto, deque::end == deque::begin.

Osservazioni:

end viene usato per verificare se un iteratore ha raggiunto la fine del relativo oggetto deque.

Esempio

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

Rimuove un elemento o un intervallo di elementi in una deque da posizioni specificate.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parametri

_Where
Posizione dell'elemento da rimuovere da deque.

first
Posizione del primo elemento rimosso da deque.

last
Posizione immediatamente successiva all'ultimo elemento rimosso da deque.

Valore restituito

Iteratore ad accesso casuale che definisce il primo elemento rimanente oltre qualsiasi elemento rimosso o un puntatore alla fine di deque se tale elemento non esiste.

Osservazioni:

erase non genera mai un'eccezione.

Esempio

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

Restituisce un riferimento al primo elemento in una deque.

reference front();

const_reference front() const;

Valore restituito

Se è deque vuoto, il valore restituito non è definito.

Osservazioni:

Se il valore restituito di front viene assegnato a un const_referenceoggetto , l'oggetto deque non può essere modificato. Se il valore restituito di front viene assegnato a un referenceoggetto , l'oggetto deque può essere modificato.

Esempio

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

Restituisce una copia dell'oggetto allocatore utilizzato per costruire l'oggetto deque.

Allocator get_allocator() const;

Valore restituito

Allocatore utilizzato dall'oggetto deque.

Osservazioni:

Gli allocatori per la deque classe specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti acclusi alle classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. Scrivere e usare una classe allocator personalizzata è un argomento di C++ avanzato.

Esempio

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

Inserisce un elemento o un numero di elementi o un intervallo di elementi in deque in una posizione specificata.

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

Parametri

Where
Posizione nella destinazione deque in cui viene inserito il primo elemento.

Val
Valore dell'elemento da inserire nell'oggetto deque.

Count
Numero di elementi inseriti nell'oggetto deque.

First
Posizione del primo elemento nell'intervallo di elementi nell'argomento deque da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi nell'argomento deque da copiare.

IList
Oggetto initializer_list degli elementi da inserire.

Valore restituito

Le prime due funzioni di inserimento restituiscono un iteratore che punta alla posizione in cui è stato inserito il nuovo elemento nell'oggetto deque.

Osservazioni:

Un'operazione di inserimento può essere dispendiosa.

`iterator`

Tipo che fornisce un iteratore ad accesso casuale che può leggere o modificare qualsiasi elemento in una deque.

typedef implementation-defined iterator;

Osservazioni:

È possibile utilizzare un tipo iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per begin.

`max_size`

Restituisce la lunghezza massima del deque.

size_type max_size() const;

Valore restituito

Lunghezza massima possibile dell'oggetto deque.

Esempio

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

Restituisce un riferimento all'elemento deque in una posizione specificata.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parametri

pos
Posizione dell'elemento deque a cui fare riferimento.

Valore restituito

Un riferimento all'elemento la cui posizione è specificata nell'argomento. Se la posizione specificata è maggiore delle dimensioni di deque, il risultato non è definito.

Osservazioni:

Se il valore restituito di operator[] viene assegnato a un const_referenceoggetto , l'oggetto deque non può essere modificato. Se il valore restituito di operator[] viene assegnato a un referenceoggetto , l'oggetto deque può essere modificato.

Quando viene compilato usando _ITERATOR_DEBUG_LEVEL definito come 1 o 2, si verificherà un errore di runtime se si tenta di accedere a un elemento al di fuori dei limiti di deque. Per altre informazioni, vedere Checked Iterators .

Esempio

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

Sostituisce gli elementi di utilizzando deque gli elementi di un altro dequeoggetto .

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parametri

right
Oggetto deque che fornisce il nuovo contenuto.

Osservazioni:

Il primo override copia gli elementi in questo deque da right, l'origine dell'assegnazione. Il secondo override sposta gli elementi in questo deque da right.

Gli elementi contenuti in questo deque oggetto prima dell'esecuzione dell'operatore vengono rimossi.

Esempio

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

Fornisce un puntatore a un elemento in un oggetto deque.

typedef typename Allocator::pointer pointer;

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento. Un iterator oggetto viene usato più comunemente per accedere a un deque elemento .

`pop_back`

Elimina l'elemento alla fine dell'oggetto deque.

void pop_back();

Osservazioni:

L'ultimo elemento non deve essere vuoto. pop_back non genera mai un'eccezione.

Esempio

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

Elimina l'elemento all'inizio di deque.

void pop_front();

Osservazioni:

Il primo elemento non deve essere vuoto. pop_front non genera mai un'eccezione.

Esempio

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

Aggiunge un elemento alla fine della deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parametri

val
Elemento aggiunto alla fine dell'oggetto deque.

Osservazioni:

Se viene generata un'eccezione, l'oggetto deque viene lasciato inalterato e viene nuovamente generata l'eccezione.

`push_front`

Aggiunge un elemento all'inizio di deque.

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

Parametri

val
Elemento aggiunto all'inizio dell'oggetto deque.

Osservazioni:

Se viene generata un'eccezione, l'oggetto deque viene lasciato inalterato e viene nuovamente generata l'eccezione.

Esempio

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

Restituisce un iteratore al primo elemento di un oggetto invertito deque.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore ad accesso casuale inverso che punta al primo elemento in un oggetto deque invertito o che punta a ciò che era stato l'ultimo elemento nell'oggetto non invertito deque.

Osservazioni:

rbegin viene usato con un oggetto invertito deque esattamente come begin viene usato con un oggetto deque.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto deque non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iteratoroggetto , l'oggetto deque può essere modificato.

rbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto deque.

Esempio

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

Tipo che fornisce un riferimento a un elemento archiviato in un deque.

typedef typename Allocator::reference reference;

Esempio

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

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un deque invertito.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Iteratore ad accesso casuale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto invertito (la posizione che aveva preceduto deque il primo elemento nell'oggetto non invertito deque).

Osservazioni:

rend viene usato con un oggetto invertito deque esattamente come end viene usato con un oggetto deque.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto deque non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iteratoroggetto , l'oggetto deque può essere modificato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo deque.

Il valore restituito da rend non deve essere dereferenziato.

Esempio

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

Specifica una nuova dimensione per deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parametri

_Newsize
Nuova dimensione dell'oggetto deque.

val
Valore dei nuovi elementi da aggiungere a deque se la nuova dimensione è maggiore della dimensione originale. Se il valore viene omesso, ai nuovi elementi viene assegnato il valore predefinito per la classe.

Osservazioni:

Se l'oggetto dequeè minore di _Newsizesize , gli elementi vengono aggiunti a fino a deque raggiungere le dimensioni _Newsize.

Se l'oggetto dequeè maggiore di _Newsizesize , gli elementi più vicini alla fine di deque vengono eliminati fino a deque raggiungere le dimensioni _Newsize.

Se la dimensione attuale di deque è uguale _Newsizea , non viene eseguita alcuna azione.

size riflette le dimensioni correnti dell'oggetto deque.

Esempio

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

Tipo che fornisce un iteratore ad accesso casuale in grado di leggere o modificare un elemento in un oggetto dequeinvertito.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per scorrere l'oggetto deque.

Esempio

Vedere l'esempio per rbegin.

`shrink_to_fit`

Elimina la capacità in eccesso.

void shrink_to_fit();

Osservazioni:

Non esiste un modo portabile per determinare se shrink_to_fit riduce lo spazio di archiviazione usato da un oggetto deque.

Esempio

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

Restituisce il numero di elementi nel deque.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto deque.

Esempio

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

Tipo che conta il numero di elementi in una deque.

typedef typename Allocator::size_type size_type;

Esempio

Vedere l'esempio per size.

`swap`

Scambia gli elementi di due deque.

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

Parametri

right
Oggetto deque che fornisce gli elementi da scambiare o i deque cui elementi devono essere scambiati con quelli dell'oggetto deque left.

left
Oggetto deque i cui elementi devono essere scambiati con quelli di deque right.

Esempio

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

Tipo che rappresenta il tipo di dati archiviati in un deque.

typedef typename Allocator::value_type value_type;

Osservazioni:

value_type è un sinonimo per il parametro di modello Type.

Esempio

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

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++

Condividi tramite

Classe deque

Sintassi

Parametri

Osservazioni:

Membri

Costruttori

Typedef

Funzioni

Operatori

allocator_type

Osservazioni:

Esempio

assign

Parametri

Osservazioni:

Esempio

at

Parametri

Valore restituito

Osservazioni:

Esempio

back

Valore restituito

Osservazioni:

Esempio

begin

Valore restituito

Osservazioni:

Esempio

cbegin

Valore restituito

Osservazioni:

cend

Valore restituito

Osservazioni:

clear

Esempio

const_iterator

Osservazioni:

Esempio

const_pointer

Osservazioni:

const_reference

Osservazioni:

Esempio

const_reverse_iterator

Osservazioni:

Esempio

crbegin

Valore restituito

Osservazioni:

Esempio

crend

Valore restituito

Osservazioni:

Esempio

deque

Parametri

Osservazioni:

Esempio

difference_type

Osservazioni:

Esempio

emplace

Parametri

Valore restituito

Osservazioni:

Esempio

emplace_back

Parametri

Esempio

emplace_front

Parametri

Esempio

empty

Valore restituito

Esempio

end

Valore restituito

Classe `deque`

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