algorithm (STL/CLR)

Article
04/03/2023

Définit des modèles de fonction conteneur STL/CLR qui effectuent des algorithmes.

Syntaxe

#include <cliext/algorithm>

Spécifications

Header :<cliext/algorithm>

Espace de noms : cliext

Déclarations

Fonction	Description
adjacent_find (STL/CLR)	Recherche deux éléments adjacents qui sont égaux.
binary_search (STL/CLR)	Teste si une séquence triée contient une valeur donnée.
copy (STL/CLR)	Copie les valeurs d’une plage source vers une plage de destination, en itérant dans la direction vers l’avant.
copy_backward (STL/CLR)	Copie les valeurs d’une plage source vers une plage de destination, en itérant dans la direction descendante.
count (STL/CLR)	Retourne le nombre d'éléments d'une plage dont les valeurs correspondent à une valeur spécifiée.
count_if (STL/CLR)	Retourne le nombre d'éléments d'une plage dont les valeurs correspondent à une condition spécifiée.
equal (STL/CLR)	Compare deux plages, élément par élément.
equal_range (STL/CLR)	Recherche une séquence ordonnée de valeurs et retourne deux positions qui délimitent une sous-séquence de valeurs qui sont toutes égales à un élément donné.
fill (STL/CLR)	Affecte la même nouvelle valeur à chaque élément d'une plage spécifiée.
fill_n (STL/CLR)	Attribue une nouvelle valeur à un nombre spécifié d’éléments d’une plage commençant par un élément particulier.
find (STL/CLR)	Retourne la position de la première occurrence d’une valeur spécifiée.
find_end (STL/CLR)	Retourne la dernière sous-séquence dans une plage identique à une séquence spécifiée.
find_first_of (STL/CLR)	Recherche une plage pour la première occurrence d’une plage donnée d’éléments.
find_if (STL/CLR)	Retourne la position du premier élément dans une séquence de valeurs où l’élément satisfait à une condition spécifiée.
for_each (STL/CLR)	Applique un objet de fonction spécifié à chaque élément d’une séquence de valeurs et retourne l’objet de fonction.
generate (STL/CLR)	Affecte les valeurs générées par un objet de fonction à chaque élément dans une séquence de valeurs.
generate_n (STL/CLR)	Affecte les valeurs générées par un objet de fonction à un nombre spécifié d’éléments.
includes (STL/CLR)	Teste si une plage triée contient tous les éléments d’une deuxième plage triée.
inplace_merge (STL/CLR)	Combine les éléments de deux plages triées consécutives en une seule plage triée.
iter_swap (STL/CLR)	Échange deux valeurs référencées par une paire d'itérateurs spécifiés.
lexicographical_compare (STL/CLR)	Compare deux séquences, élément par élément, identifiant la séquence la plus petite des deux.
lower_bound (STL/CLR)	Recherche la position du premier élément dans une séquence ordonnée de valeurs dont la valeur est supérieure ou égale à une valeur spécifiée.
make_heap (STL/CLR)	Convertit les éléments d’une plage spécifiée en tas où le premier élément du tas est le plus grand.
max (STL/CLR))	Compare deux objets et retourne le plus grand des deux.
max_element (STL/CLR)	Recherche le plus grand élément dans une séquence de valeurs spécifiée.
merge (STL/CLR))	Combine tous les éléments de deux plages sources triées en une seule plage de destination triée.
min (STL/CLR)	Compare deux objets et retourne la moindre des deux.
min_element (STL/CLR)	Recherche le plus petit élément dans une séquence de valeurs spécifiée.
mismatch (STL/CLR)	Compare deux plages par élément et retourne la première position où se produit une différence.
next_permutation (STL/CLR)	Réorganise les éléments d’une plage afin que l’ordre d’origine soit remplacé par le lexicographiquement suivant une permutation plus grande s’il existe.
nth_element (STL/CLR)	Partitionne une séquence d’éléments, localisant correctement le `n`ième élément de la séquence afin que tous les éléments devant celui-ci soient inférieurs ou égaux à celui-ci et que tous les éléments qui suivent sont supérieurs ou égaux à celui-ci.
partial_sort (STL/CLR)	Organise un nombre spécifié des éléments plus petits d’une plage dans un ordre non décréscissant.
partial_sort_copy (STL/CLR)	Copie les éléments d’une plage source dans une plage de destination afin que les éléments de la plage source soient classés.
partition (STL/CLR)	Organise les éléments d’une plage de sorte que ces éléments qui répondent à un prédicat unaire précèdent ceux qui ne le satisfont pas.
pop_heap (STL/CLR)	Déplace le plus grand élément du devant d’un tas à la fin, puis forme un nouveau tas à partir des éléments restants.
prev_permutation (STL/CLR)	Réorganise une séquence d’éléments afin que l’ordre d’origine soit remplacé par la permutation lexicographique précédente plus grande s’il existe.
push_heap (STL/CLR)	Ajoute un élément qui se trouve à la fin d'une plage à un tas existant, constitué des éléments précédents de la plage.
random_shuffle (STL/CLR)	Réorganise une séquence d’éléments `N` dans une plage en un des éléments `N`! dispositions possibles, sélectionnées de manière aléatoire.
remove (STL/CLR)	Supprime une valeur spécifiée d’une plage donnée sans déranger l’ordre des éléments restants et retourne la fin d’une nouvelle plage libre de la valeur spécifiée.
remove_copy (STL/CLR)	Copie les éléments d’une plage source vers une plage de destination, sauf que les éléments d’une valeur spécifiée ne sont pas copiés, sans perturber l’ordre des éléments restants.
remove_copy_if (STL/CLR)	Copie les éléments d’une plage source vers une plage de destination, à l’exception des éléments qui répondent à un prédicat, sans perturber l’ordre des éléments restants.
remove_if (STL/CLR)	Supprime les éléments qui répondent à un prédicat d’une plage donnée sans perturber l’ordre des éléments restants. .
replace (STL/CLR)	Remplace les éléments d’une plage qui correspondent à une valeur spécifiée par une nouvelle valeur.
replace_copy (STL/CLR)	Copie les éléments d’une plage source vers une plage de destination, en remplaçant les éléments qui correspondent à une valeur spécifiée par une nouvelle valeur.
replace_copy_if (STL/CLR)	Examine tous les éléments d'une plage source et les remplace s'ils répondent à un prédicat, tout en copiant le résultat dans une nouvelle plage de destination.
replace_if (STL/CLR)	Examine tous les éléments d’une plage et les remplace s’ils répondent à un prédicat spécifié.
reverse (STL/CLR)	Inverse l'ordre des éléments d'une plage.
reverse_copy (STL/CLR)	Inverse l’ordre des éléments dans une plage source tout en les copiant dans une plage de destination.
rotate (STL/CLR)	Échange les éléments de deux plages adjacentes.
rotate_copy (STL/CLR)	Échange les éléments de deux plages adjacentes au sein d'une plage source et copie le résultat dans une plage de destination.
search (STL/CLR)	Recherche la première occurrence d’une séquence au sein d’une plage cible dont les éléments sont égaux à ceux d’une séquence d’éléments donnée ou dont les éléments sont équivalents à ceux d’une séquence donnée, selon un prédicat binaire spécifié.
search_n (STL/CLR)	Recherche la première sous-séquence d’une plage dont un nombre spécifié d’éléments ont une valeur particulière ou une relation à cette valeur, selon un prédicat binaire spécifié.
set_difference (STL/CLR)	Regroupe tous les éléments qui appartiennent à une plage source triée, mais pas à une autre plage source triée, en une même plage de destination triée. Un critère de tri peut être spécifié par un prédicat binaire.
set_intersection (STL/CLR)	Regroupe tous les éléments de deux plages sources triées au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.
set_symmetric_difference (STL/CLR)	Regroupe tous les éléments qui appartiennent à l'une de deux plages sources triées (mais pas aux deux) au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.
set_union (STL/CLR))	Regroupe tous les éléments qui appartiennent au moins à l'une de deux plages sources triées au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.
sort (STL/CLR)	Réorganise les éléments d’une plage spécifiée, dans un ordre non décroissant, ou selon un critère de tri spécifié par un prédicat binaire.
sort_heap (STL/CLR)	Convertit un tas en une plage triée.
stable_partition (STL/CLR)	Classe les éléments d’une plage en deux ensembles disjoints. Les éléments qui répondent à un prédicat unaire doivent précéder ceux qui n’y répondent pas, et l’ordre relatif des éléments équivalents doit être conservé.
stable_sort (STL/CLR)	Classe les éléments d’une plage spécifiée dans un ordre non décroissant, ou selon un critère de tri spécifié par un prédicat binaire, et conserve l’ordre relatif des éléments équivalents.
swap (STL/CLR)	Échange les valeurs des éléments de deux types d'objets, en assignant le contenu du premier objet au deuxième objet, et le contenu du deuxième au premier.
swap_ranges (STL/CLR)	Échange les éléments d'une plage avec ceux d'une autre plage de taille égale.
transform (STL/CLR)	Applique un objet de fonction spécifié à chaque élément d'une plage source ou à une paire d'éléments de deux plages sources, et copie les valeurs de retour de l'objet de fonction dans une plage de destination.
unique (STL/CLR)	Supprime les éléments en double adjacents dans une plage spécifiée.
unique_copy (STL/CLR)	Copie les éléments d'une plage source dans une plage de destination, à l'exception des éléments en double adjacents.
upper_bound (STL/CLR)	Recherche la position du premier élément d’une plage triée dont la valeur est supérieure à une valeur spécifiée. Le critère de tri peut être spécifié par un prédicat binaire.

Membres

adjacent_find (STL/CLR)

Recherche deux éléments adjacents qui ont la même valeur ou qui répondent à une condition spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction adjacent_findde bibliothèque standard C++. Pour plus d’informations, consultez adjacent_find.

binary_search (STL/CLR)

Teste si un élément d’une plage triée est égal à une valeur spécifiée ou équivalent, selon une condition spécifiée par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction binary_searchde bibliothèque standard C++. Pour plus d’informations, consultez binary_search.

copy (STL/CLR)

Assigne les valeurs des éléments d'une plage source à une plage de destination, en procédant à une itération via la séquence source d'éléments et en leur assignant de nouvelles positions, du haut vers le bas.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction copyde bibliothèque standard C++. Pour plus d’informations, consultez copie.

copy_backward (STL/CLR)

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction copy_backwardde bibliothèque standard C++. Pour plus d’informations, consultez copy_backward.

count (STL/CLR)

Retourne le nombre d'éléments d'une plage dont les valeurs correspondent à une valeur spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction countde bibliothèque standard C++. Pour plus d’informations, consultez le nombre.

count_if (STL/CLR)

Retourne le nombre d'éléments d'une plage dont les valeurs correspondent à une condition spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction count_ifde bibliothèque standard C++. Pour plus d’informations, consultez count_if.

equal (STL/CLR)

Compare deux plages, élément par élément, à la recherche d’une égalité ou d’une équivalence, selon une condition spécifiée par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction equalde bibliothèque standard C++. Pour plus d’informations, voir égal.

equal_range (STL/CLR)

Recherche une paire de positions dans une plage triée. La première inférieure ou équivalente à la position d’un élément spécifié, et la deuxième supérieure à la position de cet élément. L’équivalence ou le tri utilisés pour établir des positions dans la séquence peuvent être spécifiés par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction equal_rangede bibliothèque standard C++. Pour plus d’informations, consultez equal_range.

fill (STL/CLR)

Affecte la même nouvelle valeur à chaque élément d'une plage spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction fillde bibliothèque standard C++. Pour plus d’informations, consultez remplissage.

fill_n (STL/CLR)

Attribue une nouvelle valeur à un nombre spécifié d’éléments d’une plage commençant par un élément particulier.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction fill_nde bibliothèque standard C++. Pour plus d’informations, consultez fill_n.

find (STL/CLR)

Recherche la position de la première occurrence d'un élément d'une plage ayant une valeur spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction findde bibliothèque standard C++. Pour plus d’informations, consultez la section Rechercher.

find_end (STL/CLR)

Recherche dans une plage la dernière sous-séquence qui est identique à une séquence spécifiée ou qui est équivalente, selon une condition spécifiée par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction find_endde bibliothèque standard C++. Pour plus d’informations, consultez find_end.

find_first_of (STL/CLR)

Recherche la première occurrence parmi plusieurs valeurs d’une plage cible, ou la première occurrence parmi plusieurs éléments qui sont équivalents, selon une condition spécifiée par un prédicat binaire, à un ensemble d’éléments spécifiés.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction find_first_ofde bibliothèque standard C++. Pour plus d’informations, consultez find_first_of.

find_if (STL/CLR)

Recherche la position de la première occurrence d'un élément d'une plage qui répond à une condition spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction find_ifde bibliothèque standard C++. Pour plus d’informations, consultez find_if.

for_each (STL/CLR)

Applique un objet de fonction spécifié à chaque élément d'une plage, du haut vers le bas, et retourne l'objet de la fonction.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction for_eachde bibliothèque standard C++. Pour plus d’informations, consultez for_each.

generate (STL/CLR)

Assigne les valeurs générées par un objet de fonction à chaque élément d'une plage.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction generatede bibliothèque standard C++. Pour plus d’informations, consultez générer.

generate_n (STL/CLR)

Assigne les valeurs générées par un objet de fonction à un nombre spécifié d'éléments d'une plage, et retourne à la position située juste après la dernière valeur assignée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction generate_nde bibliothèque standard C++. Pour plus d’informations, consultez generate_n.

includes (STL/CLR)

Teste si une plage triée contient tous les éléments d’une autre plage triée. Le critère de tri ou d’équivalence entre les éléments peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction includesde bibliothèque standard C++. Pour plus d’informations, consultez les rubriques suivantes :

inplace_merge (STL/CLR)

Regroupe les éléments de deux plages triées consécutives au sein d’une même plage triée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction inplace_merge de bibliothèque standard C++ Pour plus d’informations, consultez inplace_merge.

iter_swap (STL/CLR)

Échange deux valeurs référencées par une paire d'itérateurs spécifiés.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction iter_swapde bibliothèque standard C++. Pour plus d’informations, consultez iter_swap.

lexicographical_compare (STL/CLR)

Compare deux séquences, élément par élément, pour déterminer lequel est inférieur à l'autre.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction lexicographical_comparede bibliothèque standard C++. Pour plus d’informations, consultez lexicographical_compare.

lower_bound (STL/CLR)

Recherche la position du premier élément dans une plage ordonnée qui a une valeur inférieure ou équivalente à une valeur spécifiée, où le critère de classement peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction lower_boundde bibliothèque standard C++. Pour plus d’informations, consultez lower_bound.

make_heap (STL/CLR)

Convertit les éléments d’une plage spécifiée en un tas, dans lequel le premier élément est le plus grand, et pour lequel un critère de tri peut être spécifié à l’aide d’un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction make_heapde bibliothèque standard C++. Pour plus d’informations, consultez make_heap.

max (STL/CLR)

Compare deux objets et retourne le plus grand des deux. Un critère de tri peut être spécifié à l’aide d’un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction maxde bibliothèque standard C++. Pour plus d’informations, consultez max.

max_element (STL/CLR)

Recherche la première occurrence du plus grand élément dans une plage spécifiée. Un critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction max_elementde bibliothèque standard C++. Pour plus d’informations, consultez max_element.

merge (STL/CLR)

Regroupe tous les éléments de deux plages sources triées au sein d’une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction mergede bibliothèque standard C++. Pour plus d’informations, consultez fusion.

min (STL/CLR)

Compare deux objets et retourne le plus petit des deux. Un critère de tri peut être spécifié à l’aide d’un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction minde bibliothèque standard C++. Pour plus d’informations, consultez min.

min_element (STL/CLR)

Recherche la première occurrence du plus petit élément dans une plage spécifiée. Un critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction min_elementde bibliothèque standard C++. Pour plus d’informations, consultez min_element.

mismatch (STL/CLR)

Compare deux plages, élément par élément, à la recherche d’une égalité ou d’une équivalence, selon une condition spécifiée par un prédicat binaire, et recherche la première position où se trouve une différence.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction mismatchde bibliothèque standard C++. Pour plus d’informations, consultez incompatibilité.

next_permutation (STL/CLR)

Réorganise les éléments d’une plage, de sorte que le tri d’origine soit remplacé par la prochaine permutation plus élevée d’un point de vue lexicographique (s’il en existe une). La notion de "prochaine" peut être définie à l’aide d’un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction next_permutationde bibliothèque standard C++. Pour plus d’informations, consultez next_permutation.

nth_element (STL/CLR)

Partitionne une plage d’éléments, localisant correctement le nième élément de la séquence dans la plage afin que tous les éléments devant celui-ci soient inférieurs ou égaux à celui-ci et que tous les éléments qui le suivent dans la séquence soient supérieurs ou égaux à celui-ci.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction nth_elementde bibliothèque standard C++. Pour plus d’informations, consultez nth_element.

partial_sort (STL/CLR)

Réorganise un nombre spécifié d’éléments plus petits au sein d’une plage, dans un ordre non décroissant, ou selon un critère de tri spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction partial_sortde bibliothèque standard C++. Pour plus d’informations, consultez partial_sort.

partial_sort_copy (STL/CLR)

Copie les éléments d’une plage source dans une plage de destination. Les éléments sources sont triés par ordre croissant ou selon un autre prédicat binaire spécifié.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction partial_sort_copyde bibliothèque standard C++. Pour plus d’informations, consultez partial_sort_copy.

partition (STL/CLR)

Répartit les éléments d’une plage en deux ensembles disjoints. Les éléments qui répondent à un prédicat unaire doivent précéder ceux qui n’y répondent pas.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction partitionde bibliothèque standard C++. Pour plus d’informations, consultez partition.

pop_heap (STL/CLR)

Retire le plus grand élément du début du tas et le place à l'avant-dernière position de la plage, puis forme un nouveau tas à partir des éléments restants.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction pop_heapde bibliothèque standard C++. Pour plus d’informations, consultez pop_heap.

prev_permutation (STL/CLR)

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction prev_permutationde bibliothèque standard C++. Pour plus d’informations, consultez prev_permutation.

push_heap (STL/CLR)

Ajoute un élément qui se trouve à la fin d'une plage à un tas existant, constitué des éléments précédents de la plage.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction push_heapde bibliothèque standard C++. Pour plus d’informations, consultez push_heap.

random_shuffle (STL/CLR)

Réorganise une séquence d’éléments N dans une plage en un des éléments N! dispositions possibles, sélectionnées de manière aléatoire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction random_shufflede bibliothèque standard C++. Pour plus d’informations, consultez random_shuffle.

remove (STL/CLR)

Élimine une valeur spécifiée d'une plage donnée sans modifier l'ordre des éléments restants, et retourne la fin d'une nouvelle plage exempte de la valeur spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction removede bibliothèque standard C++. Pour plus d’informations, consultez supprimer.

remove_copy (STL/CLR)

Copie les éléments d'une plage source vers une plage de destination. Les éléments ayant une valeur spécifiée ne sont pas copiés. L'ordre des éléments restants n'est pas modifié et la fin d'une nouvelle plage de destination est retournée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction remove_copyde bibliothèque standard C++. Pour plus d’informations, consultez remove_copy.

remove_copy_if (STL/CLR)

Copie les éléments d'une plage source vers une plage de destination. Les éléments répondant à un prédicat ne sont pas copiés. L'ordre des éléments restants n'est pas modifié et la fin d'une nouvelle plage de destination est retournée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction remove_copy_ifde bibliothèque standard C++. Pour plus d’informations, consultez remove_copy_if.

remove_if (STL/CLR)

Élimine d’une plage donnée les éléments qui répondent à un prédicat, sans modifier l’ordre des éléments restants et en retournant la fin d’une nouvelle plage exempte de la valeur spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction remove_ifde bibliothèque standard C++. Pour plus d’informations, consultez remove_if.

replace (STL/CLR)

Examine tous les éléments d'une plage et les remplace s'ils correspondent à une valeur spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction replacede bibliothèque standard C++. Pour plus d’informations, consultez remplacer.

replace_copy (STL/CLR)

Examine tous les éléments d'une plage source et les remplace s'ils correspondent à une valeur spécifiée, tout en copiant le résultat dans une nouvelle plage de destination.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction replace_copyde bibliothèque standard C++. Pour plus d’informations, consultez replace_copy.

replace_copy_if (STL/CLR)

Examine tous les éléments d'une plage source et les remplace s'ils répondent à un prédicat, tout en copiant le résultat dans une nouvelle plage de destination.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction replace_copy_ifde bibliothèque standard C++. Pour plus d’informations, consultez replace_copy_if.

replace_if (STL/CLR)

Examine tous les éléments d’une plage et les remplace s’ils répondent à un prédicat spécifié.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction replace_ifde bibliothèque standard C++. Pour plus d’informations, consultez replace_if.

reverse (STL/CLR)

Inverse l'ordre des éléments d'une plage.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction reversede bibliothèque standard C++. Pour plus d’informations, consultez inverse.

reverse_copy (STL/CLR)

Inverse l’ordre des éléments dans une plage source tout en les copiant dans une plage de destination.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction reverse_copyde bibliothèque standard C++. Pour plus d’informations, consultez reverse_copy.

rotate (STL/CLR)

Échange les éléments de deux plages adjacentes.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction rotatede bibliothèque standard C++. Pour plus d’informations, consultez rotation.

rotate_copy (STL/CLR)

Échange les éléments de deux plages adjacentes au sein d'une plage source et copie le résultat dans une plage de destination.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction rotate_copyde bibliothèque standard C++. Pour plus d’informations, consultez rotate_copy.

search (STL/CLR)

Recherche la première occurrence d’une séquence au sein d’une plage cible dont les éléments sont égaux à ceux d’une séquence d’éléments donnée ou dont les éléments sont équivalents à ceux d’une séquence donnée, selon un prédicat binaire spécifié.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction searchde bibliothèque standard C++. Pour plus d’informations, consultez la recherche.

search_n (STL/CLR)

Recherche la première sous-séquence d’une plage dont un nombre spécifié d’éléments ont une valeur particulière ou une relation à cette valeur, selon un prédicat binaire spécifié.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction search_nde bibliothèque standard C++. Pour plus d’informations, consultez search_n.

set_difference (STL/CLR)

Regroupe tous les éléments qui appartiennent à une plage source triée, mais pas à une autre plage source triée, en une même plage de destination triée. Un critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction set_differencede bibliothèque standard C++. Pour plus d’informations, consultez set_difference.

set_intersection (STL/CLR)

Regroupe tous les éléments de deux plages sources triées au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction set_intersectionde bibliothèque standard C++. Pour plus d’informations, consultez set_intersection.

set_symmetric_difference (STL/CLR)

Regroupe tous les éléments qui appartiennent à l'une de deux plages sources triées (mais pas aux deux) au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction set_symmetric_differencede bibliothèque standard C++. Pour plus d’informations, consultez set_symmetric_difference.

set_union (STL/CLR)

Regroupe tous les éléments qui appartiennent au moins à l'une de deux plages sources triées au sein d'une même plage de destination triée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction set_unionde bibliothèque standard C++. Pour plus d’informations, consultez set_union.

sort (STL/CLR)

Réorganise les éléments d’une plage spécifiée, dans un ordre non décroissant, ou selon un critère de tri spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction sortde bibliothèque standard C++. Pour plus d’informations, consultez tri.

sort_heap (STL/CLR)

Convertit un tas en une plage triée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction sort_heapde bibliothèque standard C++. Pour plus d’informations, consultez sort_heap.

stable_partition (STL/CLR)

Classe les éléments d’une plage en deux ensembles disjoints. Les éléments qui répondent à un prédicat unaire doivent précéder ceux qui n’y répondent pas, et l’ordre relatif des éléments équivalents doit être conservé.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction stable_partitionde bibliothèque standard C++. Pour plus d’informations, consultez stable_partition.

stable_sort (STL/CLR)

Classe les éléments d’une plage spécifiée dans un ordre non décroissant, ou selon un critère de tri spécifié par un prédicat binaire, et conserve l’ordre relatif des éléments équivalents.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction stable_sortde bibliothèque standard C++. Pour plus d’informations, consultez stable_sort.

swap (STL/CLR)

Échange les valeurs des éléments de deux types d'objets, en assignant le contenu du premier objet au deuxième objet, et le contenu du deuxième au premier.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction swapde bibliothèque standard C++. Pour plus d’informations, consultez échange.

swap_ranges (STL/CLR)

Échange les éléments d'une plage avec ceux d'une autre plage de taille égale.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction swap_rangesde bibliothèque standard C++. Pour plus d’informations, consultez swap_ranges.

transform (STL/CLR)

Applique un objet de fonction spécifié à chaque élément d'une plage source ou à une paire d'éléments de deux plages sources, et copie les valeurs de retour de l'objet de fonction dans une plage de destination.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction transformde bibliothèque standard C++. Pour plus d’informations, consultez transformation.

unique (STL/CLR)

Supprime les éléments en double adjacents dans une plage spécifiée.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction uniquede bibliothèque standard C++. Pour plus d’informations, consultez unique.

unique_copy (STL/CLR)

Copie les éléments d'une plage source dans une plage de destination, à l'exception des éléments en double adjacents.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction unique_copyde bibliothèque standard C++. Pour plus d’informations, consultez unique_copy.

upper_bound (STL/CLR)

Recherche la position du premier élément d’une plage triée dont la valeur est supérieure à une valeur spécifiée. Le critère de tri peut être spécifié par un prédicat binaire.

Syntaxe

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

Notes

Cette fonction se comporte de la même façon que la fonction upper_boundde bibliothèque standard C++. Pour plus d’informations, consultez upper_bound.