一直比較好奇 boost::bind 里面占位符和參數(shù)的順序是怎么實(shí)現(xiàn)的，也一直看不太懂這方面源代碼，昨晚好好看了下，終于有點(diǎn)弄懂了。小記一筆，與大家分享。
先看一個(gè)簡(jiǎn)單的用例：
#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;
}
這里有兩個(gè)步驟，第一步是綁定過(guò)程，第二步是調(diào)用。
綁定過(guò)程給出了 boost::bind 所需要的幾乎所有信息——只有兩個(gè)參數(shù)——_1 和 _2——的類型和值，有待確定。但是他們的順序是確定了的，類型實(shí)際上也由函數(shù)簽名所限制。bind 是一個(gè)函數(shù)，返回一個(gè) bind_t 類型的對(duì)象，bind_t 是一個(gè)仿函數(shù)。
三個(gè)參數(shù)時(shí) bind_t 應(yīng)具備的參數(shù)信息：
| 參數(shù)1 | 參數(shù)2 | 參數(shù)3 |
| 占位符2 | 綁定值 | 占位符1 |
調(diào)用的時(shí)候給出的參數(shù)表只有兩個(gè)：
調(diào)用時(shí)的參數(shù)匹配過(guò)程如下：
我們暫且把第二列中的參數(shù)表稱為 BindList，第三列的參數(shù)表稱為 CallList。BindList 和 CallList 都需要保存參數(shù)，這部分公用的東西先簡(jiǎn)單實(shí)現(xiàn)如下：
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;
};
為了簡(jiǎn)潔和突出關(guān)鍵，我們暫時(shí)只實(shí)現(xiàn)到 3 個(gè)參數(shù)。從上面的代碼看，多一個(gè)參數(shù)，代碼是線性增長(zhǎng)的，不是指數(shù)級(jí)增長(zhǎng)的，所以很容易（人工地）擴(kuò)充到所需要的參數(shù)個(gè)數(shù)。如果需要玩些花樣，可以使用宏循環(huán)技巧自動(dòng)生成代碼，這部分東西在《C++ 下 Function 對(duì)象的實(shí)現(xiàn)（下）》中已經(jīng)談到過(guò)，本文不再贅述。
接下來(lái)實(shí)現(xiàn) CallList0 到 CallList3，它除了存儲(chǔ)參數(shù)，還具備用占位符查詢出實(shí)際值的能力。占位符實(shí)現(xiàn)如下：
static struct PlaceHolder1
{
} _1;
static struct PlaceHolder2
{
} _2;
static struct PlaceHolder3
{
} _3;
對(duì)，就這么簡(jiǎn)單粗暴就可以了。網(wǎng)上有些文章說(shuō)使用 int to type，那也可以，做成這樣：
template <int i>
struct PlaceHolder
{
};
static PlaceHolder<1> _1;
static PlaceHolder<2> _2;
static PlaceHolder<3> _3;
但關(guān)鍵點(diǎn)不在這里。我們只要能對(duì)各種占位符區(qū)分類型就可以了。下文以第一個(gè)簡(jiǎn)單的定義為準(zhǔn)。
CallList 這樣子定義（灰色的先假裝沒(méi)看見(jiàn)）：
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;
}
};
存儲(chǔ)已經(jīng)由 BindArguments 負(fù)責(zé)了，CallList 實(shí)現(xiàn)了 operator[] 用于從 PlaceHolderN 查詢調(diào)用時(shí)的參數(shù) aN。
還有一個(gè)問(wèn)題，CallList 中的參數(shù)個(gè)數(shù)往往會(huì)比 BindList 中的少（其中某幾個(gè)已經(jīng)用實(shí)際值綁定了），這樣，從 BindList 到 CallList 查詢的時(shí)候，需要判斷哪些是 PlaceHolder，哪些是實(shí)際參數(shù)，這就不太好操作了。為了到時(shí)候統(tǒng)一寫法，我們讓 CallList 不僅支持使用 PlaceHolder 查詢，也支持使用實(shí)際參數(shù)值來(lái)查詢。增加上面灰色代碼，使用實(shí)際參數(shù)查詢的時(shí)候，直接返回那個(gè)值。
CallList 就到此為止。現(xiàn)在開(kāi)始實(shí)現(xiàn) BindList。跟 CallList 一樣，每個(gè) BindList 都繼承 BindArguments。……似乎這樣就完事了？BindList 貌似沒(méi)其他事情好做了。。。不過(guò)，BindList 里面保存了最原始的參數(shù)個(gè)數(shù)信息，如果我們不對(duì)函數(shù)進(jìn)行萃取的話，參數(shù)個(gè)數(shù)只能從這里獲取，因此調(diào)用過(guò)程只能寫在這里——貌似還沒(méi)說(shuō)清楚，不要緊，這是后話。暫且把相關(guān)代碼變灰，等下就可以看到原委了。
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]);
}
};
快到最后一步了。我們現(xiàn)在可以來(lái)考慮 Bind 的最終形式了——模版類？模板函數(shù)？從使用上來(lái)說(shuō)，模版類在用的時(shí)候必須給出模版參數(shù)，想象一下這樣的寫法：
bind<int (bool, int, double), PlaceHolder2, int, PlaceHolder1>(foo, _2, 2, _1)）
……太沒(méi)有易用性了。而模版函數(shù)則不用事先給出模版參數(shù)。boost::bind 也實(shí)現(xiàn)成了一組模板函數(shù)。同時(shí)，函數(shù) Bind 返回的東西必須是可執(zhí)行體，而且要包含一個(gè)BindList，C++ 里面只有仿函數(shù)能做到。這個(gè)結(jié)構(gòu)我們定義為 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 保存了函數(shù) f 以及 BindList bl。我們找一個(gè) operator()(A1 a1) 來(lái)看，里面寫成了 bl(f, CallList1<A1>(a1));，這得益于 BindList 里面實(shí)現(xiàn)了 operator()()。
按通常理解，可能會(huì)寫成這樣：
CallList1<A1> cl(a1);
f(cl[bl.a1], cl[bl.a2], ……) 等等，bl 里面到底有幾個(gè)元素？這就不知道了，因?yàn)?BindT 接受的只是一個(gè) BindList，所以需要 BindList 給出執(zhí)行形式。因此，上面 BindList 需要灰色部分的 operator()() 代碼。（當(dāng)然，也可以換種實(shí)現(xiàn)方法，拋棄 BindList，在 BindT 中將參數(shù)散開(kāi)來(lái)，這看上去也是可行的。）
最后，給出一組 Bind 模版函數(shù)，作為最終使用接口：
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));
}
好了，簡(jiǎn)單實(shí)現(xiàn)到此為止。我們這里只是注重了參數(shù)表如何存儲(chǔ)，如何使用占位符更改順序，對(duì)于其他問(wèn)題則沒(méi)有做過(guò)多考慮。還有諸如 const/非const、有返回值/無(wú)返回值，引用/非引用、函數(shù)指針/成員函數(shù)/仿函數(shù)等問(wèn)題都沒(méi)有涉及。以上代碼僅僅支持普通函數(shù)，不支持成員函數(shù)和仿函數(shù)。
做個(gè)簡(jiǎn)單的測(cè)試：
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;
}
將以上代碼合起來(lái)（去除開(kāi)頭第一段代碼和中間一個(gè) PlaceHolder<N>的代碼），就是可運(yùn)行的程序了。（VS2010通過(guò)）
示例程序中的各個(gè)結(jié)構(gòu)與 boost::bind 實(shí)際代碼的對(duì)應(yīng)關(guān)系如下：
| 示例代碼 | boost |
| Bind | bind |
| BindT | _bi::bind_t |
| BindListN | listN |
| CallListN | listN |
| BindArgumentsN | storageN |
| PlaceHolderN | arg<N> |
BindList 和 CallList 在 boost::bind 的實(shí)現(xiàn)中是合并的，這是閱讀時(shí)的很大干擾源。所以剛才把他們拆了講，但愿能寫明白些。
好久沒(méi)發(fā)了，請(qǐng)各位指教。
posted on 2012-04-21 15:01
溪流 閱讀(3464)
評(píng)論(5) 編輯 收藏 引用