algorithm (STL/CLR)

Define modelos de função de contêiner STL/CLR que executam algoritmos.

Sintaxe

#include <cliext/algorithm>

Requisitos

Cabeçalho:<cliext/algoritmo>

Namespace: cliext

Declarações

Membros

adjacent_find (STL/CLR)

Procura dois elementos adjacentes que sejam iguais ou atendam a uma condição especificada.

Sintaxe

template<class _FwdIt> inline
    _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função adjacent_find da Biblioteca Padrão C++. Para obter mais informações, confira adjacent_find.

binary_search (STL/CLR)

Testa se há um elemento em um intervalo classificado que seja igual a um valor especificado ou equivalente a ele de modo especificado por um predicado binário.

Sintaxe

template<class _FwdIt, class _Ty> inline
    bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    bool binary_search(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função binary_search da Biblioteca Padrão C++. Para obter mais informações, confira binary_search.

copy (STL/CLR)

Atribui os valores dos elementos de um intervalo de origem a um intervalo de destino, iterando pela sequência de elementos de origem e atribuindo-lhes novas posições em uma direção progressiva.

Sintaxe

template<class _InIt, class _OutIt> inline
    _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest);

Comentários

Essa função se comporta da mesma forma que a função copy da Biblioteca Padrão C++. Para obter mais informações, confira copy.

copy_backward (STL/CLR)

Atribui os valores dos elementos de um intervalo de origem a um intervalo de destino, iterando pela sequência de elementos de origem e atribuindo-lhes novas posições em uma direção retroativa.

Sintaxe

template<class _BidIt1, class _BidIt2> inline
    _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last,
        _BidIt2 _Dest);

Comentários

Essa função se comporta da mesma forma que a função copy_backward da Biblioteca Padrão C++. Para obter mais informações, confira copy_backward.

count (STL/CLR)

Retorna o número de elementos em um intervalo cujos valores correspondem a um valor especificado.

Sintaxe

template<class _InIt, class _Ty> inline
    typename iterator_traits<_InIt>::difference_type
        count(_InIt _First, _InIt _Last, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função count da Biblioteca Padrão C++. Para obter mais informações, confira count.

count_if (STL/CLR)

Retorna o número de elementos em um intervalo cujos valores correspondem a uma condição especificada.

Sintaxe

template<class _InIt, class _Pr> inline
    typename iterator_traits<_InIt>::difference_type
        count_if(_InIt _First, _InIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função count_if da Biblioteca Padrão C++. Para obter mais informações, confira count_if.

equal (STL/CLR)

Compara a igualdade ou equivalência de dois intervalos, elemento por elemento, de certo modo especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2> inline
    bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função equal da Biblioteca Padrão C++. Para obter mais informações, confira equal.

equal_range (STL/CLR)

Localiza um par de posições em um intervalo ordenado, o primeiro menor ou equivalente à posição de um elemento especificado e o segundo maior que a posição do elemento, em que o sentido de equivalência ou de ordenação usada para estabelecer as posições na sequência pode ser especificado por um predicado binário.

Sintaxe

template<class _FwdIt, class _Ty> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função equal_range da Biblioteca Padrão C++. Para obter mais informações, confira equal_range.

fill (STL/CLR)

Atribui o mesmo novo valor para cada elemento em um intervalo especificado.

Sintaxe

template<class _FwdIt, class _Ty> inline
    void fill(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função fill da Biblioteca Padrão C++. Para obter mais informações, confira fill.

fill_n (STL/CLR)

Atribui um novo valor a um número especificado de elementos em um intervalo começando com um elemento específico.

Sintaxe

template<class _OutIt, class _Diff, class _Ty> inline
    void fill_n(_OutIt _First, _Diff _Count, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função fill_n da Biblioteca Padrão C++. Para obter mais informações, confira fill_n.

find (STL/CLR)

Localiza a posição da primeira ocorrência de um elemento em um intervalo que tem um valor especificado.

Sintaxe

template<class _InIt, class _Ty> inline
    _InIt find(_InIt _First, _InIt _Last, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função find da Biblioteca Padrão C++. Para obter mais informações, confira find.

find_end (STL/CLR)

Examina um intervalo em busca da última subsequência que seja idêntica a uma sequência especificada ou que seja equivalente de certo modo especificado por um predicado binário.

Sintaxe

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função find_end da Biblioteca Padrão C++. Para obter mais informações, confira find_end.

find_first_of (STL/CLR)

Procura a primeira ocorrência de qualquer um dos vários valores em um intervalo de destino ou a primeira ocorrência de qualquer um dos vários elementos que são equivalentes de certo modo especificado por um predicado binário a um conjunto especificado dos elementos.

Sintaxe

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função find_first_of da Biblioteca Padrão C++. Para obter mais informações, confira find_first_of.

find_if (STL/CLR)

Localiza a posição da primeira ocorrência de um elemento em um intervalo que atende a uma condição especificada.

Sintaxe

template<class _InIt, class _Pr> inline
    _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função find_if da Biblioteca Padrão C++. Para obter mais informações, confira find_if.

for_each (STL/CLR)

Aplica um objeto de função especificado a cada elemento em uma ordem progressiva dentro de um intervalo e retorna o objeto de função.

Sintaxe

template<class _InIt, class _Fn1> inline
    _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func);

Comentários

Essa função se comporta da mesma forma que a função for_each da Biblioteca Padrão C++. Para obter mais informações, confira for_each.

generate (STL/CLR)

Atribui os valores gerados por um objeto de função a cada elemento em um intervalo.

Sintaxe

template<class _FwdIt, class _Fn0> inline
    void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func);

Comentários

Essa função se comporta da mesma forma que a função generate da Biblioteca Padrão C++. Para mais informações, confira generate.

generate_n (STL/CLR)

Atribui os valores gerados por um objeto de função a um número especificado de elementos em um intervalo e retorna para uma posição antes do último valor atribuído.

Sintaxe

template<class _OutIt, class _Diff, class _Fn0> inline
    void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func);

Comentários

Essa função se comporta da mesma forma que a função generate_n da Biblioteca Padrão C++. Para obter mais informações, confira generate_n.

includes (STL/CLR)

Testa se um intervalo classificado contém todos os elementos contidos em um segundo intervalo classificado, em que o critério de equivalência ou ordenação entre elementos pode ser especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2> inline
    bool includes(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool includes(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função includes da Biblioteca Padrão C++. Para obter mais informações, confira includes.

inplace_merge (STL/CLR)

Combina os elementos de dois intervalos classificados consecutivos em um único intervalo classificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _BidIt> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função inplace_merge da Biblioteca Padrão C++ Para obter mais informações, confira inplace_merge.

iter_swap (STL/CLR)

Troca dois valores referenciados por um par de iteradores especificados.

Sintaxe

template<class _FwdIt1, class _FwdIt2> inline
    void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right);

Comentários

Essa função se comporta da mesma forma que a função iter_swap da Biblioteca Padrão C++. Para obter mais informações, confira iter_swap.

lexicographical_compare (STL/CLR)

Compara elemento por elemento entre duas sequências para determinar qual é o menor dos dois.

Sintaxe

template<class _InIt1, class _InIt2> inline
    bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
    bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função lexicographical_compare da Biblioteca Padrão C++. Para obter mais informações, confira lexicographical_compare.

lower_bound (STL/CLR)

Localiza a posição do primeiro elemento em um intervalo ordenado com um valor que é menor ou equivalente a um valor especificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _FwdIt, class _Ty> inline
    _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função lower_bound da Biblioteca Padrão C++. Para obter mais informações, confira lower_bound.

make_heap (STL/CLR)

Converte os elementos de um intervalo especificado em um heap no qual o primeiro elemento é o maior e para o qual um critério de classificação pode ser especificado com um predicado binário.

Sintaxe

template<class _RanIt> inline
    void make_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função make_heap da Biblioteca Padrão C++. Para obter mais informações, confira make_heap.

max (STL/CLR)

Compara dois objetos e retorna o maior dos dois, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _Ty> inline
    const _Ty max(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
    const _Ty max(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função max da Biblioteca Padrão C++. Para obter mais informações, confira max.

max_element (STL/CLR)

Localiza a primeira ocorrência do maior elemento em um intervalo especificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _FwdIt> inline
    _FwdIt max_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função max_element da Biblioteca Padrão C++. Para obter mais informações, confira max_element.

merge (STL/CLR)

Combina todos os elementos de dois intervalos classificados de origem em um único intervalo de destino classificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt merge(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função merge da Biblioteca Padrão C++. Para obter mais informações, confira merge.

min (STL/CLR)

Compara dois objetos e retorna o menor dos dois, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _Ty> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função min da Biblioteca Padrão C++. Para obter mais informações, confira min.

min_element (STL/CLR)

Localiza a primeira ocorrência do menor elemento em um intervalo especificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _FwdIt> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função min_element da Biblioteca Padrão C++. Para obter mais informações, confira min_element.

mismatch (STL/CLR)

Compara dois intervalos, elemento por elemento, por igualdade ou equivalência de certo modo especificado por um predicado binário e localiza a primeira posição onde ocorre uma diferença.

Sintaxe

template<class _InIt1, class _InIt2> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
            _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função mismatch da Biblioteca Padrão C++. Para obter mais informações, confira mismatch.

next_permutation (STL/CLR)

Reordena os elementos em um intervalo para que a ordenação original seja substituída pela próxima permutação lexicograficamente maior, se ela existir, em que o sentido de próxima pode ser especificado com um predicado binário.

Sintaxe

template<class _BidIt> inline
    bool next_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função next_permutation da Biblioteca Padrão C++. Para obter mais informações, confira next_permutation.

nth_element (STL/CLR)

Particiona um intervalo de elementos, localizando corretamente o nº elemento da sequência no intervalo para que todos os elementos anteriores sejam menores ou iguais a ele e todos os elementos posteriores na sequência sejam maiores ou iguais a ele.

Sintaxe

template<class _RanIt> inline
    void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função nth_element da Biblioteca Padrão C++. Para obter mais informações, confira nth_element.

partial_sort (STL/CLR)

Organiza um número especificado de elementos menores em um intervalo em ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário.

Sintaxe

template<class _RanIt> inline
    void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função partial_sort da Biblioteca Padrão C++. Para obter mais informações, confira partial_sort.

partial_sort_copy (STL/CLR)

Copia elementos de um intervalo de origem em um intervalo de destino, em que os elementos de origem são ordenados por menor que ou outro predicado binário especificado.

Sintaxe

template<class _InIt, class _RanIt> inline
    _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
        _RanIt _First2, _RanIt _Last2);
template<class _InIt, class _RanIt, class _Pr> inline
    _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,
        _RanIt _First2, _RanIt _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função partial_sort_copy da Biblioteca Padrão C++. Para obter mais informações, confira partial_sort_copy.

partition (STL/CLR)

Classifica os elementos de um intervalo em dois conjuntos separados, com esses elementos atendendo a um predicado unário que precede aqueles que não o atendem.

Sintaxe

template<class _BidIt, class _Pr> inline
    _BidIt partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função partition da Biblioteca Padrão C++. Para obter mais informações, confira partition.

pop_heap (STL/CLR)

Remove o maior elemento da frente de um heap para a penúltima posição no intervalo e, em seguida, forma um novo heap com os elementos restantes.

Sintaxe

template<class _RanIt> inline
    void pop_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função pop_heap da Biblioteca Padrão C++. Para obter mais informações, confira pop_heap.

prev_permutation (STL/CLR)

Reordena os elementos em um intervalo para que a ordenação original seja substituída pela próxima permutação lexicograficamente maior, se ela existir, em que o sentido de próxima pode ser especificado com um predicado binário.

Sintaxe

template<class _BidIt> inline
    bool prev_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função prev_permutation da Biblioteca Padrão C++. Para obter mais informações, confira prev_permutation.

push_heap (STL/CLR)

Adiciona um elemento que está no fim de um intervalo a um heap existente que consiste em elementos anteriores no intervalo.

Sintaxe

template<class _RanIt> inline
    void push_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função push_heap da Biblioteca Padrão C++. Para obter mais informações, confira push_heap.

random_shuffle (STL/CLR)

Reorganiza uma sequência de elementos N em um intervalo em um de N! possíveis organizações selecionadas aleatoriamente.

Sintaxe

template<class _RanIt> inline
    void random_shuffle(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Fn1> inline
    void random_shuffle(_RanIt _First, _RanIt _Last, _Fn1% _Func);

Comentários

Essa função se comporta da mesma forma que a função random_shuffle da Biblioteca Padrão C++. Para obter mais informações, confira random_shuffle.

remove (STL/CLR)

Elimina um valor especificado de um determinado intervalo sem afetar a ordem dos elementos restantes e retornando ao fim de um novo intervalo livre do valor especificado.

Sintaxe

template<class _FwdIt, class _Ty> inline
    _FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função remove da Biblioteca Padrão C++. Para obter mais informações, confira remove.

remove_copy (STL/CLR)

Copia os elementos de um intervalo de origem em um intervalo de destino, exceto os elementos de um valor especificado não são copiados, sem afetar a ordem dos elementos restantes e retornando ao fim de um novo intervalo de destino.

Sintaxe

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt remove_copy(_InIt _First, _InIt _Last,
        _OutIt _Dest, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função remove_copy da Biblioteca Padrão C++. Para obter mais informações, confira remove_copy.

remove_copy_if (STL/CLR)

Copia os elementos de um intervalo de origem em um intervalo de destino, exceto os que atendem a um predicado não são copiados, sem afetar a ordem dos elementos restantes e retornando ao fim de um novo intervalo de destino.

Sintaxe

template<class _InIt, class _OutIt, class _Pr> inline
    _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função remove_copy_if da Biblioteca Padrão C++. Para obter mais informações, confira remove_copy_if.

remove_if (STL/CLR)

Elimina elementos que atendem a um predicado de um determinado intervalo sem afetar a ordem dos elementos restantes e retornando ao fim de um novo intervalo livre do valor especificado.

Sintaxe

template<class _FwdIt, class _Pr> inline
    _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função remove_if da Biblioteca Padrão C++. Para obter mais informações, confira remove_if.

replace (STL/CLR)

Examina cada elemento em um intervalo e o substitui se ele corresponder a um valor especificado.

Sintaxe

template<class _FwdIt, class _Ty> inline
    void replace(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Oldval, const _Ty% _Newval);

Comentários

Essa função se comporta da mesma forma que a função replace da Biblioteca Padrão C++. Para obter mais informações, confira replace.

replace_copy (STL/CLR)

Examina cada elemento em um intervalo de origem e o substitui se ele corresponder a um valor especificado ao copiar o resultado em um novo intervalo de destino.

Sintaxe

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
        const _Ty% _Oldval, const _Ty% _Newval);

Comentários

Essa função se comporta da mesma forma que a função replace_copy da Biblioteca Padrão C++. Para obter mais informações, confira replace_copy.

replace_copy_if (STL/CLR)

Examina cada elemento em um intervalo de origem e o substitui se ele atender a um predicado especificado ao copiar o resultado em um novo intervalo de destino.

Sintaxe

template<class _InIt, class _OutIt, class _Pr, class _Ty> inline
    _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred, const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função replace_copy_if da Biblioteca Padrão C++. Para obter mais informações, confira replace_copy_if.

replace_if (STL/CLR)

Examina cada elemento em um intervalo e o substitui se ele atender a um predicado especificado.

Sintaxe

template<class _FwdIt, class _Pr, class _Ty> inline
    void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred,
        const _Ty% _Val);

Comentários

Essa função se comporta da mesma forma que a função replace_if da Biblioteca Padrão C++. Para obter mais informações, confira replace_if.

reverse (STL/CLR)

Inverte a ordem dos elementos em um intervalo.

Sintaxe

template<class _BidIt> inline
    void reverse(_BidIt _First, _BidIt _Last);

Comentários

Essa função se comporta da mesma forma que a função reverse da Biblioteca Padrão C++. Para obter mais informações, confira reverse.

reverse_copy (STL/CLR)

Inverte a ordem dos elementos em um intervalo de origem ao copiá-los em um intervalo de destino.

Sintaxe

template<class _BidIt, class _OutIt> inline
    _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest);

Comentários

Essa função se comporta da mesma forma que a função reverse_copy da Biblioteca Padrão C++. Para obter mais informações, confira reverse_copy.

rotate (STL/CLR)

Troca os elementos em dois intervalos adjacentes.

Sintaxe

template<class _FwdIt> inline
    void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last);

Comentários

Essa função se comporta da mesma forma que a função rotate da Biblioteca Padrão C++. Para obter mais informações, confira rotate.

rotate_copy (STL/CLR)

Troca os elementos em dois intervalos adjacentes em um intervalo de origem e copia o resultado em um intervalo de destino.

Sintaxe

template<class _FwdIt, class _OutIt> inline
    _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,
        _OutIt _Dest);

Comentários

Essa função se comporta da mesma forma que a função rotate_copy da Biblioteca Padrão C++. Para obter mais informações, confira rotate_copy.

search (STL/CLR)

Procura a primeira ocorrência de uma sequência em um intervalo de destino cujos elementos são iguais àqueles em uma determinada sequência de elementos ou cujos elementos são equivalentes de certo modo especificado por um predicado binário para os elementos na sequência determinada.

Sintaxe

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
    _FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função search da Biblioteca Padrão C++. Para obter mais informações, confira search.

search_n (STL/CLR)

Procura a primeira subsequência em um intervalo de um número especificado de elementos com um valor particular ou uma relação com esse valor, conforme especificado por um predicado binário.

Sintaxe

template<class _FwdIt1, class _Diff2, class _Ty> inline
    _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
        _Diff2 _Count, const _Ty& _Val);
template<class _FwdIt1, class _Diff2, class _Ty, class _Pr> inline
    _FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,
        _Diff2 _Count, const _Ty& _Val, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função search_n da Biblioteca Padrão C++. Para obter mais informações, confira search_n.

set_difference (STL/CLR)

Une todos os elementos que pertencem a um intervalo de origem classificado, mas não a um segundo intervalo de origem classificado, em um único intervalo de destino classificado, em que o critério de ordenação pode ser especificado por um predicado específico.

Sintaxe

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2,_OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função set_difference da Biblioteca Padrão C++. Para obter mais informações, confira set_difference.

set_intersection (STL/CLR)

Une todos os elementos que pertencem a ambos os intervalos de origem classificados em um único intervalo de destino classificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função set_intersection da Biblioteca Padrão C++. Para obter mais informações, confira set_intersection.

set_symmetric_difference (STL/CLR)

Une todos os elementos que pertencem a um (mas não a ambos) dos intervalos de origem classificados em um único intervalo de destino classificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função set_symmetric_difference da Biblioteca Padrão C++. Para obter mais informações, confira set_symmetric_difference.

set_union (STL/CLR)

Une todos os elementos que pertencem a pelo menos um dos dois intervalos de origem classificados em um único intervalo de destino classificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _InIt1, class _InIt2, class _OutIt> inline
    _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
    _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função set_union da Biblioteca Padrão C++. Para obter mais informações, confira set_union.

sort (STL/CLR)

Organiza os elementos de um intervalo especificado em ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário.

Sintaxe

template<class _RanIt> inline
    void sort(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort(_RanIt _First, _RanIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função sort da Biblioteca Padrão C++. Para obter mais informações, confira sort.

sort_heap (STL/CLR)

Converte um heap em um intervalo classificado.

Sintaxe

template<class _RanIt> inline
    void sort_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função sort_heap da Biblioteca Padrão C++. Para obter mais informações, confira sort_heap.

stable_partition (STL/CLR)

Classifica os elementos de um intervalo em dois conjuntos separados, com esses elementos atendendo a um predicado unário que precede aqueles que não o atendem, preservando a ordem relativa dos elementos equivalentes.

Sintaxe

template<class _BidIt, class _Pr> inline
    _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função stable_partition da Biblioteca Padrão C++. Para obter mais informações, confira stable_partition.

stable_sort (STL/CLR)

Organiza os elementos de um intervalo especificado em ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário e preserva a ordenação relativa de elementos equivalentes.

Sintaxe

template<class _BidIt> inline
    void stable_sort(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    void stable_sort(_BidIt _First, _BidIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função stable_sort da Biblioteca Padrão C++. Para obter mais informações, confira stable_sort.

swap (STL/CLR)

Troca os valores dos elementos entre dois tipos de objeto, atribuindo o conteúdo do primeiro objeto ao segundo objeto e o conteúdo do segundo ao primeiro.

Sintaxe

<class _Ty> inline
    void swap(_Ty% _Left, _Ty% _Right);

Comentários

Essa função se comporta da mesma forma que a função swap da Biblioteca Padrão C++. Para obter mais informações, confira swap.

swap_ranges (STL/CLR)

Troca os elementos de um intervalo com os elementos de outro, de tamanho igual.

Sintaxe

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2);

Comentários

Essa função se comporta da mesma forma que a função swap_ranges da Biblioteca Padrão C++. Para obter mais informações, confira swap_ranges.

transform (STL/CLR)

Aplica um objeto de função especificado a cada elemento em um intervalo de origem ou a um par de elementos de dois intervalos de origem e copia os valores de retorno do objeto de função em um intervalo de destino.

Sintaxe

template<class _InIt, class _OutIt, class _Fn1> inline
    _OutIt transform(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Fn1 _Func);
template<class _InIt1, class _InIt2, class _OutIt, class _Fn2> inline
    _OutIt transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
        _OutIt _Dest, _Fn2 _Func);

Comentários

Essa função se comporta da mesma forma que a função transform da Biblioteca Padrão C++. Para obter mais informações, confira transform.

unique (STL/CLR)

Remove elementos duplicados que são adjacentes um ao outro em um intervalo especificado.

Sintaxe

template<class _FwdIt> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função unique da Biblioteca Padrão C++. Para obter mais informações, confira unique.

unique_copy (STL/CLR)

Copia elementos de um intervalo de origem em um intervalo de destino, exceto os elementos duplicados que são adjacentes um ao outro.

Sintaxe

template<class _InIt, class _OutIt> inline
    _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest);
template<class _InIt, class _OutIt, class _Pr> inline
    _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função unique_copy da Biblioteca Padrão C++. Para obter mais informações, confira unique_copy.

upper_bound (STL/CLR)

Localiza a posição do primeiro elemento em um intervalo ordenado com um valor que é maior a um valor especificado, em que o critério de ordenação pode ser especificado por um predicado binário.

Sintaxe

template<class _FwdIt, class _Ty> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred);

Comentários

Essa função se comporta da mesma forma que a função upper_bound da Biblioteca Padrão C++. Para obter mais informações, confira upper_bound.