原文地址：http://www.cppblog.com/Streamlet/archive/2012/04/21/172241.html 点击打开链接
一直比较好奇 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，它除了存储参数，还具备用占位符查询出实际值的能力。占位符实现如下：
staticstruct PlaceHolder1
{
} _1;
staticstruct PlaceHolder2
{
} _2;
staticstruct 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:
voidoperator ()()
{
bl(f, CallList0());
}
template <typename A1>
voidoperator ()(A1 a1)
{
bl(f, CallList1<A1>(a1));
}
template <typename A1,typename A2>
voidoperator ()(A1 a1, A2 a2)
{
bl(f, CallList2<A1, A2>(a1, a2));
}
template <typename A1,typename A2, typename A3>
voidoperator ()(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 的实现中是合并的，这是阅读时的很大干扰源。所以刚才把他们拆了讲，但愿能写明白些。
好久没发了，请各位指教。
#include <iostream>
using namespace std;
struct BindArguments0 {};
template <typename A1>
struct BindArguments1 : public BindArguments0
{
public:
BindArguments1(A1 a1) : a1(a1) {}
A1 a1;
};
template <typename A1, typename A2>
struct BindArguments2 : public BindArguments1<A1>
{
public:
BindArguments2(A1 a1, A2 a2) : BindArguments1<A1>(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>(a1, a2), a3(a3) {}
A3 a3;
};
///
#if 1
static struct PlaceHolder1 {} _1;
static struct PlaceHolder2 {} _2;
static struct PlaceHolder3 {} _3;
#else
template <int i>
struct PlaceHolder {};
static PlaceHolder<1> _1;
static PlaceHolder<2> _2;
static PlaceHolder<3> _3;
#endif
///
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 this->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 this->a1;}
A2 operator [](PlaceHolder2) { return this->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>(a1, a2, a3) {}
public:
A1 operator [](PlaceHolder1) { return this->a1;}
A2 operator [](PlaceHolder2) { return this->a2;}
A3 operator [](PlaceHolder3) { return this->a3;}
template <typename T>
T operator [](T t) { return t;}
};
///
class BindList0 : public BindArguments0
{
public:
BindList0() {}
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) {}
template <typename F, typename A>
void operator ()(F f, A a) { f (a[this->a1]);}
};
template <typename A1, typename A2>
class BindList2 : public BindArguments2<A1, A2>
{
public:
BindList2(A1 a1, A2 a2) : BindArguments2<A1, A2>(a1, a2) {}
template <typename F, typename A>
void operator ()(F f, A a) { f(a[this->a1], a[this->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>(a1, a2, a3) {}
public:
template <typename F, typename A>
void operator ()(F f, A a) { f(a[this->a1], a[this->a2], a[this->a3]); }
};
template <typename F, typename BL>
class BindT
{
public:
BindT(F f, BL bl) : f(f), bl(bl) {}
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;
};
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));
}
int foo0()
{
printf ("%s\n", "foo0");
return 0;
}
int foo1(int a)
{
printf ("%s (a) = %s (%d)\n", "foo1", "foo1", a);
return 0;
}
int foo2(int a, int b)
{
printf ("%s (a, b) = %s (%d, %d)\n", "foo2", "foo2", a, b);
return 0;
}
int foo3(int a, int b, int c)
{
printf ("%s (a, b, c) = %s (%d, %d, %d)\n", "foo3", "foo3", a, b, 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;
}