從C的回調函數說起

在C語言中，回調函數是一個非常重要的概念，它的定義

回調函數就是一個通過函數指針調用的函數。如果你把函數的指針（地址）作為參數傳遞給另一個函數，當這個指針被用來調用其所指向的函數時，我們就說這是回調函數。

回調函數不是由該函數的實現方直接調用，而是在特定的事件或條件發生時由另外的一方調用的，用于對該事件或條件進行響應。

其實說白了就是把一個函數當做參數傳下去。

C中實現回調函數比較簡單，請看下面這個例子：

#include 


typedef void (*p_CB)(int);
void CB(int a)              { printf("CB a = %d\\n", a); }
void runCB(p_CB CB, int a)  { printf("run CB\\n"); CB(a); }


int main()
{
    p_CB cb = &CB;
    runCB(cb, 20);
    return 0;
}

C++中的回調函數的問題

在C++中的一個重要概念就是類，所以我們一般想讓類的成員函數作為回調函數（如果直接用非類的成員函數作為回調函數，其實就和C語言中的方法一樣），但是想實現這樣的功能，還是存在一些限制的。

主要原因是，類的成員函數的參數都隱藏了this指針這個參數，既然多加了一個參數，那么成員函數的參數個數就和定義的回調函數個數不匹配，導致調用失敗。

舉個例子：

#include 


typedef void (*p_CB)(int);
void runCB(p_CB CB, int a) { printf("run CB\\n"); CB(a); }


class B
{
public:
    void CB(int a) { printf("CB a = %d\\n", a); }
};


int main()
{
    B b;
    runCB(B::CB, 20); //錯誤
    return 0;
}

我們這樣寫，在15行會報下面的錯誤。

test_class_cb.cpp: In function ‘int main()’:
test_class_cb.cpp:15:14: error: invalid use of non-static member function ‘void B::CB(int)’
     runCB(B::CB, 20); //錯誤

報的錯說使用了非靜態的函數，分析下原因，其實是B::CB的函數是非靜態成員函數，它隱藏了this參數，導致p_CB和B::CB這兩個函數的參數不匹配。

而編譯器報的這個錯誤，其實也是同樣的意思，編譯器說我們調用的不是非靜態函數，當我們把B::CB定義成靜態函數也就不會報錯了(也就是去掉了this指針)。

C++中的回調函數的實現

靜態函數

既然成員函數都會存在this指針，那么我們可以去掉this指針呢？其實是可以的，我們把成員函數定義為靜態函數，靜態函數是屬于整個類的，不屬于某個對象，也就沒有this指針了。

這個例子的話，就是我們在上一個章節提到的，大家可以直接加上static。

這種方法其實有一定的缺點，靜態會帶來諸多的不變，因為靜態函數沒有this指針，那么它就訪問不了普通的成員函數或者數據成員，會給我們在開發中帶來不小的影響，特別是工程比較大的時候。

成員函數的函數指針

這個方法從另外一個角度出發，我們可以定義一個成員函數的函數指針，其實相當于這個函數指針有了this參數了。

例子如下：

#include 


class B
{
public:
    void CB(int a) { printf("CB a = %d\\n", a); }
};


typedef void (B::*p_CB)(int);
// using p_CB = void (B::*)(int);
void runCB(p_CB CB, B b, int a)  { printf("run CB\\n"); (b.*CB)(a); }


int main()
{
    B b;
    p_CB p_f1 = &B::CB;
    runCB(p_f1, b, 20);
    return 0;
}

這種寫法晦澀難懂，特別是(b.*CB)(a)這種寫法一看上去就覺得很奇怪，代碼寫的越生僻，越復雜，帶來的風險就越大。

另外，如果想要采用這種方法實現回調，那么在定義回調函數的時候就得知道誰會調用它，顯然，這個要求是不合理的，所以，這種方法很不常用，只是介紹這種方法。

單例模式

這個方法是上面靜態函數方法的進一步優化，因為靜態函數沒有傳進去this指針，那么我們可不可以想辦法得到this指針呢？單例模式就可以做到，一般上單例模式為了讓類只存在一個對象，一般都會在類的內部定義一個指向自己的指針，我們就可以通過這個指針，在任何地方都可以訪問到這個對象。

簡單例子：

#include 


class B
{
public:
    static B *get_instance() {
        static B instance;
        return &instance;
    }
    void CB(int a) { printf("CB a = %d\\n", a); }
};


void runCB(int a)
{
    printf("run CB\\n"); 
    B *b_ptr = B::get_instance();
    b_ptr->CB(a);
}


int main(int argc, char *argv[])
{
  B *b_ptr = B::get_instance();
    runCB(20);
    return 0;
}

使用這種方法，在任何地方都可以訪問該對象，可以很方便得調用對象的方法，是比較好的一種方法了，需要注意的就是單例模式的一些限制而已。

另外說一下，單例模式只能說是一種可以解決回調函數的辦法，不一定是因為要回調，才設計成單例。

C++11的function和bind

如果你的編譯器支持C++11標準的話（現在編譯器基本上都會支持），還有一種更加方便快捷的方法。

function模板

首先介紹一下什么叫 可調用對象 ，簡單來說就是可以使用()來調用的對象，在C++11中，包括函數、函數指針、lambda表達式、bind創建的對象和重載了()的類。

function是一個模板函數，它的功能和函數指針很像，但是函數指針只能針對非成員函數，而function則可以調用C++中所有的可調用實體。

對于成員函數來說，function不能直接調用，這就需要通過下面的bind來做“媒介”。

bind函數

bind函數簡單介紹，就是可以綁定到任意一個可調用對象，下面是它的定義。

可以講bind看作一個通用的函數適配器，他接受一個可調用對象，生成一個新的可調用對象來“適應”原對象的參數列表。 ----《c++Primer》

也就是說，通過bind綁定類的非靜態成員函數，生成一個可調用對象，然后通過function模板去調用這個可調用對象，也就實現了調用類的非靜態成員函數。

下面通過一個簡單的例子來說明如何使用。

例子

#include 
#include 
// typedef std::function
using funCB = std::function<void(int)>; //可以這樣寫，更直觀
class B
{
public:
    void setCB(funCB CB)    { m_CB = CB; }
    void runCB(int a)       { std::cout << "runCB" << std::endl; m_CB(a); }
    void printB(int a)      { std::cout << "a = " << a << std::endl; }
    funCB m_CB;
};
class C
{
public:
    void cbfun(int a) { std::cout << "CB a = "
                        << a << std::endl; }
};
int main()
{
    B b; C c;
    funCB fun = std::bind(&C::cbfun, &c, std::placeholders::_1);
    b.setCB(fun);
    b.runCB(20);
    return 0;
}

在這個例子中，b.runCB()，然后會調用m_CB函數，而m_CB通過setCB綁定到了C::cbfun，所以C::cbfun也會被調用。也就是就是通過b的成函數調用到了c的成員函數，實現了回調。

這種方式是不是看起很簡單呢，

后記

這邊文章介紹了在C++中實現回調的幾種方法，總的來說C++11的function&bind是比較好的方法，另外說一點，function的bind的功能不止這些，這里介紹的只是他們的一種用法。

審核編輯：劉清