Namespaces
Variants

    std::experimental::ranges:: search_n

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

    Contenido

    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
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    		encuentra la última secuencia de elementos en un cierto rango
    (plantilla de función)
    		encuentra el primer elemento que satisface criterios específicos
    (plantilla de función)
    		busca un rango de elementos
    (plantilla de función)