Simple callback system...

#include <iostream>
#include <string>

class CallbackWrapper
{
    public:
        virtual ~CallbackWrapper() { };
        virtual void Call() = 0;
};

template <typename MT> class CallbackFunction : public CallbackWrapper
{
    typedef void (*CALLBACK)(MT);
    CALLBACK func;
    MT data;
    public:
        CallbackFunction() { };
        void SetData(void (*f)(MT), MT d)
        {
            func = f;
            data = d;
        }
        void Call()
        {
            func(data);
        }
};

class Callback
{
    CallbackWrapper *CallbackClass;
    public:
        Callback() { };
        ~Callback()
        {
            delete CallbackClass;
        }
        template <typename T> void SetCallback(CallbackFunction <T> *func)
        {
            CallbackClass = func;
        }
        void Call()
        {
            CallbackClass->Call();
        }
};

template <typename CT> Callback NewCallback(void (*func)(CT), CT data)
{
    CallbackFunction <CT> *cf = new CallbackFunction <CT>;
    cf->SetData(func, data);
    Callback cb;
    cb.SetCallback(cf);
    return cb;
};

void Call(Callback CallbackFunc)
{
    CallbackFunc.Call();
}

void foo(std::string str)
{
    std::cout << str << "\n";
}

int main()
{
    std::string str;
    str.append("Hello, World!");
    Call( NewCallback(&foo, str) );
    return 0;
}