Calling C++ class methods from C using callbacks

Question

I have a class, Component, which has to interact with C code.

//// Component.h file   ////
class Component{
public:
    uint8_t getdevice1Value();
    void setdevice1Value(uint8_t value);

    uint8_t getdevice2Value();
    void setdevice2Value(uint8_t uint8_t);
private:
    uint8_t device1Value;
    uint8_t device2Value;
}

The object of the class would be created when its relevant thread is created in some Application.cpp file:

///////Some function where the Component is used//////
createThread(){
    Component myComponent;  // Scope within the thread
    // Some actions
}

Now comes my C code, which happens to be event driven. Within these functions, I would like to link my Class methods:

//// device1_event.c file   ////
void command_get_device_value()
{
    // code
    // assign variable  = Component::getdevice1Value() function
    // code
}

void command_set_device_value()
{
    // code
    // call Component::setdevice1Value(variable)  passing some variable
    // code
}

Similar to device1_event.c file, I have another device2_event.c where I would like to map the function calls to getdevice2Value and setdevice2Value.

I looked at the questions Using a C++ class member function (cannot be static) as a C callback function or also this Pass a C++ member function to a C function, where a struct registers the context and the function pointers.

I have a constraint in my case of not being able to dynamic allocation. So, I cannot use the new operator.

Now I have a few questions regarding these:

1. Is the callback concept applicable in my case?
2. If the first question is a yes, then:
   • How do I go about implementing it. I am a bit confused about this. I mean the call-functions need to be placed within the C-functions and also I need to register them once the Component instance is created. How can I exactly do this?
   • How do I bring the callback functions to my C files?
3. In this question a struct was employed. Where do I declare the 'struct'? I did try declaring it in the Component.h file and introduced it as an extern within the device1_event.c file. But I get an incomplete type error.

Answer 1

The classical C way of passing callbacks is to pass two values: a pointer to the callback itself, and an opaque pointer which will be passed to the callback as an additional argument (take a look at qsort_r for example). When interfacing with C++, that opaque value may be used as instance pointer; you will only need to write a thin wrapper:

class B {
    void my_callback(int arg);
    static void my_callback_wrapper(int arg, void *u) {
        ((B*)u)->my_callback(arg);
    }
};

// or even:
extern "C" void my_callback_wrapper(int arg, void *u) {
    ((B*)u)->my_callback(arg);
}

and pass a pointer to the wrapper, along with a pointer to the object, to the C part. Be careful to use the exact same class type on both sides and not base/derived classes, for example.

Note that while it may be possible to get a pointer to the (non-static) method itself, on some compilers (tested on MSVC a long time ago) they have a special calling convention so that the pointer will not be compatible with any normal function pointer.