C++: location of definition/declaration of non-member function

Question

I have a class Myclass:

in Myclass.h file:

class{
private:
    int sd;
    int sd2;

public:
    void func(int sd, short op, void *ptr);

    void start();
};

in Myclass.cpp file:

void Myclass::start(){
     struct arg_t *arg = (struct arg_t *)malloc(sizeof(struct arg_t));
     ....
     event_set(ev, sd, EV_READ, call_func, arg ); //this is a library API, which trigger the callback of call_func(sd, op, arg);
}

void Myclass::func(int sd, short op, void *ptr)){
...
if(some_conditions){
     struct arg_t *arg = (struct arg_t *)malloc(sizeof(struct arg_t))
     .... 
     event_set(ev, sd2, EV_READ, call_func, arg );
     .....

}
...
}

in main.cpp

int main(){
   Myclass obj;
   ....
   obj.start();
   ....
}

in start(), the event_set need a function of void(*func)() type as argument,but func() is of void Myclass::(*func)() type, so I define a new function something like below (the codes are not correct, but just show what I expect):

void call_func(int sd, short op, void *ptr){
    Myclass::func(int sd, short op, void *ptr);
}

however, I'm at a loss where to delcare and define call_func() so that the Myclass::start() can use call_func as argument and call_func() can call Myclass::func()

Answer 1

This is a known problem. Since pointers to class members are not regular pointers, one can not use class member functions in naive callbacks, which expect a simple function pointer.

A solution is to make a callback function static , often private , and call the corresponding class function using the callback argument. In your case, it would look like following:

class C {
private:
    int sd;
    static void call_func(int sd, short op, void* ptr) {
        C* obj = static_cast<C*>(ptr);
        obj->func(sd, op);
    }


public:
    void func(int sd, short op);

    void start()  {
        event_set(ev, sd, EV_READ, &call_func, this);
    }
};

EDIT

Fixed messed up start() and func() .

Answer 2

I'm at a loss where to delcare and define call_func() so that the Myclass::start() can use call_func as argument and call_func() can call Myclass::func()

You can put this all in your Myclass.cpp file, above the definition of Myclass::start().`

#include <Myclass.h>

void call_func(int sd, short op, void *ptr){
    Myclass::func(int sd, short op, void *ptr);
}

void Myclass::start(){
     event_set(ev, sd, EV_READ, call_func, NULL ); //this is a library API, which trigger the callback of call_func(sd, op, NULL);
}

void Myclass::func(int sd, short op, void *ptr)){
...
...
}

One other thing, with callback functions, the void* ptr is how you can pass a pointer to some data that the callback function will use. If you don't need anything like that then you don't need to be calling a non-static member function as the callback and you could simplify things. But to call non-static member function the way you're describing, you need an object to call it on, and that's what you would pass as the void *ptr :

// Myclass.h
class Myclass {
private:
    int sd;

public:
    void func(int sd, short op); // no void*
    void start();
};


// Myclass.cpp
#include <Myclass.h>

void call_func(int sd, short op, void *ptr){
    assert(ptr != NULL);
    static_cast<Myclass *>(ptr)->func(int sd, short op); // cast data to 'this' pointer
}

void Myclass::start(){
     event_set(ev, sd, EV_READ, call_func, this ); // pass the 'this' pointer as data
}

void Myclass::func(int sd, short op)){
...
...
}

the last argument of event_set() is still needed to be used for a pointer to an additional structure, so it can't be this

You need to pass this somehow or you can't call a member function, so if you have another structure you need to think about how to pass both.

Can the other structure or a pointer to it be a member of the object? If so, then do that and pass this as the void *ptr .

Another option is to define a struct just for passing the data through the callback:

struct callback_params {
  Myclass *c;
  other_struct *s;
};

But you have to create this callback_params struct somewhere where it will live long enough for the callback to be able to receive it, which can be tricky.

Answer 3

WRONG ANSWER!!!!

My old tablet didn't load the code sections of the question correctly and I miss important parts of the question...
Leaving here just as sake of completeness - maybe this can be util for someone else

SORRY

I don't know the complete stuff that you're doing but in this cases, if i don't need interface with old code I will go for std::function for sure.

But if is absolutely needed the pointers stuff, I generally do:

• Put a very ugly name in the function - So every one will know that this is a 'hack' and not a good thing. ex: _func_call_wrapper_(...)
• Put into the top of .cpp file the definition with the appropriated comments and so on. ex:

//This is a wrapper neeeded for... void __func_call_wrappper_(..);

• Finally in the bottom of the .cpp file I define the function, of course, with a lot of comments of why this is needed.

Refs: ccpreference