<cliext/utility> (STL/CLR)
Incluya el encabezado <cliext/utility> STL/CLR para definir la plantilla pair de clase y varias plantillas de función auxiliares.
Sintaxis
#include <cliext/utility>
Requisitos
Encabezado:<cliext/utility>
Espacio de nombres:cliext
Declaraciones
| Clase | Descripción |
|---|---|
pair |
Pone un par de elementos en un contenedor. |
| Operator | Descripción |
|---|---|
operator== (par) |
pair igual comparación. |
operator!= (par) |
pair no es igual a la comparación. |
operator< (par) |
pair menor que la comparación. |
operator<= (par) |
pair menor o igual que la comparación. |
operator> (par) |
pair mayor que la comparación. |
operator>= (par) |
pair mayor o igual que la comparación. |
| Función | Descripción |
|---|---|
make_pair |
Crea un pair a partir de un par de valores. |
pair
La clase de plantilla describe un objeto que encapsula un par de valores.
Sintaxis
template<typename Value1,
typename Value2>
ref class pair;
Parámetros
Value1
Tipo del primer valor encapsulado.
Value2
Tipo del segundo valor encapsulado.
Miembros
| Definición de tipo | Descripción |
|---|---|
pair::first_type |
Tipo del primer valor encapsulado. |
pair::second_type |
Tipo del segundo valor encapsulado. |
| Member (objeto) | Descripción |
|---|---|
pair::first |
Primer valor almacenado. |
pair::second |
Segundo valor almacenado. |
| Función de miembro | Descripción |
|---|---|
pair::pair |
Construye un objeto pair. |
pair::swap |
Intercambia el contenido de dos objetos pair. |
| Operator | Descripción |
|---|---|
pair::operator= |
Reemplaza el par de valores almacenado. |
Comentarios
El objeto almacena un par de valores. Esta clase de plantilla se usa para combinar dos valores en un solo objeto. Además, el objeto cliext::pair (que se describe aquí) almacena solo tipos administrados. Para almacenar un par de tipos no administrados, use std::pair, declarado en <utility>.
pair::first
Primer valor encapsulado.
Sintaxis
Value1 first;
Comentarios
El objeto almacena el primer valor encapsulado.
Ejemplo
// 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 primer valor encapsulado.
Sintaxis
typedef Value1 first_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Value1.
Ejemplo
// 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=
Reemplaza el par de valores almacenado.
Sintaxis
pair<Value1, Value2>% operator=(pair<Value1, Value2>% right);
Parámetros
right
pair para copiar.
Comentarios
El operador miembro copia right en el objeto y, a continuación, devuelve *this. Se usa para reemplazar el par almacenado de valores por una copia del par almacenado de valores en right.
Ejemplo
// 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
Construye un objeto pair.
Sintaxis
pair();
pair(pair<Coll>% right);
pair(pair<Coll>^ right);
pair(Value1 val1, Value2 val2);
Parámetros
right
pair para almacenar.
val1
Primer valor que se almacena.
val2
Segundo valor que se almacena.
Comentarios
El constructor:
pair();
inicializa el par almacenado con valores construidos predeterminados.
El constructor:
pair(pair<Value1, Value2>% right);
inicializa el par almacenado con right.first y right.second.
pair(pair<Value1, Value2>^ right);
inicializa el par almacenado con right->first y right->second.
El constructor:
pair(Value1 val1, Value2 val2);
inicializa el par almacenado con val1 y val2.
Ejemplo
// 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
Segundo valor encapsulado.
Sintaxis
Value2 second;
Comentarios
El objeto almacena el segundo valor encapsulado.
Ejemplo
// 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 segundo valor encapsulado.
Sintaxis
typedef Value2 second_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Value2.
Ejemplo
// 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
Intercambia el contenido de dos objetos pair.
Sintaxis
void swap(pair<Value1, Value2>% right);
Parámetros
right
pair para intercambiar contenido con.
Comentarios
La función miembro intercambia el par almacenado de valores entre *this y right.
Ejemplo
// 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
Crea un pair a partir de un par de valores.
Sintaxis
template<typename Value1,
typename Value2>
pair<Value1, Value2> make_pair(Value1 first, Value2 second);
Parámetros
Value1
Tipo del primer valor encapsulado.
Value2
Tipo del segundo valor encapsulado.
first
Primer valor que se encapsula.
second
Segundo valor que se encapsula.
Comentarios
La plantilla de función devuelve pair<Value1, Value2>(first, second). Se usa para construir un objeto pair<Value1, Value2> a partir de un par de valores.
Ejemplo
// 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!= (par)
pair no es igual a la comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator!=(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve !(left == right). Se usa para probar si left no se ordena igual que right cuando los dos pair objetos se comparan por elemento.
Ejemplo
// 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 menor que la comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator<(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve left.first < right.first || !(right.first < left.first && left.second < right.second. Se usa para probar si left se ordena antes right cuando se comparan los dos pair objetos por elemento.
Ejemplo
// 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 menor o igual que la comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator<=(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve !(right < left). Se usa para probar si left no se ordena después right de cuando los dos pair objetos se comparan por elemento.
Ejemplo
// 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 igual comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator==(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve left.first == right.first && left.second == right.second. Se usa para probar si left se ordena igual que right cuando los dos pair objetos se comparan por elemento.
Ejemplo
// 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 mayor que la comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator>(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve right < left. Se usa para probar si left se ordena después right de cuando los dos pair objetos se comparan elemento por elemento.
Ejemplo
// 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 mayor o igual que la comparación.
Sintaxis
template<typename Value1,
typename Value2>
bool operator>=(pair<Value1, Value2>% left,
pair<Value1, Value2>% right);
Parámetros
left
Izquierda pair que se va a comparar.
right
Derecho pair a comparar.
Comentarios
La función de operador devuelve !(left < right). Se usa para probar si left no se ordena antes right cuando los dos pair objetos se comparan por elemento.
Ejemplo
// 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
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de