将成员函数作为回调传递给构造函数的其他类

Question

Hi I want to pass member function as argument to constructor other class. I tried lot solutions but all given me fail. So.. First class..

class WebSocketsServerRunner : public WebSocketsServer {
   private:
       ThreadController<uint8_t> threads = ThreadController<uint8_t>();
       SensorsState sensorsState;

    void notifyClient(uint8_t clientNumber) { // this is the callback
        String message = sensorsState.readAsJSON();
        WebSocketsServer::sendTXT(clientNumber, message);
    }

    void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {

        // solution bellow doesn't work!
        Thread<uint8_t>* thread = new Thread<uint8_t>(static_cast<int>(num),  &WebSocketsServerRunner::notifyClient, num, 5000);

        threads.add(thread);

    } 
};

And Thread constructor declaration:

    Thread(int _id, void (*callback)(void) = NULL, long _interval = 0);
    Thread(int _id, void (*callback)(Arg), Arg arg, long _interval = 0);

Where Arg is template <typename Arg>

I tried everything.. std::bind, &CLASS_NAME::METHOD_NAME, static_cast but nothing works..

Compile gives me :

no known conversion for argument 2 from 'void (WebSocketsServerRunner::*)(uint8_t) {aka void (WebSocketsServerRunner::*)(unsigned char)}' to 'void (*)(unsigned char)'

...

no matching function for call to 'Thread<unsigned char>::Thread(int, void (WebSocketsServerRunner::*)(uint8_t), uint8_t&, int)'

Answer 1

Pointers to member functions have different syntax than ordinary function pointers:

void(*function)();                  // pointer to function
void(YourClass::*memberFunction)(); // pointer to member function

Reason behind is that member functions have an additional, hidden/transparent parameter accepting the object the function is called on and is presented to you as this pointer.

So calling a member function differs as well (you need an object to call the function on):

void(YourClass::*memberFunction)() = &YourClass::someFunction;
YourClass instance;
YourClass* pointer = &instance;
(instance.*memberFunction)();
(pointer->*memberFunction)();

Be aware that both .* and ->* operators have lower precedence than function call operator () (if it was a good decision might be arguable, but it is as it is...), so you need the parentheses.

The following I show only for illustration of the nature of member functions, be aware that it actually is undefined behaviour (but it is very likely to work) – don't ever use this in productive code :

void(*functionR)(YourClass&)
    = reinterpret_cast<&void(*)(YourClass&)(&YourClass::someFunction);
void(*functionP)(YourClass*)
    = reinterpret_cast<&void(*)(YourClass*)(&YourClass::someFunction);
YourClass instance;
YourClass* pointer = &instance;
functionR(instance);
functionP(pointer);

The interesting aspect of is that both reference and pointer should do the trick, revealing that under the hoods, references – if instanciated at all – are nothing more than pointers as well, solely with specific rules applied (so in the end, syntactic sugar).

Above reveals as well, though, that to call a member function, even if you illegally use an ordinary function pointer, you still need an object on which you can call the function!

So which are the options?

static member functions do not have the transparent this function parameter, ie they can be used just like any ordinary function:

static void notifyClient(uint8_t clientNumber)
// ^^^ (!)
{
     WebSocketsServerRunner& instance = selectById(clientNumber);
     String message = instance.sensorsState.readAsJSON();
     WebSocketsServer::sendTXT(clientNumber, message);
}

If you cannot get the instance using the client number, you'll have to modify the Thread class such that it holds the object to call the function on as well.

Most generic , not necessarily the safest one, though, is using a void* pointer:

class Thread
{
    void(*function)(void*);
    void* parameter;

     void run()
     {
         function(parameter);
     }
};

You now could use static member and normal functions, but you need to cast the parameter back to get the instance, additionally you cannot use smart pointers for safe memory management. Better approach:

template <typename T> 
class Thread
{
    std::function<void(T*)>;
    std::shared_ptr<T> instance;

     void run()
     {
         function(instance.get());
     }
public:
     template <typename F>
     Thread(F function, std::shared_ptr<T>& instance)
         : function(function), instance(instance)
     { }
};

The interesting part of is that you can store both pointer to member function as well as free-standing functions in the std::function object. Another variant:

template <typename T> 
class Thread
{
    T t;

     void run()
     {
         t();
     }
public:
     Thread(T&& t)
         : t(std::move(t))
     { }
};

This one could be feeded with lambdas:

Thread t([&instance]() { instance.doSomething(); });

It possibly might be an interesting alternative to use std::thread directly:

 class WebSocketsServerRunner { public: static void run(uint8_t clientNumber) { WebSocketsServerRunner instance; for(;;) { // do whatever your Thread class did } } }; std::thread t10(&WebSocketsServerRunner::run, 10U); std::thread t12(&WebSocketsServerRunner::run, 12U); 

Edit: according to your comments, not suitable...