一直比較好奇 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 的實現中是合併的，這是閱讀時的很大幹擾源。所以剛纔把他們拆了講，但願能寫明白些。