deque (STL/CLR)

Articolo
10/12/2023

La classe modello descrive un oggetto che controlla una sequenza di elementi di lunghezza variabile con accesso casuale. Il contenitore deque viene usato per gestire una sequenza di elementi che assomiglia a un blocco contiguo di archiviazione, ma che può aumentare o compattarsi a una delle due estremità senza dover copiare gli elementi rimanenti. Può quindi implementare in modo efficiente un oggetto double-ended queue. (Da qui il nome.

Nella descrizione seguente GValue , è uguale Value a a meno che quest'ultimo non sia un tipo ref, nel qual caso è Value^.

Sintassi

template<typename Value>
    ref class deque
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IDeque<GValue>
    { ..... };

Parametri

GValue
Tipo generico di un elemento nella sequenza controllata.

valore
Tipo di un elemento nella sequenza controllata.

Requisiti

Header:<cliext/deque>

Spazio dei nomi: cliext

Dichiarazioni

Definizione del tipo	Descrizione
deque::const_iterator (STL/CLR)	Tipo di un iteratore costante per la sequenza controllata.
deque::const_reference (STL/CLR)	Tipo di un riferimento costante a un elemento.
deque::const_reverse_iterator (STL/CLR)	Tipo di un iteratore inverso costante per la sequenza controllata.
deque::difference_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
deque::generic_container (STL/CLR)	Tipo dell'interfaccia generica per il contenitore.
deque::generic_iterator (STL/CLR)	Tipo di iteratore per l'interfaccia generica per il contenitore.
deque::generic_reverse_iterator (STL/CLR)	Tipo di iteratore inverso per l'interfaccia generica per il contenitore.
deque::generic_value (STL/CLR)	Tipo di elemento per l'interfaccia generica per il contenitore.
deque::iterator (STL/CLR)	Tipo di un iteratore per la sequenza controllata.
deque::reference (STL/CLR)	Tipo di un riferimento a un elemento.
deque::reverse_iterator (STL/CLR)	Tipo di un iteratore inverso della sequenza controllata.
deque::size_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
deque::value_type (STL/CLR)	Tipo di un elemento.

Funzione membro	Descrizione
deque::assign (STL/CLR)	Sostituisce tutti gli elementi.
deque::at (STL/CLR)	Accede a un elemento in una posizione specificata.
deque::back (STL/CLR)	Accede all'ultimo elemento.
deque::begin (STL/CLR)	Indica l'inizio della sequenza controllata.
deque::clear (STL/CLR)	Rimuove tutti gli elementi.
deque::deque (STL/CLR)	Costruisce un oggetto contenitore.
deque::empty (STL/CLR)	Verifica se sono presenti o meno degli elementi.
deque::end (STL/CLR)	Designa la fine della sequenza controllata.
deque::erase (STL/CLR)	Rimuove gli elementi in corrispondenza delle posizioni specificate.
deque::front (STL/CLR)	Accede al primo elemento.
deque::insert (STL/CLR)	Aggiunge elementi in una posizione specificata.
deque::pop_back (STL/CLR)	Rimuove l'ultimo elemento.
deque::pop_front (STL/CLR)	Rimuove il primo elemento.
deque::push_back (STL/CLR)	Aggiunge un nuovo ultimo elemento.
deque::push_front (STL/CLR)	Aggiunge un nuovo primo elemento.
deque::rbegin (STL/CLR)	Indica l'inizio della sequenza controllata inversa.
deque::rend (STL/CLR)	Indica la fine della sequenza controllata inversa.
deque::resize (STL/CLR)	Modifica il numero di elementi.
deque::size (STL/CLR)	Conta il numero di elementi.
deque::swap (STL/CLR)	Scambia il contenuto di due contenitori.
deque::to_array (STL/CLR)	Copia la sequenza controllata in una nuova matrice.

Proprietà	Descrizione
deque::back_item (STL/CLR)	Accede all'ultimo elemento.
deque::front_item (STL/CLR)	Accede al primo elemento.

Operatore	Descrizione
deque::operator!= (STL/CLR)	Determina se due `deque` oggetti non sono uguali.
deque::operator(STL/CLR)	Accede a un elemento in una posizione specificata.
operator< (deque) (STL/CLR)	Determina se un `deque` oggetto è minore di un altro `deque` oggetto.
operator<= (deque) (STL/CLR)	Determina se un `deque` oggetto è minore o uguale a un altro `deque` oggetto.
operator= (deque) (STL/CLR)	Sostituisce la sequenza controllata.
operator== (deque) (STL/CLR)	Determina se un `deque` oggetto è uguale a un altro `deque` oggetto.
operator> (deque) (STL/CLR)	Determina se un `deque` oggetto è maggiore di un altro `deque` oggetto.
operator>= (deque) (STL/CLR)	Determina se un `deque` oggetto è maggiore o uguale a un altro `deque` oggetto.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto .
IEnumerable	Sequenzia tra elementi.
ICollection	Mantenere il gruppo di elementi.
IEnumerable<T>	Sequenzia tra elementi tipizzato.
ICollection<T>	Mantenere un gruppo di elementi tipizzato.
IList<T>	Mantenere un gruppo ordinato di elementi tipizzato.
Valore IDeque<>	Gestire un contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla tramite una matrice archiviata di handle che designano blocchi di Value elementi. La matrice cresce su richiesta. La crescita si verifica in modo tale che il costo del prepending o dell'accodamento di un nuovo elemento è un tempo costante e nessun elemento rimanente viene disturbato. È anche possibile rimuovere un elemento alla fine del tempo costante e senza disturbare gli elementi rimanenti. Pertanto, una deque è un buon candidato per il contenitore sottostante per la coda di classi modello (STL/CLR) o lo stack di classi modello (STL/CLR).

Un deque oggetto supporta iteratori ad accesso casuale, il che significa che è possibile fare riferimento a un elemento direttamente in base alla relativa posizione numerica, contando da zero per il primo elemento (anteriore) a deque::size (STL/CLR)() - 1 per l'ultimo elemento (indietro). Significa anche che una deque è un buon candidato per il contenitore sottostante per la classe modello priority_queue (STL/CLR).

Un iteratore deque archivia un handle all'oggetto deque associato, insieme alla distorsione dell'elemento designato. È possibile usare gli iteratori solo con gli oggetti contenitore associati. La distorsione di un elemento deque non è necessariamente la stessa della sua posizione. Il primo elemento inserito ha la distorsione zero, l'elemento aggiunto successivo ha la distorsione 1, ma il successivo elemento anteporto ha la distorsione -1.

L'inserimento o la cancellazione di elementi in entrambe le estremità non modifica il valore di un elemento archiviato in qualsiasi distorsione valida. L'inserimento o la cancellazione di un elemento interno, tuttavia, può modificare il valore dell'elemento archiviato in una determinata distorsione, in modo che il valore designato da un iteratore possa anche cambiare. Il contenitore potrebbe dover copiare gli elementi verso l'alto o verso il basso per creare un foro prima di un inserimento o per riempire un foro dopo una cancellazione. Tuttavia, un iteratore deque rimane valido fino a quando la distorsione designa un elemento valido. Inoltre, un iteratore valido rimane dereferenziabile - è possibile usarlo per accedere o modificare il valore dell'elemento designato - purché la distorsione non sia uguale alla distorsione per l'iteratore restituito da end().

Cancellare o rimuovere un elemento chiama il distruttore per il valore archiviato. L'eliminazione definitiva del contenitore cancella tutti gli elementi. Pertanto, un contenitore il cui tipo di elemento è una classe ref garantisce che nessun elemento scadeni il contenitore. Si noti, tuttavia, che un contenitore di handle non elimina definitivamente i relativi elementi.

Membri

deque::assign (STL/CLR)

Sostituisce tutti gli elementi.

Sintassi

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Enumerazione da inserire.

val
Valore dell'elemento da inserire.

Osservazioni:

La prima funzione membro sostituisce la sequenza controllata con una ripetizione di elementi count di valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.

Se InIt è un tipo integer, la seconda funzione membro si comporta come assign((size_type)first, (value_type)last). In caso contrario, sostituisce la sequenza controllata con la sequenza [first, last). Viene usato per rendere la sequenza controllata una copia di un'altra sequenza.

La terza funzione membro sostituisce la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. È possibile usarla per rendere la sequenza controllata una copia di una sequenza descritta da un enumeratore.

Esempio

// cliext_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::deque<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

deque::at (STL/CLR)

Accede a un elemento in una posizione specificata.

Sintassi

reference at(size_type pos);

Parametri

pos
Posizione dell'elemento a cui accedere.

Osservazioni:

La funzione membro restituisce un riferimento all'elemento della sequenza controllata in corrispondenza della posizione pos. È possibile usarlo per leggere o scrivere un elemento la cui posizione si conosce.

Esempio

// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

    // change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::back (STL/CLR)

Accede all'ultimo elemento.

Sintassi

reference back();

Osservazioni:

La funzione membro restituisce un riferimento all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per accedere all'ultimo elemento, quando si sa che esiste.

Esempio

// cliext_deque_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

    // alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

deque::back_item (STL/CLR)

Accede all'ultimo elemento.

Sintassi

property value_type back_item;

Osservazioni:

La proprietà accede all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per leggere o scrivere l'ultimo elemento, quando si sa che esiste.

Esempio

// cliext_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

    // alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

deque::begin (STL/CLR)

Indica l'inizio della sequenza controllata.

Sintassi

iterator begin();

Osservazioni:

La funzione membro restituisce un iteratore ad accesso casuale che definisce il primo elemento della sequenza controllata o appena oltre la fine di una sequenza vuota. Viene usato per ottenere un iteratore che designa l'inizio current della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

deque::clear (STL/CLR)

Rimuove tutti gli elementi.

Sintassi

void clear();

Osservazioni:

La funzione membro chiama in modo efficace deque::erase (STL/CLR)( deque::begin (STL/CLR)(), deque::end (STL/CLR).()) Viene usato per assicurarsi che la sequenza controllata sia vuota.

Esempio

// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

deque::const_iterator (STL/CLR)

Tipo di un iteratore costante per la sequenza controllata.

Sintassi

typedef T2 const_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T2 non specificato che può fungere da iteratore costante ad accesso casuale per la sequenza controllata.

Esempio

// cliext_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reference (STL/CLR)

Tipo di un riferimento costante a un elemento.

Sintassi

typedef value_type% const_reference;

Osservazioni:

Il tipo descrive un riferimento costante a un elemento.

Esempio

// cliext_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::deque<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reverse_iterator (STL/CLR)

Tipo di iteratore inverso costante per la sequenza controllata.

Sintassi

typedef T4 const_reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T4 non specificato che può fungere da iteratore inverso costante per la sequenza controllata.

Esempio

// cliext_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::deque<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::deque (STL/CLR)

Costruisce un oggetto contenitore.

Sintassi

deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
    deque(InIt first, InIt last);
deque(System::Collections::Generic::IEnumerable<Value>^ right);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Oggetto o un intervallo da inserire.

val
Valore dell'elemento da inserire.

Osservazioni:

Costruttore:

deque();

inizializza la sequenza controllata senza elementi. Viene usato per specificare una sequenza controllata iniziale vuota.

Costruttore:

deque(deque<Value>% right);

inizializza la sequenza controllata con la sequenza [right.begin(), right.end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dal diritto dell'oggetto deque. Per altre informazioni sugli iteratori, vedere deque::begin (STL/CLR) e deque::end (STL/CLR).For more information on the iterators, see deque::begin (STL/CLR) and deque::end (STL/CLR).

Costruttore:

deque(deque<Value>^ right);

inizializza la sequenza controllata con la sequenza [right->begin(), right->end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto deque il cui handle è corretto.

Costruttore:

explicit deque(size_type count);

inizializza la sequenza controllata con gli elementi count ognuno con valore value_type(). Viene usato per riempire il contenitore con tutti gli elementi con il valore predefinito.

Costruttore:

deque(size_type count, value_type val);

inizializza la sequenza controllata con gli elementi count ognuno con valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.

Costruttore:

template<typename InIt>

deque(InIt first, InIt last);

inizializza la sequenza controllata con la sequenza [first, last). È possibile usarla per rendere la sequenza controllata una copia di un'altra sequenza.

Costruttore:

deque(System::Collections::Generic::IEnumerable<Value>^ right);

inizializza la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. Viene usata per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore.

Esempio

// cliext_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::deque<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // construct with a repetition of values
    cliext::deque<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    cliext::deque<wchar_t>::iterator it = c3.end();
    cliext::deque<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration
    cliext::deque<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    cliext::deque<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    cliext::deque<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

deque::difference_type (STL/CLR)

Tipi di distanza con segno tra due elementi.

Sintassi

typedef int difference_type;

Osservazioni:

Il tipo descrive un conteggio degli elementi con segno.

Esempio

// cliext_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::difference_type diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

deque::empty (STL/CLR)

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota. Equivale a deque::size (STL/CLR).() == 0 Viene usato per verificare se la deque è vuota.

Esempio

// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

deque::end (STL/CLR)

Designa la fine della sequenza controllata.

Sintassi

iterator end();

Osservazioni:

La funzione membro restituisce un iteratore ad accesso casuale che punta appena oltre la fine della sequenza controllata. È possibile usarlo per ottenere un iteratore che designa la current fine della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    cliext::deque<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

deque::erase (STL/CLR)

Rimuove gli elementi in corrispondenza delle posizioni specificate.

Sintassi

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Parametri

first
Inizio dell'intervallo da cancellare.

last
Fine dell'intervallo da cancellare.

where
Elemento da cancellare.

Osservazioni:

La prima funzione membro rimuove l'elemento della sequenza controllata a cui punta dove. Viene usato per rimuovere un singolo elemento.

La seconda funzione membro rimuove gli elementi della sequenza controllata nell'intervallo [first, last). È possibile usarlo per rimuovere zero o più elementi contigui.

Entrambe le funzioni membro restituiscono un iteratore che definisce il primo elemento rimanente oltre qualsiasi elemento rimosso o deque::end (STL/CLR)() se tale elemento non esiste.

Quando si cancellano gli elementi, il numero di copie degli elementi è lineare nel numero di elementi tra la fine della cancellazione e la fine più vicina della sequenza. Quando si cancella uno o più elementi alla fine della sequenza, non viene eseguita alcuna copia di elementi.

Esempio

// cliext_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    cliext::deque<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

deque::front (STL/CLR)

Accede al primo elemento.

Sintassi

reference front();

Osservazioni:

La funzione membro restituisce un riferimento al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.

Esempio

// cliext_deque_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

    // alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

deque::front_item (STL/CLR)

Accede al primo elemento.

Sintassi

property value_type front_item;

Osservazioni:

La proprietà accede al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.

Esempio

// cliext_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

    // alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

deque::generic_container (STL/CLR)

Tipo dell'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::
    IDeque<generic_value>
    generic_container;

Osservazioni:

Il tipo descrive l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

deque::generic_iterator (STL/CLR)

Tipo di iteratore da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value> generic_iterator;

Osservazioni:

Il tipo descrive un iteratore generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::generic_reverse_iterator (STL/CLR)

Tipo di iteratore inverso da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

Osservazioni:

Il tipo descrive un iteratore inverso generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

deque::generic_value (STL/CLR)

Tipo di un elemento da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef GValue generic_value;

Osservazioni:

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello.

Esempio

// cliext_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::insert (STL/CLR)

Aggiunge elementi in una posizione specificata.

Sintassi

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Enumerazione da inserire.

val
Valore dell'elemento da inserire.

where
Posizione nel contenitore da inserire prima.

Osservazioni:

Ognuna delle funzioni membro inserisce, prima dell'elemento a cui punta dove nella sequenza controllata, una sequenza specificata dagli operandi rimanenti.

La prima funzione membro inserisce un elemento con valore val e restituisce un iteratore che designa l'elemento appena inserito. Viene usato per inserire un singolo elemento prima di una posizione designata da un iteratore.

La seconda funzione membro inserisce una ripetizione di elementi count di valore val. Viene usato per inserire zero o più elementi contigui che sono tutte copie dello stesso valore.

Se InIt è di tipo Integer, la terza funzione membro si comporta come insert(where, (size_type)first, (value_type)last). In caso contrario, inserisce la sequenza [first, last). Viene usato per inserire zero o più elementi contigui copiati da un'altra sequenza.

La quarta funzione membro inserisce la sequenza designata dalla destra. Viene usato per inserire una sequenza descritta da un enumeratore.

Quando si inserisce un singolo elemento, il numero di copie degli elementi è lineare nel numero di elementi tra il punto di inserimento e la fine più vicina della sequenza. Quando si inseriscono uno o più elementi alla fine della sequenza, non vengono eseguite copie di elementi. Se InIt è un iteratore di input, la terza funzione membro esegue in modo efficace un singolo inserimento per ogni elemento nella sequenza. In caso contrario, quando si inseriscono N elementi, il numero di copie degli elementi è lineare in N più il numero di elementi tra il punto di inserimento e la fine più vicina della sequenza.

Esempio

// cliext_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value using iterator
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a repetition of values
    cliext::deque<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

deque::iterator (STL/CLR)

Tipo di un iteratore per la sequenza controllata.

Sintassi

typedef T1 iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T1 non specificato che può fungere da iteratore ad accesso casuale per la sequenza controllata.

Esempio

// cliext_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

    // alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

deque::operator!= (STL/CLR)

Confronto non uguale a deque.

Sintassi

template<typename Value>
    bool operator!=(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left == right). Viene usato per verificare se left non è ordinato come a destra quando i due deques vengono confrontati elemento per elemento.

Esempio

// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

deque::operator(STL/CLR)

Accede a un elemento in una posizione specificata.

Sintassi

reference operator[](size_type pos);

Parametri

pos
Posizione dell'elemento a cui accedere.

Osservazioni:

L'operatore membro restituisce un referene all'elemento in corrispondenza della posizione pos. È possibile usarlo per accedere a un elemento la cui posizione si conosce.

Esempio

// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

    // change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::pop_back (STL/CLR)

Rimuove l'ultimo elemento.

Sintassi

void pop_back();

Osservazioni:

La funzione membro rimuove l'ultimo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per abbreviare la deque di un elemento nella parte posteriore.

Esempio

// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

deque::pop_front (STL/CLR)

Rimuove il primo elemento.

Sintassi

void pop_front();

Osservazioni:

La funzione membro rimuove il primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per abbreviare la deque di un elemento nella parte anteriore.

Esempio

// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_front();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
b c

deque::push_back (STL/CLR)

Aggiunge un nuovo ultimo elemento.

Sintassi

void push_back(value_type val);

Osservazioni:

La funzione membro inserisce un elemento con valore val alla fine della sequenza controllata. È possibile usarlo per aggiungere un altro elemento alla deque.

Esempio

// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::push_front (STL/CLR)

Aggiunge un nuovo primo elemento.

Sintassi

void push_front(value_type val);

Osservazioni:

La funzione membro inserisce un elemento con valore val all'inizio della sequenza controllata. Viene usato per anteporre un altro elemento alla deque.

Esempio

// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_front(L'a');
    c1.push_front(L'b');
    c1.push_front(L'c');

    // display contents " c b a"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::rbegin (STL/CLR)

Indica l'inizio della sequenza controllata inversa.

Sintassi

reverse_iterator rbegin();

Osservazioni:

La funzione membro restituisce un iteratore inverso che definisce l'ultimo elemento della sequenza controllata o appena oltre l'inizio di una sequenza vuota. Di conseguenza, designa l'oggetto beginning della sequenza inversa. Viene usato per ottenere un iteratore che definisce l'inizio current della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

deque::reference (STL/CLR)

Tipo di un riferimento a un elemento.

Sintassi

typedef value_type% reference;

Osservazioni:

Il tipo descrive un riferimento a un elemento.

Esempio

// cliext_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

    // modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

deque::rend (STL/CLR)

Indica la fine della sequenza controllata inversa.

Sintassi

reverse_iterator rend();

Osservazioni:

La funzione membro restituisce un iteratore inverso che punta appena oltre l'inizio della sequenza controllata. Di conseguenza, designa l'oggetto end della sequenza inversa. Viene usato per ottenere un iteratore che designa la current fine della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// cliext_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

deque::resize (STL/CLR)

Modifica il numero di elementi.

Sintassi

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Parametri

new_size
Nuove dimensioni della sequenza controllata.

val
Valore dell'elemento di riempimento.

Osservazioni:

Le funzioni membro assicurano che deque::size (STL/CLR)() restituisca quindi new_size. Se deve rendere più lunga la sequenza controllata, la prima funzione membro aggiunge elementi con valore value_type(), mentre la seconda funzione membro aggiunge elementi con value val. Per rendere più breve la sequenza controllata, entrambe le funzioni membro cancellano efficacemente l'ultimo elemento deque::size (STL/CLR).() - new_size Viene usato per assicurarsi che la sequenza controllata abbia dimensioni new_size, tagliando o riempimento la sequenza controllata corrente.

Esempio

// cliext_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container and pad with default values
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

    // resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

deque::reverse_iterator (STL/CLR)

Tipo di un iteratore inverso della sequenza controllata.

Sintassi

typedef T3 reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo non specificato T3 che può essere utilizzato come iteratore inverso per la sequenza controllata.

Esempio

// cliext_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

    // alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

deque::size (STL/CLR)

Conta il numero di elementi.

Sintassi

size_type size();

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se tutto ciò che interessa è se la sequenza ha dimensioni diverse da zero, vedere deque::empty (STL/CLR).If all you care about is if the sequence has notzero size, see deque::empty (STL/CLR)().

Esempio

// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

deque::size_type (STL/CLR)

Tipo di distanza con segno tra due elementi.

Sintassi

typedef int size_type;

Osservazioni:

Il tipo descrive un numero di elementi non negativi.

Esempio

// cliext_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

deque::swap (STL/CLR)

Scambia il contenuto di due contenitori.

Sintassi

void swap(deque<Value>% right);

Parametri

right
Contenitore con cui scambiare il contenuto.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e destra. Lo fa in tempo costante e non genera eccezioni. È possibile usarlo come modo rapido per scambiare il contenuto di due contenitori.

Esempio

// cliext_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    cliext::deque<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

deque::to_array (STL/CLR)

Copia la sequenza controllata in una nuova matrice.

Sintassi

cli::array<Value>^ to_array();

Osservazioni:

La funzione membro restituisce una matrice contenente la sequenza controllata. Viene usato per ottenere una copia della sequenza controllata in formato matrice.

Esempio

// cliext_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

deque::value_type (STL/CLR)

Tipo di un elemento.

Sintassi

typedef Value value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value.

Esempio

// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using value_type
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::deque<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`operator<` (deque) (STL/CLR)

Deque minore di confronto.

Sintassi

template<typename Value>
    bool operator<(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce true se, per la posizione i più bassa per la quale !(right[i] < left[i]) è anche true che left[i] < right[i]. In caso contrario, restituisce left->size() < right->size() You use it per verificare se left è ordinato prima di destra quando i due deques vengono confrontati elemento per elemento.

Esempio

// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (deque) (STL/CLR)

Confronto minore o uguale a deque.

Sintassi

template<typename Value>
    bool operator<=(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(right < left). Viene usato per verificare se left non viene ordinato dopo destra quando i due deques vengono confrontati elemento per elemento.

Esempio

// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator= (deque) (STL/CLR)

Sostituisce la sequenza controllata.

Sintassi

deque<Value>% operator=(deque<Value>% right);

Parametri

right
Contenitore da copiare.

Osservazioni:

L'operatore membro copia direttamente nell'oggetto , quindi restituisce *this. Lo si usa per sostituire la sequenza controllata con una copia della sequenza controllata a destra.

Esempio

// cliext_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

operator== (deque) (STL/CLR)

Confronto di uguale deque.

Sintassi

template<typename Value>
    bool operator==(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione operator restituisce true solo se le sequenze controllate da sinistra e destra hanno la stessa lunghezza e, per ogni posizione i, left[i] == right[i]. Viene usato per verificare se a sinistra viene ordinato lo stesso valore di destra quando i due deques vengono confrontati in base all'elemento.

Esempio

// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (deque) (STL/CLR)

Deque maggiore del confronto.

Sintassi

template<typename Value>
    bool operator>(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce right < left. È possibile usarlo per verificare se a sinistra viene ordinato dopo destra quando i due deques vengono confrontati in base all'elemento.

Esempio

// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (deque) (STL/CLR)

Deque maggiore o uguale a confronto.

Sintassi

template<typename Value>
    bool operator>=(deque<Value>% left,
        deque<Value>% right);

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left < right). È possibile usarlo per verificare se left non è ordinato prima di destra quando i due deques vengono confrontati elemento per elemento.

Esempio

// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Condividi tramite

deque (STL/CLR)

Sintassi

Parametri

Requisiti

Dichiarazioni

Interfacce

Osservazioni:

Membri

deque::assign (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

deque::at (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

deque::back (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::back_item (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::begin (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::clear (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::const_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::const_reference (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::const_reverse_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::deque (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

deque::difference_type (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::empty (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::end (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::erase (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

deque::front (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::front_item (STL/CLR)

Sintassi

Osservazioni:

Esempio

deque::generic_container (STL/CLR)

Sintassi

Osservazioni: