Namespaces
Variants

std::experimental::ranges:: search_n

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 T,

class Pred = ranges:: equal_to <> , class Proj = ranges:: identity >
requires IndirectlyComparable < I, const T * , Pred, Proj >
I search_n ( I first, S last, ranges :: difference_type_t < I > count,

const T & value, Pred pred = Pred { } , Proj proj = Proj { } ) ;
(1) (ranges TS)
template < ForwardRange R, class T, class Pred = ranges:: equal_to <> ,

class Proj = ranges:: identity >
requires IndirectlyComparable < ranges:: iterator_t < R > , const T * , Pred, Proj >
ranges:: safe_iterator_t < R > search_n ( R && r,
ranges :: difference_type_t < ranges:: iterator_t < R >> count,

const T & value, Pred pred = Pred { } , Proj proj = Proj { } ) ;
(2) (ranges TS)
1) Recherche dans l'intervalle [ first , last ) la première séquence de count éléments dont les valeurs projetées sont chacune égales à la valeur donnée value selon le prédicat pred .
2) Identique à (1) , mais utilise r comme plage source, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

Table des matières

Paramètres

first, last - la plage d'éléments à examiner
r - la plage d'éléments à examiner
count - la longueur de la séquence à rechercher
value - la valeur à rechercher
pred - le prédicat qui compare les éléments projetés avec value
proj - la projection à appliquer aux éléments

Valeur de retour

Itérateur vers le début de la séquence trouvée dans la plage [ first , last ) . Si aucune telle séquence n'est trouvée, un itérateur qui compare égal à last est retourné.

Complexité

Au plus last - first applications du prédicat et de la projection.

Implémentation possible 

template<ForwardIterator I, Sentinel<I> S, class T,
         class Pred = ranges::equal_to<>, class Proj = ranges::identity>
    requires IndirectlyComparable<I, const T*, Pred, Proj>
I search_n(I first, S last, ranges::difference_type_t<I> count,
           const T& value, Pred pred = Pred{}, Proj proj = Proj{})
{
    for (; first != last; ++first)
    {
        if (!ranges::invoke(pred, ranges::invoke(proj, *first), value))
            continue;
        I candidate = first;
        ranges::difference_type_t<I> cur_count = 0;
        while (true)
        {
            ++cur_count;
            if (cur_count == count)
                // succès
                return candidate;
            ++first;
            if (first == last)
                // liste épuisée
                return first;
            if (!ranges::invoke(pred, ranges::invoke(proj, *first), value))
                // trop peu consécutifs
                break;
        }
    }
    return first;
}

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

recherche la première occurrence d'un nombre de copies consécutives d'un élément dans une plage
(modèle de fonction)
trouve la dernière séquence d'éléments dans une certaine plage
(modèle de fonction)
trouve le premier élément satisfaisant des critères spécifiques
(modèle de fonction)
recherche une plage d'éléments
(modèle de fonction)