Namespaces
Variants

    std::experimental::ranges:: adjacent_find

    From fr.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    Défini dans l'en-tête <experimental/ranges/algorithm>
    template < ForwardIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectRelation < projected < I, Proj >> Pred = ranges:: equal_to <> >

    I adjacent_find ( I first, S last, Pred pred = Pred { } , Proj proj = Proj { } ) ;
    		(1) (ranges TS)
    template < ForwardRange R, class Proj = ranges:: identity ,

    IndirectRelation < projected < ranges:: iterator_t < R > , Proj >> Pred = ranges:: equal_to <> >

    ranges:: safe_iterator_t < R > adjacent_find ( R && r, Pred pred = Pred { } , Proj proj = Proj { } ) ;
    		(2) (ranges TS)
    1) Recherche dans l'intervalle [ first , last ) deux éléments identiques consécutifs. Les éléments sont comparés en utilisant pred après avoir été projetés avec proj .
    2) Identique à (1) , mais utilise r comme plage source, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Sommaire

    Paramètres

    first, last - la plage d'éléments à examiner
    r - la plage d'éléments à examiner
    pred - prédicat à utiliser pour comparer les éléments projetés
    proj - projection à appliquer aux éléments

    Valeur de retour

    Un itérateur vers le premier de la première paire d'éléments identiques, c'est-à-dire le premier itérateur i tel que i et i + 1 soient tous deux dans l'intervalle [ first , last ) et que ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) , ranges:: invoke ( proj, * ( i + 1 ) ) ) ! = false .

    Si aucun élément de ce type n'est trouvé, un itérateur qui est égal à last est retourné.

    Complexité

    Si la plage n'est pas vide, exactement min((result - first) + 1, (last - first) - 1) applications du prédicat où result est la valeur de retour, et au maximum deux fois plus d'applications de la projection.

    Implémentation possible 

    template<ForwardIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectRelation<projected<I, Proj>> Pred = ranges::equal_to<>>
I adjacent_find(I first, S last, Pred pred = Pred{}, Proj proj = Proj{})
{
    if (first == last)
        return first;
    I next = first;
    ++next;
    while (next != last)
    {
        if (ranges::invoke(pred, ranges::invoke(proj, *first),
                                 ranges::invoke(proj, *next)))
            return first;
        ++next;
        ++first;
    }
    return next;
}

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    		 trouve les deux premiers éléments adjacents qui sont égaux (ou satisfont un prédicat donné)
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		supprime les éléments en double consécutifs dans une plage
    (modèle de fonction)