<algorithm>

Define as funções padrão do modelo do contêiner de (STL) da biblioteca do modelo que executam algoritmos.

namespace std {
template<class InputIterator, class Predicate>
    bool all_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool any_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool none_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Function>
    Fn1 for_each (
        InputIterator _First, 
        InputIterator _Last, 
        Function _Func
    );
template<class InputIterator, class Type>
    InputIterator find (
        InputIterator _First, 
        InputIterator _Last, 
        const Type& _Val
    );
template<class InputIterator, class Predicate>
    InputIterator find_if (
        InputIterator _First, 
        InputIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    InputIterator find_if_not (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    ); 
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class InputIterator, class ForwardIterator>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2
    );
template<class InputIterator, class ForwardIterator, 
         class Predicate>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last
    );
template<class ForwardIterator, class Predicate>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Type>
    typename iterator_traits<InputIterator>::difference_type
        count (
            InputIterator _First, 
            InputIterator _Last,
            const Type& _Val
        );
template<class InputIterator, class Predicate>
    typename iterator_traits<InputIterator>::difference_type
        count_if (
            InputIterator _First, 
            InputIterator _Last,
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2
        );
template<class InputIterator1, class InputIterator2, class Predicate>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2, 
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2
    );
template<class InputIterator1, class InputIterator2, class Predicate>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2, 
        Predicate _Pred
    );
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator, class Size, class Type>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val
    );
template<class ForwardIterator, class Size, class Type, 
         class Predicate>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val, 
        Predicate _Pred
    );

Comentários

Os algoritmos de STL são genéricas porque podem operar em uma variedade de estruturas de dados.Estruturas de dados que podem operar em inclui não apenas classes do contêiner de STL como vector e list, mas estruturas de dados e matrizes definidas também programa de elementos que satisfaz os requisitos de um algoritmo específico.Os algoritmos de STL obtém o nível de acesso e generalidade para percorrer os elementos de um contêiner indiretamente com iteradores.

Os algoritmos de STL processam os intervalos de iterador que geralmente são especificados pelas posições de início ou final.Os intervalos referenciados deve ser válido no sentido dos ponteiros em intervalos devem ser dereferenceable e, dentro das seqüências de cada intervalo, a posição da última deve ser alcançável da primeira incrementação.

Os algoritmos de STL estendem as ações operações suportadas pelas funções de membro de cada contêiner de STL e reservam-nas funcionar, por exemplo, com diferentes tipos de objetos recipiente ao mesmo tempo.Dois sufixos foram usados para transmitir informações sobre a finalidade de algoritmos.

• Se o sufixo indica que o algoritmo é usado com a função objetos o funcionamento nos valores dos elementos em vez de nos valores dos elementos próprios.O algoritmo de find_if procurar elementos cujos valores no critério especificado por um objeto de função, e o algoritmo de find procura por um valor específico.

• O sufixo _copy indica que o algoritmo manipula não apenas os valores dos elementos mas também copia os valores alterados em um intervalo de destino.O algoritmo de reverse inverte a ordem dos elementos dentro de um intervalo, e o algoritmo de reverse_copy também copia o resultado em um intervalo de destino.

Os algoritmos de STL são classificados com freqüência em grupos que indicam algo sobre seus requisitos ou finalidade.Esses incluem os algoritmos de alteração que alteram o valor dos elementos na comparação algoritmos nonmodifying que não.Os algoritmos transformando-se alterar a ordem dos elementos, mas não os valores de seus elementos.Remova os algoritmos pode eliminar os elementos de um intervalo ou uma cópia de um intervalo.Os algoritmos de classificação reorganizam elementos em um intervalo em várias formas e os algoritmos classificados de intervalo funcionam apenas nos algoritmos cujos elementos são classificadas em uma maneira específica.

Os algoritmos numéricos de STL que são fornecidos para o processamento numérico tem seu próprio arquivo de cabeçalho <numeric>, e funcionam objetos e adaptadores são definidos na função de <functional> de cabeçalho objeto que os valores Booleanos de retorno são conhecidos como predicados.O predicado a comparação binária padrão é operator<.Geralmente, os elementos que são ordenados necessidade de ser menor que comparável dado, de modo que todos os dois elementos, pode determinar se qualquer um que são equivalentes (no sentido que nenhum for menor do que o outro) ou um que é menor que o outro.Isso resulta em ordenação entre elementos nonequivalent.

Funções

adjacent_find	Procura por dois elementos adjacentes que são iguais ou satisfazem uma condição especificada.
all_of	Retorna true enquanto uma condição está presente em cada elemento em um determinado intervalo.
any_of	Retorna true enquanto uma condição está presente pelo menos uma vez no intervalo especificado de elementos.
binary_search	Testa se há um elemento em um intervalo classificado que é igual ao valor especificado ou que é equivalente a ela de certo modo especifica por um predicado binário.
impressão	Atribui os valores dos elementos de um intervalo de origem a um intervalo de destino, iterando com a seqüência de origem de elementos e atribuindo-lhes novos posições em uma direção direta.
copy_backward	Atribui os valores dos elementos de um intervalo de origem a um intervalo de destino, iterando com a seqüência de origem de elementos e atribuindo-lhes novos posições em uma direção inversa.
copy_if	Copiar todos os elementos em um determinado intervalo que eles testam true para uma condição especificada
copy_n	Copia um número especificado de elementos.
contagem	Retorna o número de elementos em um intervalo cujos valores coincidem com um valor especificado.
count_if	Retorna o número de elementos em um intervalo cujos valores coincidem com uma condição especificada.
igual	Compara o elemento de dois intervalos pelo elemento para igualdade ou equivalência de certo modo especificada por um predicado binário.
equal_range	Localiza um par de posições em um intervalo ordenada, no primeiro menor que ou o equivalente à posição de um elemento especificado e o segundo maior do que a posição do elemento, onde o sentido de equivalência ou de ordenação usada para estabelecer as posições na seqüência pode ser especificado por um predicado binário.
preenchimento	Atribui o mesmo novo valor para cada elemento em um intervalo especificado.
fill_n	Atribuir um novo valor a um número especificado de elementos em um intervalo que começa com um elemento específico.
localizar	Localiza a posição da primeira ocorrência de um elemento em um intervalo que tem um valor especificado.
find_end	Parece em um intervalo para o subsequence o último que são idênticos a uma seqüência específica ou que é equivalente de certo modo especificado por um predicado binário.
find_first_of	Procura a primeira ocorrência de qualquer um dos vários valores em uma carreira de captura ou para a primeira ocorrência de qualquer um dos vários elementos que são equivalentes de certo modo especificados por um predicado binário a um conjunto especificado de elementos.
find_if	Localiza a posição da primeira ocorrência de um elemento em um intervalo que satisfaz uma condição especificada.
find_if_not	Retorna o primeiro elemento no intervalo observado que não satisfazem uma condição.
for_each	Aplica um objeto especificado de função para cada elemento em uma ordem para frente em um intervalo e retorna o objeto de função.
gere	Atribui os valores gerados por um objeto de função para cada elemento em um intervalo.
generate_n	Atribui os valores gerados por um objeto da função a um número especificado de elemento é um intervalo e retorna a posição um passado o último atribuído ao valor.
inclui	Testa se um intervalo classificado contém qualquer intervalo classificado contido em um segundo elementos, onde ordenação ou o critério de equivalência entre elementos podem ser especificados por um predicado binário.
inplace_merge	Combina os elementos de dois espaços consecutivos classificados em um único intervalo ordenada, onde o critério classificação pode ser especificado por um predicado binário.
is_heap	Retorna true se os elementos no intervalo especificado windows um heap.
is_heap_until	Retorna true se o intervalo especificado forma um heap até o último elemento.
is_partitioned	Retorna true se todos os elementos de um determinado intervalo que eles testam true para uma condição vêm antes de todos os elementos que testarem false.
is_sorted	Retorna true se os elementos no intervalo especificado estão em ordem classificada.
is_sorted_until	Retorna true se os elementos no intervalo especificado estão em ordem classificada.
iter_swap	A troca dois valores referenciavam por um par de iteradores especificados.
lexicographical_compare	Compara o elemento por um elemento entre duas seqüências para determinar qual é menos de dois.
lower_bound	Localiza a posição do primeiro elemento em um intervalo ordenada que tem um valor maior que ou o equivalente a um valor especificado, onde o critério classificação pode ser especificado por um predicado binário.
make_checked_array_iterator	Cria checked_array_iterator que pode ser usado por outros algoritmos.
make_heap	Converte os elementos de um intervalo especificado em um heap em que o primeiro elemento é o maior e para o qual um critério de classificação pode ser especificado com um predicado binário.
máximo	Compara dois objetos e retorna o maior dos dois, onde o critério classificação pode ser especificado por um predicado binário.
max_element	Localiza a primeira ocorrência do maior elemento em um intervalo especificado onde o critério classificação pode ser especificado por um predicado binário.
mesclagem	Combina todos os elementos de dois intervalos de origem classificadas em um único, classificados intervalo de destino, onde o critério classificação pode ser especificado por um predicado binário.
minuto	Compara dois objetos e retorna os menos de dois, onde o critério classificação pode ser especificado por um predicado binário.
min_element	Localiza a primeira ocorrência do elemento menor em um intervalo especificado onde o critério classificação pode ser especificado por um predicado binário.
minmax	Compara dois parâmetros de entrada e retorna-os como um par de ordem, pelo menos o grande.
minmax_element	Executa o trabalho é executado por min_element e por max_element em uma chamada.
incompatibilidade	Compara o elemento de dois intervalos pelo elemento para igualdade ou o equivalente de certo modo especificada por um predicado binário e localize a primeira posição onde uma diferença surge.
<alg> move	Elementos de movimentação associados com um intervalo especificado.
move_backward	Move os elementos de um iterador para outro.Inicia o movimento com o último elemento em um intervalo especificado, e termina com o primeiro elemento no intervalo.
next_permutation	Reordena elementos em um intervalo de modo que a ordem de original é substituído por permutação maior lexicographically seguir se existir, onde o sentido de em seguida pode ser especificado com um predicado binário.
none_of	Retorna true enquanto uma condição nunca atual está entre elementos em um determinado intervalo.
nth_element	Divide um intervalo de elementos, localizando corretamente nth oelemento da seqüência no intervalo de modo que todos os elementos na frente de ele é menor ou igual a ele e todos os elementos que seguem o na seqüência maior ou igual a.
partial_sort	Organiza um número especificado de elementos menores em um intervalo em uma ordem nondescending ou de acordo com um critério classificação especificado por um predicado binário.
partial_sort_copy	Os elementos das cópias de um intervalo de origem em um destino variam onde os elementos de origem são ordenados por menor que ou por outro predicado binário especificado.
partition	Classifica os elementos em um intervalo em separam dois conjuntos, com elementos que satisfazem um predicado unário que precede aqueles que não o conteúdo.
partition_copy	Copiar os elementos para que uma condição é true a um destino, e para que a condição for false para outro.Os elementos devem vir de um intervalo especificado.
partition_point	Retorna o primeiro elemento em um determinado intervalo que não satisfaz a condição.Os elementos são classificados de modo que aqueles que satisfazem a condição venham antes de aqueles que não.
pop_heap	Remove o elemento maior da frente de um heap a seguir - posição de à- último no intervalo e forma em um novo heap dos elementos restantes.
prev_permutation	Reordena elementos em um intervalo de modo que a ordem de original é substituído por permutação maior lexicographically seguir se existir, onde o sentido de em seguida pode ser especificado com um predicado binário.
push_heap	Adicione um elemento que está no final da heap um intervalo um existente que consiste nos elementos anteriores no intervalo.
random_shuffle	Reordena uma seqüência de elementos de N em um intervalo em um de Em!organizações possíveis selecionada aleatoriamente.
remova	Elimina um valor de um determinado intervalo especificado sem perturbar a ordem dos elementos restantes e retornar ao final de um novo espaço livre do valor especificado.
remove_copy	Os elementos das cópias de um intervalo de origem a um intervalo de destino, exceto que os elementos de um valor especificado não são copiados, sem perturbar a ordem dos elementos restantes e retornar ao final de um novo intervalo de destino.
remove_copy_if	Os elementos das cópias de um intervalo de origem a um intervalo de destino, exceto que a satisfazer um predicado não são copiados, sem perturbar a ordem dos elementos restantes e retornar ao final de um novo intervalo de destino.
remove_if	Elimina os elementos que satisfazem um predicado de um determinado intervalo sem perturbar a ordem dos elementos restantes e retornar ao final de um novo espaço livre do valor especificado.
substitua	Examina cada elemento em um intervalo e substituí-lo se coincide com um valor especificado.
replace_copy	Examina cada elemento em um intervalo de origem e substituí-lo se coincide com um valor especificado para copiar o resultado em um novo intervalo de destino.
replace_copy_if	Examina cada elemento em um intervalo de origem e substituí-lo se satisfaz um predicado especificado para copiar o resultado em um novo intervalo de destino.
replace_if	Examina cada elemento em um intervalo e substituí-lo se satisfaz um predicado especificado.
inverso	Inverte a ordem dos elementos dentro de um intervalo.
reverse_copy	Inverte a ordem dos elementos dentro de um intervalo de origem para copiar em um intervalo de destino
girar	Troca os dois elementos em intervalos adjacentes.
rotate_copy	Troca os dois elementos em intervalos adjacentes dentro de um intervalo de origem e copia o resultado a um intervalo de destino.
pesquisa	Procura a primeira ocorrência de uma seqüência em uma carreira de captura cujos elementos sejam iguais a esses elementos em uma determinada seqüência dos elementos ou cujos elementos são equivalentes de certo modo especificados por um predicado binário aos elementos na seqüência determinada.
search_n	Procura o primeiro subsequence em um intervalo de um número especificado de elementos que têm um valor específico ou relação ao valor como especificado por um predicado binário.
set_difference	Une todos os elementos que pertencem a um intervalo de origem ordenada, mas não para um segundo intervalo de origem ordenada, em um único, classificados intervalo de destino, onde o critério classificação pode ser especificado por um predicado binário.
set_intersection	Une todos os elementos que pertencem a ambos os intervalos de origem classificadas em um único, classificados intervalo de destino, onde o critério classificação pode ser especificado por um predicado binário.
set_symmetric_difference	Une todos os elementos que pertencem a um, mas não ambos, os intervalos de origem classificadas em um único classificaram, o intervalo de destino, onde o critério classificação pode ser especificado por um predicado binário.
set_union	Une todos os elementos que pertencem a pelo menos um dos intervalos de origem classificadas em um único, classificados intervalo de destino, onde o critério classificação pode ser especificado por um predicado binário.
tipo	Organiza elementos em um intervalo especificado em uma ordem nondescending ou de acordo com um critério classificação especificado por um predicado binário.
sort_heap	Converte um heap em um intervalo classificado.
stable_partition	Classifica os elementos em um intervalo em separam dois conjuntos, com elementos que satisfazem um predicado unário que precede aqueles que não o conteúdo, preservando a ordem relativo de elementos equivalentes.
stable_sort	Organiza elementos em um intervalo especificado em uma ordem nondescending ou de acordo com um critério classificação especificado por um predicado binário e ordenação preserva relativo dos elementos equivalentes.
troca	Troca os valores dos elementos entre dois tipos de objetos, atribuindo o conteúdo do primeiro objeto para o segundo objeto e o conteúdo de segundos para o primeiro.
swap_ranges	Troca os elementos de um intervalo com elementos do outro, igual intervalo - dimensionado.
transform	Aplica um objeto especificado de função para 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.
exclusivo	Remove os elementos duplicados que são junto a se em um intervalo especificado.
unique_copy	Os elementos das cópias de um intervalo de origem em um destino variam a exceção de elementos duplicados que são junto a se.
upper_bound	Localiza a posição do primeiro elemento em um intervalo ordenada que possui um valor que é maior do que um valor especificado, onde o critério classificação pode ser especificado por um predicado binário.

Consulte também

Referência

Segurança do thread na biblioteca C++ padrão

Standard Template Library

Outros recursos

Arquivos de cabeçalho