Getting undeclared args when trying to bind std::function using parameter pack - c++

Question

I'm trying to create a variadic template class that looks like this :
template <class... Args>
class Message
{
private:
std::function<void(Args...)> _function;
public:
//stuff
};
I want to have an option to bind so the user can bind any function (with corresponding arguments) when he wants. I've tried this approach (this function is a part of the Message class, so Args... comes from the template argument of the class):
template<class T>
void Message::bindFunction(void(T::*function)(Args... args), T* ownerPtr)
{
//This doesn't work
_function = boost::bind(function,args, ownerPtr);
}
However the above doesn't work, I've tried to create the tuple from the args in the bind function, but the compiler keeps saying:
<args_0> undeclared identifier.
(If I pass more arguments it changes)
From the user's point of view it should look like this:
class Foo
{
public:
void test2(int a, float b, double c)
{
std::cout << "bla";
}
};
int main()
{
Foo f;
Message<int,float,double> Mess;
Mess.bindFunction(&Foo::test2, &f);
}
I've seen a lot of articles talking about forwarding the parameters, however most of the answers confuse me more than I am already with different template structures without explaining them.

Answer 1

Use a lambda because they're much nicer (Live Demo (C++11)):
template<class T>
void bindFunction(void(T::*function)(Args...), T* ownerPtr)
{
_function = [function, ownerPtr](Args... args)
{
(ownerPtr->*function)(args...);
};
}
We are capturing the function pointer and pointer to instance of the class with [function, ownerPtr] in the lambda declaration.
The lambda accepts a list of arguments whose types are specified in the variadic template for the Message class: Args... args.
Internally we call the function using our instance with the (ownerPtr->*function) syntax, and then pass in the arguments by expanding the parameter pack (args...)
To call the function you might write something like this:
void callFunction(Args&&... args)
{
_function(std::forward<Args>(args)...);
}
We use perfect forwarding to pass our arguments to the std::function<void(Args...)> member.