deque (STL/CLR)

Article
10/12/2023

La classe de modèle décrit un objet qui contrôle une séquence variable d’éléments ayant un accès aléatoire. Vous utilisez le conteneur deque pour gérer une séquence d’éléments qui ressemblent à un bloc de stockage contigu, mais qui peut croître ou réduire à la fin sans avoir à copier les éléments restants. Ainsi, il peut implémenter efficacement un double-ended queue. (Par conséquent, le nom.)

Dans la description ci-dessous, GValue est la même que Value si ce dernier est un type ref, auquel cas il s’agit Value^.

Syntaxe

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>
    { ..... };

Paramètres

GValue
Type générique d’un élément dans la séquence contrôlée.

Valeur
Type d'un élément dans la séquence contrôlée.

Spécifications

Header :<cliext/deque>

Namespace : cliext

Déclarations

Définition de type	Description
deque::const_iterator (STL/CLR)	Type d'un itérateur constant pour la séquence contrôlée.
deque::const_reference (STL/CLR)	Type d'une référence constante à un élément.
deque::const_reverse_iterator (STL/CLR)	Type d'un itérateur inserve constant pour la séquence contrôlée.
deque::difference_type (STL/CLR)	Type d'une distance signée entre deux éléments.
deque::generic_container (STL/CLR)	Type de l’interface générique pour le conteneur.
deque::generic_iterator (STL/CLR)	Type d’itérateur pour l’interface générique du conteneur.
deque::generic_reverse_iterator (STL/CLR)	Type d’itérateur inverse pour l’interface générique du conteneur.
deque::generic_value (STL/CLR)	Type d’un élément pour l’interface générique du conteneur.
deque::iterator (STL/CLR)	Type d'un itérateur pour la séquence contrôlée.
deque::reference (STL/CLR)	Type d'une référence à un élément.
deque::reverse_iterator (STL/CLR)	Type d'un itérateur inverse pour la séquence contrôlée.
deque::size_type (STL/CLR)	Type d'une distance signée entre deux éléments.
deque::value_type (STL/CLR)	Type d’un élément.

Fonction membre	Description
deque::assign (STL/CLR)	Remplace tous les éléments.
deque::at (STL/CLR)	Accède à un élément à une position spécifiée.
deque::back (STL/CLR)	Accède au dernier élément.
deque::begin (STL/CLR)	Désigne le début de la séquence contrôlée.
deque::clear (STL/CLR)	Supprime tous les éléments.
deque::deque (STL/CLR)	Construit un objet conteneur.
deque::empty (STL/CLR)	Vérifie l'absence d'éléments.
deque::end (STL/CLR)	Désigne la fin de la séquence contrôlée.
deque::erase (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
deque::front (STL/CLR)	Accède au premier élément.
deque::insert (STL/CLR)	Ajoute des éléments à une position spécifiée.
deque::pop_back (STL/CLR)	Supprime le dernier élément.
deque::pop_front (STL/CLR)	Supprime le premier élément.
deque::push_back (STL/CLR)	Ajoute un nouvel élément.
deque::push_front (STL/CLR)	Ajoute un nouvel élément.
deque::rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inverse.
deque::rend (STL/CLR)	Désigne la fin de la séquence contrôlée inverse.
deque::resize (STL/CLR)	Modifie le nombre d’éléments.
deque::size (STL/CLR)	Compte le nombre d'éléments.
deque::swap (STL/CLR)	Échange le contenu de deux conteneurs.
deque::to_array (STL/CLR)	Copie la séquence contrôlée dans un nouveau tableau.

Propriété	Description
deque::back_item (STL/CLR)	Accède au dernier élément.
deque::front_item (STL/CLR)	Accède au premier élément.

Opérateur	Description
deque::operator!= (STL/CLR)	Détermine si deux `deque` objets ne sont pas égaux.
deque::operator(STL/CLR)	Accède à un élément à une position spécifiée.
operator< (deque) (STL/CLR)	Détermine si un `deque` objet est inférieur à un autre `deque` objet.
operator<= (deque) (STL/CLR)	Détermine si un `deque` objet est inférieur ou égal à un autre `deque` objet.
operator= (deque) (STL/CLR)	Remplace la séquence contrôlée.
operator== (deque) (STL/CLR)	Détermine si un `deque` objet est égal à un autre `deque` objet.
operator> (deque) (STL/CLR)	Détermine si un `deque` objet est supérieur à un autre `deque` objet.
operator>= (deque) (STL/CLR)	Détermine si un `deque` objet est supérieur ou égal à un autre `deque` objet.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Séquencer des éléments.
ICollection	Conservez le groupe d’éléments.
IEnumerable<T>	Séquence à l’aide d’éléments typés.
ICollection<T>	Conservez le groupe d’éléments typés.
IList<T>	Conservez le groupe ordonné d’éléments typés.
Valeur IDeque<>	Gérer le conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle via un tableau de handles stocké qui désigne des blocs d’éléments Value . Le tableau augmente à la demande. La croissance se produit de telle sorte que le coût de l’ajout ou de l’ajout d’un nouvel élément est un temps constant, et aucun élément restant n’est perturbé. Vous pouvez également supprimer un élément à la fin en temps constant et sans déranger les éléments restants. Ainsi, une file d’attente est un bon candidat pour le conteneur sous-jacent pour la file d’attente de classes de modèle (STL/CLR) ou la pile de classes de modèle (STL/CLR).

Un deque objet prend en charge les itérateurs d’accès aléatoire, ce qui signifie que vous pouvez faire référence à un élément directement en fonction de sa position numérique, en comptant de zéro pour le premier élément (avant), à deque ::size (STL/CLR)() - 1 pour le dernier élément (précédent). Cela signifie également qu’une file d’attente est un bon candidat pour le conteneur sous-jacent pour la classe de modèle priority_queue (STL/CLR).

Un itérateur de file d’attente stocke un handle dans son objet de file d’attente associé, ainsi que le biais de l’élément qu’il désigne. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneur associés. Le biais d’un élément de file d’attente n’est pas nécessairement identique à sa position. Le premier élément inséré a un biais zéro, l’élément ajouté suivant a un biais 1, mais l’élément prépendé suivant a un biais -1.

L’insertion ou l’effacement d’éléments à la fin ne modifie pas la valeur d’un élément stocké à un biais valide. Toutefois, l’insertion ou l’effacement d’un élément intérieur peuvent modifier la valeur de l’élément stockée à un biais donné, de sorte que la valeur désignée par un itérateur peut également changer. (Le conteneur peut avoir à copier des éléments vers le haut ou vers le bas pour créer un trou avant une insertion ou pour remplir un trou après une effacement.) Néanmoins, un itérateur de file d’attente reste valide tant que son biais désigne un élément valide. En outre, un itérateur valide reste déreferencable - vous pouvez l’utiliser pour accéder ou modifier la valeur d’élément qu’il désigne - tant que son biais n’est pas égal au biais de l’itérateur retourné par end().

L’effacement ou la suppression d’un élément appelle le destructeur pour sa valeur stockée. La destruction du conteneur efface tous les éléments. Ainsi, un conteneur dont le type d’élément est une classe ref garantit qu’aucun élément n’est hors service du conteneur. Notez toutefois qu’un conteneur de handles ne détruit pas ses éléments.

Membres

deque::assign (STL/CLR)

Remplace tous les éléments.

Syntaxe

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

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

Notes

La première fonction membre remplace la séquence contrôlée par une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

S’il InIt s’agit d’un type entier, la deuxième fonction membre se comporte de la même façon que assign((size_type)first, (value_type)last). Sinon, il remplace la séquence contrôlée par la séquence [first, last). Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence.

La troisième fonction membre remplace la séquence contrôlée par la séquence désignée par le droit de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une séquence décrite par un énumérateur.

Exemple

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

Accède à un élément à une position spécifiée.

Syntaxe

reference at(size_type pos);

Paramètres

pos
Position de l'élément auquel accéder.

Notes

La fonction membre retourne une référence à l’élément de la séquence contrôlée à la position . Vous l’utilisez pour lire ou écrire un élément dont vous connaissez la position.

Exemple

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

Accède au dernier élément.

Syntaxe

reference back();

Notes

La fonction membre retourne une référence au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour accéder au dernier élément, lorsque vous savez qu’il existe.

Exemple

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

Accède au dernier élément.

Syntaxe

property value_type back_item;

Notes

La propriété accède au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le dernier élément, lorsque vous savez qu’il existe.

Exemple

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

Désigne le début de la séquence contrôlée.

Syntaxe

iterator begin();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

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

Supprime tous les éléments.

Syntaxe

void clear();

Notes

La fonction membre appelle effectivement deque ::erase (STL/CLR)( deque ::begin (STL/CLR)(), deque ::end (STL/CLR)()). Vous l’utilisez pour vous assurer que la séquence contrôlée est vide.

Exemple

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

Type d'un itérateur constant pour la séquence contrôlée.

Syntaxe

typedef T2 const_iterator;

Notes

Le type décrit un objet de type T2 non spécifié qui peut servir d’itérateur d’accès aléatoire constant pour la séquence contrôlée.

Exemple

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

Type d'une référence constante à un élément.

Syntaxe

typedef value_type% const_reference;

Notes

Le type décrit une référence constante à un élément.

Exemple

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

Type d’itérateur inverse constant pour la séquence contrôlée.

Syntaxe

typedef T4 const_reverse_iterator;

Notes

Le type décrit un objet de type T4 non spécifié qui peut servir d’itérateur inverse constant pour la séquence contrôlée.

Exemple

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

Construit un objet conteneur.

Syntaxe

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

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Objet ou plage à insérer.

val
Valeur de l’élément à insérer.

Notes

Constructeur :

deque();

initialise la séquence contrôlée sans éléments. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide.

Constructeur :

deque(deque<Value>% right);

initialise la séquence contrôlée avec la séquence [right.begin(), right.end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par le droit de l’objet de file d’attente. Pour plus d’informations sur les itérateurs, consultez deque ::begin (STL/CLR) et deque ::end (STL/CLR).

Constructeur :

deque(deque<Value>^ right);

initialise la séquence contrôlée avec la séquence [right->begin(), right->end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet de file d’attente dont le handle est correct.

Constructeur :

explicit deque(size_type count);

initialise la séquence contrôlée avec des éléments de nombre chacun avec la valeur value_type(). Vous l’utilisez pour remplir le conteneur avec des éléments qui ont toutes la valeur par défaut.

Constructeur :

deque(size_type count, value_type val);

initialise la séquence contrôlée avec des éléments de nombre chacun avec valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

Constructeur :

template<typename InIt>

deque(InIt first, InIt last);

initialise la séquence contrôlée avec la séquence [first, last). Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence.

Constructeur :

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

initialise la séquence contrôlée avec la séquence désignée par la droite de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur.

Exemple

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

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments signés.

Exemple

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

Vérifie l'absence d'éléments.

Syntaxe

bool empty();

Notes

La fonction membre retourne la valeur true pour une séquence contrôlée vide. Il équivaut à deque ::size (STL/CLR)() == 0. Vous l’utilisez pour tester si la file d’attente est vide.

Exemple

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

Désigne la fin de la séquence contrôlée.

Syntaxe

iterator end();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui pointe juste au-delà de la fin de la séquence contrôlée. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

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

Supprime les éléments placés aux positions spécifiées.

Syntaxe

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

Paramètres

first
Début de la plage à effacer.

last
Fin de la plage à effacer.

where
Élément à effacer.

Notes

La première fonction membre supprime l’élément de la séquence contrôlée vers laquelle. Vous l’utilisez pour supprimer un seul élément.

La deuxième fonction membre supprime l’élément de la séquence contrôlée dans la plage [first, last). Vous l’utilisez pour supprimer zéro ou plusieurs éléments contigus.

Les deux fonctions membres retournent un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou deque ::end (STL/CLR)() s’il n’existe aucun élément de ce type.

Lors de l’effacement des éléments, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre la fin de l’effacement et la fin la plus proche de la séquence. (Lors de l’effacement d’un ou plusieurs éléments à la fin de la séquence, aucun élément ne se produit.)

Exemple

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

Accède au premier élément.

Syntaxe

reference front();

Notes

La fonction membre retourne une référence au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

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

Accède au premier élément.

Syntaxe

property value_type front_item;

Notes

La propriété accède au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

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

Type de l’interface générique pour le conteneur.

Syntaxe

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

Notes

Le type décrit l’interface générique pour cette classe de conteneur de modèle.

Exemple

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

Type d’itérateur à utiliser avec l’interface générique du conteneur.

Syntaxe

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

Notes

Le type décrit un itérateur générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

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

Type d’itérateur inverse à utiliser avec l’interface générique du conteneur.

Syntaxe

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

Notes

Le type décrit un itérateur inverse générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

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

Type d’un élément à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef GValue generic_value;

Notes

Le type décrit un objet de type GValue qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

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

Ajoute des éléments à une position spécifiée.

Syntaxe

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

Paramètres

count
Nombre d’éléments à insérer.

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

where
Emplacement dans le conteneur à insérer avant.

Notes

Chacune des fonctions membres insère, avant l’élément pointé vers l’endroit où , dans la séquence contrôlée, une séquence spécifiée par les opérandes restants.

La première fonction membre insère un élément avec valeur val et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un élément unique avant un emplacement désigné par un itérateur.

La deuxième fonction membre insère une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus qui sont toutes des copies de la même valeur.

Si InIt est un type entier, la troisième fonction membre se comporte comme insert(where, (size_type)first, (value_type)last). Sinon, il insère la séquence [first, last). Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus copiés à partir d’une autre séquence.

La quatrième fonction membre insère la séquence désignée par la droite. Vous l’utilisez pour insérer une séquence décrite par un énumérateur.

Lors de l’insertion d’un élément unique, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre le point d’insertion et la fin la plus proche de la séquence. (Lors de l’insertion d’un ou de plusieurs éléments à la fin de la séquence, aucun élément ne se produit.) S’il InIt s’agit d’un itérateur d’entrée, la troisième fonction membre effectue efficacement une insertion unique pour chaque élément de la séquence. Sinon, lors de l’insertion d’éléments N , le nombre de copies d’éléments est linéaire en N plus du nombre d’éléments entre le point d’insertion et la fin plus proche de la séquence.

Exemple

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

Type d'un itérateur pour la séquence contrôlée.

Syntaxe

typedef T1 iterator;

Notes

Le type décrit un objet de type T1 non spécifié qui peut servir d’itérateur d’accès aléatoire pour la séquence contrôlée.

Exemple

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

Comparaison différente de la file d’attente.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left == right). Vous l’utilisez pour tester si la gauche n’est pas triée de la même façon que la droite lorsque les deux deques sont comparées par élément.

Exemple

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

Accède à un élément à une position spécifiée.

Syntaxe

reference operator[](size_type pos);

Paramètres

pos
Position de l'élément auquel accéder.

Notes

L’opérateur membre retourne un référencen à l’élément à la position de position. Vous l’utilisez pour accéder à un élément dont vous connaissez la position.

Exemple

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

Supprime le dernier élément.

Syntaxe

void pop_back();

Notes

La fonction membre supprime le dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir la file d’attente d’un élément à l’arrière.

Exemple

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

Supprime le premier élément.

Syntaxe

void pop_front();

Notes

La fonction membre supprime le premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir la file d’attente d’un élément à l’avant.

Exemple

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

Ajoute un nouvel élément.

Syntaxe

void push_back(value_type val);

Notes

La fonction membre insère un élément avec une valeur val à la fin de la séquence contrôlée. Vous l’utilisez pour ajouter un autre élément à la file d’attente.

Exemple

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

Ajoute un nouvel élément.

Syntaxe

void push_front(value_type val);

Notes

La fonction membre insère un élément avec une valeur val au début de la séquence contrôlée. Vous l’utilisez pour ajouter un autre élément à la file d’attente.

Exemple

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

Désigne le début de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rbegin();

Notes

La fonction membre retourne un itérateur inverse qui désigne le dernier élément de la séquence contrôlée, ou juste au-delà du début d’une séquence vide. Par conséquent, il désigne la beginning séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

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

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

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

Désigne la fin de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rend();

Notes

La fonction membre retourne un itérateur inverse qui pointe juste au-delà du début de la séquence contrôlée. Par conséquent, il désigne la end séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

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

Modifie le nombre d’éléments.

Syntaxe

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

Paramètres

new_size
Nouvelle taille de la séquence contrôlée.

val
Valeur de l’élément de remplissage.

Notes

Les fonctions membres garantissent tous deux que deque ::size (STL/CLR)() retourne désormais new_size. Si elle doit rendre la séquence contrôlée plus longue, la première fonction membre ajoute des éléments avec valeur value_type(), tandis que la deuxième fonction membre ajoute des éléments avec valeur val. Pour raccourcir la séquence contrôlée, les deux fonctions membres effacent efficacement le dernier élément deque ::size (STL/CLR).() - new_size Vous l’utilisez pour vous assurer que la séquence contrôlée a une taille new_size, en rognant ou en remplissage de la séquence contrôlée actuelle.

Exemple

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

Type d'un itérateur inverse pour la séquence contrôlée.

Syntaxe

typedef T3 reverse_iterator;

Notes

Le type décrit un objet de type T3 non spécifié qui peut servir d’itérateur inverse pour la séquence contrôlée.

Exemple

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

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si tout ce que vous vous souciez est de savoir si la séquence a une taille différente de zéro, consultez deque ::empty (STL/CLR)().

Exemple

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

Type d’une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

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

Échange le contenu de deux conteneurs.

Syntaxe

void swap(deque<Value>% right);

Paramètres

right
Conteneur avec lequel échanger le contenu.

Notes

La fonction membre échange les séquences contrôlées entre *this et droite. Il le fait en temps constant et ne lève aucune exception. Vous l’utilisez comme moyen rapide d’échanger le contenu de deux conteneurs.

Exemple

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

Copie la séquence contrôlée dans un nouveau tableau.

Syntaxe

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

Notes

La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.

Exemple

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

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

Le type est un synonyme de la valeur du paramètre de modèle.

Exemple

// 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 inférieur à la comparaison.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne true si, pour la position i la plus basse pour laquelle !(right[i] < left[i]) il est également vrai que left[i] < right[i]. Sinon, elle retourne left->size() < right->size() vous permet de tester si la gauche est ordonnée avant la droite lorsque les deux deques sont comparées par élément.

Exemple

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

Déconseil inférieur ou égal à la comparaison.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(right < left). Vous l’utilisez pour tester si la gauche n’est pas triée après la droite lorsque les deux deques sont comparées par élément.

Exemple

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

Remplace la séquence contrôlée.

Syntaxe

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

Paramètres

right
Conteneur à copier.

Notes

L’opérateur membre copie le droit vers l’objet, puis retourne *this. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée à droite.

Exemple

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

Comparaison égale à la file d’attente.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction opérateur retourne true uniquement si les séquences contrôlées par gauche et droite ont la même longueur et, pour chaque position i, left[i] == right[i]. Vous l’utilisez pour tester si la gauche est triée de la même façon que la droite lorsque les deux deques sont comparées à l’élément par élément.

Exemple

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

File d’attente supérieure à la comparaison.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne right < left. Vous l’utilisez pour tester si la gauche est ordonnée après la droite lorsque les deux deques sont comparées par élément.

Exemple

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

Déconseil supérieur ou égal à la comparaison.

Syntaxe

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

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left < right). Vous l’utilisez pour tester si la gauche n’est pas ordonnée avant la droite lorsque les deux deques sont comparées par élément.

Exemple

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

Partager via

deque (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

deque::assign (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

deque::at (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

deque::back (STL/CLR)

Syntaxe

Notes

Exemple

deque::back_item (STL/CLR)

Syntaxe

Notes

Exemple

deque::begin (STL/CLR)

Syntaxe

Notes

Exemple

deque::clear (STL/CLR)

Syntaxe

Notes

Exemple

deque::const_iterator (STL/CLR)

Syntaxe

Notes

Exemple

deque::const_reference (STL/CLR)

Syntaxe

Notes

Exemple

deque::const_reverse_iterator (STL/CLR)

Syntaxe

Notes

Exemple

deque::deque (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

deque::difference_type (STL/CLR)

Syntaxe

Notes

Exemple

deque::empty (STL/CLR)

Syntaxe

Notes

Exemple

deque::end (STL/CLR)

Syntaxe

Notes

Exemple

deque::erase (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

deque::front (STL/CLR)

Syntaxe

Notes

Exemple

deque::front_item (STL/CLR)

Syntaxe

Notes

Exemple

deque::generic_container (STL/CLR)

Syntaxe

Notes