Namespaces
Variants

std::experimental::ranges:: adjacent_find

From 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.

Table des matières

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 qui satisfont un prédicat donné)
(modèle de fonction)
supprime les éléments en double consécutifs dans une plage
(modèle de fonction)