C Callback Using Class Member with Generic Implementation

The original question aimed to create a generic event-handling mechanism that would work consistently across different classes. Instead of relying on static methods and passing around class instance pointers, a more modern C approach can be employed using std::function and std::bind.

Event Handler with std::function

The event handler class now accepts a std::function object as an argument. A function object represents a callable entity that can be passed around like a regular function pointer. The event handler method addHandler takes a std::function as an argument, where the passed function has no return value and takes an integer as an argument.

class EventHandler
{
public:
    void addHandler(std::function callback)
    {
        cout 
Binding Specific Functions
To bind a specific class method to the event handler, std::bind is used. std::bind specifies the this pointer and the function to be called when the event is triggered.
class MyClass
{
public:
    MyClass();

    // Note: No longer marked `static`, and only takes the actual argument
    void Callback(int x);
private:
    int private_x;
};

MyClass::MyClass()
{
    using namespace std::placeholders; // for `_1`

    private_x = 5;
    handler->addHandler(std::bind(&MyClass::Callback, this, _1));
}

void MyClass::Callback(int x)
{
    // No longer needs an explicit `instance` argument,
    // as `this` is set up properly
    cout 
Free-Standing Functions and Lambda Functions
If the callback is a free-standing function without a class context, std::bind is not required.
void freeStandingCallback(int x)
{
    // ...
}

int main()
{
    // ...
    handler->addHandler(freeStandingCallback);
}
For anonymous callbacks, lambda functions can be used with the event handler.
handler->addHandler([](int x) { std::cout 
In this way, using std::function and std::bind provides a flexible and generic solution for callbacks that can be applied to different classes and functions.