◐ Shell
clean mode source ↗

std::find_first_of - cppreference.com

De 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 ForwardIt1, class ForwardIt2 > ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );

 (hasta C++11)

template< class InputIt, class ForwardIt > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last );

 (desde C++11)
(hasta C++20)

template< class InputIt, class ForwardIt > constexpr InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last );

 (desde C++20)

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );

 (2) (desde C++17)
(3)

template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );

 (hasta C++11)

template< class InputIt, class ForwardIt, class BinaryPredicate > InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );

 (desde C++11)
(hasta C++20)

template< class InputIt, class ForwardIt, class BinaryPredicate > constexpr InputIt find_first_of( InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );

 (desde C++20)

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 find_first_of( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );

 (4) (desde C++17)

Busca en el rango [first, last) por cualquiera de los elementos en el rango [s_first, s_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 se ejecuta conforme 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.
s_first, s_last - El rango 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)).
Los tipos Tipo1 y Tipo2 deben ser tales que objetos de tipo ForwardIt1 y ForwardIt2 pueden ser desreferenciados y luego convertidos implícitamente a Tipo1 and Tipo2 respectively. ​

Requisitos de tipo
-InputIt debe satisfacer los requisitos de InputIterator.
-ForwardIt1 debe satisfacer los requisitos de ForwardIterator.
-ForwardIt2 debe satisfacer los requisitos de ForwardIterator.

Valor de retorno

Iterador al primer elemento en el rango [first, last) que es igual a un elemento del rango [s_first, s_last). Si no se encuentra tal secuencia, se devuelve last .

Complejidad

Realiza a lo sumo (S*N) comparaciones, donde S = std::distance(s_first, s_last) y N = std::distance(first, last).

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

Primera versión 
template<class InputIt, class ForwardIt>
InputIt find_first_of(InputIt first, InputIt last,
                      ForwardIt s_first, ForwardIt s_last)
{
    for (; first != last; ++first) {
        for (ForwardIt it = s_first; it != s_last; ++it) {
            if (*first == *it) {
                return first;
            }
        }
    }
    return last;
}
Segunda versión 
template<class InputIt, class ForwardIt, class BinaryPredicate>
InputIt find_first_of(InputIt first, InputIt last,
                      ForwardIt s_first, ForwardIt s_last,
                      BinaryPredicate p)
{
    for (; first != last; ++first) {
        for (ForwardIt it = s_first; it != s_last; ++it) {
            if (p(*first, *it)) {
                return first;
            }
        }
    }
    return last;
}

Ejemplo

El siguiente código busca por cualquiera de los enteros especificados en un vector de enteros:

#include <algorithm>
#include <iostream>
#include <vector>

auto imprimir_secuencia = [](auto const id, auto const& secuencia, int pos = -1) {
    std::cout << id << "{ ";
    for (int i{}; auto const& e : secuencia) {
        const bool marca {i == pos};
        std::cout << (i++ ? ", " : "");
        std::cout << (marca ? ">> " : "") << e << (marca ? " <<" : "");
    }
    std::cout << " }\n";
};

int main()
{
    const std::vector<int> v{0, 2, 3, 25, 5};
    const auto t1 = {19, 10, 3, 4};
    const auto t2 = {1, 6, 7, 9};

    auto cualquiera_de = [](const auto& v, const auto& t) {
        const auto resultado = std::find_first_of(v.begin(), v.end(),
                                               t.begin(), t.end());
        if (resultado == v.end()) {
            std::cout << "Ningún elemento de v es igual a ningún elemento de ";
            imprimir_secuencia("t = ", t);
            imprimir_secuencia("v = ", v);
        } else {
            const auto pos = std::distance(v.begin(), resultado);
            std::cout << "Se encontró una coincidencia (" << *resultado << ") en la posición " << pos;
            imprimir_secuencia(", donde t = ", t);
            imprimir_secuencia("v = ", v, pos);
        }
    };

    cualquiera_de(v, t1);
    cualquiera_de(v, t2);
}

Salida: 

Se encontró una coincidencia (3) en la posición 2, donde t = { 19, 10, 3, 4 }
v = { 0, 2, >> 3 <<, 25, 5 }
Ningún elemento de v es igual a ningún elemento de t = { 1, 6, 7, 9 }
v = { 0, 2, 3, 25, 5 }

Véase también