Namespaces
Variants

    std::experimental:: boyer_moore_horspool_searcher, std::experimental:: make_boyer_moore_horspool_searcher

    From es.cppreference.net
    C++
    Experimental
    Library fundamentals
    Definido en el encabezado <experimental/functional>
    template < class RandomIt1,

    class Hash = std:: hash < typename std:: iterator_traits < RandomIt1 > :: value_type > ,
    class BinaryPredicate = std:: equal_to <> >

    class boyer_moore_horspool_searcher ;
    		(library fundamentals TS)

    Un buscador adecuado para usar con std::experimental::search que implementa el algoritmo de búsqueda de cadenas Boyer-Moore-Horspool .

    boyer_moore_horspool_searcher es CopyConstructible y CopyAssignable .

    RandomIt1 debe cumplir con los requisitos de LegacyRandomAccessIterator .

    Contenido

    Funciones miembro

    std::experimental::boyer_moore_horspool_searcher::boyer_moore_horspool_searcher

    boyer_moore_horspool_searcher( RandomIt1 pat_first,
                               RandomIt1 pat_last,
                               Hash hf = Hash(),
                               BinaryPredicate pred = BinaryPredicate() );

    Construye un boyer_moore_horspool_searcher almacenando copias de pat_first, pat_last, hf y pred, configurando las estructuras de datos internas necesarias.

    El tipo de valor de RandomIt1 debe ser DefaultConstructible, CopyConstructible y CopyAssignable.

    Para dos valores cualesquiera A y B del tipo std::iterator_traits<RandomIt1>::value_type, si pred(A, B) == true, entonces hf(A) == hf(B) debe ser true.

    Parámetros

    pat_first, pat_last - un par de iteradores que designan la cadena a buscar
    hf - un objeto invocable utilizado para hashear los elementos de la cadena
    pred - un objeto invocable utilizado para determinar igualdad

    Excepciones

    Cualquier excepción lanzada por

    • el constructor copia de RandomIt1;
    • el constructor por defecto, constructor copia u operador de asignación copia del tipo de valor de RandomIt1; o
    • el constructor copia o el operador de llamada a función de BinaryPredicate o Hash.

    También puede lanzar std::bad_alloc si no se puede asignar la memoria adicional requerida para las estructuras de datos internas.

    std::experimental::boyer_moore_horspool_searcher::operator()

    template< class RandomIt2 >
RandomIt2 operator()( RandomIt2 first, RandomIt2 last ) const;
    		(hasta C++17) 
    template< class RandomIt2 >
std::pair<RandomIt2,RandomIt2> operator()( RandomIt2 first, RandomIt2 last ) const;
    		(desde C++17)

    La función miembro llamada por std::experimental::search para realizar una búsqueda con este buscador. RandomIt2 debe cumplir los requisitos de LegacyRandomAccessIterator.

    RandomIt1 y RandomIt2 deben tener el mismo tipo de valor.

    Parámetros

    first, last - un par de iteradores que designan la cadena a examinar

    Valor de retorno

    Si el patrón [ pat_first , pat_last ) está vacío, retorna first .

    De lo contrario, un iterador a la primera posición en [ first , last ) donde se encuentra una subsecuencia que compara igual a [ pat_first , pat_last ) según lo definido por pred , o una copia de last en caso contrario.

    		(hasta C++17)

    Si el patrón [ pat_first , pat_last ) está vacío, retorna make_pair ( first, first ) .

    De lo contrario, retorna un par de iteradores a la primera y una posición después de la última en [ first , last ) donde se encuentra una subsecuencia que compara igual a [ pat_first , pat_last ) según lo definido por pred , o make_pair ( last, last ) en caso contrario.

    		(desde C++17)

    Funciones auxiliares

    template< class RandomIt,
          class Hash = std::hash<typename
                                 std::iterator_traits<RandomIt>::value_type>,
          class BinaryPredicate = std::equal_to<> >
boyer_moore_horspool_searcher<RandomIt, Hash, BinaryPredicate>
    make_boyer_moore_horspool_searcher( RandomIt pat_first,
                                        RandomIt pat_last,
                                        Hash hf = Hash(),
                                        BinaryPredicate pred = BinaryPredicate()
    );
    		(library fundamentals TS)

    Función auxiliar que construye un std::experimental::boyer_moore_horspool_searcher mediante deducción de argumentos de plantilla. Equivalente a return boyer_moore_horspool_searcher<RandomIt, Hash, BinaryPredicate>(pat_first, pat_last, hf, pred);

    Parámetros

    pat_first, pat_last - un par de iteradores que designan la cadena a buscar
    hf - un objeto invocable utilizado para aplicar hash a los elementos de la cadena
    pred - un objeto invocable utilizado para determinar igualdad

    Valor de retorno

    Un boyer_moore_horspool_searcher construido con los argumentos pat_first , pat_last , hf , y pred .

    Ejemplo

    Ejecutar este código 
    #include <experimental/algorithm>
#include <experimental/functional>
#include <iostream>
#include <string>
int main()
{
    std::string in = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
                     " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
    std::string needle = "pisci";
    auto it = std::experimental::search(in.begin(), in.end(),
                  std::experimental::make_boyer_moore_horspool_searcher(
                      needle.begin(), needle.end()));
    if (it != in.end())
        std::cout << "The string " << needle << " found at offset "
                  << it - in.begin() << '\n';
    else
        std::cout << "The string " << needle << " not found\n";
}

    Salida: 

    The string pisci found at offset 43

    Véase también

    		 busca la primera ocurrencia de un rango de elementos
    (plantilla de función & objeto función de algoritmo)
    (C++20)