问题
Consider three ways to implement a routine in c++: through functors, member functions, and non-member functions. For example,
#include <iostream>
#include <string>
using std::cout;
using std::endl;
using std::string;
class FOO
{
public:
void operator() (string word) // first: functor
{
cout << word << endl;
}
void m_function(string word) // second: member-function
{
cout << word << endl;
}
} FUNCTOR;
void function(string word) // third: non-member function
{
cout << word << endl;
}
Now consider a template-function to call the three functions above:
template<class T>
void eval(T fun)
{
fun("Using an external function");
}
What is the proper way to call FOO::m_function
through eval?
I tried:
FUNCTOR("Normal call"); // OK: call to ‘void FOO::operator()(string)‘
eval(FUNCTOR); // OK: instantiation of ‘void eval(T) [with T = FOO]’
function("Normal call"); // OK: call to ‘void function(string)’
eval(function); // OK: instantiation of ‘void eval(T) [with T = void (*)(string)]’
FUNCTOR.m_function("Normal call"); // OK: call to member-function ‘FOO::m_function(string)’
eval(FUNCTOR.m_function); // ERROR: cannot convert ‘FOO::m_function’ from type
// ‘void (FOO::)(std::string) {aka void (FOO::)(string)}’
// to type ‘void (FOO::*)(std::basic_string<char>)’
// In instantiation of ‘void eval(T) [with T = void (FOO::*)(string)]’:
// ERROR: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘fun (...)’, e.g. ‘(... ->* fun) (...)’
回答1:
A pointer to member function and a pointer to function are two different beasts. The former takes an implicit first argument, the this
pointer, or in other words, a pointer to the instance on which the member function is to be invoked on.
Typically, in order to be able to pass the member function as a callable object, you bind the instance on which it is to be invoked on, and then use placeholders to indicate arguments that will be passed to the callable later. In your case
eval(std::bind(&FOO::m_function, &FUNCTOR, std::placeholders::_1));
The first argument to bind
above is the pointer to member function that you want to invoke, and the second is a pointer to the FOO
instance on which you want to invoke m_function
. The last one is a placeholder that indicates the first argument passed to the callable created by bind
should be used when calling the member function.
Another way to do this is to pass a lambda expression to eval
that takes a char const *
(or std::string const&
) argument and calls the member function.
eval([](char const *c) { FUNCTOR.m_function(c); });
Live demo
回答2:
Inside eval
, you cannot call a member function because you don't have any object;
you may go for this:
template<class T, class U>
void eval(T&& object, U fun)
{
(object.*fun)("Using an external function");
}
and then
eval(FUNCTOR, &FOO::m_function);
来源:https://stackoverflow.com/questions/30609314/passing-member-function-as-argument-to-function-template