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

Artigo
07/05/2024

Inclua o cabeçalho <cliext/utility> STL/CLR para definir o modelo pair de classe e vários modelos de função de suporte.

Sintaxe

#include <cliext/utility>

Requisitos

Cabeçalho:< cliext/utility>

Namespace: cliext

Declarações

Classe	Descrição
`pair`	Encapsule um par de elementos.

Operador	Descrição
`operator==` (par)	`pair` comparação igual.
`operator!=` (par)	`pair` comparação não igual.
`operator<` (par)	`pair` menos do que comparação.
`operator<=` (par)	`pair` menor ou igual comparação.
`operator>` (par)	`pair` maior do que a comparação.
`operator>=` (par)	`pair` comparação maior ou igual.

Função	Descrição
`make_pair`	Cria um `pair` a partir de um par de valores.

`pair`

A classe do modelo descreve um objeto que encapsula um par de valores.

Sintaxe

template<typename Value1,
    typename Value2>
    ref class pair;

Parâmetros

Value1
O tipo do primeiro valor encapsulado.

Value2
O tipo de segundo valor encapsulado.

Membros

Definição do tipo	Descrição
`pair::first_type`	O tipo do primeiro valor encapsulado.
`pair::second_type`	O tipo do segundo valor encapsulado.

Objeto de membro	Descrição
`pair::first`	O primeiro valor armazenado.
`pair::second`	O segundo valor armazenado.

Função de membro	Descrição
`pair::pair`	Constrói um objeto `pair`.
`pair::swap`	Troca o conteúdo de dois `pair` objetos.

Operador	Descrição
`pair::operator=`	Substitui o par de valores armazenado.

Comentários

O objeto armazena um par de valores. Use essa classe de modelo para combinar dois valores em um único objeto. Além disso, o objeto cliext::pair (descrito aqui) armazena apenas tipos gerenciados; para armazenar um par de tipos não gerenciados, use std::pair, declarado em <utility>.

`pair::first`

O primeiro valor encapsulado.

Sintaxe

Value1 first;

Comentários

O objeto armazena o primeiro valor encapsulado.

Exemplo

// 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`

O tipo do primeiro valor encapsulado.

Sintaxe

typedef Value1 first_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloValue1.

Exemplo

// 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=`

Substitui o par de valores armazenado.

Sintaxe

pair<Value1, Value2>% operator=(pair<Value1, Value2>% right);

Parâmetros

right
pair para copiar.

Comentários

O operador membro copia right para o objeto e retorna *this. Você o usa para substituir o par de valores armazenado por uma cópia do par de valores armazenados no right.

Exemplo

// 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`

Constrói um objeto pair.

Sintaxe

pair();
pair(pair<Coll>% right);
pair(pair<Coll>^ right);
pair(Value1 val1, Value2 val2);

Parâmetros

right
pair para armazenar.

val1
Primeiro valor a ser armazenado.

val2
Segundo valor a ser armazenado.

Comentários

O construtor:

pair();

inicializa o par armazenado com valores construídos padrão.

O construtor:

pair(pair<Value1, Value2>% right);

inicializa o par armazenado com right.first e right.second.

pair(pair<Value1, Value2>^ right);

inicializa o par armazenado com right->first e right->second.

O construtor:

pair(Value1 val1, Value2 val2);

inicializa o par armazenado com val1 e val2.

Exemplo

// 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`

O segundo valor encapsulado.

Sintaxe

Value2 second;

Comentários

O objeto armazena o segundo valor encapsulado.

Exemplo

// 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`

O tipo do segundo valor encapsulado.

Sintaxe

typedef Value2 second_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloValue2.

Exemplo

// 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`

Troca o conteúdo de dois pair objetos.

Sintaxe

void swap(pair<Value1, Value2>% right);

Parâmetros

right
pair para trocar conteúdo.

Comentários

A função membro troca o par de valores armazenado entre *this e right.

Exemplo

// 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`

Cria um pair a partir de um par de valores.

Sintaxe

template<typename Value1,
    typename Value2>
    pair<Value1, Value2> make_pair(Value1 first, Value2 second);

Parâmetros

Value1
O tipo do primeiro valor encapsulado.

Value2
O tipo do segundo valor encapsulado.

first
Primeiro valor a ser encapsulado.

second
Segundo valor a ser encapsulado.

Comentários

O modelo de função retorna pair<Value1, Value2>(first, second). Use-o para construir um objeto pair<Value1, Value2> a partir de um par de valores.

Exemplo

// 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 comparação não igual.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator!=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna !(left == right). Você o usa para testar se left não está ordenado da mesma forma que right quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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 menos do que comparação.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator<(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna left.first < right.first || !(right.first < left.first && left.second < right.second. Você o usa para testar se left é ordenado antes right quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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 ou igual comparação.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator<=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna !(right < left). Você o usa para testar se left não está ordenado depois right de quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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 comparação igual.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator==(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna left.first == right.first && left.second == right.second. Você o usa para testar se left é ordenado da mesma forma que right quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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 maior do que a comparação.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator>(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna right < left. Você o usa para testar se left é ordenado depois de right quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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 comparação maior ou igual.

Sintaxe

template<typename Value1,
    typename Value2>
    bool operator>=(pair<Value1, Value2>% left,
        pair<Value1, Value2>% right);

Parâmetros

left
Esquerda pair para comparar.

right
Direito pair de comparar.

Comentários

A função do operador retorna !(left < right). Você o usa para testar se left não está ordenado antes right quando os dois pair objetos são comparados elemento por elemento.

Exemplo

// 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

Compartilhar via

<cliext/utility> (STL/CLR)

Sintaxe

Requisitos

Declarações

pair

Sintaxe

Parâmetros

Membros

Comentários

pair::first

Sintaxe

Comentários

Exemplo

pair::first_type

Sintaxe

Comentários

Exemplo

pair::operator=

Sintaxe

Parâmetros

Comentários

Exemplo

pair::pair

Sintaxe

Parâmetros

Comentários

Exemplo

pair::second

Sintaxe

Comentários

Exemplo

pair::second_type

Sintaxe

Comentários

Exemplo

pair::swap

Sintaxe

Parâmetros

Comentários

Exemplo

make_pair

Sintaxe

Parâmetros

Comentários

Exemplo

operator!= (par)

Sintaxe

Parâmetros

Comentários

Exemplo

operator<

Sintaxe

Parâmetros

Comentários

Exemplo

operator<=

Sintaxe

Parâmetros

Comentários

Exemplo

operator==

Sintaxe

Parâmetros

Comentários

Exemplo

pair::operator>

Sintaxe

Parâmetros

Comentários

Exemplo

operator>=

Sintaxe

Parâmetros

Comentários

Exemplo

Comentários

Recursos adicionais

`<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>=`