Vfrdtyky

In my code I have now something like

    Foo bar;

    std::unordered_set<Foo>::iterator minElement =

      std::min_element(std::begin(mySet),

                       std::end(mySet),

                       [&bar](Foo const &lhs, Foo const &rhs) {

                         return bar.myWeakLessOperator(lhs, rhs);

                       });

I wonder wether it exists a way to simplify it by passing directly the member function myWeakLessOperator (that is not static) instead of writing a lambda function just to make to call.

I would like to obtain something like

    Foo bar;

    std::unordered_set<Foo>::iterator minElement =

      std::min_element(std::begin(mySet),

                       std::end(mySet),

                       /* something that rely to */ bar.myWeakLessOperator);

Any idea if it possible and how to do it ?

A possible solution is to use a struct that satisfies Compare inside Foo:

class Foo 

{

public:

    struct WeakLessOperator

    {

        bool operator()(const Foo& a, const Foo& b)

        {

            // implementation - take care of meeting requirements of Compare

            return true;

        }

    };

    WeakLessOperator myWeakLessOperator;

};



Foo bar;



auto minElement =

    std::min_element(std::begin(mySet),

                     std::end(mySet),

                     bar.myWeakLessOperator);

So you want to have a function object that represents a member function bound to a particular receiver. Unfortunately, there's nothing I could find in the standard or Boost that does that.

What you can do is write your own fairly easily.

template <typename R, typename T>

struct member_function_binder {

    T *receiver;

    R T::*pmf;



    template <typename... Args>

    auto operator()(Args&&... args) {

        return (receiver->*pmf)(std::forward<Args>(args)...);

    }

};



template <typename R, typename T>

auto bind_member_function(R T::*pmf, T &receiver) {

    return member_function_binder<R, T>{&receiver, pmf};

}

Have a look at the live demo, I think this might be what you want.

Even more concise, you don't need to have a separate class member_function_binder if you return a lambda from bind_member_function like so:

template <typename R, typename T>

auto bind_member_function(R T::*pmf, T &receiver) {

    return [pmf, &receiver](auto&&... args) {

        return (receiver.*pmf)(std::forward<decltype(args)>(args)...);

    };

}

Live demo

Solution to pass a unary member function like Foo::compareTo(const Foo &rhs), not what OP asked:

What you want is std::mem_fn; it's a wrapper that makes a member function pointer into a function object. You would use it like this:

auto min = std::min_element(

        begin(mySet), end(mySet), std::mem_fn(&Foo::myWeakLessOperator));

you can use std::bind, or some other wrapper.

EXAMPLE:

using namespace std::placeholders;

Foo bar;

std::unordered_set<Foo>::iterator minElement =

  std::min_element(std::begin(mySet),

                   std::end(mySet),

                   std::bind(&Foo::myWeakLessOperator, bar, _1, _2));

OR

Foo bar;

std::unordered_set<Foo>::iterator minElement =

  std::min_element(std::begin(mySet),

                   std::end(mySet),

                   gnr::memfun<MEMFUN(Foo::myWeakLessOperator)>(bar));

The closest to what you want is maybe

auto minElement =

  std::min_element(

            std::begin(mySet),

            std::end(mySet),

            mem_fun_functor(&Foo::myWeakLessOperator) 

  );

There is std::mem_fun (deprecated in c++11) and std::mem_fn both wrap a member function pointer, though both take a instance as parameter to invoke the member function. If you want a functor that wraps the object also, i think you need to write your own:

auto mem_fun_functor = 

    [&bar](decltype(&Foo::myWeakLessOperator) f){

        return [f,&bar](const Foo& a,const Foo& b) {

                  return (bar.*f)(a,b); 

               };

};

However, given that none of the answers is really much shorter or leading to cleaner code, I would consider to just use your first version with the lambda (unless you maybe have many different member functions that you want to use as comparator).

What do you actually mean by "simplifying" ? You do need to specify the object you want to call the member function on, you need to specify how you want to forward the parameters. Thats basically all the lambda does.

Defering all this to a functor as for example above makes your code more complicated rather than simpler. In your first snippet anybody familiar with standard algorithms can look at that few lines of code and fully understand what is going on.

Eventually it is a matter of style, and what you consider as readable, but being able to declare stuff in the most narrowest scope is one big advantage of using lambdas.