`stack` (STL/CLR)

Articolo
10/12/2023

La classe modello descrive un oggetto che controlla una sequenza di elementi di lunghezza variabile con accesso last-in first-out. Usare l'adattatore stack contenitore per gestire un contenitore sottostante come stack di push-down.

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

Sintassi

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

Parametri

Value
Tipo di un elemento nella sequenza controllata.

Container
Tipo del contenitore sottostante.

Requisiti

Intestazione:<cliext/stack>

Spazio dei nomi: cliext

Dichiarazioni

Definizione dei tipi	Descrizione
`stack::const_reference`	Tipo di un riferimento costante a un elemento.
`stack::container_type`	Tipo del contenitore sottostante.
`stack::difference_type`	Tipo di una distanza Signed tra due elementi.
`stack::generic_container`	Tipo dell'interfaccia generica per l'adattatore contenitore.
`stack::generic_value`	Tipo di un elemento per l'interfaccia generica per l'adattatore contenitore.
`stack::reference`	Tipo di un riferimento a un elemento.
`stack::size_type`	Tipo di una distanza Signed tra due elementi.
`stack::value_type`	Tipo di un elemento.

Funzione membro	Descrizione
`stack::assign`	Sostituisce tutti gli elementi.
`stack::empty`	Verifica se sono presenti o meno degli elementi.
`stack::get_container`	Accede al contenitore sottostante.
`stack::pop`	Rimuove l'ultimo elemento.
`stack::push`	Aggiunge un nuovo ultimo elemento.
`stack::size`	Conta il numero di elementi.
`stack::stack`	Costruisce un oggetto contenitore.
`stack::top`	Accede all'ultimo elemento.
`stack::to_array`	Copia la sequenza controllata in una nuova matrice.

Proprietà	Descrizione
`stack::top_item`	Accede all'ultimo elemento.

Operatore	Descrizione
`stack::operator=`	Sostituisce la sequenza controllata.
`operator!=` (stack)	Determina se un `stack` oggetto non è uguale a un altro `stack` oggetto.
`operator<` (stack)	Determina se un `stack` oggetto è minore di un altro `stack` oggetto.
`operator<=` (stack)	Determina se un `stack` oggetto è minore o uguale a un altro `stack` oggetto.
`operator==` (stack)	Determina se un `stack` oggetto è uguale a un altro `stack` oggetto.
`operator>` (stack)	Determina se un `stack` oggetto è maggiore di un altro `stack` oggetto.
`operator>=` (stack)	Determina se un `stack` oggetto è maggiore o uguale a un altro `stack` oggetto.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto .
`IStack<Value, Container>`	Mantenere l'adattatore contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla tramite un contenitore sottostante di tipo Container che archivia Value gli elementi e aumenta su richiesta. L'oggetto limita l'accesso al push e all'estrazione solo dell'ultimo elemento, implementando una coda last-in first-out (nota anche come coda LIFO o stack).

Membri

`stack::assign`

Sostituisce tutti gli elementi.

Sintassi

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

Parametri

right
Adattatore contenitore da inserire.

Osservazioni:

La funzione membro viene right.get_container() assegnata al contenitore sottostante. Viene usato per modificare l'intero contenuto dello stack.

Esempio

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

Tipo di un riferimento costante a un elemento.

Sintassi

typedef value_type% const_reference;

Osservazioni:

Il tipo descrive un riferimento costante a un elemento.

Esempio

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

Tipo del contenitore sottostante.

Sintassi

typedef Container value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Container.

Esempio

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

Tipi di distanza con segno tra due elementi.

Sintassi

typedef int difference_type;

Osservazioni:

Il tipo descrive un numero di elementi potenzialmente negativo.

Esempio

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

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota. È equivalente a size() == 0. Viene usato per verificare se l'oggetto stack è vuoto.

Esempio

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

Tipo dell'interfaccia generica per l'adattatore contenitore.

Sintassi

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

Osservazioni:

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

Esempio

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

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

Sintassi

typedef GValue generic_value;

Osservazioni:

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello. (GValue è value_type o value_type^ se value_type è un tipo ref.

Esempio

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

Accede al contenitore sottostante.

Sintassi

container_type^ get_container();

Osservazioni:

La funzione membro restituisce un handle per il contenitore sottostante. È possibile usarlo per ignorare le restrizioni imposte dal wrapper del contenitore.

Esempio

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

Sostituisce la sequenza controllata.

Sintassi

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

Parametri

right
Adattatore contenitore da copiare.

Osservazioni:

L'operatore membro copia right nell'oggetto , quindi restituisce *this. Viene usato per sostituire la sequenza controllata con una copia della sequenza controllata in right.

Esempio

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

Rimuove l'ultimo elemento.

Sintassi

void pop();

Osservazioni:

La funzione membro rimuove l'ultimo elemento della sequenza controllata, che deve essere non vuoto. Viene usato per abbreviare l'elemento stack per un elemento nella parte posteriore.

Esempio

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

Aggiunge un nuovo ultimo elemento.

Sintassi

void push(value_type val);

Osservazioni:

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

Esempio

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

Tipo di un riferimento a un elemento.

Sintassi

typedef value_type% reference;

Osservazioni:

Il tipo descrive un riferimento a un elemento.

Esempio

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

Conta il numero di elementi.

Sintassi

size_type size();

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se è importante sapere se la sequenza ha dimensioni diverse da zero, vedere stack::empty.

Esempio

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

Tipo di una distanza Signed tra due elementi.

Sintassi

typedef int size_type;

Osservazioni:

Il tipo descrive un numero di elementi non negativi.

Esempio

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

Costruisce un oggetto adattatore contenitore.

Sintassi

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

Parametri

right
Oggetto da copiare.

wrapped
Contenitore di cui eseguire il wrapping da usare.

Osservazioni:

Costruttore:

stack();

crea un contenitore incapsulato vuoto. Viene usato per specificare una sequenza controllata iniziale vuota.

Costruttore:

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

crea un contenitore di cui è stato eseguito il wrapping che è una copia di right.get_container(). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto stack right.

Costruttore:

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

crea un contenitore di cui è stato eseguito il wrapping che è una copia di right->get_container(). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto stack *right.

Costruttore:

explicit stack(container_type% wrapped);

usa il contenitore wrapped esistente come contenitore di cui è stato eseguito il wrapping. Viene usato per costruire un stack oggetto da un contenitore esistente.

Esempio

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

Copia la sequenza controllata in una nuova matrice.

Sintassi

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

Osservazioni:

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

Esempio

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

Accede all'ultimo elemento.

Sintassi

reference top();

Osservazioni:

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

Esempio

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

Accede all'ultimo elemento.

Sintassi

property value_type top_item;

Osservazioni:

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

Esempio

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

Tipo di un elemento.

Sintassi

typedef Value value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value.

Esempio

// 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!=` (stack)

Stack confronto diverso.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

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

Esempio

// 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<` (stack)

Stack minore di confronto.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione operatore restituisce true se, per la posizione i più bassa per la quale !(right[i] < left[i]) è true anche .left[i] < right[i] In caso contrario, viene restituito left->size() < right->size(). Viene usato per verificare se left viene ordinato prima right di quando i due stack vengono confrontati in base all'elemento.

Esempio

// 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<=` (stack)

Stack confronto minore o uguale.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(right < left). È possibile usarlo per verificare se left non viene ordinato dopo right quando i due stack vengono confrontati in base all'elemento.

Esempio

// 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==` (stack)

Stack confronto uguale.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce true solo se le sequenze controllate da left e right hanno la stessa lunghezza e, per ogni posizione i, left[i] == right[i]. Viene usato per verificare se left viene ordinato come right quando i due stack vengono confrontati in base all'elemento.

Esempio

// 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>` (stack)

Stack maggiore del confronto.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce right < left. Viene usato per verificare se left viene ordinato dopo right quando i due stack vengono confrontati in base all'elemento.

Esempio

// 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>=` (stack)

Stack confronto maggiore o uguale.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left < right). Viene usato per verificare se left non è ordinato prima right quando i due stack vengono confrontati in base all'elemento.

Esempio

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

Condividi tramite

stack (STL/CLR)

Sintassi

Parametri

Requisiti

Dichiarazioni

Interfacce

Osservazioni:

Membri

stack::assign

Sintassi

Parametri

Osservazioni:

Esempio

stack::const_reference

Sintassi

Osservazioni:

Esempio

stack::container_type

Sintassi

Osservazioni:

Esempio

stack::difference_type

Sintassi

Osservazioni:

Esempio

stack::empty

Sintassi

Osservazioni:

Esempio

stack::generic_container

Sintassi

Osservazioni:

Esempio

stack::generic_value

Sintassi

Osservazioni:

Esempio

stack::get_container

Sintassi

Osservazioni:

Esempio

stack::operator=

Sintassi

Parametri

Osservazioni:

Esempio

stack::pop

Sintassi

Osservazioni:

Esempio

stack::push

Sintassi

Osservazioni:

Esempio

stack::reference

Sintassi

Osservazioni:

Esempio

stack::size

Sintassi

Osservazioni:

Esempio

stack::size_type

Sintassi

Osservazioni:

Esempio

stack::stack

Sintassi

Parametri

Osservazioni:

Esempio

stack::to_array

Sintassi

Osservazioni:

Esempio

stack::top

Sintassi

Osservazioni:

Esempio

`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!=` (stack)

`operator<` (stack)

`operator<=` (stack)

`operator==` (stack)

`operator>` (stack)

`operator>=` (stack)