stl find_if and case-insensitive string comparison

boost, c++, c++03, string

Solution

Calling, rather than binding, a function

boost::iequals(boost::bind(&Model::mName, _1), assetName)

The bind is a red herring: this is currently not a functor, but a function call.

You're (accidentally) trying to call it immediately, and use the boolean result as the comparison function for `std::find_if`. Naturally, that's not correct.

You were right to bind the model name, but you'll still have to bind the actual call to `iequals`, too.

Here's a prior example on the Boost users' mailing list - first Google result for `bind iequals`.

Try something like:

boost::bind(
   &boost::iequals<std::string,std::string>,
   boost::bind(&Model::mName, _1), // 1st arg to iequals
   assetName,                      // 2nd arg to iequals
   std::locale()                   // 3rd arg to iequals
)

Notice that template argument deduction is not possible here; also notice that we have to provide `boost::iequals`'s default third argument explicitly, because defaults don't provide us the magic of being able to omit arguments when binding functions.

Full working testcase:

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/algorithm/string/predicate.hpp>

struct Model
{
    Model(const std::string& name) : name(name) {};
    std::string mName() const
    {
        return name;
    }

private:
    std::string name;
};

int main()
{
    std::vector<Model> mModels;
    mModels.push_back(Model("a"));
    mModels.push_back(Model("b"));
    mModels.push_back(Model("c"));

    const std::string assetName = "B";

    std::vector<Model>::iterator it = std::find_if(
        mModels.begin(),
        mModels.end(),
        boost::bind(
            &boost::iequals<std::string,std::string>,
            boost::bind(&Model::mName, _1),
            assetName,
            std::locale()
        )
    );

    assert(it != mModels.end());
    std::cout << it->mName() << std::endl; // expected: "b"
}

(See it working live here.)

Why did my original code work, then?

In `boost::bind(&Model::mName, _1) == assetName`, the operator `==` is overloaded when used with `boost::bind` to do magic; although it looks like you're doing a direct comparison, the comparison is not actually evaluated in the argument to `std::find_if`, but deferred until later (essentially by performing an implicit `bind` that you can't see).

In the case of a normal function call, though, such as to `boost::iequals`, we have to apply that "magic" ourselves, which is what the above is all about.

Problem

Original source