`stack` (STL/CLR)

Article
10/12/2023

La classe de modèle décrit un objet qui contrôle une séquence d’éléments de longueur variable qui dispose d’un accès de dernière première sortie. Vous utilisez l’adaptateur stack de conteneur pour gérer un conteneur sous-jacent en tant que pile push-down.

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^. De même, GContainer c’est la même que Container si ce dernier est un type ref, auquel cas il s’agit Container^.

Syntaxe

template<typename Value,
    typename Container>
    ref class stack
        :   public
        System::ICloneable,
        Microsoft::VisualC::StlClr::IStack<GValue, GContainer>
    { ..... };

Paramètres

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

Container
Type du conteneur sous-jacent.

Spécifications

Header :<cliext/stack>

Espace de noms :cliext

Déclarations

Définition de types	Description
`stack::const_reference`	Type d'une référence constante à un élément.
`stack::container_type`	Type du conteneur sous-jacent.
`stack::difference_type`	Type d'une distance signée entre deux éléments.
`stack::generic_container`	Type de l’interface générique pour l’adaptateur de conteneur.
`stack::generic_value`	Type d’un élément pour l’interface générique de l’adaptateur de conteneur.
`stack::reference`	Type d'une référence à un élément.
`stack::size_type`	Type d'une distance signée entre deux éléments.
`stack::value_type`	Type d’un élément.

Fonction membre	Description
`stack::assign`	Remplace tous les éléments.
`stack::empty`	Vérifie l'absence d'éléments.
`stack::get_container`	Accède au conteneur sous-jacent.
`stack::pop`	Supprime le dernier élément.
`stack::push`	Ajoute un nouvel élément.
`stack::size`	Compte le nombre d'éléments.
`stack::stack`	Construit un objet conteneur.
`stack::top`	Accède au dernier élément.
`stack::to_array`	Copie la séquence contrôlée dans un nouveau tableau.

Propriété	Description
`stack::top_item`	Accède au dernier élément.

Opérateur	Description
`stack::operator=`	Remplace la séquence contrôlée.
`operator!=` (pile)	Détermine si un `stack` objet n’est pas égal à un autre `stack` objet.
`operator<` (pile)	Détermine si un `stack` objet est inférieur à un autre `stack` objet.
`operator<=` (pile)	Détermine si un `stack` objet est inférieur ou égal à un autre `stack` objet.
`operator==` (pile)	Détermine si un `stack` objet est égal à un autre `stack` objet.
`operator>` (pile)	Détermine si un `stack` objet est supérieur à un autre `stack` objet.
`operator>=` (pile)	Détermine si un `stack` objet est supérieur ou égal à un autre `stack` objet.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
`IStack<Value, Container>`	Conservez l’adaptateur de conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle via un conteneur sous-jacent de type Container qui stocke Value les éléments et augmente à la demande. L’objet limite l’accès à l’envoi (push) et au pavage du dernier élément, en implémentant une file d’attente de première sortie (également appelée file d’attente LIFO ou pile).

Membres

`stack::assign`

Remplace tous les éléments.

Syntaxe

void assign(stack<Value, Container>% right);

Paramètres

right
Adaptateur de conteneur à insérer.

Notes

La fonction membre affecte right.get_container() au conteneur sous-jacent. Vous l’utilisez pour modifier l’intégralité du contenu de la pile.

Exemple

// cliext_stack_assign.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign a repetition of values
    Mystack c2;
    c2.assign(c1);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

`stack::const_reference`

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_stack_const_reference.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

// display reversed contents " c b a"
    for (; !c1.empty(); c1.pop())
        {   // get a const reference to an element
        Mystack::const_reference cref = c1.top();
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

c b a

`stack::container_type`

Type du conteneur sous-jacent.

Syntaxe

typedef Container value_type;

Notes

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

Exemple

// cliext_stack_container_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

// display contents " a b c" using container_type
    Mystack::container_type wc1 = c1.get_container();
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

`stack::difference_type`

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 potentiellement négatif.

Exemple

// cliext_stack_difference_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// compute negative difference
    Mystack::difference_type diff = c1.size();
    c1.push(L'd');
    c1.push(L'e');
    diff -= c1.size();
    System::Console::WriteLine("pushing 2 = {0}", diff);

// compute positive difference
    diff = c1.size();
    c1.pop();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("popping 3 = {0}", diff);
    return (0);
    }

a b c
pushing 2 = -2
popping 3 = 3

`stack::empty`

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. Cela équivaut à size() == 0. Vous l’utilisez pour tester si la valeur stack est vide.

Exemple

// cliext_stack_empty.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1.get_container())
        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.pop();
    c1.pop();
    c1.pop();
    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

`stack::generic_container`

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

Syntaxe

typedef Microsoft::VisualC::StlClr::IStack<Value>
    generic_container;

Notes

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

Exemple

// cliext_stack_generic_container.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// get interface to container
    Mystack::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

// modify original and display generic
    c1.push(L'e');
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

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

`stack::generic_value`

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. (GValue est un value_type type ref ou value_type^ s’il s’agit value_type d’un type ref.)

Exemple

// cliext_stack_generic_value.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// get interface to container
    Mystack::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display in reverse using generic_value
    for (; !gc1->empty(); gc1->pop())
        {
        Mystack::generic_value elem = gc1->top();

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

a b c
a b c
c b a

`stack::get_container`

Accède au conteneur sous-jacent.

Syntaxe

container_type^ get_container();

Notes

La fonction membre retourne un handle pour le conteneur sous-jacent. Vous l’utilisez pour contourner les restrictions imposées par le wrapper de conteneur.

Exemple

// cliext_stack_get_container.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

// display contents " a b c" using container_type
    Mystack::container_type wc1 = c1.get_container();
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

`stack::operator=`

Remplace la séquence contrôlée.

Syntaxe

stack<Value, Container>% operator=(stack<Value, Container>% right);

Paramètres

right
Adaptateur de conteneur à copier.

Notes

L’opérateur membre copie right dans 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 dans right.

Exemple

// cliext_stack_operator_as.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

a b c
a b c

`stack::pop`

Supprime le dernier élément.

Syntaxe

void pop();

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 l’élément stack d’un élément à l’arrière.

Exemple

// cliext_stack_pop.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

a b c
a b

`stack::push`

Ajoute un nouvel élément.

Syntaxe

void push(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 pile.

Exemple

// cliext_stack_push.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

a b c

`stack::reference`

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_stack_reference.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// modify top of stack and redisplay
    Mystack::reference ref = c1.top();
    ref = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b x

`stack::size`

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 dont vous vous souciez est de savoir si la séquence a une taille différente de zéro, voir stack::empty.

Exemple

// cliext_stack_size.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// pop an item and reinspect
    c1.pop();
    System::Console::WriteLine("size() = {0} after popping", c1.size());

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

a b c
size() = 3 starting with 3
size() = 2 after popping
size() = 4 after adding 2

`stack::size_type`

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_stack_size_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// compute positive difference
    Mystack::size_type diff = c1.size();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("size difference = {0}", diff);
    return (0);
    }

a b c
size difference = 2

`stack::stack`

Construit un objet d’adaptateur de conteneur.

Syntaxe

stack();
stack(stack<Value, Container>% right);
stack(stack<Value, Container>^ right);
explicit stack(container_type% wrapped);

Paramètres

right
Objet à copier.

wrapped
Conteneur encapsulé à utiliser.

Notes

Constructeur :

stack();

crée un conteneur encapsulé vide. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide.

Constructeur :

stack(stack<Value, Container>% right);

crée un conteneur encapsulé qui est une copie de right.get_container(). 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 stackright.

Constructeur :

stack(stack<Value, Container>^ right);

crée un conteneur encapsulé qui est une copie de right->get_container(). 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 stack*right.

Constructeur :

explicit stack(container_type% wrapped);

utilise le conteneur wrapped existant comme conteneur encapsulé. Vous l’utilisez pour construire un stack conteneur existant.

Exemple

// cliext_stack_construct.cpp
// compile with: /clr
#include <cliext/stack>
#include <cliext/vector>

typedef cliext::stack<wchar_t> Mystack;
typedef cliext::vector<wchar_t> Myvector;
typedef cliext::stack<wchar_t, Myvector> Mystack_vec;
int main()
    {
// construct an empty container
    Mystack c1;
    System::Console::WriteLine("size() = {0}", c1.size());

// construct from an underlying container
    Myvector v2(5, L'x');
    Mystack_vec c2(v2);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    Mystack_vec c3(c2);
    for each (wchar_t elem in c3.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container through handle
    Mystack_vec c4(%c2);
    for each (wchar_t elem in c4.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

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

`stack::to_array`

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_stack_to_array.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    c1.push(L'd');
    for each (wchar_t elem in c1.get_container())
        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

`stack::top`

Accède au dernier élément.

Syntaxe

reference top();

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 en existe un.

Exemple

// cliext_stack_top.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

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

a b c
top() = c
a b x

`stack::top_item`

Accède au dernier élément.

Syntaxe

property value_type top_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 en existe un.

Exemple

// cliext_stack_top_item.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

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

a b c
top_item = c
a b x

`stack::value_type`

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

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

Exemple

// cliext_stack_value_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

// display reversed contents " a b c" using value_type
    for (; !c1.empty(); c1.pop())
        {   // store element in value_type object
        Mystack::value_type val = c1.top();

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

c b a

`operator!=` (pile)

Stack comparaison différente.

Syntaxe

template<typename Value,
    typename Container>
    bool operator!=(stack<Value, Container>% left,
        stack<Value, Container>% 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 s’il left n’est pas ordonné de la même façon que right lorsque les deux piles sont comparées par élément.

Exemple

// cliext_stack_operator_ne.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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<` (pile)

Stack inférieur à la comparaison.

Syntaxe

template<typename Value,
    typename Container>
    bool operator<(stack<Value, Container>% left,
        stack<Value, Container>% 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]) elle est également vraie.left[i] < right[i] Sinon, left->size() < right->size()est retourné. Vous l’utilisez pour tester s’il left est ordonné avant right que les deux piles soient comparées par élément.

Exemple

// cliext_stack_operator_lt.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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<=` (pile)

Stack comparaison inférieure ou égale.

Syntaxe

template<typename Value,
    typename Container>
    bool operator<=(stack<Value, Container>% left,
        stack<Value, Container>% 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 s’il left n’est pas ordonné après right le moment où les deux piles sont comparées par élément.

Exemple

// cliext_stack_operator_le.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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==` (pile)

Stack comparaison égale.

Syntaxe

template<typename Value,
    typename Container>
    bool operator==(stack<Value, Container>% left,
        stack<Value, Container>% 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 left et right ont la même longueur et, pour chaque position i, left[i] == right[i]. Vous l’utilisez pour tester si left l’ordre est le même que right lorsque les deux piles sont comparées par élément.

Exemple

// cliext_stack_operator_eq.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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>` (pile)

Stack supérieur à la comparaison.

Syntaxe

template<typename Value,
    typename Container>
    bool operator>(stack<Value, Container>% left,
        stack<Value, Container>% 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 left elle est triée après right le moment où les deux piles sont comparées par élément.

Exemple

// cliext_stack_operator_gt.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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>=` (pile)

Stack supérieur ou égal à la comparaison.

Syntaxe

template<typename Value,
    typename Container>
    bool operator>=(stack<Value, Container>% left,
        stack<Value, Container>% 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 s’il left n’est pas ordonné avant right que les deux piles soient comparées par élément.

Exemple

// cliext_stack_operator_ge.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

// assign to a new container
    Mystack c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2.get_container())
        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

stack (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

stack::assign

Syntaxe

Paramètres

Notes

Exemple

stack::const_reference

Syntaxe

Notes

Exemple

stack::container_type

Syntaxe

Notes

Exemple

stack::difference_type

Syntaxe

Notes

Exemple

stack::empty

Syntaxe

Notes

Exemple

stack::generic_container

Syntaxe

Notes

Exemple

stack::generic_value

Syntaxe

Notes

Exemple

stack::get_container

Syntaxe

Notes

Exemple

stack::operator=

Syntaxe

Paramètres

Notes

Exemple

stack::pop

Syntaxe

Notes

Exemple

stack::push

Syntaxe

Notes

Exemple

stack::reference

Syntaxe

Notes

Exemple

stack::size

Syntaxe

Notes

Exemple

stack::size_type

Syntaxe

Notes

Exemple

stack::stack

Syntaxe

Paramètres

Notes

Exemple

stack::to_array

Syntaxe

Notes

Exemple

stack::top

Syntaxe

Notes

Exemple

stack::top_item

`stack` (STL/CLR)

`stack::assign`

`stack::const_reference`

`stack::container_type`

`stack::difference_type`

`stack::empty`

`stack::generic_container`

`stack::generic_value`

`stack::get_container`

`stack::operator=`

`stack::pop`

`stack::push`

`stack::reference`

`stack::size`

`stack::size_type`

`stack::stack`

`stack::to_array`

`stack::top`

`stack::top_item`

`stack::value_type`

`operator!=` (pile)

`operator<` (pile)

`operator<=` (pile)

`operator==` (pile)

`operator>` (pile)

`operator>=` (pile)