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

Artikel
10/12/2023

Fügen Sie den STL/CLR-Header <cliext/utility> ein, um die Klassenvorlage pair und mehrere unterstützende Funktionsvorlagen zu definieren.

Syntax

#include <cliext/utility>

Requirements (Anforderungen)

Header:<cliext/utility>

Namespace:cliext

Deklarationen

Klasse	Beschreibung
`pair`	Umschließen sie ein Elementpaar.

Operator	Beschreibung
`operator==` (Paar)	`pair` gleicher Vergleich.
`operator!=` (Paar)	`pair` ungleicher Vergleich.
`operator<` (Paar)	`pair` kleiner als vergleich.
`operator<=` (Paar)	`pair` kleiner oder gleicher Vergleich.
`operator>` (Paar)	`pair` größer als der Vergleich.
`operator>=` (Paar)	`pair` größer als oder gleicher Vergleich.

Function	Beschreibung
`make_pair`	Erstellen Sie ein `pair` Aus einem Wertepaar.

`pair`

Die Vorlagenklasse beschreibt ein Objekt, das ein Wertepaar umschließt.

Syntax

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

Parameter

Value1
Der Typ des ersten umschlossenen Werts.

Value2
Der Typ des zweiten umschlossenen Werts.

Member

Typdefinition	Beschreibung
`pair::first_type`	Der Typ des ersten umschlossenen Werts.
`pair::second_type`	Der Typ des zweiten umschlossenen Werts.

Member-Objekt	Beschreibung
`pair::first`	Der erste gespeicherte Wert.
`pair::second`	Der zweite gespeicherte Wert.

Memberfunktion	Beschreibung
`pair::pair`	Erstellt ein `pair`-Objekt.
`pair::swap`	Vertauscht den Inhalt von zwei `pair`-Objekten.

Operator	Beschreibung
`pair::operator=`	Ersetzt das gespeicherte Wertepaar.

Hinweise

Das Objekt speichert ein Wertepaar. Sie verwenden diese Vorlagenklasse, um zwei Werte in einem einzelnen Objekt zu kombinieren. Außerdem speichert das Objekt cliext::pair (hier beschrieben) nur verwaltete Typen; um ein Paar nicht verwalteter Typen zu speichern, std::pairdie in deklariert sind <utility>.

`pair::first`

Der erste umschlossene Wert.

Syntax

Value1 first;

Hinweise

Das Objekt speichert den ersten umschlossenen Wert.

Beispiel

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

Der Typ des ersten umschlossenen Werts.

Syntax

typedef Value1 first_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Value1dar.

Beispiel

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

Ersetzt das gespeicherte Wertepaar.

Syntax

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

Parameter

right
pair zu kopieren.

Hinweise

Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie verwenden es, um das gespeicherte Wertepaar durch eine Kopie des gespeicherten Wertepaars in right.

Beispiel

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

Erstellt ein pair-Objekt.

Syntax

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

Parameter

right
pair zu speichern.

val1
Erster Wert, der gespeichert werden soll.

val2
Zweiter Wert, der gespeichert werden soll.

Hinweise

Der Konstruktor:

pair();

initialisiert das gespeicherte Paar mit konstruierten Standardwerten.

Der Konstruktor:

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

initialisiert das gespeicherte Paar mit right.first und right.second.

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

initialisiert das gespeicherte Paar mit right->first und right->second.

Der Konstruktor:

pair(Value1 val1, Value2 val2);

initialisiert das gespeicherte Paar mit val1 und val2.

Beispiel

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

Der zweite umschlossene Wert.

Syntax

Value2 second;

Hinweise

Das Objekt speichert den zweiten umschlossenen Wert.

Beispiel

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

Der Typ des zweiten umschlossenen Werts.

Syntax

typedef Value2 second_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Value2dar.

Beispiel

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

Vertauscht den Inhalt von zwei pair-Objekten.

Syntax

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

Parameter

right
pair um Inhalte zu tauschen.

Hinweise

Die Memberfunktion tauscht das gespeicherte Wertepaar zwischen *this und right.

Beispiel

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

Erstellen Sie ein pair Aus einem Wertepaar.

Syntax

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

Parameter

Value1
Der Typ des ersten umschlossenen Werts.

Value2
Der Typ des zweiten umschlossenen Werts.

first
Erster Wert, der umbrochen werden soll.

second
Zweiter Wert, der umbrochen werden soll.

Hinweise

Die Funktionsvorlage gibt zurück pair<Value1, Value2>(first, second). Sie verwenden es, um ein pair<Value1, Value2> Objekt aus einem Wertepaar zu konstruieren.

Beispiel

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

pair ungleicher Vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück !(left == right). Sie verwenden sie, um zu testen, ob left die Reihenfolge nicht identisch ist, wenn right die beiden pair Objekte nach Element verglichen werden.

Beispiel

// 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 kleiner als vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück left.first < right.first || !(right.first < left.first && left.second < right.second. Sie verwenden es, um zu testen, ob left das Vorher right sortiert wird, wenn die beiden pair Objekte nach Element verglichen werden.

Beispiel

// 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 kleiner oder gleicher Vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück !(right < left). Sie verwenden es, um zu testen, ob left das Element nach Element nicht sortiert right wird, wenn die beiden pair Objekte nach Element verglichen werden.

Beispiel

// 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 gleicher Vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück left.first == right.first && left.second == right.second. Sie verwenden es, um zu testen, ob left die Reihenfolge wie bei einem Vergleich der beiden pair Objekte nach Element identisch right ist.

Beispiel

// 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 größer als der Vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück right < left. Sie verwenden es, um zu testen, ob left nach right dem Vergleich der beiden pair Objekte Element nach Element sortiert wird.

Beispiel

// 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 größer als oder gleicher Vergleich.

Syntax

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

Parameter

left
Links pair , um zu vergleichen.

right
Recht pair zum Vergleichen.

Hinweise

Die Operatorfunktion gibt zurück !(left < right). Sie verwenden sie, um zu testen, ob die beiden pair Objekte nach Element verglichen werden, bevor leftright sie nicht sortiert werden.

Beispiel

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

<cliext/utility> (STL/CLR)

Syntax

Requirements (Anforderungen)

Deklarationen

pair

Syntax

Parameter

Member

Hinweise

pair::first

Syntax

Hinweise

Beispiel

pair::first_type

Syntax

Hinweise

Beispiel

pair::operator=

Syntax

Parameter

Hinweise

Beispiel

pair::pair

Syntax

Parameter

Hinweise

Beispiel

pair::second

Syntax

Hinweise

Beispiel

pair::second_type

Syntax

Hinweise

Beispiel

pair::swap

Syntax

Parameter

Hinweise

Beispiel

make_pair

Syntax

Parameter

Hinweise

Beispiel

operator!= (Paar)

Syntax

Parameter

Hinweise

Beispiel

operator<

Syntax

Parameter

Hinweise

Beispiel

operator<=

Syntax

Parameter

Hinweise

Beispiel

operator==

Syntax

Parameter

Hinweise

Beispiel

pair::operator>

Syntax

Parameter

Hinweise

Beispiel

operator>=

Syntax

Parameter

Hinweise

Beispiel

Feedback

Feedback

Zusätzliche Ressourcen

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

`pair`

`pair::first`

`pair::first_type`

`pair::operator=`

`pair::pair`

`pair::second`

`pair::second_type`

`pair::swap`

`make_pair`

`operator!=` (Paar)

`operator<`

`operator<=`

`operator==`

`pair::operator>`

`operator>=`