std::search_n

template< class ForwardIt, class Size, class T >
ForwardIt search_n( ForwardIt first, ForwardIt last,
                    Size count, const T& value );

template< class ForwardIt, class Size,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type >
constexpr ForwardIt search_n( ForwardIt first, ForwardIt last,
                              Size count, const T& value );

template< class ExecutionPolicy,
          class ForwardIt, class Size, class T >
ForwardIt search_n( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                    Size count, const T& value );

template< class ExecutionPolicy,
          class ForwardIt, class Size,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type >
ForwardIt search_n( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                    Size count, const T& value );

template< class ForwardIt, class Size, class T, class BinaryPred >
ForwardIt search_n( ForwardIt first, ForwardIt last,
                    Size count, const T& value, BinaryPred p );

template< class ForwardIt, class Size,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type,
          class BinaryPred >
constexpr ForwardIt search_n( ForwardIt first, ForwardIt last,
                    Size count, const T& value, BinaryPred p );

template< class ExecutionPolicy, class ForwardIt, class Size,
          class T, class BinaryPred >
ForwardIt search_n( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                    Size count, const T& value, BinaryPred p );

template< class ExecutionPolicy, class ForwardIt, class Size,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type,
          class BinaryPred >
ForwardIt search_n( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,
                    Size count, const T& value, BinaryPred p );

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

Parámetros

Valor de retorno

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

Si no se encuentra dicha secuencia, last es retornado.

Si count es cero o negativo, first es devuelto.

Complejidad

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

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

template<class ForwardIt, class Size,
         class T = typename std::iterator_traits<ForwardIt>::value_type>
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; // éxito
            ++first;
            if (first == last)
                return last; // lista agotada
            if (!(*first == value))
                break; // muy pocos consecutivos
        }
    }
    return last;
}

template<class ForwardIt, class Size,
         class T = typename std::iterator_traits<ForwardIt>::value_type,
         class BinaryPred>
ForwardIt search_n(ForwardIt first, ForwardIt last, Size count, const T& value,
                   BinaryPred 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; // éxito
            ++first;
            if (first == last)
                return last; // lista agotada
            if (!p(*first, value))
                break; // muy pocos consecutivos
        }
    }
    return last;
}

Notas

Ejemplo

#include <algorithm>
#include <cassert>
#include <complex>
#include <iostream>
#include <iterator>
#include <vector>
template<class Container, class Size, class T>
constexpr bool consecutive_values(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 sequence[] = ".0_0.000.0_0.";
    static_assert(consecutive_values(sequence, 3, '0'));
    for (int n : {4, 3, 2})
        std::cout << std::boolalpha
                  << "Tiene " << n << " ceros consecutivos: "
                  << consecutive_values(sequence, n, '0') << '\n';
    std::vector<std::complex<double>> nums{{4, 2}, {4, 2}, {1, 3}};
    #ifdef __cpp_lib_algorithm_default_value_type
        auto it = std::search_n(nums.cbegin(), nums.cend(), 2, {4, 2});
    #else
        auto it = std::search_n(nums.cbegin(), nums.cend(), 2, std::complex<double>{4, 2});
    #endif
    assert(it == nums.begin());
}

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también