stack
(STL/CLR)
Klasa szablonu opisuje obiekt, który kontroluje różną długość sekwencji elementów, które mają ostatni dostęp do pierwszego wyjścia. Adapter kontenera stack
służy do zarządzania kontenerem bazowym jako stosem wypychanym.
W poniższym GValue
opisie jest taki sam, jak Value
w przypadku, gdy ten ostatni jest typem ref, w takim przypadku jest Value^
to . Podobnie, GContainer
jest taki sam jak Container
, chyba że ten ostatni jest typem ref, w takim przypadku jest to Container^
.
Składnia
template<typename Value,
typename Container>
ref class stack
: public
System::ICloneable,
Microsoft::VisualC::StlClr::IStack<GValue, GContainer>
{ ..... };
Parametry
Value
Typ elementu w kontrolowanej sekwencji.
Container
Typ kontenera bazowego.
Wymagania
Header:<cliext/stack>
Przestrzeń nazw: cliext
Deklaracje
Definicja typu | opis |
---|---|
stack::const_reference |
Typ stałego odwołania do elementu. |
stack::container_type |
Typ kontenera bazowego. |
stack::difference_type |
Typ odległości ze znakiem między dwoma elementami. |
stack::generic_container |
Typ interfejsu ogólnego dla karty kontenera. |
stack::generic_value |
Typ elementu dla interfejsu ogólnego dla karty kontenera. |
stack::reference |
Typ odwołania do elementu. |
stack::size_type |
Typ odległości ze znakiem między dwoma elementami. |
stack::value_type |
Typ elementu. |
Funkcja składowa | opis |
---|---|
stack::assign |
Zastępuje wszystkie elementy. |
stack::empty |
Sprawdza, czy nie ma żadnych elementów. |
stack::get_container |
Uzyskuje dostęp do bazowego kontenera. |
stack::pop |
Usuwa ostatni element. |
stack::push |
Dodaje nowy ostatni element. |
stack::size |
Liczy liczbę elementów. |
stack::stack |
Konstruuje obiekt kontenera. |
stack::top |
Uzyskuje dostęp do ostatniego elementu. |
stack::to_array |
Kopiuje kontrolowaną sekwencję do nowej tablicy. |
Właściwości | opis |
---|---|
stack::top_item |
Uzyskuje dostęp do ostatniego elementu. |
Operator | opis |
---|---|
stack::operator= |
Zastępuje kontrolowaną sekwencję. |
operator!= (stos) |
Określa, czy stack obiekt nie jest równy innemu stack obiektowi. |
operator< (stos) |
Określa, czy stack obiekt jest mniejszy niż inny stack obiekt. |
operator<= (stos) |
Określa, czy stack obiekt jest mniejszy lub równy innemu stack obiektowi. |
operator== (stos) |
Określa, czy stack obiekt jest równy innemu stack obiektowi. |
operator> (stos) |
Określa, czy stack obiekt jest większy niż inny stack obiekt. |
operator>= (stos) |
Określa, czy stack obiekt jest większy lub równy innemu stack obiektowi. |
Interfejsy
Interfejs | opis |
---|---|
ICloneable | Duplikuj obiekt. |
IStack<Value, Container> |
Obsługa ogólnej karty kontenera. |
Uwagi
Obiekt przydziela i zwalnia magazyn dla sekwencji, którą kontroluje za pośrednictwem bazowego kontenera typu Container
, który przechowuje Value
elementy i rośnie na żądanie. Obiekt ogranicza dostęp do wypychania i wyskakywania tylko ostatniego elementu, implementując kolejkę last-in first-out (znaną również jako kolejka LIFO lub stos).
Elementy członkowskie
stack::assign
Zastępuje wszystkie elementy.
Składnia
void assign(stack<Value, Container>% right);
Parametry
right
Adapter kontenera do wstawienia.
Uwagi
Funkcja składowa przypisuje right.get_container()
do kontenera bazowego. Służy do zmiany całej zawartości stosu.
Przykład
// 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 stałego odwołania do elementu.
Składnia
typedef value_type% const_reference;
Uwagi
Typ opisuje stałe odwołanie do elementu.
Przykład
// 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 kontenera bazowego.
Składnia
typedef Container value_type;
Uwagi
Typ jest synonimem parametru Container
szablonu .
Przykład
// 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 podpisanej odległości między dwoma elementami.
Składnia
typedef int difference_type;
Uwagi
Typ opisuje prawdopodobnie ujemną liczbę elementów.
Przykład
// 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
Sprawdza, czy nie ma żadnych elementów.
Składnia
bool empty();
Uwagi
Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest to odpowiednik size() == 0
elementu . Służy do testowania, czy element stack
jest pusty.
Przykład
// 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 interfejsu ogólnego dla karty kontenera.
Składnia
typedef Microsoft::VisualC::StlClr::IStack<Value>
generic_container;
Uwagi
Typ opisuje ogólny interfejs dla tej klasy adaptera kontenera szablonu.
Przykład
// 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 do użycia z interfejsem ogólnym kontenera.
Składnia
typedef GValue generic_value;
Uwagi
Typ opisuje obiekt typu GValue
, który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu. (GValue
jest value_type
albo jeśli value_type^
value_type
jest typem ref).
Przykład
// 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
Uzyskuje dostęp do bazowego kontenera.
Składnia
container_type^ get_container();
Uwagi
Funkcja składowa zwraca uchwyt dla kontenera bazowego. Służy do obejścia ograniczeń narzuconych przez otokę kontenera.
Przykład
// 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=
Zastępuje kontrolowaną sekwencję.
Składnia
stack<Value, Container>% operator=(stack<Value, Container>% right);
Parametry
right
Adapter kontenera do skopiowania.
Uwagi
Operator elementu członkowskiego kopiuje right
do obiektu, a następnie zwraca wartość *this
. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji w pliku right
.
Przykład
// 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
Usuwa ostatni element.
Składnia
void pop();
Uwagi
Funkcja składowa usuwa ostatni element kontrolowanej sekwencji, który musi być niepusty. Służy do skrócenia ciągu stack
o jeden element z tyłu.
Przykład
// 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
Dodaje nowy ostatni element.
Składnia
void push(value_type val);
Uwagi
Funkcja składowa wstawia element z wartością val
na końcu kontrolowanej sekwencji. Służy do dołączania innego elementu do stosu.
Przykład
// 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 odwołania do elementu.
Składnia
typedef value_type% reference;
Uwagi
Typ opisuje odwołanie do elementu.
Przykład
// 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
Liczy liczbę elementów.
Składnia
size_type size();
Uwagi
Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar niezerowy, zobacz stack::empty
.
Przykład
// 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 odległości ze znakiem między dwoma elementami.
Składnia
typedef int size_type;
Uwagi
Typ opisuje nieujemną liczbę elementów.
Przykład
// 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
Tworzy obiekt adaptera kontenera.
Składnia
stack();
stack(stack<Value, Container>% right);
stack(stack<Value, Container>^ right);
explicit stack(container_type% wrapped);
Parametry
right
Obiekt do skopiowania.
wrapped
Opakowany kontener do użycia.
Uwagi
Konstruktor:
stack();
Tworzy pusty opakowany kontener. Służy do określania pustej początkowej kontrolowanej sekwencji.
Konstruktor:
stack(stack<Value, Container>% right);
Tworzy opakowany kontener, który jest kopią right.get_container()
. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej stack
przez obiekt right
.
Konstruktor:
stack(stack<Value, Container>^ right);
Tworzy opakowany kontener, który jest kopią right->get_container()
. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej stack
przez obiekt *right
.
Konstruktor:
explicit stack(container_type% wrapped);
używa istniejącego kontenera wrapped
jako opakowany kontener. Służy do konstruowania obiektu stack
z istniejącego kontenera.
Przykład
// 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
Kopiuje kontrolowaną sekwencję do nowej tablicy.
Składnia
cli::array<Value>^ to_array();
Uwagi
Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.
Przykład
// 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
Uzyskuje dostęp do ostatniego elementu.
Składnia
reference top();
Uwagi
Funkcja składowa zwraca odwołanie do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do uzyskiwania dostępu do ostatniego elementu, gdy wiadomo, że istnieje.
Przykład
// 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
Uzyskuje dostęp do ostatniego elementu.
Składnia
property value_type top_item;
Uwagi
Właściwość uzyskuje dostęp do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania ostatniego elementu, gdy wiadomo, że istnieje.
Przykład
// 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 elementu.
Składnia
typedef Value value_type;
Uwagi
Typ jest synonimem parametru Value
szablonu .
Przykład
// 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!=
(stos)
Stack
nie jest równe porównanie.
Składnia
template<typename Value,
typename Container>
bool operator!=(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(left == right)
wartość . Służy do testowania, czy left
nie jest uporządkowane tak samo, jak right
w przypadku, gdy dwa stosy są porównywane element według elementu.
Przykład
// 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<
(stos)
Stack
mniejsze niż porównanie.
Składnia
template<typename Value,
typename Container>
bool operator<(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca wartość true, jeśli dla najniższej pozycji i
, dla której !(right[i] < left[i])
jest również prawdziwe, że left[i] < right[i]
. W przeciwnym razie zwraca wartość left->size() < right->size()
. Służy do testowania, czy left
jest uporządkowane przed right
, gdy dwa stosy są porównywane element według elementu.
Przykład
// 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<=
(stos)
Stack
mniejsze niż lub równe porównanie.
Składnia
template<typename Value,
typename Container>
bool operator<=(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(right < left)
wartość . Służy do testowania, czy left
nie są uporządkowane po right
tym, jak dwa stosy są porównywane z elementem.
Przykład
// 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==
(stos)
Stack
równe porównanie.
Składnia
template<typename Value,
typename Container>
bool operator==(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca wartość true tylko wtedy, gdy sekwencje kontrolowane przez left
i right
mają taką samą długość, a dla każdej pozycji i
, left[i] == right[i]
. Służy do testowania, czy left
jest uporządkowana tak samo, jak right
w przypadku porównywania dwóch stosów według elementu.
Przykład
// 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>
(stos)
Stack
większe niż porównanie.
Składnia
template<typename Value,
typename Container>
bool operator>(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca right < left
wartość . Służy do testowania, czy left
jest uporządkowane po right
tym, jak dwa stosy są porównywane element według elementu.
Przykład
// 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>=
(stos)
Stack
większe niż lub równe porównanie.
Składnia
template<typename Value,
typename Container>
bool operator>=(stack<Value, Container>% left,
stack<Value, Container>% right);
Parametry
left
Pozostaw kontener do porównania.
right
Odpowiedni kontener do porównania.
Uwagi
Funkcja operatora zwraca !(left < right)
wartość . Służy do testowania, czy left
nie jest uporządkowana wcześniej right
, gdy dwa stosy są porównywane element według elementu.
Przykład
// 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