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

Articolo
10/12/2023

Includere l'intestazione <cliext/utility> STL/CLR per definire il modello pair di classe e diversi modelli di funzione di supporto.

Sintassi

#include <cliext/utility>

Requisiti

Intestazione:<cliext/utility>

Spazio dei nomi: cliext

Dichiarazioni

Classe	Descrizione
`pair`	Eseguire il wrapping di una coppia di elementi.

Operatore	Descrizione
`operator==` (coppia)	`pair` confronto uguale.
`operator!=` (coppia)	`pair` confronto diverso.
`operator<` (coppia)	`pair` minore di confronto.
`operator<=` (coppia)	`pair` confronto minore o uguale.
`operator>` (coppia)	`pair` maggiore del confronto.
`operator>=` (coppia)	`pair` confronto maggiore o uguale.

Funzione	Descrizione
`make_pair`	Creare un oggetto `pair` da una coppia di valori.

`pair`

La classe modello descrive un oggetto che esegue il wrapping di una coppia di valori.

Sintassi

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

Parametri

Value1
Tipo del primo valore di cui è stato eseguito il wrapping.

Value2
Tipo del secondo valore di cui è stato eseguito il wrapping.

Membri

Definizione dei tipi	Descrizione
`pair::first_type`	Tipo del primo valore di cui è stato eseguito il wrapping.
`pair::second_type`	Tipo del secondo valore di cui è stato eseguito il wrapping.

Oggetto Member	Descrizione
`pair::first`	Primo valore archiviato.
`pair::second`	Secondo valore archiviato.

Funzione membro	Descrizione
`pair::pair`	Costruisce un oggetto `pair`.
`pair::swap`	Scambia il contenuto di due `pair` oggetti.

Operatore	Descrizione
`pair::operator=`	Sostituisce la coppia di valori archiviata.

Osservazioni:

L'oggetto archivia una coppia di valori. Questa classe modello viene usata per combinare due valori in un singolo oggetto. Inoltre, l'oggetto cliext::pair (descritto qui) archivia solo i tipi gestiti. Per archiviare una coppia di tipi non gestiti, usare std::pair, dichiarato in <utility>.

`pair::first`

Primo valore di cui è stato eseguito il wrapping.

Sintassi

Value1 first;

Osservazioni:

L'oggetto archivia il primo valore di cui è stato eseguito il wrapping.

Esempio

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

Tipo del primo valore di cui è stato eseguito il wrapping.

Sintassi

typedef Value1 first_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value1.

Esempio

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

Sostituisce la coppia di valori archiviata.

Sintassi

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

Parametri

right
pair da copiare.

Osservazioni:

L'operatore membro copia right nell'oggetto , quindi restituisce *this. Viene usato per sostituire la coppia archiviata di valori con una copia della coppia di valori archiviata in right.

Esempio

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

Costruisce un oggetto pair.

Sintassi

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

Parametri

right
pair per archiviare.

val1
Primo valore da archiviare.

val2
Secondo valore da archiviare.

Osservazioni:

Costruttore:

pair();

inizializza la coppia archiviata con valori costruiti predefiniti.

Costruttore:

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

inizializza la coppia archiviata con right.first e right.second.

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

inizializza la coppia archiviata con right->first e right->second.

Costruttore:

pair(Value1 val1, Value2 val2);

inizializza la coppia archiviata con val1 e val2.

Esempio

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

Secondo valore di cui è stato eseguito il wrapping.

Sintassi

Value2 second;

Osservazioni:

L'oggetto archivia il secondo valore di cui è stato eseguito il wrapping.

Esempio

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

Tipo del secondo valore di cui è stato eseguito il wrapping.

Sintassi

typedef Value2 second_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value2.

Esempio

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

Scambia il contenuto di due pair oggetti.

Sintassi

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

Parametri

right
pair per scambiare il contenuto con .

Osservazioni:

La funzione membro scambia la coppia archiviata di valori tra *this e right.

Esempio

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

Creare un oggetto pair da una coppia di valori.

Sintassi

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

Parametri

Value1
Tipo del primo valore di cui è stato eseguito il wrapping.

Value2
Tipo del secondo valore di cui è stato eseguito il wrapping.

first
Primo valore di cui eseguire il wrapping.

second
Secondo valore di cui eseguire il wrapping.

Osservazioni:

Il modello di funzione restituisce pair<Value1, Value2>(first, second). Viene usato per costruire un pair<Value1, Value2> oggetto da una coppia di valori.

Esempio

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

pair confronto diverso.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

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

Esempio

// 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 minore di confronto.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

La funzione dell'operatore restituisce left.first < right.first || !(right.first < left.first && left.second < right.second. Viene usato per verificare se left viene ordinato prima right quando i due pair oggetti vengono confrontati in base all'elemento.

Esempio

// 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 confronto minore o uguale.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

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

Esempio

// 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 confronto uguale.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

La funzione dell'operatore restituisce left.first == right.first && left.second == right.second. Viene usato per verificare se left viene ordinato come right quando i due pair oggetti vengono confrontati in base all'elemento.

Esempio

// 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 maggiore del confronto.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

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

Esempio

// 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 confronto maggiore o uguale.

Sintassi

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

Parametri

left
Sinistra pair da confrontare.

right
Diritto pair di confronto.

Osservazioni:

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

Esempio

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

Condividi tramite

<cliext/utility> (STL/CLR)

Sintassi

Requisiti

Dichiarazioni

pair

Sintassi

Parametri

Membri

Osservazioni:

pair::first

Sintassi

Osservazioni:

Esempio

pair::first_type

Sintassi

Osservazioni:

Esempio

pair::operator=

Sintassi

Parametri

Osservazioni:

Esempio

pair::pair

Sintassi

Parametri

Osservazioni:

Esempio

pair::second

Sintassi

Osservazioni:

Esempio

pair::second_type

Sintassi

Osservazioni:

Esempio

pair::swap

Sintassi

Parametri

Osservazioni:

Esempio

make_pair

Sintassi

Parametri

Osservazioni:

Esempio

operator!= (coppia)

Sintassi

Parametri

Osservazioni:

Esempio

operator<

Sintassi

Parametri

Osservazioni:

Esempio

operator<=

Sintassi

Parametri

Osservazioni:

Esempio

operator==

Sintassi

Parametri

Osservazioni:

Esempio

pair::operator>

Sintassi

Parametri

Osservazioni:

Esempio

operator>=

Sintassi

Parametri

Osservazioni:

Esempio

Commenti e suggerimenti

Risorse aggiuntive

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

`pair`

`pair::first`

`pair::first_type`

`pair::operator=`

`pair::pair`

`pair::second`

`pair::second_type`

`pair::swap`

`make_pair`

`operator!=` (coppia)

`operator<`

`operator<=`

`operator==`

`pair::operator>`

`operator>=`