C ++：成员函数地址（函数指针）

Question

I have a class X which has this method:

void setRxHandler(void (*h)(int));

And I want to pass to it a member function that exists in instances of class Y .

void comm_rxHandler(int status);

I tried the following:

x.setRxHandler(comm_rxHandler) 

But it get the following compile error (I'm using Qt):

error: no matching function for call to 'X::setRxHandler(< unresolved overloaded function type>)'

So, how can I do that?

I noticed if I declare comm_rxHandler (class Y) as static, I have no errors. But I want comm_rxHandler as a non-static method. Also I want setRxHandler method (class X) to be generic and not class-specific. So I can't declare that method as:

setRxHandler(void (Y::*h)(int))

How to do that? Can you help me on this?

Thanks!

Answer 1

C++ doesn't support bound methods . To invoke a member function through a function pointer, you need to have two things: an instance of the class and the function pointer.

So setRxHandler(void (Y::*h)(int)) is almost correct. You need to declare it as:

void setRxHandler(Y*, void (Y::*h)(int));

To invoke setRxHandler() , you need to pass it arguments as follows:

Y y;
setRxHandler(&y, &Y::comm_rxHandler);

In the setRxHandler() method, you can invoke the function pointer using this syntax:

void setRxHandler ( Y* y, void (Y::*h)(int) )
{
    // ...
    (y->*h)(0);
    // ...
}

To make generic, you need to abstract the Y parameter away, but this is difficult to get right. Check out Boost.Function for an existing implementation that supports this use case, and many more.

Answer 2

Change your callback to this:

void setRxHandler(std::function(<void(int)>);

Then you can use binders:

setRxHandler( std::bind(&class_name::comm_rxHandler, obj) );

( std::function and std::bind are part of the upcomming next version of the C++ standard. It's quite likely your compiler already comes with them. If not, they might live in namespace std::tr1 . If all else fails, you will find them at boost - which is where they were invented - as boost::function and boost::bind .)

You can, however, also pass non-member or static functions to setRxHandler , as well as function objects (which is the result of std::bind ).

If your compiler already supports lambda functions (also part of the next standard, but already supported by, eg, recent versions of GCC and VC), you can also use one of those:

setRxHandler( [](){obj.comm_rxHandler();} );

Answer 3

As it is now, the setRxHandler prototype takes a pointer to a function that doesn't return anything and takes an int . As you have noticed, this won't work with member functions because they can't be called like a normal function (you have to handle the this pointer as well, which means having an instance of that class to call the method on).

To make it both work with member functions and non-specific ( generic ), you have to either make a base class and have all classes you want to use setRxHandler with derive from that class:

class Base { ... };
class Derived : public Base { ... };

// then for the prototype
void setRxHandler(void (Base::*h)(int)) { ... }
// and you can use setRxHandler for all types that derive from Base, which gives you more control than the second option, which is:

or use templates:

template<typename T>
void setRxHandler(void (T::*h)(int)) { ... }

With the template option, you really have no control over what class will be used with setRxHandler (excluding RTTI), which can be exactly what you want.

Answer 4

You can either make a base class for Y and use that (to avoid being "class specific"), or use templates:

template <class T>
setRxHandler(void (T::*h)(int));

But then this may raise questions of how to use the member function (you tell us if it does).

Answer 5

As others have already mentioned, C++ does not provide this functionality.

Another option you could use is libsigc++ which is widely used in gtkmm, see this example in their tutorial for instance on how to pass pointers to member-functions. Your example could look something like:

// sigc::slot<void, int> is a 'slot' to hold a function with return type void 
// and 1 int argument.
void setRxHandler(sigc::slot<void, int> slot);
void comm_rxHandler(int status);

//sigc::mem_fun() can convert a member function to a function slot.
x.setRxHandler(sigc::mem_fun(*this, &X::comm_rxHandler));