一直比較好奇 boost::bind 里面占位符和參數的順序是怎么實現的，也一直看不太懂這方面源代碼，昨晚好好看了下，終于有點弄懂了。小記一筆，與大家分享。

先看一個簡單的用例：

#include <boost/bind.hpp>

 

int foo(bool a, int b, double c)

{

    return 0;

}

 

int main()

{

    boost::bind(foo, _2, 2, _1)(3.0, true);  // foo(true, 2, 3.0)

 

    return 0;

}

這里有兩個步驟，第一步是綁定過程，第二步是調用。

綁定過程給出了 boost::bind 所需要的幾乎所有信息——只有兩個參數——_1 和 _2——的類型和值，有待確定。但是他們的順序是確定了的，類型實際上也由函數簽名所限制。bind 是一個函數，返回一個 bind_t 類型的對象，bind_t 是一個仿函數。

三個參數時 bind_t 應具備的參數信息：

參數1	參數2	參數3
占位符2	綁定值	占位符1

調用的時候給出的參數表只有兩個：

參數1	參數2
值1	值2

調用時的參數匹配過程如下：

我們暫且把第二列中的參數表稱為 BindList，第三列的參數表稱為 CallList。BindList 和 CallList 都需要保存參數，這部分公用的東西先簡單實現如下：

struct BindArguments0

{

 

};

 

template <typename A1>

struct BindArguments1 : public BindArguments0

{

    BindArguments1(A1 a1) : a1(a1)

    {

 

    }

 

    A1 a1;

};

 

template <typename A1, typename A2>

struct BindArguments2 : public BindArguments1<A1>

{

    BindArguments2(A1 a1, A2 a2) : BindArguments1(a1), a2(a2)

    {

 

    }

 

    A2 a2;

};

 

template <typename A1, typename A2, typename A3>

struct BindArguments3 : public BindArguments2<A1, A2>

{

    BindArguments3(A1 a1, A2 a2, A3 a3) : BindArguments2(a1, a2), a3(a3)

    {

 

    }

 

    A3 a3;

};

為了簡潔和突出關鍵，我們暫時只實現到 3 個參數。從上面的代碼看，多一個參數，代碼是線性增長的，不是指數級增長的，所以很容易（人工地）擴充到所需要的參數個數。如果需要玩些花樣，可以使用宏循環技巧自動生成代碼，這部分東西在《C++ 下 Function 對象的實現（下）》中已經談到過，本文不再贅述。

接下來實現 CallList0 到 CallList3，它除了存儲參數，還具備用占位符查詢出實際值的能力。占位符實現如下：

static struct PlaceHolder1

{

 

} _1;

 

static struct PlaceHolder2

{

 

} _2;

 

static struct PlaceHolder3

{

 

} _3;

對，就這么簡單粗暴就可以了。網上有些文章說使用 int to type，那也可以，做成這樣：

template <int i>

struct PlaceHolder

{

 

};

 

static PlaceHolder<1> _1;

static PlaceHolder<2> _2;

static PlaceHolder<3> _3;

但關鍵點不在這里。我們只要能對各種占位符區分類型就可以了。下文以第一個簡單的定義為準。

CallList 這樣子定義（灰色的先假裝沒看見）：

class CallList0 : public BindArguments0

{

public:

    CallList0()

    {

 

    }

 

public:

    template <typename T>

    T operator [](T t)

    {

        return t;

    }

};

 

template <typename A1>

class CallList1 : public BindArguments1<A1>

{

public:

    CallList1(A1 a1) : BindArguments1<A1>(a1)

    {

 

    }

 

public:

    A1 operator [](PlaceHolder1)

    {

        return a1;

    }

 

    template <typename T>

    T operator [](T t)

    {

        return t;

    }

};

 

template <typename A1, typename A2>

class CallList2 : public BindArguments2<A1, A2>

{

public:

    CallList2(A1 a1, A2 a2) : BindArguments2<A1, A2>(a1, a2)

    {

 

    }

 

public:

    A1 operator [](PlaceHolder1)

    {

        return a1;

    }

 

    A2 operator [](PlaceHolder2)

    {

        return a2;

    }

 

    template <typename T>

    T operator [](T t)

    {

        return t;

    }

};

 

template <typename A1, typename A2, typename A3>

class CallList3: public BindArguments3<A1, A2, A3>

{

public:

    CallList3(A1 a1, A2 a2, A3 a3) : BindArguments3(a1, a2, a3)

    {

 

    }

 

public:

    A1 operator [](PlaceHolder1)

    {

        return a1;

    }

 

    A2 operator [](PlaceHolder2)

    {

        return a2;

    }

 

    A3 operator [](PlaceHolder3)

    {

        return a3;

    }

 

    template <typename T>

    T operator [](T t)

    {

        return t;

    }

};

存儲已經由 BindArguments 負責了，CallList 實現了 operator[] 用于從 PlaceHolderN 查詢調用時的參數 aN。

還有一個問題，CallList 中的參數個數往往會比 BindList 中的少（其中某幾個已經用實際值綁定了），這樣，從 BindList 到 CallList 查詢的時候，需要判斷哪些是 PlaceHolder，哪些是實際參數，這就不太好操作了。為了到時候統一寫法，我們讓 CallList 不僅支持使用 PlaceHolder 查詢，也支持使用實際參數值來查詢。增加上面灰色代碼，使用實際參數查詢的時候，直接返回那個值。

CallList 就到此為止。現在開始實現 BindList。跟 CallList 一樣，每個 BindList 都繼承 BindArguments。……似乎這樣就完事了？BindList 貌似沒其他事情好做了。。。不過，BindList 里面保存了最原始的參數個數信息，如果我們不對函數進行萃取的話，參數個數只能從這里獲取，因此調用過程只能寫在這里——貌似還沒說清楚，不要緊，這是后話。暫且把相關代碼變灰，等下就可以看到原委了。

class BindList0 : public BindArguments0

{

public:

    BindList0()

    {

 

    }

 

public:

    template <typename F, typename A>

    void operator ()(F f, A a)

    {

        f();

    }

};

 

template <typename A1>

class BindList1 : public BindArguments1<A1>

{

public:

    BindList1(A1 a1) : BindArguments1<A1>(a1)

    {

 

    }

 

public:

    template <typename F, typename A>

    void operator ()(F f, A a)

    {

        f(a[a1]);

    }

};

 

template <typename A1, typename A2>

class BindList2 : public BindArguments2<A1, A2>

{

public:

    BindList2(A1 a1, A2 a2) : BindArguments2<A1, A2>(a1, a2)

    {

 

    }

 

public:

    template <typename F, typename A>

    void operator ()(F f, A a)

    {

        f(a[a1], a[a2]);

    }

};

 

template <typename A1, typename A2, typename A3>

class BindList3: public BindArguments3<A1, A2, A3>

{

public:

    BindList3(A1 a1, A2 a2, A3 a3) : BindArguments3(a1, a2, a3)

    {

 

    }

 

public:

    template <typename F, typename A>

    void operator ()(F f, A a)

    {

        f(a[a1], a[a2], a[a3]);

    }

};

快到最后一步了。我們現在可以來考慮 Bind 的最終形式了——模版類？模板函數？從使用上來說，模版類在用的時候必須給出模版參數，想象一下這樣的寫法：

bind<int (bool, int, double), PlaceHolder2, int, PlaceHolder1>(foo, _2, 2, _1)）

……太沒有易用性了。而模版函數則不用事先給出模版參數。boost::bind 也實現成了一組模板函數。同時，函數 Bind 返回的東西必須是可執行體，而且要包含一個BindList，C++ 里面只有仿函數能做到。這個結構我們定義為 BindT。先看代碼：

template <typename F, typename BL>

class BindT

{

public:

    BindT(F f, BL bl) : f(f), bl(bl)

    {

 

    }

 

public:

    void operator ()()

    {

        bl(f, CallList0());

    }

 

    template <typename A1>

    void operator ()(A1 a1)

    {

        bl(f, CallList1<A1>(a1));

    }

 

    template <typename A1, typename A2>

    void operator ()(A1 a1, A2 a2)

    {

        bl(f, CallList2<A1, A2>(a1, a2));

    }

 

    template <typename A1, typename A2, typename A3>

    void operator ()(A1 a1, A2 a2, A3 a3)

    {

        bl(f, CallList3<A1, A2, A3>(a1, a2, a3));

    }

 

private:

    F f;

    BL bl;

};

BindT 保存了函數 f 以及 BindList bl。我們找一個 operator()(A1 a1) 來看，里面寫成了 bl(f, CallList1<A1>(a1));，這得益于 BindList 里面實現了 operator()()。

按通常理解，可能會寫成這樣：

CallList1<A1> cl(a1);

f(cl[bl.a1], cl[bl.a2], ……) 等等，bl 里面到底有幾個元素？這就不知道了，因為 BindT 接受的只是一個 BindList，所以需要 BindList 給出執行形式。因此，上面 BindList 需要灰色部分的 operator()() 代碼。（當然，也可以換種實現方法，拋棄 BindList，在 BindT 中將參數散開來，這看上去也是可行的。）

最后，給出一組 Bind 模版函數，作為最終使用接口：

template <typename F>

BindT<F, BindList0> Bind(F f)

{

    return BindT<F, BindList0>(f, BindList0());

}

 

template <typename F, typename T1>

BindT<F, BindList1<T1>> Bind(F f, T1 t1)

{

    return BindT<F, BindList1<T1>>(f, BindList1<T1>(t1));

}

 

template <typename F, typename T1, typename T2>

BindT<F, BindList2<T1, T2>> Bind(F f, T1 t1, T2 t2)

{

    return BindT<F, BindList2<T1, T2>>(f, BindList2<T1, T2>(t1, t2));

}

 

template <typename F, typename T1, typename T2, typename T3>

BindT<F, BindList3<T1, T2, T3>> Bind(F f, T1 t1, T2 t2, T3 t3)

{

    return BindT<F, BindList3<T1, T2, T3>>(f, BindList3<T1, T2, T3>(t1, t2, t3));

}

好了，簡單實現到此為止。我們這里只是注重了參數表如何存儲，如何使用占位符更改順序，對于其他問題則沒有做過多考慮。還有諸如 const/非const、有返回值/無返回值，引用/非引用、函數指針/成員函數/仿函數等問題都沒有涉及。以上代碼僅僅支持普通函數，不支持成員函數和仿函數。

 

做個簡單的測試：

int foo0()

{

    return 0;

}

 

int foo1(int a)

{

    return 0;

}

 

int foo2(int a, int b)

{

    return 0;

}

 

int foo3(int a, int b, int c)

{

    return 0;

}

 

int main()

{

    Bind(foo0)();

    Bind(foo1, _1)(1);

    Bind(foo1, 2)();

    Bind(foo2, _1, _2)(1, 2);

    Bind(foo2, _2, _1)(1, 2);

    Bind(foo2, _1, 1)(2);

    Bind(foo2, 1, _1)(2);

    Bind(foo2, 1, 2)();

    Bind(foo3, _1, _2, _3)(1, 2, 3);

    Bind(foo3, _1, _3, _2)(1, 2, 3);

    Bind(foo3, _2, _1, _3)(1, 2, 3);

    Bind(foo3, _2, _3, _1)(1, 2, 3);

    Bind(foo3, _3, _1, _2)(1, 2, 3);

    Bind(foo3, _3, _2, _1)(1, 2, 3);

    Bind(foo3, _1, _2, 3)(1, 2);

    Bind(foo3, _2, _1, 3)(1, 2);

    Bind(foo3, _1, 2, 3)(1);

 

    return 0;

}

將以上代碼合起來（去除開頭第一段代碼和中間一個 PlaceHolder<N>的代碼），就是可運行的程序了。（VS2010通過）

示例程序中的各個結構與 boost::bind 實際代碼的對應關系如下：

示例代碼	boost
Bind	bind
BindT	_bi::bind_t
BindListN	listN
CallListN	listN
BindArgumentsN	storageN
PlaceHolderN	arg<N>

BindList 和 CallList 在 boost::bind 的實現中是合并的，這是閱讀時的很大干擾源。所以剛才把他們拆了講，但愿能寫明白些。

好久沒發了，請各位指教。