Storing Member Functions in std::function

Yes, you can store a member function in a std::function object, but you need to provide an object instance on which to invoke the member function. This is because a member function requires an object to be called on.

Here's an example of how you can store a member function in a std::function and invoke it:

1#include <functional>
2#include <iostream>
3
4class MyClass {
5 public:
6  void MyMethod(int x) {
7    std::cout << "MyMethod called with: "
8      << x << "\n";
9  }
10};
11
12int main() {
13  MyClass obj;
14  std::function<void(MyClass*, int)> Callable{
15    &MyClass::MyMethod};  
16
17  Callable(&obj, 42);  
18}

1MyMethod called with: 42

In this example, we store a pointer to the MyMethod member function of MyClass in the Callable std::function object. The std::function is declared with a signature that takes a MyClass* as the first argument (the object to call the method on) and an int as the second argument (the argument to pass to MyMethod).

When invoking Callable, we pass a pointer to obj (an instance of MyClass) as the first argument, and 42 as the second argument.

Alternatively, if you have a std::shared_ptr to your object, you can use std::bind to bind the member function to the object and store the result in a std::function:

1#include <functional>
2#include <iostream>
3#include <memory>
4
5class MyClass {
6 public:
7  void MyMethod(int x) {
8    std::cout << "MyMethod called with: "
9      << x << "\n";
10  }
11};
12
13int main() {
14  auto obj{std::make_shared<MyClass>()};
15
16  std::function<void(int)> Callable{
17    std::bind(
18      &MyClass::MyMethod,
19      obj,
20      std::placeholders::_1
21    )
22  };  
23
24  Callable(42);
25}

1MyMethod called with: 42

Here, std::bind creates a new callable that invokes MyMethod on obj when called. The std::placeholders::_1 is a placeholder for the argument that will be passed to Callable.