问题
class Child;
class Parent
{
public:
void (*funcPointer)();
void (*funcPointer2)(Parent* _this);
void (Child::*funcPointer3)();
};
class Child: public Parent
{
public:
void TestFunc(){
}
void Do(){
Parent p;
p.funcPointer=TestFunc; // error, '=': cannot convert from 'void (__thiscall Child::* )(void)' to 'void (__cdecl *)(void)'
p.funcPointer2=TestFunc; // error too, '=': cannot convert from 'void (__thiscall Child::* )(void)' to 'void (__cdecl *)(Parent *)'
p.funcPointer3=TestFunc; //this works
p.funcPointer3=&Child::TestFunc; // this works too.
p.funcPointer3(); // error, term does not evaluate to a function taking 0 arguments
}
};
How can I pass a member function to a function pointer, and then how would I then call that function pointer?
回答1:
You can't. You either pass a pointer to a static method or Parent has to accept also a pointer to the object.
You might want to look at boost::bind and boost::function for that:
#include <boost/bind.hpp>
#include <boost/function.hpp>
struct Y
{
void say(void) { std::cout << "hallo!";}
boost::function<void()> getFunc() { return boost::bind(&Y::say, this); }
};
struct X
{
//non-boost:
void (Y::*func)();
Y* objectY;
void callFunc() { (objectY->*func)(); }
//boost version:
boost::function<void()> f;
};
X x;
Y y;
x.f = boost::bind(&Y::say, boost::ref(y));
x.f = y.getFunc();
x.f();
x.func = &Y::say;
x.objectY = &y;
x.callFunc();
回答2:
In response to your last edit, to form a pointer-to-member, you have to use &
and classkey::
. There's no equivalent to the function name to pointer-to-function implicit conversion for normal functions.
// not valid:
p.funcPointer3=TestFunc;
// valid:
p.funcPointer3 = &Child::TestFunc;
To access a member through a pointer-to-member you have to use either the .*
or ->*
operator.
E.g.
(this->*p.funcPointer3)();
回答3:
We can actually accomplish all 3 of your funcPointer*
s in C++11 with the advent of bind and Lambda Functions. Let's talk about each one first and discuss what they are doing:
funcPointer
seeks to call aChild
method without taking in aChild
object, so theChild
object would have to be saved. The child object could be saved by pointer:bind(&Child::TestFunc, this)
Or in C++14 it could be saved by value:[arg = *this]() mutable { arg.TestFunc(); }
funcPointer2
seeks to call aChild
method with aParent*
. We could do this like:[](Parent* arg){ static_cast<Child*>(arg)->TestFunc(); }
Of course this wouldn't be any more legal than(new Parent)->TestFunc()
so we're assuming that theParent*
is in reality aChild*
, if you were willing to makeParent
a Polymorphic Type you could verify before calling in your lambda:
[](Parent* arg) {
assert(dynamic_cast<Child*>(arg) != nullptr);
static_cast<Child*>(arg)->TestFunc();
}
funcPointer3
seeks to store a pointer to aChild
method, and you already had that working. You just needed to use aChild
object to call it, for example:(this->*p.funcPointer3)()
. But you must assignfuncPointer3
like this:funcPointer3 = &Child::TestFunc
, cause if you try to do this:funcPointer3 = &TestFunc
you will get the error:
'&': illegal operation on bound member function expression
Next, a function pointer or a member function pointer cannot be used to reference a Closure Type, so we'll need to convert your function pointers to function objects. (funcPointer3
is just a member function pointer, so it doesn't need to be converted, but I will convert it to demonstrate that a function
object can contain a member function pointer and it simplifies the call to: p.funcPointer(this)
):
class Parent {
public:
function<void()> funcPointer;
function<void(Parent*)> funcPointer2;
function<void(Child*)> funcPointer3;
};
Now that we've adapted Parent
we can easily assign as demonstrated in 1, 2, and 3:
void Child::Do() {
Parent p;
p.funcPointer = bind(&Child::TestFunc, this);
p.funcPointer2 = [](Parent* arg) { static_cast<Child*>(arg)->TestFunc(); };
p.funcPointer3 = &Child::TestFunc;
p.funcPointer();
p.funcPointer2(this);
p.funcPointer3(this);
}
You probably know this and were just testing, but we could have just as easily used the members of the Parent
that Child
inherited from as we could create a new Parent
object in Child::Do
. I'm going to switch that up and throw the code in an example: http://ideone.com/yD7Rom
来源:https://stackoverflow.com/questions/4296281/how-can-i-pass-a-member-function-to-a-function-pointer