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) (...)’
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); });
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);
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.