<algorithm>

Définit les fonctions de modèle de conteneur de (STL) de modèles Standard qui effectuent des algorithmes.

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
    );

Notes

Les algorithmes STL sont génériques car ils peuvent traiter diverses structures de données.Les structures de données qu'ils peuvent traiter incluent pas uniquement les classes de conteneurs STL telles que vector et list, mais également les structures de données et les tableaux définis par programme des éléments qui répondent aux conditions d'un algorithme donné.Les algorithmes STL atteignent ce niveau de la généralité en accédant et en parcourant les éléments d'un conteneur indirectement via des itérateurs.

Les algorithmes STL fonctionnent sur des plages d'itérateur qui sont en général spécifiées par leurs positions de début ou de fin.Les plages visés doivent être valides dans le sens que tous les pointeurs dans des plages doivent être deréférençables et, dans les séquences de chaque plage, la dernière position doit être accessible dès le début par l'augmentation.

Les algorithmes STL étendent les actions prises en charge par les opérations et les fonctions membres de chaque conteneur STL et permettent l', par exemple, avec différents types d'objets conteneurs en même temps.Deux suffixes ont été utilisés pour fournir des informations sur la finalité des algorithmes.

• Si le suffixe indique que l'algorithme est utilisé avec la fonction objets l'opération sur les valeurs des éléments plutôt que sur les valeurs des éléments eux-mêmes.L'algorithme d' find_if rechercher les éléments dont les valeurs sont conformes au critère spécifié par un objet de fonction, et l'algorithme d' find recherche une valeur particulière.

• Le suffixe _copy indique que l'algorithme manipule non seulement les valeurs des éléments mais copie également les valeurs modifiées dans une plage de destination.L'algorithme d' reverse inverse l'ordre des éléments dans une plage, et l'algorithme d' reverse_copy copie également le résultat dans une plage de destination.

Les algorithmes STL sont souvent classés en groupes qui indiquent un élément sur leur objectif ou spécifications.Ceux-ci incluent modifier les algorithmes qui modifient la valeur des éléments par rapport aux algorithmes nonmodifying qui ne font pas.Faisant muter les algorithmes modifiez l'ordre des éléments, mais pas les valeurs de leurs éléments.Supprimer des algorithmes peut éliminer les éléments d'une plage ou d'une copie d'un intervalle.Les algorithmes de commande tri de nouveau les éléments dans une plage dans différentes manières et les algorithmes triés de plage agissent uniquement sur les algorithmes dont les éléments ont été triées d'une façon particulière.

Les algorithmes numériques STL fournis pour traiter numérique ont leur propre fichier d'en-tête <numeric>, et fonctionnent les objets et les adaptateurs sont définis dans les objets de fonction de <functional> d'en-tête qui les valeurs booléennes de retour sont appelés attributs.l'attribut binaire par défaut est la comparaison operator<.En général les éléments qui est dimensionné le besoin d'être moins que comparable afin que, avec deux éléments quelconques, il puisse déterminer l'un ou l'autre qu'ils sont équivalents (dans le sens que ni l'un ni l'autre n'est inférieure à l'autre) ou qu'un est inférieure à l'autre.Cela provoque le classement entre des éléments d'inégalité.

Fonctions

adjacent_find	Recherche deux éléments adjacents qui sont égales ou remplissent une condition spécifiée.
all_of	Retourne true lorsqu'une condition est présente à chaque élément de l'intervalle donné.
any_of	Retourne true lorsqu'une condition est présente au moins une fois dans l'intervalle spécifié d'éléments.
binary_search	Les tests si un élément dans une plage trié qui est égale à une valeur spécifiée ou qui est équivalent à ce dernier dans une certaine mesure spécifié par un attribut binaire.
copy	Assigne les valeurs des éléments d'une plage source à une plage de destination, itérant au sein de la séquence source d'éléments et leur assigner de nouvelles positions dans une direction en avant.
copy_backward	Assigne les valeurs des éléments d'une plage source à une plage de destination, itérant au sein de la séquence source d'éléments et leur assigner de nouvelles positions dans une direction descendante.
copy_if	Copiez tous les éléments dans une plage donnée qui testent true d'un état spécifié
copy_n	Copie un nombre spécifié d'éléments.
count	Retourne le nombre d'éléments dans une plage dont les valeurs correspondent à une valeur spécifiée.
count_if	Retourne le nombre d'éléments dans une plage dont les valeurs correspondent à une condition spécifiée.
est égal à	Compare l'élément de deux plages par l'élément d'égalité ou l'équivalence dans une certaine mesure spécifiée par un attribut binaire.
equal_range	Recherche une paire de positions dans une plage dimensionné, le premier inférieure ou l'équivalent à la position d'un élément spécifié et le deuxième supérieur à la position de l'élément, où le sens de l'équivalence ou de classer utilisé pour générer des positions dans la séquence peut être spécifié par un attribut binaire.
fill	Assigne la même nouvelle valeur à chaque élément dans une plage spécifiée.
fill_n	Assigne une valeur à un nombre spécifié d'éléments dans une plage à partir d'un élément particulier.
find	Recherche la position de la première occurrence d'un élément dans une plage qui a une valeur spécifiée.
find_end	Le recherche dans une plage pour le dernier sous-séquence identique à une séquence spécifiée ou qui est équivalent dans une certaine mesure spécifié par un attribut binaire.
find_first_of	Recherche la première occurrence de laquelle plusieurs valeurs dans une fourchette objectif ou pour la première occurrence de laquelle plusieurs éléments qui sont équivalents dans une certaine mesure spécifiés par un attribut binaire à un ensemble spécifié d'éléments.
find_if	Recherche la position de la première occurrence d'un élément dans une plage qui remplit une condition spécifiée.
find_if_not	Retourne le premier élément dans l'intervalle désigné qui ne remplit pas de condition.
for_each	Applique un objet spécifié de fonction à chaque élément d'une commande en avant dans une plage et retourne l'objet de fonction.
générer	Assigne des valeurs générées par un objet de fonction à chaque élément d'un intervalle.
generate_n	Assigne des valeurs générées par un objet de fonction à un nombre spécifié d'éléments est une plage et retourne à la position une au delà de la dernière valeur assignée.
inclut	Teste si une plage trié contient tous les éléments contenus dans un deuxième intervalle trié, où le classement ou le critère d'équivalence entre les éléments peut être spécifié par un attribut binaire.
inplace_merge	Combine les éléments de deux plages triés consécutifs dans une plage trié unique, où le critère de classement peut être spécifié par un attribut binaire.
is_heap	Retourne true si les éléments de la plage spécifiée forment un tas.
is_heap_until	Retourne true si la plage spécifiée forme un tas jusqu ' à le dernier élément.
is_partitioned	Retourne true si tous les éléments de la plage donnée qui testent true pour un composant proviennent avant tous les éléments qui testent false.
is_sorted	Retourne true si les éléments de l'intervalle spécifié dans sont triées.
is_sorted_until	Retourne true si les éléments de l'intervalle spécifié dans sont triées.
iter_swap	Les échanges deux valeurs sont rapportés par une paire d'itérateurs spécifiés.
lexicographical_compare	Compare l'élément par élément entre deux séquences pour déterminer qui est moins de deux.
lower_bound	Recherche la position du premier élément dans une plage dimensionné avec une valeur supérieure ou l'équivalent à une valeur spécifiée, où le critère de classement peut être spécifié par un attribut binaire.
make_checked_array_iterator	Crée checked_array_iterator qui peut être utilisé par d'autres algorithmes.
make_heap	Convertit les éléments d'une plage spécifiée dans un tas dans lequel le premier élément est le plus grand et pour ce qu'un critère de tri peut être spécifié avec un attribut binaire.
max	Compare deux objets et retourne le plus grand les deux, où le critère de classement peut être spécifié par un attribut binaire.
max_element	Rechercher la première occurrence du plus grand élément dans une plage spécifiée où le critère de classement peut être spécifié par un attribut binaire.
merge	Combine tous les éléments de deux plages sources triées dans un intervalle unique et trié de destination, où le critère de classement peut être spécifié par un attribut binaire.
min	Compare deux objets et retourne les moins de deux, où le critère de classement peut être spécifié par un attribut binaire.
min_element	Rechercher la première occurrence du plus petit élément dans une plage spécifiée où le critère de classement peut être spécifié par un attribut binaire.
minmax	Compare deux paramètres d'entrée et les retourne tant que paire, dans l'ordre mineurs à plus grande.
minmax_element	Exécute le travail effectué par min_element et max_element dans un appel.
incompatibilité	Compare l'élément de deux plages par l'élément d'égalité ou l'équivalent dans une certaine mesure spécifié par un attribut binaire et recherche la première position où une différence se produit.
<alg> move	Éléments de mouvements associés à une plage spécifiée.
move_backward	Déplace les éléments d'un itérateur vers un autre.Le déplacement commence par le dernier élément dans une plage spécifiée, et se termine par le premier élément dans cet intervalle.
next_permutation	Réorganise les éléments dans une plage de sorte que l'ordre d'origine est remplacée par la permutation supérieure lexicographique suivante s'il existe, où le sens de mai suivant est spécifié avec un attribut binaire.
none_of	Retourne true lorsqu'une condition n'est jamais répertorie entre les éléments dans l'intervalle donné.
nth_element	Partitionne une plage d'éléments, de définir correctement le nièmeélément de la séquence dans la plage afin que tous les éléments devant lui soient inférieur ou égal à celui-ci et tous les éléments qui suivent le dans la séquence être supérieur ou égal à ce.
partial_sort	Réorganise un nombre spécifié d'éléments plus petits dans une plage dans une commande nondescending ou selon un critère de classement spécifié par un attribut binaire.
partial_sort_copy	Copie des éléments d'une plage source dans un intervalle de destination dans lequel les éléments sources sont classés par un inférieure ou un attribut binaire spécifié différent.
partition	Classifie des éléments dans une plage en deux disjoignent des jeux, avec ces éléments satisfaite un attribut unaire précédant ceux qui ne le contenu pas.
partition_copy	Copie les éléments pour lesquels une condition est true à une destination, et pour ce que la condition est false à un autre.Les éléments doivent provenir d'une plage spécifiée.
partition_point	Retourne le premier élément de la plage donnée qui ne remplit pas la condition.Les éléments sont triés afin que celles qui remplissent la condition proviennent avant ceux qui ne le font pas.
pop_heap	Supprime le plus grand élément de devant d'un tas vers le prochain - à- dernière position dans la plage puis forme d'un tas les éléments restants.
prev_permutation	Réorganise les éléments dans une plage de sorte que l'ordre d'origine est remplacée par la permutation supérieure lexicographique suivante s'il existe, où le sens de mai suivant est spécifié avec un attribut binaire.
push_heap	Ajoute un élément qui correspond à la fin d'une plage à un tas existant qui se compose des éléments antérieurs dans l'intervalle.
random_shuffle	Réorganise une séquence d'éléments N dans une plage dans un N!dispositions possibles sélectionnées au hasard.
remove	Supprime une valeur spécifiée d'une plage donnée sans toucher à l'ordre des éléments restants et retourner la fin d'une nouvelle plage exempte de la valeur spécifiée.
remove_copy	Copie des éléments d'une plage source à une plage de destination, sauf que les éléments d'une valeur spécifiée ne sont pas copiés, sans toucher à l'ordre des éléments restants et retourner la fin d'un nouvel intervalle de destination.
remove_copy_if	Copie des éléments d'une plage source à une plage de destination, sauf que satisfaite un attribut ne sont pas copiés, sans toucher à l'ordre des éléments restants et retourner la fin d'un nouvel intervalle de destination.
remove_if	Supprime les éléments qui satisfont un attribut d'un intervalle spécifié sans toucher à l'ordre des éléments restants et retourner la fin d'une nouvelle plage exempte de la valeur spécifiée.
replace	Examine chaque élément dans une plage et le remplace s'il correspond à une valeur spécifiée.
replace_copy	Examine chaque élément dans une plage source et le remplace s'il correspond à une valeur spécifiée en copiant le résultat dans un nouvel intervalle de destination.
replace_copy_if	Examine chaque élément dans une plage source et le remplace le cas d'un attribut spécifié en copiant le résultat dans un nouvel intervalle de destination.
replace_if	Examine chaque élément dans une plage et le remplace le cas d'un attribut spécifié.
inverse	Inverse l'ordre des éléments dans une plage.
reverse_copy	Inverse l'ordre des éléments dans une plage source en les copiant dans un intervalle de destination
rotation	Permute les éléments dans deux plages adjacents.
rotate_copy	Permute les éléments dans deux plages adjacents dans une plage source et imprimer le résultat sur une plage de destination.
recherche	Recherche la première occurrence d'une séquence dans une fourchette objectif dont les éléments sont égaux à celles d'une séquence donnée d'éléments ou dont les éléments sont équivalents dans une certaine mesure spécifiés par un attribut binaire aux éléments de la séquence donnée.
search_n	Recherche le premier sous-séquence dans une plage qui d'un nombre spécifié d'éléments ayant une valeur particulière ou une relation à cette valeur comme spécifié par un attribut binaire.
set_difference	Unit tous les éléments qui appartiennent à une plage source triée, mais pas à un deuxième a trié la plage source, dans une plage unique et trié de destination, où le critère de classement peut être spécifié par un attribut binaire.
set_intersection	Unit tous les éléments qui appartiennent aux deux des plages sources triées dans un intervalle unique et trié de destination, où le critère de classement peut être spécifié par un attribut binaire.
set_symmetric_difference	Unit tous les éléments qui appartiennent à un, mais pas les deux, plages sources triées dans un unique, a trié la plage de destination, où le critère de classement peut être spécifié par un attribut binaire.
set_union	Unit tous les éléments qui appartiennent au moins une de deux plages sources triées dans un intervalle unique et trié de destination, où le critère de classement peut être spécifié par un attribut binaire.
sort	Réorganise les éléments dans une plage spécifiée dans une commande nondescending ou selon un critère de classement spécifié par un attribut binaire.
sort_heap	Convertit un tas dans une plage trié.
stable_partition	Classifie des éléments dans une plage en deux disjoignent des jeux, avec ces éléments satisfaite un attribut unaire précédant ceux qui ne le contenu pas, en conservant la commande relative d'éléments équivalents.
stable_sort	Réorganise les éléments dans une plage spécifiée dans une commande nondescending ou selon un critère de classement spécifié par un attribut binaire et conserve le classement relatif des éléments équivalents.
échange	Permute les valeurs des éléments entre deux types d'objets, assignant le contenu du premier objet au deuxième objet et le contenu du deuxième au premier.
swap_ranges	Permute les éléments d'une plage avec les éléments des autres, plage de taille d'égal.
transformation	Applique un objet spécifié de fonction à chaque élément dans une plage source ou à une paire d'éléments des deux plages sources et copie les valeurs de retour de l'objet de fonction dans une plage de destination.
unique	Supprime les éléments en double qui sont en regard de l'un de l'autre dans une plage spécifiée.
unique_copy	Copie des éléments d'une plage source dans un intervalle de destination à l'exception de les éléments en double qui sont en regard de l'un de l'autre.
upper_bound	Recherche la position du premier élément dans une plage dimensionné avec une valeur qui est supérieure à une valeur spécifiée, où le critère de classement peut être spécifié par un attribut binaire.

Voir aussi

Référence

Sécurité des threads dans la bibliothèque C++ standard

Modèles Standard

Autres ressources

Fichiers d'en-tête