std::search_n - cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado `<algorithm>`
	(1)
`template< class ForwardIt, class Size, class T > ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value );`			(hasta C++20)
`template< class ForwardIt, class Size, class T > constexpr ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value );`			(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class Size, class T > ForwardIt search_n( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, Size count, const T& value );`		(2)	(desde C++17)
		(3)
`template< class ForwardIt, class Size, class T, class BinaryPredicate > ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value, BinaryPredicate p );`				(hasta C++20)
`template< class ForwardIt, class Size, class T, class BinaryPredicate > constexpr ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value, BinaryPredicate p );`				(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class Size, class T, class BinaryPredicate > ForwardIt search_n( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, Size count, const T& value, BinaryPredicate p );`			(4)	(desde C++17)

Busca en el rango [first, last) la primera secuencia de count elementos idénticos, cada uno igual al valor value dado.

1) Los elementos se comparan usando operator==.

3) Los elementos se comparan usando el predicado binario dado p.

2,4) Igual que (1,3), pero ejecutado de acuerdo a la política de ejecución policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Parámetros

first, last	-	El rango de los elementos a examinar.
count	-	La longitud de la secuencia a buscar.
value	-	El valor de los elementos a buscar.
policy	-	La política de ejecución a usar. Véase política de ejecución para más detalles.
p	-	Predicado binario que devuelve `true` si los elementos deben tratarse como iguales. La signatura de la función predicado deberá ser equivalente a la siguiente: `bool pred(const Tipo1 &a, const Tipo2 &b);` Mientras que la signatura no necesita tener `const &`, la función no debe modificar los objetos que se le han pasado y debe ser capaz de aceptar todos los valores de tipo (posiblemente `const`) `Tipo1` y `Tipo2` independientemente de la categoría de valor (por lo tanto, no se permite `Tipo1 &`, ni `Tipo1` a menos que para `Tipo1` un movimiento sea equivalente a una copia (desde C++11)). El tipo `Tipo1` debe ser tal que un objeto de tipo `ForwardIt` puede ser desreferenciado y luego convertido implícitamente a `Tipo1`. El tipo `Tipo2` debe ser tal que un objeto de tipo `T` puede convertirse implícitamente a `Tipo2`.
Requisitos de tipo
-`ForwardIt` debe satisfacer los requisitos de ForwardIterator.
-`Size` Debe ser convertible a un tipo entero.

Valor de retorno

Si count es positivo, devuelve un iterador al principio de la primera secuencia encontrada en el rango [first, last). Cada iterador it en la secuencia debe cumplir con la siguiente condición:

1,2) *it == value es true

3,4) p(*it, value) != false es true

Si no se encuentra tal secuencia, se devuelve last.

Si count es cero o negativo, se devuelve first.

Complejidad

Dado N como std::distance(first, last):

1,2) A lo sumo N comparaciones con el valor, usando operator==.

3,4) A lo sumo N aplicaciones del predicado p.

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:

Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

search_n (1)
template<class ForwardIt, class Size, class T> ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value) { if (count <= 0) return first; for (; first != last; ++first) { if (!(first == value)) continue; ForwardIt candidate = first; for (Size cur_count = 1; true; ++cur_count) { if (cur_count >= count) return candidate; // success ++first; if (first == last) return last; // exhausted the list if (!(first == value)) break; // too few in a row } } return last; }
search_n (3)
template<class ForwardIt, class Size, class T, class BinaryPredicate> ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value, BinaryPredicate p) { if (count <= 0) return first; for (; first != last; ++first) { if (!p(first, value)) continue; ForwardIt candidate = first; for (Size cur_count = 1; true; ++cur_count) { if (cur_count >= count) return candidate; // success ++first; if (first == last) return last; // exhausted the list if (!p(first, value)) break; // too few in a row } } return last; }

search_n (1)

template<class ForwardIt, class Size, class T>
ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value)
{
    if (count <= 0)
        return first;
    
    for (; first != last; ++first)
    {
        if (!(*first == value))
            continue;
        
        ForwardIt candidate = first;
        
        for (Size cur_count = 1; true; ++cur_count)
        {
            if (cur_count >= count)
                return candidate; // success
            
            ++first;
            if (first == last)
                return last; // exhausted the list
            
            if (!(*first == value))
                break; // too few in a row
        }
    }
    return last;
}

search_n (3)

template<class ForwardIt, class Size, class T, class BinaryPredicate>
ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value,
                   BinaryPredicate p)
{
    if (count <= 0)
        return first;
    
    for (; first != last; ++first)
    {
        if (!p(*first, value))
            continue;
        
        ForwardIt candidate = first;
        
        for (Size cur_count = 1; true; ++cur_count)
        {
            if (cur_count >= count)
                return candidate; // success
            
            ++first;
            if (first == last)
                return last; // exhausted the list
            
            if (!p(*first, value))
                break; // too few in a row
        }
    }
    return last;
}

Ejemplo

#include <algorithm>
#include <iostream>
#include <iterator>

template<class Container, class Size, class T>
[[nodiscard]]
constexpr bool valores_consecutivos(const Container& c, Size count, const T& v)
{
    return std::search_n(std::begin(c), std::end(c), count, v) != std::end(c);
}

int main()
{
    constexpr char secuencia[] = "1001010100010101001010101";

    static_assert(valores_consecutivos(secuencia, 3, '0'));

    std::cout << std::boolalpha
              << "Tiene 4 ceros consecutivos: "
              << valores_consecutivos(secuencia, 4, '0') << '\n'
              << "Tiene 3 ceros consecutivos: "
              << valores_consecutivos(secuencia, 3, '0') << '\n';
}

Salida:

Tiene 4 ceros consecutivos: false
Tiene 3 ceros consecutivos: true

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 283	C++98	Se requiere que `T` sea EqualityComparable, pero el tipo valor de `InputIt` no siempre es `T`.	Se eliminó el requisito.
LWG 426	C++98	El límite superior de la complejidad es `N·count`, es negativo si `count` es negativo	El límite superior es `0` si `count` es no positivo.
LWG 714	C++98	Si `count > 0`, el límite superior de la complejidad es `N·count`, pero en el peor caso, el número de comparaciones/operaciones siempre es `N`	Se cambió el límite superior a `N` en este caso.