`<cliext/utility>` (STL/CLR)

Artykuł
10/12/2023

Dołącz nagłówek <cliext/utility> STL/CLR, aby zdefiniować szablon pair klasy i kilka szablonów pomocniczych funkcji.

Składnia

#include <cliext/utility>

Wymagania

Header:<cliext/utility>

Przestrzeń nazw: cliext

Deklaracje

Klasa	opis
`pair`	Zawijaj parę elementów.

Operator	opis
`operator==` (para)	`pair` równe porównanie.
`operator!=` (para)	`pair` nie jest równe porównanie.
`operator<` (para)	`pair` mniejsze niż porównanie.
`operator<=` (para)	`pair` mniejsze niż lub równe porównanie.
`operator>` (para)	`pair` większe niż porównanie.
`operator>=` (para)	`pair` większe niż lub równe porównanie.

Function	opis
`make_pair`	Utwórz wartość `pair` na podstawie pary wartości.

`pair`

Klasa szablonu opisuje obiekt, który opakowuje parę wartości.

Składnia

template<typename Value1,
    typename Value2>
    ref class pair;

Parametry

Value1
Typ pierwszej opakowanej wartości.

Value2
Typ drugiej opakowanej wartości.

Elementy członkowskie

Definicja typu	opis
`pair::first_type`	Typ pierwszej opakowanej wartości.
`pair::second_type`	Typ drugiej opakowanej wartości.

Obiekt członkowski	opis
`pair::first`	Pierwsza przechowywana wartość.
`pair::second`	Druga przechowywana wartość.

Funkcja składowa	opis
`pair::pair`	`pair` Tworzy obiekt.
`pair::swap`	Zamienia zawartość dwóch `pair` obiektów.

Operator	opis
`pair::operator=`	Zastępuje przechowywaną parę wartości.

Uwagi

Obiekt przechowuje parę wartości. Ta klasa szablonu służy do łączenia dwóch wartości w jeden obiekt. Ponadto obiekt cliext::pair (opisany tutaj) przechowuje tylko typy zarządzane; aby przechowywać parę niezarządzanych typów, użyj metody std::pair, zadeklarowanej w pliku <utility>.

`pair::first`

Pierwsza opakowana wartość.

Składnia

Value1 first;

Uwagi

Obiekt przechowuje pierwszą opakowaną wartość.

Przykład

// cliext_pair_first.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

    cliext::pair<wchar_t, int>::first_type first_val = c1.first;
    cliext::pair<wchar_t, int>::second_type second_val = c1.second;
    System::Console::WriteLine("[{0}, {1}]", first_val, second_val);
    return (0);
    }

[x, 3]

`pair::first_type`

Typ pierwszej opakowanej wartości.

Składnia

typedef Value1 first_type;

Uwagi

Typ jest synonimem parametru Value1szablonu .

Przykład

// cliext_pair_first_type.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

    cliext::pair<wchar_t, int>::first_type first_val = c1.first;
    cliext::pair<wchar_t, int>::second_type second_val = c1.second;
    System::Console::WriteLine("[{0}, {1}]", first_val, second_val);
    return (0);
    }

[x, 3]

`pair::operator=`

Zastępuje przechowywaną parę wartości.

Składnia

pair<Value1, Value2>% operator=(pair<Value1, Value2>% right);

Parametry

right
pair do skopiowania.

Uwagi

Operator elementu członkowskiego kopiuje right do obiektu, a następnie zwraca wartość *this. Służy do zastępowania przechowywanej pary wartości kopią przechowywanej pary wartości w pliku right.

Przykład

// cliext_pair_operator_as.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

// assign to a new pair
    cliext::pair<wchar_t, int> c2;
    c2 = c1;
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);
    return (0);
    }

[x, 3]
[x, 3]

`pair::pair`

pair Tworzy obiekt.

Składnia

pair();
pair(pair<Coll>% right);
pair(pair<Coll>^ right);
pair(Value1 val1, Value2 val2);

Parametry

right
pair do przechowywania.

val1
Pierwsza wartość do przechowywania.

val2
Druga wartość do przechowywania.

Uwagi

Konstruktor:

pair();

Inicjuje przechowywaną parę z wartościami domyślnymi.

Konstruktor:

pair(pair<Value1, Value2>% right);

inicjuje przechowywaną parę z elementami right.first i right.second.

pair(pair<Value1, Value2>^ right);

inicjuje przechowywaną parę z elementami right->first i right->second.

Konstruktor:

pair(Value1 val1, Value2 val2);

inicjuje przechowywaną parę z elementami val1 i val2.

Przykład

// cliext_pair_construct.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
// construct an empty container
    cliext::pair<wchar_t, int> c1;
    System::Console::WriteLine("[{0}, {1}]",
        c1.first == L'\0' ? "\\0" : "??", c1.second);

// construct with a pair of values
    cliext::pair<wchar_t, int> c2(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

// construct by copying another pair
    cliext::pair<wchar_t, int> c3(c2);
    System::Console::WriteLine("[{0}, {1}]", c3.first, c3.second);

// construct by copying a pair handle
    cliext::pair<wchar_t, int> c4(%c3);
    System::Console::WriteLine("[{0}, {1}]", c4.first, c4.second);

    return (0);
    }

[\0, 0]
[x, 3]
[x, 3]
[x, 3]

`pair::second`

Druga opakowana wartość.

Składnia

Value2 second;

Uwagi

Obiekt przechowuje drugą opakowaną wartość.

Przykład

// cliext_pair_second.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

    cliext::pair<wchar_t, int>::first_type first_val = c1.first;
    cliext::pair<wchar_t, int>::second_type second_val = c1.second;
    System::Console::WriteLine("[{0}, {1}]", first_val, second_val);
    return (0);
    }

[x, 3]

`pair::second_type`

Typ drugiej opakowanej wartości.

Składnia

typedef Value2 second_type;

Uwagi

Typ jest synonimem parametru Value2szablonu .

Przykład

// cliext_pair_second_type.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

    cliext::pair<wchar_t, int>::first_type first_val = c1.first;
    cliext::pair<wchar_t, int>::second_type second_val = c1.second;
    System::Console::WriteLine("[{0}, {1}]", first_val, second_val);
    return (0);
    }

[x, 3]

`pair::swap`

Zamienia zawartość dwóch pair obiektów.

Składnia

void swap(pair<Value1, Value2>% right);

Parametry

right
pair aby zamienić zawartość na.

Uwagi

Funkcja składowa zamienia przechowywaną parę wartości między *this i right.

Przykład

// cliext_pair_swap.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>

typedef cliext::collection_adapter<
    System::Collections::ICollection> Mycoll;
int main()
    {
    cliext::deque<wchar_t> d1;
    d1.push_back(L'a');
    d1.push_back(L'b');
    d1.push_back(L'c');
    Mycoll c1(%d1);

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

// construct another container with repetition of values
    cliext::deque<wchar_t> d2(5, L'x');
    Mycoll c2(%d2);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

`make_pair`

Utwórz wartość pair na podstawie pary wartości.

Składnia

template<typename Value1,
    typename Value2>
    pair<Value1, Value2> make_pair(Value1 first, Value2 second);

Parametry

Value1
Typ pierwszej opakowanej wartości.

Value2
Typ drugiej opakowanej wartości.

first
Pierwsza wartość do opakowania.

second
Druga wartość do opakowania.

Uwagi

Szablon funkcji zwraca wartość pair<Value1, Value2>(first, second). Służy do konstruowania pair<Value1, Value2> obiektu z pary wartości.

Przykład

// cliext_make_pair.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);

    c1 = cliext::make_pair(L'y', 4);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    return (0);
    }

[x, 3]
[y, 4]

`operator!=` (para)

pair nie jest równe porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator!=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair 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 pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_ne.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] != [x 3] is {0}",
        c1 != c1);
    System::Console::WriteLine("[x 3] != [x 4] is {0}",
        c1 != c2);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] != [x 3] is False
[x 3] != [x 4] is True

`operator<`

pair mniejsze niż porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator<(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair do porównania.

Uwagi

Funkcja operatora zwraca left.first < right.first || !(right.first < left.first && left.second < right.secondwartość . Służy do testowania, czy left są uporządkowane przed right , gdy dwa pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_lt.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] < [x 3] is {0}",
        c1 < c1);
    System::Console::WriteLine("[x 3] < [x 4] is {0}",
        c1 < c2);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] < [x 3] is False
[x 3] < [x 4] is True

`operator<=`

pair mniejsze niż lub równe porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator<=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair 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 pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_le.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] <= [x 3] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[x 4] <= [x 3] is {0}",
        c2 <= c1);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] <= [x 3] is True
[x 4] <= [x 3] is False

`operator==`

pair równe porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator==(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair do porównania.

Uwagi

Funkcja operatora zwraca left.first == right.first && left.second == right.secondwartość . Służy do testowania, czy left jest uporządkowane tak samo, jak right w przypadku, gdy dwa pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_eq.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] == [x 3] is {0}",
        c1 == c1);
    System::Console::WriteLine("[x 3] == [x 4] is {0}",
        c1 == c2);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] == [x 3] is True
[x 3] == [x 4] is False

`pair::operator>`

pair większe niż porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator>(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair do porównania.

Uwagi

Funkcja operatora zwraca right < leftwartość . Służy do testowania, czy left jest uporządkowane po right tym, jak dwa pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_gt.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] > [x 3] is {0}",
        c1 > c1);
    System::Console::WriteLine("[x 4] > [x 3] is {0}",
        c2 > c1);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] > [x 3] is False
[x 4] > [x 3] is True

`operator>=`

pair większe niż lub równe porównanie.

Składnia

template<typename Value1,
    typename Value2>
    bool operator>=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parametry

left
W lewo pair , aby porównać.

right
Prawo pair do porównania.

Uwagi

Funkcja operatora zwraca !(left < right)wartość . Służy do testowania, czy left nie są uporządkowane przed right , gdy dwa pair obiekty są porównywane element według elementu.

Przykład

// cliext_pair_operator_ge.cpp
// compile with: /clr
#include <cliext/utility>

int main()
    {
    cliext::pair<wchar_t, int> c1(L'x', 3);
    System::Console::WriteLine("[{0}, {1}]", c1.first, c1.second);
    cliext::pair<wchar_t, int> c2(L'x', 4);
    System::Console::WriteLine("[{0}, {1}]", c2.first, c2.second);

    System::Console::WriteLine("[x 3] >= [x 3] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[x 3] >= [x 4] is {0}",
        c1 >= c2);
    return (0);
    }

[x, 3]
[x, 4]
[x 3] >= [x 3] is True
[x 3] >= [x 4] is False

Udostępnij za pośrednictwem

<cliext/utility> (STL/CLR)

Składnia

Wymagania

Deklaracje

pair

Składnia

Parametry

Elementy członkowskie

Uwagi

pair::first

Składnia

Uwagi

Przykład

pair::first_type

Składnia

Uwagi

Przykład

pair::operator=

Składnia

Parametry

Uwagi

Przykład

pair::pair

Składnia

Parametry

Uwagi

Przykład

pair::second

Składnia

Uwagi

Przykład

pair::second_type

Składnia

Uwagi

Przykład

pair::swap

Składnia

Parametry

Uwagi

Przykład

make_pair

Składnia

Parametry

Uwagi

Przykład

operator!= (para)

Składnia

Parametry

Uwagi

Przykład

operator<

Składnia

Parametry

Uwagi

Przykład

operator<=

Składnia

Parametry

Uwagi

Przykład

operator==

Składnia

Parametry

Uwagi

Przykład

pair::operator>

Składnia

Parametry

Uwagi

Przykład

operator>=

Składnia

Parametry

Uwagi

Przykład

Opinia

Dodatkowe zasoby

`<cliext/utility>` (STL/CLR)

`pair`

`pair::first`

`pair::first_type`

`pair::operator=`

`pair::pair`

`pair::second`

`pair::second_type`

`pair::swap`

`make_pair`

`operator!=` (para)

`operator<`

`operator<=`

`operator==`

`pair::operator>`

`operator>=`