C++ Find with Predicate

Introduction

In C++, the std::find algorithm is used to search for an element in a given range. However, it only works when the elements can be compared with the == operator. In cases where the elements need to be compared using a custom predicate, std::find_if should be used.

What is a Predicate?

A predicate is a function that returns a boolean value indicating whether a given condition is true or false. In the context of the std::find_if algorithm, a predicate is a function that takes a single element as input and returns a boolean value indicating whether that element matches the search criteria.

Syntax

The syntax for std::find_if is as follows:

std::find_if(start, end, predicate)

• start: iterator pointing to the beginning of the range to be searched.
• end: iterator pointing to the end of the range to be searched.
• predicate: a function that returns true if the element matches the criteria, and false otherwise.

Example

Suppose we have a vector of integers and we want to find the first even number in it. We can use a lambda function as a predicate to achieve this as follows:

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

int main()
{
    std::vector<int> vec = {1, 3, 5, 2, 7, 9, 8, 4, 6};
    
    auto it = std::find_if(vec.begin(), vec.end(), [](int x) { return x % 2 == 0; });
    
    if (it != vec.end())
        std::cout << "The first even number in vec is " << *it << std::endl;
    else
        std::cout << "There are no even numbers in vec." << std::endl;
    
    return 0;
}

In this example, the lambda function [](int x) { return x % 2 == 0; } returns true if the input integer is even, and false otherwise. The std::find_if algorithm returns an iterator to the first element in the range for which the predicate returns true, or to the end of the range if no such element is found.

Conclusion

The std::find_if algorithm is useful for searching for elements in a range using a custom predicate. By providing a predicate that matches the desired criteria, we can easily find elements that would not be found using the std::find algorithm.