Store class member function in a template

Question

I need to store a member function pointer like this somewhere:

void Class1::function1(int a, int b)
{
  ...
}

struct parameters
{
   int a;
   int b;
}

myStoreClass.store(&Class1::function1, parameters);

and then be able to call it later like this:

myStoreClass.call();

so that the function is called with the appropriate parameters.

Since it's a member function I suppose I should store a Class1 object pointer too, but how can I store a member function pointer with a template?

I don't see a template anywhere. Is Class1 a template class? — Nikos C., Jul 31 '13 at 15:59
@juanchopanza yes. They're fixed. At nikos C. I want to write myStoreClass as a template class to be able to do this — Marco A., Jul 31 '13 at 16:01
Do you want to use a pointer-to-member-function as a non-type template parameter? This answer has an example of the syntax: http://stackoverflow.com/questions/17218712/how-to-allow-templated-functor-work-on-both-member-and-non-member-functions/17237671#17237671 — willj, Jul 31 '13 at 16:01
If it's a memeber function, you'd need an object and a pointer to member. If it's static, a regular function pointer will work. — StoryTeller - Unslander Monica, Jul 31 '13 at 16:07

score 0 · Accepted Answer · answered Jul 31 '13 at 16:11

You need to parameterize the type of object that the member function is on, and pass a pointer to the function. In order to call the member function you also need to pass a pointer to the object, and the parameters for the call. Here is a sample:

class Foo 
{
public:
    void DoIt (int a, int b)
    {   
    }   
};

class Bar 
{
public:
    void DoItAgain (int x, int y)
    {   
    }   
};

template <typename Obj>
void DoSomething (Obj* that, void (Obj::*fnThat)(int,int), int i, int j)
{
    (that->*fnThat)(i, j); 
}

int main()
{
    Foo foo;
    Bar bar;

    void (Foo::*fnFoo)(int,int) = &Foo::DoIt;

    (foo.*fnFoo)(42,43);

    DoSomething (&foo, fnFoo, 99, 100);
    DoSomething (&bar, &Bar::DoItAgain, 200, 300);
}

Nikos C. · Answer 2 · 2013-07-31T17:12:26.353

If you're using a C++11 compiler, then it's rather simple. Given this class:

class Class1 {
public:
    void function1(int a, int b);
};

you can just prepare a call using std::bind:

#include <functional>
// ...

Class1 class1Obj;
auto myStore = std::bind(&Class1::function1, &class1Obj, 10, 20);

and you can call it later with:

myStore();
// The above has the same effect as:
// class1Obj.function1(10, 20);

You don't actually need a StoreClass at all (it's pretty much what std::bind does already.)

This is just an example. You obviously need to make sure that the instance of Class1 you're calling Class1::function1() on (class1Obj in the above example) still exists when you perform the call.

If you're not on C++11, then you can use Boost instead:

#include <boost/function.hpp>
#include <boost/bind.hpp>
// ...

boost::function<void()> myStore = boost::bind(&Class1::function1,
                                              &class1Obj, 10, 20);

the call is the same:

myStore();

In both cases, the type of the function returned by bind is void (). Meaning a function returning void and taking no arguments (since they've been "swallowed" up by bind.) So if you still need to create a template in order to parameterize the type of member function calls you can store, you only need to do so on the return type of the member functions, not their arguments. For example:

template <typename T>
// ...
std::function<T ()> storedCall;
// or with Boost:
// boost::function<T ()> storedCall;

Note that Boost.Bind and Boost.Function are header-only libraries. That means they're easy to use and don't require you to link against any libraries at all.

Store class member function in a template

2 Answers2