C++ 回调函数

回调函数是静态函数

#include <iostream>  

using namespace std;

class App
{
public:
    typedef void(* pClassFun )(void*);

    static void m_CreateCb(void* user_data)
    {
        App *pThis = static_cast<App*>(user_data);
        printf("pThis = %p\n", pThis);
    }

    void demo(pClassFun func, void * user_data)
    {
        func(user_data);
    }

    void printfFuncAddress()
    {

        printf("Function m_CreateCb address = %p\n", m_CreateCb);

    }

    void begin()
    {
        demo(&m_CreateCb, this);
    }

};

int main()
{

    App a;
    a.printfFuncAddress();

    a.begin();
    return 0;
}

回调函数是非静态函数

#include <iostream>

using namespace std;

class App
{
public:
    typedef void(App::*pClassFun)(void*);

    static void m_CreateCb(void* user_data)
    {
        cout << "m_CreateCb" << endl;
    }

    void CreateCb(void * user_data)
    {
        cout << "CreateCb" << endl;
    }

    void demo(pClassFun func, void * user_data)
    {
        (this->*func)(user_data);
    }

    void printfFuncAddress()
    {
        //error C2276: '&' : illegal operation on bound member function expression
        //printf("Function CreateCb address = %p\n", &CreateCb);

        printf("Function CreateCb address = %p\n", &App::CreateCb);

    }

    void begin()
    {
        //demo(m_CreateCb, this);
        demo(&App::CreateCb, this);
    }

};

int main()
{

    App a;
    a.printfFuncAddress();

    a.begin();
    return 0;
}

静态函数作为回调函数，这种用法很常用。理解C++中非静态成员方法有点困难，

首先要理解:

->* 指向成员操作的指针 ptr->*ptr_to_member

.* 指向成员操作的指针 obj.*ptr_to_member

->* .* 这两货是操作符

对比两种指针：

#include <iostream>

using namespace std;

class App
{
public:
    typedef void(App::*pClassFun)(void*);
    typedef void(*pCommonFun)(void*);

    static void m_CreateCb(void* user_data)
    {
        cout << " static  m_CreateCb" << endl;
    }

    void CreateCb(void * user_data)
    {
        cout << "CreateCb" << endl;
    }

    void bind(pClassFun classFunc, void * user_data)
    {
        m_ClassFunc = classFunc;
        ClassFuncData = user_data;
    }

    void RegisterCallback(pCommonFun commonFunc, void * user_data)
    {
        m_CommonFunc = commonFunc;
        CommonFuncData = user_data;
    }

    void Demo()
    {
        RegisterCallback(m_CreateCb, this);
        bind(&App::CreateCb, this);

        //do something and then trigger callback
        (this->*m_ClassFunc)(ClassFuncData);
        m_CommonFunc(CommonFuncData);
    }

    void printfFuncAddress()
    {
        //error C2276: '&' : illegal operation on bound member function expression
        //printf("Function CreateCb address = %p\n", &CreateCb);

        printf("ClassFunc CreateCb address = %p\n", &App::CreateCb);
        printf("Common static CreateCb address = %p\n", &App::m_CreateCb);
    }

private:
    pClassFun m_ClassFunc;
    void *ClassFuncData;

    pCommonFun m_CommonFunc;
    void *CommonFuncData;
};

int main()
{
    App app;
    app.printfFuncAddress();
    app.Demo();
    return 0;
}

最后我们来看看非静态函数作为回调函数的应用

sigslot的实现

#include <vector>
#include <iostream>
using namespace std;

template<typename T, typename T1>
class slot
{
public:
    slot(T* pObj, void (T::*pMemberFunc)(T1))
    {
        m_pObj = pObj;
        m_pMemberFunc = pMemberFunc;
    }
    void Execute(T1 para)
    {
        (m_pObj->*m_pMemberFunc)(para);
    }
private:
    T* m_pObj;
    void (T::*m_pMemberFunc)(T1);
};

template<typename T, typename T1>
class signal
{
public:
    void bind(T* pObj, void (T::*pMemberFunc)(T1 para))
    {
        m_slots.push_back(new slot<T, T1>(pObj, pMemberFunc));
    }
    ~signal()
    {
        vector<slot<T, T1>* >::iterator ite = m_slots.begin();
        for (; ite != m_slots.end(); ite++)
        {
            delete *ite;
        }
    }
    void operator()(T1 para)
    {
        vector<slot<T, T1>* >::iterator ite = m_slots.begin();
        for (; ite != m_slots.end(); ite++)
        {
            (*ite)->Execute(para);
        }
    }

private:
    vector<slot<T, T1>* > m_slots;
};

class receiver
{
public:
    void callback1(int a)
    {
        cout << "receiver1: " << a << endl;
    }
    void callback2(int a)
    {
        cout << "receiver2: " << a << endl;
    }
};


class sender
{
public:
    sender() : m_value(0)  {}
    int get_value()
    {
        return m_value;
    }
    void set_value(int new_value)
    {
        if (new_value != m_value)
        {
            m_value = new_value;
            m_sig(new_value);
        }
    }
    signal<receiver, int> m_sig;
private:
    int m_value;
};



int main(int argc, char** arg)
{
    receiver r;
    sender s;
    s.m_sig.bind(&r, &receiver::callback1);
    s.m_sig.bind(&r, &receiver::callback2);
    s.set_value(1);
    return 0;
}