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
Definido en el encabezado <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) Busca en el rango [ first , last ) la primera secuencia de count elementos cuyos valores proyectados son iguales al valor dado value según el predicado pred .
2) Igual que (1) , pero utiliza r como el rango fuente, como si se usara ranges:: begin ( r ) como first y ranges:: end ( r ) como last .

Contenidos

Parámetros

first, last - el rango de elementos a examinar
r - el rango de elementos a examinar
count - la longitud de la secuencia a buscar
value - el valor a buscar
pred - el predicado que compara los elementos proyectados con value
proj - la proyección a aplicar a los elementos

Valor de retorno

Iterador al inicio de la secuencia encontrada en el rango [ first , last ) . Si no se encuentra tal secuencia, se retorna un iterador que compara igual a last .

Complejidad

Como máximo last - first aplicaciones del predicado y la proyección.

Implementación posible 

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)
                // éxito
                return candidate;
            ++first;
            if (first == last)
                // lista agotada
                return first;
            if (!ranges::invoke(pred, ranges::invoke(proj, *first), value))
                // muy pocos consecutivos
                break;
        }
    }
    return first;
}

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Véase también

busca la primera aparición de un número de copias consecutivas de un elemento en un rango
(function template)
encuentra la última secuencia de elementos en un rango determinado
(function template)
encuentra el primer elemento que satisface criterios específicos
(function template)
busca un rango de elementos
(function template)