Compartir a través de


<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