std::search

Definido en el encabezado `<algorithm>`
template< class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(1)	(constexpr desde C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(2)	(desde C++17)
template< class ForwardIt1, class ForwardIt2, class BinaryPred > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );	(3)	(constexpr desde C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );	(4)	(desde C++17)
template< class ForwardIt, class Searcher > ForwardIt search( ForwardIt first, ForwardIt last, const Searcher& searcher );	(5)	(desde C++17) (constexpr desde C++20)

1-4) Busca la primera ocurrencia de la secuencia de elementos [s_first, s_last) en el rango [first, last).

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 según policy.

Estas sobrecargas participan en la resolución de sobrecarga solo si el valor de la siguiente expresión es true:

`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)

5) Busca en el rango [first, last) el patrón especificado en el constructor de searcher.

La biblioteca estándar proporciona los siguientes buscadores:

default_searcher (C++17)	implementación del algoritmo de búsqueda de la biblioteca estándar de C++ (plantilla de clase)
boyer_moore_searcher (C++17)	implementación del algoritmo de búsqueda de Boyer-Moore (plantilla de clase)
boyer_moore_horspool_searcher (C++17)	implementación del algoritmo de búsqueda de Boyer-Moore-Horspool (plantilla de clase)

(desde C++17)

Parámetros

first, last	-	el par de iteradores que define el rango de elementos a examinar
s_first, s_last	-	el par de iteradores que define el rango de elementos a buscar
policy	-	la política de ejecución a utilizar
searcher	-	el buscador que encapsula el algoritmo de búsqueda y el patrón a buscar
p	-	predicado binario que devuelve true si los elementos deben tratarse como iguales. La firma de la función predicado debe ser equivalente a la siguiente: bool pred ( const Type1 & a, const Type2 & b ) ; Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) `Type1` y `Type2` independientemente de la categoría de valor (por lo tanto, Type1 & no está permitido , ni tampoco Type1 a menos que para `Type1` un movimiento sea equivalente a una copia (desde C++11) ). Los tipos Type1 y Type2 deben ser tales que los objetos de tipos ForwardIt1 y ForwardIt2 puedan ser desreferenciados y luego convertidos implícitamente a Type1 y Type2 respectivamente.
Requisitos de tipo
- `ForwardIt1, ForwardIt2` deben cumplir con los requisitos de LegacyForwardIterator .
- `BinaryPred` debe cumplir con los requisitos de BinaryPredicate .

Valor de retorno

1-4) Iterador al inicio de la primera ocurrencia de la secuencia

s_first

s_last

en el rango

first

last

. Si no se encuentra dicha ocurrencia, last es retornado.

Si

s_first

s_last

está vacío, first se devuelve.

5) searcher ( first, last ) . first .

Complejidad

1-4) Dado

N

como std:: distance ( first, last ) y

S

como std:: distance ( s_first, s_last ) :

1,2) Como máximo

N\cdotS

comparaciones usando operator == .

3,4) Como máximo

N\cdotS

aplicaciones del predicado p .

5) Depende de searcher .

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

búsqueda (1)

template<class ForwardIt1, class ForwardIt2>
constexpr //< since C++20
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                  ForwardIt2 s_first, ForwardIt2 s_last)
{
    while (true)
    {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it)
        {
            if (s_it == s_last)
                return first;
            if (it == last)
                return last;
            if (!(*it == *s_it))
                break;
        }
        ++first;
    }
}

búsqueda (3)

template<class ForwardIt1, class ForwardIt2, class BinaryPred>
constexpr //< since C++20
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                  ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p)
{
    while (true)
    {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it)
        {
            if (s_it == s_last)
                return first;
            if (it == last)
                return last;
            if (!p(*it, *s_it))
                break;
        }
        ++first;
    }
}

Ejemplo

Ejecutar este código

#include <algorithm>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string_view>
#include <vector>
using namespace std::literals;
bool contains(const auto& cont, std::string_view s)
{
    // str.find() (or str.contains(), since C++23) can be used as well
    return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}
int main()
{
    const auto str{"why waste time learning, when ignorance is instantaneous?"sv};
    assert(contains(str, "learning"));
    assert(not contains(str, "lemming"));
    const std::vector vec(str.begin(), str.end());
    assert(contains(vec, "learning"));
    assert(not contains(vec, "leaning"));
    // The C++17 overload with searchers demo:
    constexpr auto quote
    {
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed "
        "do eiusmod tempor incididunt ut labore et dolore magna aliqua"sv
    };
    for (const auto word : {"pisci"sv, "Pisci"sv})
    {
        std::cout << "The string " << std::quoted(word) << ' ';
        const std::boyer_moore_searcher searcher(word.begin(), word.end());
        const auto it = std::search(quote.begin(), quote.end(), searcher);
        if (it == quote.end())
            std::cout << "not found\n";
        else
            std::cout << "found at offset " << std::distance(quote.begin(), it) << '\n';
    }
}

Salida:

The string "pisci" found at offset 43
The string "Pisci" not found

Informes de defectos

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

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
LWG 1205	C++98	el valor de retorno no estaba claro si `[` s_first `,` s_last `)` está vacío	retorna first en este caso
LWG 1338	C++98	la resolución de LWG issue 1205 fue aplicada incorrectamente, haciendo que first sea retornado si no se encuentra ninguna ocurrencia	retorna last en este caso
LWG 2150	C++98	la condición de "ocurrencia de secuencia" era incorrecta	corregida

Véase también

find_end	encuentra la última secuencia de elementos en un rango determinado (plantilla de función & objeto función de algoritmo)
ranges::find_end (C++20)
includes	determina si una secuencia es una subsecuencia de otra (plantilla de función & objeto función de algoritmo)
ranges::includes (C++20)
equal	determina si dos conjuntos de elementos son iguales (plantilla de función & objeto función de algoritmo)
ranges::equal (C++20)
findfind_iffind_if_not (C++11)	encuentra el primer elemento que satisface criterios específicos (plantilla de función & objeto función de algoritmo)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)
lexicographical_compare	compara dos rangos lexicográficamente (plantilla de función & objeto función de algoritmo)
ranges::lexicographical_compare (C++20)
mismatch	encuentra la primera posición donde dos rangos difieren (plantilla de función & objeto función de algoritmo)
ranges::mismatch (C++20)
search_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)
ranges::search_n (C++20)
default_searcher (C++17)	implementación del algoritmo de búsqueda de la biblioteca estándar de C++ (plantilla de clase)
boyer_moore_searcher (C++17)	implementación del algoritmo de búsqueda Boyer-Moore (plantilla de clase)
boyer_moore_horspool_searcher (C++17)	implementación del algoritmo de búsqueda Boyer-Moore-Horspool (plantilla de clase)
ranges::search (C++20)	busca la primera aparición de un rango de elementos (objeto función de algoritmo)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos con nombre
Macros de prueba de características (C++20)
Biblioteca de soporte del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca de numéricos
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca de sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

es.cppreference.net

Namespaces

Variants