<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
| 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
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour