Using std::apply on class method

Question

I'm trying to get the following to compile (g++-11.2, C++20), but I get:

error: no matching function for call to '__invoke(std::_Mem_fn<void (Foo::*)(int, double)>, std::__tuple_element_t<0, std::tuple<int, double> >, std::__tuple_element_t<1, std::tuple<int, double> >)'
 1843 |       return std::__invoke(std::forward<_Fn>(__f),

Code:

#include <iostream>
#include <tuple>

struct Foo
{
    void bar(const int x, const double y) 
    {  
        std::cout << x << " " << y << std::endl;
    }  


    void bar_apply()
    {  
        // fails
        std::apply(std::mem_fn(&Foo::bar), std::tuple<int, double>(1, 5.0));
    }  
};


int main()
{
    Foo foo;
    foo.bar_apply();
};

`bar` is non-static so you need to pass `this` as an argument — Alan Birtles, Oct 24 '21 at 04:39
Perhaps: `std::apply([this](int x, double y) { return bar(x,y); }, std::tuple(1, 5.0));` — Ted Lyngmo, Oct 24 '21 at 04:43
@AlanBirtles You mean `this->bar` instead of `&Foo::bar`? If so, doesn't work. — Agrim Pathak, Oct 24 '21 at 04:44
@TedLyngmo That works, but is there a way without creating a lambda? — Agrim Pathak, Oct 24 '21 at 04:46
I've not used `std::apply` but I'd imagine `std::apply(std::mem_fn(&Foo::bar), std::make_tuple(this, 1, 5.0))` will work — Alan Birtles, Oct 24 '21 at 04:46
...or `std::apply(std::mem_fn(&Foo::bar), std::tuple(this, 1, 5.0));` — Ted Lyngmo, Oct 24 '21 at 04:47
Yes, these answers works. If you write an answer, I'll accept it. Thanks! — Agrim Pathak, Oct 24 '21 at 04:49

score 6 · Accepted Answer · answered Oct 24 '21 at 05:18

6

I recommend using C++20 bind_front, which is more lightweight and intuitive. Just like its name, member functions require a specific class object to invoke, so you need to bind this pointer to Foo::bar.

void bar_apply()
{  
  std::apply(std::bind_front(&Foo::bar, this), std::tuple<int, double>(1, 5.0));
}

Demo.

answered Oct 24 '21 at 05:18

康桓瑋

33,481
5
40
90

This is nice, but I've heard the `std::bind` doesn't have optimal performance. Do you know if that's the same story with `std::bind_front`? – Agrim Pathak Oct 24 '21 at 05:27
1

One of the purposes of the introduction of `std::bind_front` is to solve the problem of insufficient performance of `std::bind`. Therefore, it is more lightweight and efficient. – 康桓瑋 Oct 24 '21 at 05:29

score 2 · Answer 2 · answered Oct 24 '21 at 05:02

std::mem_fn(&Foo::bar) does not store the instance of Foo like a capturing lambda would do:

std::apply([this](int x, double y) { return bar(x,y); },
           std::tuple<int, double>(1, 5.0));

You therefore need to supply the instance when calling the mem_fn object:

std::apply(std::mem_fn(&Foo::bar), std::tuple<Foo*, int, double>(this, 1, 5.0));

or simpler, using make_tuple:

std::apply(std::mem_fn(&Foo::bar), std::make_tuple(this, 1, 5.0));

score 2 · Answer 3 · answered Oct 24 '21 at 05:05

2

As others have pointed out, you need an instance to call the member function. This you can deliver to std::apply by wrapping the function call to a lambda expression or via tuple arguments.

However, I would suggest std::invoke, which is more apt to this task. By this way, no instance wrapping is required.

#include <functional> // std::invoke

std::invoke(&Foo::bar, this, 1, 5.0);

answered Oct 24 '21 at 05:05

JeJo

30,635
6
49
88

1

`bar(1, 5.0);` would be even simpler in this case :-) – Ted Lyngmo Oct 24 '21 at 05:14
@JeJo Good point, but the actual use case is that I'm storing the arguments of `bar` in a queue of tuples. – Agrim Pathak Oct 24 '21 at 05:29

Using std::apply on class method

3 Answers3