<cliext/utility> (STL/CLR)
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 nomicliext:
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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per