Partilhar via


find_if

Localiza a posição da primeira ocorrência de um elemento em um intervalo que atende a uma condição especificada.

template<class InputIterator, class Predicate> InputIterator find_if(InputIterator first, InputIterator last,        Predicate pred);

Parâmetros

  • first
    Um iterador de entrada que aborda a posição do primeiro elemento do intervalo a ser pesquisado.

  • last
    Um iterador de entrada que aborda a posição um após o elemento final do intervalo a ser pesquisado.

  • pred
    Objeto de função de predicado definida pelo usuário ou expressão lambda que define a condição para ser atendida pelo elemento que está sendo pesquisado. Um predicado usa único argumento e retorna true (atendido) ou false (não atendido). A assinatura de pred deve ser efetivamente bool pred(const T& arg);, em que T é um tipo para o qual InputIterator pode ser convertido implicitamente quando cancelado. A palavra-chave const é mostrada somente para ilustrar que o objeto de função ou lambda não deve modificar o argumento.

Valor de retorno

Um iterador de entrada que se refere ao primeiro elemento do intervalo que atende a condição especificada pelo predicado (o predicado resulta em true). Se nenhum elemento for encontrado para atender o predicado, retornará last.

Comentários

Essa função de modelo é uma generalização do algoritmo find, que substitui o predicado "igual a um valor específico" com qualquer predicado. Para a lógica oposta (localizar o primeiro elemento que não satisfaz o predicado), consulte find_if_not.

Exemplo

// cl.exe /W4 /nologo /EHsc /MTd
#include <vector>
#include <algorithm>
#include <iostream>
#include <string>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }
    cout << endl;
}

// Test std::find()
template <class InputIterator, class T>
void find_print_result(InputIterator first, InputIterator last, const T& value) {

    // call <algorithm> std::find()
    auto p = find(first, last, value);

    cout << "value " << value;
    if (p == last) {
        cout << " not found." << endl;
    } else {
        cout << " found." << endl;
    }
}

// Test std::find_if()
template <class InputIterator, class Predicate>
void find_if_print_result(InputIterator first, InputIterator last,
    Predicate Pred, const string& Str) {

    // call <algorithm> std::find_if()
    auto p = find_if(first, last, Pred);

    if (p == last) {
        cout << Str << " not found." << endl;
    } else {
        cout << "first " << Str << " found: " << *p << endl;
    }
}

// Function to use as the UnaryPredicate argument to find_if() in this example
bool is_odd_int(int i) {
    return ((i % 2) != 0);
}

int main()
{
    // Test using a plain old array.
    const int x[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    cout << "array x[] contents: ";
    print(x);
    // Using non-member std::begin()/std::end() to get input iterators for the plain old array.
    cout << "Test std::find() with array..." << endl;
    find_print_result(begin(x), end(x), 10);
    find_print_result(begin(x), end(x), 42);
    cout << "Test std::find_if() with array..." << endl;
    find_if_print_result(begin(x), end(x), is_odd_int, "odd integer"); // function name
    find_if_print_result(begin(x), end(x), // lambda
        [](int i){ return ((i % 2) == 0); }, "even integer");

    // Test using a vector.
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back((i + 1) * 10);
    }
    cout << endl << "vector v contents: ";
    print(v);
    cout << "Test std::find() with vector..." << endl;
    find_print_result(v.begin(), v.end(), 20);
    find_print_result(v.begin(), v.end(), 12);
    cout << "Test std::find_if() with vector..." << endl;
    find_if_print_result(v.begin(), v.end(), is_odd_int, "odd integer");
    find_if_print_result(v.begin(), v.end(), // lambda
        [](int i){ return ((i % 2) == 0); }, "even integer");
}

Saída

                               

Requisitos

Cabeçalho: <algorithm>

Namespace: std

Consulte também

Referência

<algorithm>

adjacent_find

find (STL)

find_if_not

find_end

mismatch

pesquisa