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

Artículo
10/13/2023

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

Compartir a través de

<cliext/utility> (STL/CLR)

Sintaxis

Requisitos

Declaraciones

pair

Sintaxis

Parámetros

Miembros

Comentarios

pair::first

Sintaxis

Comentarios

Ejemplo

pair::first_type

Sintaxis

Comentarios

Ejemplo

pair::operator=

Sintaxis

Parámetros

Comentarios

Ejemplo

pair::pair

Sintaxis

Parámetros

Comentarios

Ejemplo

pair::second

Sintaxis

Comentarios

Ejemplo

pair::second_type

Sintaxis

Comentarios

Ejemplo

pair::swap

Sintaxis

Parámetros

Comentarios

Ejemplo

make_pair

Sintaxis

Parámetros

Comentarios

Ejemplo

operator!= (par)

Sintaxis

Parámetros

Comentarios

Ejemplo

operator<

Sintaxis

Parámetros

Comentarios

Ejemplo

operator<=

Sintaxis

Parámetros

Comentarios

Ejemplo

operator==

Sintaxis

Parámetros

Comentarios

Ejemplo

pair::operator>

Sintaxis

Parámetros

Comentarios

Ejemplo

operator>=

Sintaxis

Parámetros

Comentarios

Ejemplo

Comentarios

Recursos adicionales

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

`pair`

`pair::first`

`pair::first_type`

`pair::operator=`

`pair::pair`

`pair::second`

`pair::second_type`

`pair::swap`

`make_pair`

`operator!=` (par)

`operator<`

`operator<=`

`operator==`

`pair::operator>`

`operator>=`