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;
}

#include <iostream>
#include <memory>
#include <boost/optional.hpp>

// примерный optional, присваивание через perfect forward
template<typename T>
struct opt_move_assign {
    ~opt_move_assign() {
        if(constructed)
            reinterpret_cast<T*>(&data)->~T();
    }
    template<typename U>
    opt_move_assign& operator=(U&& x) {
        if(constructed)
            *(reinterpret_cast<T*>(&data)) = std::forward<U>(x);
        else {
            new (&data) T(std::forward<T>(x));
            constructed = true;
        }
        return *this;
    }
    bool constructed = false;
    typename std::aligned_storage<sizeof(T)>::type data;
};
// примерный optional, присваивание не используется
template<typename T>
struct opt_move_construct {
    ~opt_move_construct() {
        if(constructed)
            reinterpret_cast<T*>(&data)->~T();
    }
    template<typename U>
    opt_move_construct& operator=(U&& x) {
        if(constructed) {
            constructed = false;
            reinterpret_cast<T*>(&data)->~T();
        }
        new (&data) T(std::forward<T>(x));
        constructed = true;
        return *this;
    }
    bool constructed = false;
    typename std::aligned_storage<sizeof(T)>::type data;
};

template<template<class> class Storage, class F>
void test(F&& f) {
    using store_type = std::decay<F>::type;
    Storage<store_type> x;
    x = std::forward<F>(f);
}


struct foo {
    void bar() {}
};

int main() {
    // вот это ок, компилится
    test<opt_move_assign>(std::make_unique<int>(111));
    test<opt_move_construct>(std::make_unique<int>(111));

    // вот это уже нет (boost 1.55)
    // test<boost::optional>(std::make_unique<int>(111));

    // а вот тут уже bind, вылезает copy tuple
    // test<opt_move_assign>(std::bind(&foo::bar, std::make_unique<foo>()));
    // хотя через move-construct всё ok
    test<opt_move_construct>(std::bind(&foo::bar, std::make_unique<foo>()));

    // ну как и в предыдушем варианте, тоже беда...
    // test<boost::optional>(std::bind(&foo::bar, std::make_unique<foo>()));
    return 0;
}

The return type shall satisfy the requirements of MoveConstructible. If all of FD and TiD
satisfy the requirements of CopyConstructible, then the return type shall satisfy the requirements
of CopyConstructible. [ Note: This implies that all of FD and TiD are MoveConstructible. — end
note ]

using namespace fastdelegate;

// Это класс
class CClass {
public:
    // Это метод класса
    int Function(int num, char *str);
};

int main(void){

    // Обьявляете тип делегата (параметр1, параметр2, тип результата)
    typedef FastDelegate2<int, char *, int> FunctionDelegate;

    // Создаете класс
    CClass a();

    // "deleg" - переменная-колбек, цепляем на неё метод класса
    FunctionDelegate deleg = MakeDelegate(&a, &CClass::Function);

    // вызываем метод класса как простую функцию
    int ret = deleg(5, "foo"); 
}

#include "stdafx.h"
#include "FastDelegate.h"

using namespace fastdelegate;

// Это класс
class CClass {
protected:
    char *m_name;
public:
    CClass(char *name) : m_name(name) {};

    // Это метод класса
    int Function(int num, char *str) {
        printf("In Function in %s. Num=%d, str = %s\n", m_name, num, str); return -1;
    }

};

int _tmain(int argc, _TCHAR* argv[])
{
    typedef FastDelegate2<int, char *, int> FunctionDelegate;
    // Создаете класс
    CClass a("Base A");

    // "deleg" - переменная-колбек
    FunctionDelegate deleg;

    // цепляем на неё метод класса и можем передать его куда угодно
    deleg = MakeDelegate(&a, &CClass::Function);

    // можем использовать как функцию
    deleg(7, "tr");
    
    // Чуть поизвращаясь, можно получить указатель на сам класс
    const detail::ClosurePtr<int, char *, int>& p = (const detail::ClosurePtr<int, char *, int>&)deleg.GetMemento();
    CClass* ap = (CClass*)p.GetClosureThis();

    // Получили класс со всеми потрохами
    ap->Function(77, "ааааа");

    return 0;
}

AHO>Имеется С библиотека с неизменяемым интерфейсом, одна из функций выглядит так:
AHO>

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

AHO>internalState – сугубо внутренняя структура библиотеки, data – данные получаемые из библиотеки, т.е. никаких void * userData нет.

AHO>Хотелось бы в плюсах 11, чтобы сallback вызывал метод класса. Решение со статическим методом и глобальным this – совсем уж убого.

addCallback(void * internalState, (Callback *)хоть-черт-с-ушами);

FunctionDelegate deleg;
addCallback(void * internalState, (Callback *)&deleg);