typedef void(*Callback)(void * internalState, Data * data);
void addCallback(void * internalState, Callback * callback);

addCallback(state, [] (void * internalState, Data * data) {});

addCallback(state, [this]/[&] (void * internalState, Data * data) {});

или

void Class::method(void * internalState, Data * data);
addCallback(state, std::bind(&Class::method, this, std::placeholders::_1, std::placeholders::_2));

typedef void(*ExtendedCallback)(void * internalState, Data * data, void* userData);

template <typename tag>
struct CallbackHolder
{
  static void Func(void * internalState, Data * data)
  {
    UserCallback(internalState, data, UserData);
  }

  static void* UserData = nullptr;
  static ExtendedCallback UserCallback = nullptr;
}

//usage
struct MyTag1 {} ;// create any number of tags
//probably, we need to define static data
void* CallbackHolder<MyTag1>::UserData = nullptr;
ExtendedCallback CallbackHolder<MyTag1>::UserCallback = nullptr;

Callback<MyTag1> c; // track lifetime as needed
Callback fn = &Callback<MyTag1>::Func;
addCallback(state, fn);

typedef void(*ExtendedCallback)(void * internalState, Data * data, void* userData);

struct ThunkData
{
  <executable code>
  void* UserData;
  ExtendedCallback UserCallback;
};

ThunkData* data = ...; <- get from pool or allocate somehow
data->UserData = myData;
data->UserCallback = mySuperCallback;
Callback fn = (Callback)(data); <--- pointer to executable code inside thunk
addCallback(state, fn);

addCallback(internal_state, make_wrapper<42>(bind(&Foo::method, foo, _1, _2)) );

AHO>typedef void(*Callback)(void * internalState, Data * data);
AHO>void addCallback(void * internalState, Callback * callback);
AHO>

struct StateWithPayload
{
    OurData payload;
    InternalState internalState;
};

#include <iostream>
#include <functional>
#include <cassert>

template<typename Function, typename Tag = void>
struct c_callback_holder { static std::function<Function> fn; };
template<typename Function, typename Tag>
std::function<Function> c_callback_holder<Function, Tag>::fn;

template<typename Function, typename Tag = void>
struct c_callback;
template<typename Tag, typename Ret, typename ...Args>
struct c_callback<Ret(Args...), Tag> {
    static Ret call(Args... args) {
        return c_callback_holder<Ret(Args...), Tag>::fn(std::forward<Args>(args)...);
    }
};
template<typename Function, typename Tag, typename F>
Function* set_callback(F&& f) {
    c_callback_holder<Function, Tag>::fn = std::forward<F>(f);
    return &c_callback<Function, Tag>::call;
}

struct foo {
    int i;
    foo(int i) : i(i) {}
    void test() { std::cout << "Hello, world!!! " << i << std::endl; }
};

int main() {

    using callback_fn = void();
    foo obj1(33);
    callback_fn* f1 = set_callback<callback_fn, foo>(std::bind(&foo::test, &obj1));
    f1();
    foo obj2(42);
    callback_fn* f2 = set_callback<callback_fn, foo>(std::bind(&foo::test, &obj2));
    assert(f1 == f2);
    f2();
    return 0;
}

#include <iostream>
#include <functional>

template<typename Function, typename Tag = void>
struct c_callback_holder { static std::function<Function> fn; };
template<typename Function, typename Tag>
std::function<Function> c_callback_holder<Function, Tag>::fn;

template<typename Function, typename Tag = void>
struct c_callback;
template<typename Tag, typename Ret, typename ...Args>
struct c_callback<Ret(Args...), Tag> {
    static Ret call(Args... args) {
        return c_callback_holder<Ret(Args...), Tag>::fn(std::forward<Args>(args)...);
    }
};
template<typename Function, typename F>
Function* set_callback(F&& f) {
    c_callback_holder<Function, F>::fn = std::forward<F>(f);
    return &c_callback<Function, F>::call;
}

struct foo {
    int i;
    foo(int i) : i(i) {}
    void test() { std::cout << "Hello, world!!! " << i << std::endl; }
};

int main() {

    using callback_fn = void();
    foo obj1(33);
    foo obj2(42);
    callback_fn* f1 = set_callback<void()>([&obj1]() { obj1.test(); });
    callback_fn* f2 = set_callback<void()>([&obj2]() { obj2.test(); });
    f1();
    f2();
    return 0;
}

#include <iostream>
#include <functional>
#include <new>
#include <type_traits>
#include <memory>

template<typename T>
struct functor_holder {
    using value_type = typename std::decay<T>::type;
    using storage_type = typename std::aligned_storage<sizeof(value_type), std::alignment_of<value_type>::value>::type;
    bool constructed = false;
    storage_type data;
    ~functor_holder() { destruct(); }
    T& get() { return *(reinterpret_cast<value_type*>(&data)); }
    void destruct() { if(constructed) reinterpret_cast<value_type*>(&data)->~value_type(); }
    template<typename U>
    void set(U&& v) {
        destruct();
        new (static_cast<void*>(&data)) value_type(std::forward<U>(v));
        constructed = true;
    }
};

template<typename Function, typename Functor, typename Tag>
struct c_callback;
template<typename Functor, typename Tag, typename Ret, typename ...Args>
struct c_callback<Ret(Args...), Functor, Tag> {
    static functor_holder<Functor> fn;
    static Ret call(Args... args) {
        return fn.get()(std::forward<Args>(args)...);
    }
};
template<typename Functor, typename Tag, typename Ret, typename ...Args>
functor_holder<Functor> c_callback<Ret(Args...), Functor, Tag>::fn;

template<typename Function, typename Tag, typename Functor>
Function* set_callback(Functor&& f) {
    c_callback<Function, Functor, Tag>::fn.set(std::forward<Functor>(f));
    return &c_callback<Function, Functor, Tag>::call;
}
template<int N> struct int_tag;
template<typename Function, int N, typename Functor>
Function* set_callback(Functor&& f) {
    return set_callback<Function, int_tag<N>, Functor>(std::forward<Functor>(f));
}

struct foo {
    int i;
    foo(int i) : i(i) {}
    void fn1() { std::cout << i << ": Hello, world!!!" << std::endl; }
    void fn2() { std::cout << i << ": Bye, world!!!" << std::endl; }
};

int main() {
    foo obj(123);
    auto f1 = set_callback<void(), 1>(std::bind(&foo::fn1, &obj));
    auto f2 = set_callback<void(), 2>(std::bind(&foo::fn2, &obj));
    f1();
    f2();
    auto o = std::make_unique<foo>(42);
    auto f = set_callback<void(), 2>(std::bind(&foo::fn2, std::move(o)));
    f();    
    return 0;
}