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

Article
10/12/2023

Incluez l’en-tête <cliext/utility> STL/CLR pour définir le modèle pair de classe et plusieurs modèles de fonction de prise en charge.

Syntaxe

#include <cliext/utility>

Spécifications

Header :<cliext/utility>

Espace de noms : cliext

Déclarations

Classe	Description
`pair`	Encapsulez une paire d’éléments.

Opérateur	Description
`operator==` (paire)	`pair` comparaison égale.
`operator!=` (paire)	`pair` comparaison différente.
`operator<` (paire)	`pair` inférieur à la comparaison.
`operator<=` (paire)	`pair` comparaison inférieure ou égale.
`operator>` (paire)	`pair` supérieur à la comparaison.
`operator>=` (paire)	`pair` supérieur ou égal à la comparaison.

Fonction	Description
`make_pair`	Créez une `pair` paire de valeurs.

`pair`

La classe de modèle décrit un objet qui encapsule une paire de valeurs.

Syntaxe

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

Paramètres

Value1
Type de première valeur encapsulée.

Value2
Type de deuxième valeur encapsulée.

Membres

Définition de types	Description
`pair::first_type`	Type de la première valeur encapsulée.
`pair::second_type`	Type de la deuxième valeur encapsulée.

Objet Member	Description
`pair::first`	Première valeur stockée.
`pair::second`	Deuxième valeur stockée.

Fonction membre	Description
`pair::pair`	Construit un objet `pair`.
`pair::swap`	Échange le contenu de deux `pair` objets.

Opérateur	Description
`pair::operator=`	Remplace la paire stockée de valeurs.

Notes

L’objet stocke une paire de valeurs. Vous utilisez cette classe de modèle pour combiner deux valeurs en un seul objet. En outre, l’objet cliext::pair (décrit ici) stocke uniquement les types managés ; pour stocker une paire de types non managés utilisent std::pair, déclaré dans <utility>.

`pair::first`

Première valeur encapsulée.

Syntaxe

Value1 first;

Notes

L’objet stocke la première valeur encapsulée.

Exemple

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

Type de la première valeur encapsulée.

Syntaxe

typedef Value1 first_type;

Notes

Le type est un synonyme du paramètre de modèle Value1.

Exemple

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

Remplace la paire stockée de valeurs.

Syntaxe

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

Paramètres

right
pair à copier.

Notes

L’opérateur membre copie right dans l’objet, puis retourne *this. Vous l’utilisez pour remplacer la paire stockée de valeurs par une copie de la paire stockée de valeurs dans right.

Exemple

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

Construit un objet pair.

Syntaxe

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

Paramètres

right
pair à stocker.

val1
Première valeur à stocker.

val2
Deuxième valeur à stocker.

Notes

Constructeur :

pair();

initialise la paire stockée avec des valeurs construites par défaut.

Constructeur :

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

initialise la paire stockée avec right.first et right.second.

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

initialise la paire stockée avec right->first et right->second.

Constructeur :

pair(Value1 val1, Value2 val2);

initialise la paire stockée avec val1 et val2.

Exemple

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

Deuxième valeur encapsulée.

Syntaxe

Value2 second;

Notes

L’objet stocke la deuxième valeur encapsulée.

Exemple

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

Type de la deuxième valeur encapsulée.

Syntaxe

typedef Value2 second_type;

Notes

Le type est un synonyme du paramètre de modèle Value2.

Exemple

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

Échange le contenu de deux pair objets.

Syntaxe

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

Paramètres

right
pair pour échanger le contenu avec.

Notes

La fonction membre échange la paire stockée de valeurs entre *this et right.

Exemple

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

Créez une pair paire de valeurs.

Syntaxe

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

Paramètres

Value1
Type de la première valeur encapsulée.

Value2
Type de la deuxième valeur encapsulée.

first
Première valeur à encapsuler.

second
Deuxième valeur à encapsuler.

Notes

Le modèle de fonction retourne pair<Value1, Value2>(first, second). Vous l’utilisez pour construire un pair<Value1, Value2> objet à partir d’une paire de valeurs.

Exemple

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

pair comparaison différente.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne !(left == right). Vous l’utilisez pour tester si left l’élément n’est pas classé de la même façon que right lorsque les deux pair objets sont comparés par élément.

Exemple

// 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 inférieur à la comparaison.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne left.first < right.first || !(right.first < left.first && left.second < right.second. Vous l’utilisez pour tester si left l’objet précédent right est classé lorsque les deux pair objets sont comparés par élément.

Exemple

// 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 comparaison inférieure ou égale.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne !(right < left). Vous l’utilisez pour tester s’il left n’est pas ordonné après right le moment où les deux pair objets sont comparés par élément.

Exemple

// 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 comparaison égale.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne left.first == right.first && left.second == right.second. Vous l’utilisez pour tester si left l’ordre est le même que right lorsque les deux pair objets sont comparés par élément.

Exemple

// 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 supérieur à la comparaison.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne right < left. Vous l’utilisez pour tester si left l’ordre est ordonné après right le moment où les deux pair objets sont comparés par élément.

Exemple

// 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 supérieur ou égal à la comparaison.

Syntaxe

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

Paramètres

left
Gauche pair à comparer.

right
Droit pair de comparer.

Notes

La fonction d’opérateur retourne !(left < right). Vous l’utilisez pour tester s’il left n’est pas ordonné avant right que les deux pair objets soient comparés par élément.

Exemple

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

Partager via

<cliext/utility> (STL/CLR)

Syntaxe

Spécifications

Déclarations

pair

Syntaxe

Paramètres

Membres

Notes

pair::first

Syntaxe

Notes

Exemple

pair::first_type

Syntaxe

Notes

Exemple

pair::operator=

Syntaxe

Paramètres

Notes

Exemple

pair::pair

Syntaxe

Paramètres

Notes

Exemple

pair::second

Syntaxe

Notes

Exemple

pair::second_type

Syntaxe

Notes

Exemple

pair::swap

Syntaxe

Paramètres

Notes

Exemple

make_pair

Syntaxe

Paramètres

Notes

Exemple

operator!= (paire)

Syntaxe

Paramètres

Notes

Exemple

operator<

Syntaxe

Paramètres

Notes

Exemple

operator<=

Syntaxe

Paramètres

Notes

Exemple

operator==

Syntaxe

Paramètres

Notes

Exemple

pair::operator>

Syntaxe

Paramètres

Notes

Exemple

operator>=

Syntaxe

Paramètres

Notes

Exemple

Commentaires

Ressources supplémentaires

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

`pair`

`pair::first`

`pair::first_type`

`pair::operator=`

`pair::pair`

`pair::second`

`pair::second_type`

`pair::swap`

`make_pair`

`operator!=` (paire)

`operator<`

`operator<=`

`operator==`

`pair::operator>`

`operator>=`