<cliext/utility> (STL/CLR)

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

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

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