`stack` (STL/CLR)

Článek
10/12/2023

Třída šablony popisuje objekt, který řídí různou délkovou sekvenci prvků, které mají poslední přístup k prvnímu outu. Adaptér stack kontejneru slouží ke správě základního kontejneru jako zásobníku push-down.

V následujícím popisu je stejný jako Value v případě, GValue že se jedná o typ odkazu, v takovém případě je Value^to . Podobně je to stejné jako Container v případě, GContainer že se jedná o typ odkazu, v takovém případě je Container^to .

Syntaxe

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

Parametry

Value
Typ elementu v řízené sekvenci

Container
Typ podkladového kontejneru.

Požadavky

Header:<cliext/stack>

Obor názvů: cliext

Deklarace

Definice typu	Popis
`stack::const_reference`	Typ konstantního odkazu na prvek
`stack::container_type`	Typ podkladového kontejneru.
`stack::difference_type`	Typ vzdálenosti se znaménkem mezi dvěma prvky
`stack::generic_container`	Typ obecného rozhraní pro adaptér kontejneru.
`stack::generic_value`	Typ elementu pro obecné rozhraní pro adaptér kontejneru.
`stack::reference`	Typ odkazu na prvek
`stack::size_type`	Typ vzdálenosti se znaménkem mezi dvěma prvky
`stack::value_type`	Typ prvku

Členová funkce	Popis
`stack::assign`	Nahradí všechny prvky.
`stack::empty`	Zkouší, zda nejsou přítomny žádné prvky.
`stack::get_container`	Přistupuje k podkladovému kontejneru.
`stack::pop`	Odebere poslední prvek.
`stack::push`	Přidá nový poslední prvek.
`stack::size`	Spočítá počet prvků.
`stack::stack`	Sestaví objekt kontejneru.
`stack::top`	Přistupuje k poslednímu prvku.
`stack::to_array`	Zkopíruje řízenou sekvenci do nového pole.

Vlastnost	Popis
`stack::top_item`	Přistupuje k poslednímu prvku.

Operátor	Popis
`stack::operator=`	Nahradí řízenou sekvenci.
`operator!=` (stack)	Určuje, jestli se objekt nerovná jinému `stack` `stack` objektu.
`operator<` (stack)	Určuje, zda `stack` je objekt menší než jiný `stack` objekt.
`operator<=` (stack)	Určuje, zda `stack` je objekt menší nebo roven jinému `stack` objektu.
`operator==` (stack)	Určuje, zda je `stack` objekt roven jinému `stack` objektu.
`operator>` (stack)	Určuje, zda `stack` je objekt větší než jiný `stack` objekt.
`operator>=` (stack)	Určuje, zda `stack` je objekt větší nebo roven jinému `stack` objektu.

Rozhraní

Rozhraní	Popis
ICloneable	Duplikovat objekt
`IStack<Value, Container>`	Udržujte obecný adaptér kontejneru.

Poznámky

Objekt přidělí a uvolní úložiště pro sekvenci, kterou řídí prostřednictvím základního kontejneru typu Container , který ukládá Value prvky a roste na vyžádání. Objekt omezuje přístup k nasdílení a přeskočení pouze posledního prvku, implementaci fronty typu poslední v prvním ven (označované také jako fronta LIFO nebo zásobník).

Členové

`stack::assign`

Nahradí všechny prvky.

Syntaxe

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

Parametry

right
Adaptér kontejneru, který se má vložit.

Poznámky

Členová funkce se přiřadí right.get_container() k podkladovému kontejneru. Použijete ho ke změně celého obsahu zásobníku.

Příklad

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

Typ konstantního odkazu na prvek

Syntaxe

typedef value_type% const_reference;

Poznámky

Typ popisuje konstantní odkaz na prvek.

Příklad

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

Typ podkladového kontejneru.

Syntaxe

typedef Container value_type;

Poznámky

Typ je synonymem pro parametr Containeršablony .

Příklad

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

Typy podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int difference_type;

Poznámky

Typ popisuje pravděpodobně záporný počet prvků.

Příklad

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

Zkouší, zda nejsou přítomny žádné prvky.

Syntaxe

bool empty();

Poznámky

Členová funkce vrátí hodnotu true pro prázdnou řízenou sekvenci. Je to ekvivalent .size() == 0 Použijete ho k otestování stack , jestli je prázdný.

Příklad

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

Typ obecného rozhraní pro adaptér kontejneru.

Syntaxe

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

Poznámky

Typ popisuje obecné rozhraní pro tuto třídu adaptéru kontejneru šablony.

Příklad

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

Typ elementu pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef GValue generic_value;

Poznámky

Typ popisuje objekt typu GValue , který popisuje uloženou hodnotu elementu pro použití s obecným rozhraním pro tuto třídu kontejneru šablony. (GValue je buď value_type nebo value_type^ je-li value_type typ odkazu.)

Příklad

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

Přistupuje k podkladovému kontejneru.

Syntaxe

container_type^ get_container();

Poznámky

Členová funkce vrátí popisovač základního kontejneru. Použijete ho k obejití omezení uložených obálkou kontejneru.

Příklad

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

Nahradí řízenou sekvenci.

Syntaxe

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

Parametry

right
Adaptér kontejneru, který se má zkopírovat.

Poznámky

Operátor člena zkopíruje right objekt a pak vrátí *this. Slouží k nahrazení řízené sekvence kopií řízené sekvence v right.

Příklad

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

Odebere poslední prvek.

Syntaxe

void pop();

Poznámky

Členová funkce odebere poslední prvek řízené sekvence, která musí být neprázdná. Použijete ho stack ke zkrácení o jeden prvek na zadní straně.

Příklad

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

Přidá nový poslední prvek.

Syntaxe

void push(value_type val);

Poznámky

Členová funkce vloží prvek s hodnotou val na konec řízené sekvence. Použijete ho k připojení dalšího prvku do zásobníku.

Příklad

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

Typ odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

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

Spočítá počet prvků.

Syntaxe

size_type size();

Poznámky

Členová funkce vrátí délku řízené sekvence. Použijete ho k určení počtu prvků aktuálně v řízené sekvenci. Pokud vám záleží na tom, zda sekvence má nenulové velikosti, podívejte se stack::emptyna .

Příklad

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

Typ vzdálenosti se znaménkem mezi dvěma prvky

Syntaxe

typedef int size_type;

Poznámky

Typ popisuje nezáporný počet prvků.

Příklad

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

Vytvoří objekt adaptéru kontejneru.

Syntaxe

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

Parametry

right
Objekt, který chcete kopírovat.

wrapped
Zabalený kontejner, který se má použít.

Poznámky

Konstruktor:

stack();

vytvoří prázdný zabalený kontejner. Použijete ho k určení prázdné počáteční řízené sekvence.

Konstruktor:

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

vytvoří zabalený kontejner, který je kopií right.get_container(). Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem stack right.

Konstruktor:

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

vytvoří zabalený kontejner, který je kopií right->get_container(). Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem stack *right.

Konstruktor:

explicit stack(container_type% wrapped);

používá existující kontejner wrapped jako zabalený kontejner. Použijete ho k vytvoření stack z existujícího kontejneru.

Příklad

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

Zkopíruje řízenou sekvenci do nového pole.

Syntaxe

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

Poznámky

Členová funkce vrátí matici obsahující řízenou sekvenci. Použijete ji k získání kopie řízené sekvence ve formuláři pole.

Příklad

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

Přistupuje k poslednímu prvku.

Syntaxe

reference top();

Poznámky

Členová funkce vrátí odkaz na poslední prvek řízené sekvence, která musí být neprázdná. Použijete ho pro přístup k poslednímu prvku, pokud víte, že existuje.

Příklad

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

Přistupuje k poslednímu prvku.

Syntaxe

property value_type top_item;

Poznámky

Vlastnost přistupuje k poslednímu prvku řízené sekvence, která musí být neprázdná. Použijete ho ke čtení nebo zápisu posledního prvku, pokud víte, že existuje.

Příklad

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

Typ prvku

Syntaxe

typedef Value value_type;

Poznámky

Typ je synonymem pro parametr Valuešablony .

Příklad

// 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 nerovná se porovnávání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left == right). Použijete ho k otestování, jestli left není seřazený stejně jako right když jsou oba zásobníky porovnávány elementem.

Příklad

// 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 menší než porovnání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true if, pro nejnižší pozici i , pro kterou !(right[i] < left[i]) je také pravda left[i] < right[i]. V opačném případě se vrátí left->size() < right->size(). Použijete ho k otestování, zda left je seřazeno před right tím, než jsou tyto dva zásobníky porovnány elementem.

Příklad

// 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 menší než nebo rovno porovnání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(right < left). Použijete ho k otestování, jestli left není seřazený po right porovnání obou zásobníků elementem.

Příklad

// 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 stejné porovnání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true pouze v případě, že sekvence řízené left a right mají stejnou délku a pro každou pozici i, left[i] == right[i]. Použijete ho k otestování, jestli left je seřazeno stejně jako right když jsou oba zásobníky porovnávány elementem.

Příklad

// 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 větší než porovnání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí right < left. Použijete ho k otestování, zda left je seřazena za right , když jsou oba zásobníky porovnávány elementem.

Příklad

// 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 větší než nebo rovno porovnání.

Syntaxe

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

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left < right). Použijete ho k otestování, zda left není seřazena před right tím, když jsou tyto dva zásobníky porovnávány elementem.

Příklad

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

Sdílet prostřednictvím

stack (STL/CLR)

Syntaxe

Parametry

Požadavky

Deklarace

Rozhraní

Poznámky

Členové

stack::assign

Syntaxe

Parametry

Poznámky

Příklad

stack::const_reference

Syntaxe

Poznámky

Příklad

stack::container_type

Syntaxe

Poznámky

Příklad

stack::difference_type

Syntaxe

Poznámky

Příklad

stack::empty

Syntaxe

Poznámky

Příklad

stack::generic_container

Syntaxe

Poznámky

Příklad

stack::generic_value

Syntaxe

Poznámky

Příklad

stack::get_container

Syntaxe

Poznámky

Příklad

stack::operator=

Syntaxe

Parametry

Poznámky

Příklad

stack::pop

Syntaxe

Poznámky

Příklad

stack::push

Syntaxe

Poznámky

Příklad

stack::reference

Syntaxe

Poznámky

Příklad

stack::size

Syntaxe

Poznámky

Příklad

stack::size_type

Syntaxe

Poznámky

Příklad

stack::stack

Syntaxe

Parametry

Poznámky

Příklad

stack::to_array

Syntaxe

Poznámky

Příklad

stack::top

Syntaxe

Poznámky

Příklad

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