C++综合系列之实现回调机制的几种方式

/* 方式一：回调函数 */

typedef void (*CallbackFun)(int i);
//调用者
void test(int i, CallbackFun callback)
{
    callback(i);
}
//被调用者
void func(int i)
{
    cout << i << endl;
}
void main()
{	
	test(2, func);
}

/* 方式二：Sink */

/*对方要求的接口*/
// 中介接口（中介器）
class IfDownloadSink
{
//public:
//    virtual ~IfDownloadSink() {}
public:
    virtual void OnDownloadFinished(const char* pURL, bool bOK) = 0;
};

/*对方的实现*/
// 调用者
class CMyDownloader
{
public:
    CMyDownloader(IfDownloadSink* pSink) :
        m_pSink(pSink)
    {

    }

    void DownloadFile(const char* pURL)
    {
        if(NULL != m_pSink)
            m_pSink->OnDownloadFinished(pURL, true);
    }

private:
    IfDownloadSink* m_pSink;
};


#include <iostream>

using namespace std;

/*你的实现*/
class CMyFile: public IfDownloadSink
{
public:
    void Download()
    {
        // 调用者
        CMyDownloader downloader(this);
        downloader.DownloadFile("www.baidu.com");
    }

    // 被调用者
    virtual void OnDownloadFinished(const char* pURL, bool bOK)
    {
        std::cout << pURL << ", " << bOK << std::endl;
    }
};
void main()
{
	CMyFile cm;
    cm.Download();
}

/* 方式三：std::function */

using Callback = std::function<void(int)>;

//中介接口（中介器）
class IfCallback
{
//public:
//    virtual ~IfCallback() {}

public:
    virtual void setCallBack(const Callback &callback) = 0;
};

// 调用者
class A: public IfCallback
{
public:
    A() {}

    void notify()
    {
        if(NULL != m_callback)
            m_callback(12);
    }

    void setCallBack(const Callback &callback)
    {
        m_callback = callback;
    }

private:
    Callback m_callback;

};

/*你的实现*/
class Foo
{
public:
    void operator()(void)
    {
        std::cout << __FUNCTION__ << std::endl;
    }
    Foo()
    {
        A a;

        // 方式一：std::bind
        Callback callback = std::bind(&Foo::callbackEntity, this, std::placeholders::_1);
        a.setCallBack(callback);

        // 方式二： lamda表达式
        auto callbackEntity = [&](int param) {
            std::cout << "lamda: " << param << std::endl;
        };
        a.setCallBack(callbackEntity);

        // 调用者
        a.notify();
    }

    // 被调用者
    void callbackEntity(int value)
    {
        std::cout << "callbackEntity: " << value << std::endl;
    }
private:
};
void main()
{
	Foo f;
}

还有高级一点的机制：delegate 和Qt的信号与槽