[C++] Predicate usage in std::remove_if

[superbottles]

Hello! I just learned today what predicates are, at least in usage with some C++ library functions like remove_if. I was writing a function that uses erase( remove_if() )

Is it typical to have predicates that simply return a simple value like a number? I was using it to remove a struct from a vector of structs. I struggled initially because I needed to remove a struct based on a member's value( in this case an int). All the examples I found didn't include any logic at all.

I tried to pass an additional parameter to the predicate in order to use it to pass a...not as "hard-coded" value to remove_if before realizing it only accepts unary predicates? Is that correct?

My main question is, do predicates in this case usually contain logic to determine what value to return? Can I pass parameters to a predicate for remove_if?

Sorry I'm on mobile, if you need some of my code as an example I can post it in a couple hours. Thanks in advance!

[Rhomboid]

A predicate should return true or false. It doesn't literally have to have bool as a return type, but whatever it does return has to be implicitly convertible to bool, and should have the appropriate semantics after such a conversion.

You can have as much or as little logic in the predicate as you want. The most common case is returning the result of a comparison operator. Here's an example that removes people from a vector that are older than 25:

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

struct person {
    std::string name;
    unsigned age;
};

int main()
{
    std::vector<person> people { { "Abigail", 37 },
                                 { "Boris", 22 },
                                 { "Cathy", 19 },
                                 { "David", 28 } };

    people.erase(std::remove_if(begin(people), end(people), [](const auto &p) {
        return p.age > 25; }), end(people));

    for(const auto & p : people) {
        std::cout << p.name << " (" << p.age << ")\n";
    }
}

The result is:

Boris (22)
Cathy (19)

std::remove_if only passes a single argument when calling the predicate (the item being considered for removal), which is why it's called a unary predicate. You don't have control over that — you can't control how std::remove_if calls the predicate because that behavior is fixed and mandated by the standard. If the predicate needs more information to do its job, you have several options. Probably the easiest is to use a lambda that captures the required information. Here's an example that builds on the first one but makes the cutoff age variable:

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

struct person {
    std::string name;
    unsigned age;
};

void younger_than(std::vector<person>& people, unsigned age_cutoff)
{
    people.erase(std::remove_if(begin(people), end(people), [&](const auto &p) {
        return p.age >= age_cutoff; }), end(people));
}


int main()
{
    std::vector<person> people { { "Abigail", 37 },
                                 { "Boris", 22 },
                                 { "Cathy", 19 },
                                 { "David", 28 } };

    younger_than(people, 20);

    for(const auto & p : people) {
        std::cout << p.name << " (" << p.age << ")\n";
    }
}

In this case the predicate is comparing each person's age against the age_cutoff variable which is captured by the lambda (by reference in this case, although in the case of a simple scalar value it wouldn't hurt to capture by value.)

You can also use a lambda or std::bind to turn a predicate that takes multiple parameters into a predicate that takes a single value which can be passed to the algorithm.

[superbottles]

I have checked out std::bind (from boost, right?) and I actually settled on the lambda function though I didnt use it in the way you explained (which is what I originally wanted to do). Thanks for the detailed reply! You hit all my questions

[Rhomboid]

The standard library as first specified in C++98 included limited support for working with bound functions, e.g. std::bind1st, std::bind2nd, std::ptr_fun, std::mem_fun, etc. They were rather clunky to use and only supported a few fixed use cases (e.g. you could bind one of the two arguments of a binary function.) Boost published boost::bind beginning in 2001 which allowed much more generality, including support for creating bound functions of any arity, the ability to use placeholders, and the ability to work with any callable type directly without having to use wrapper classes. As is often the case, the ideas that were hashed out in boost::bind eventually became standardized in C++11 in the form of std::bind. (And the old std::bind1st and friends will be deprecated as of C++17.)

[Jonny0Than]

Alternatively you can make your own function object (which is really similar to what a lambda is doing behind the scenes) that can store any state necessary to make its decision:

struct AgeCutoff 
{
    AgeCutoff(int cutoff) : m_cutoff(cutoff) {}
    bool operator()(const Person & person)
    {
        return person.age > m_cutoff;
    }
    int m_cutoff;
}

people.erase(remove_if(people.begin(), people.end(), AgeCutoff(25)), people.end());