boost.bind 如何 bind continue.1

我们先定义目标：

1. simple_bind 提供与 bind 类似的界面，可以只考虑通过对象引用（或者值）调用成员函数的情况，而不考虑 free function 或者通过指针调用等等。具体地说，就是允许

person.SetName("Ralph")      --> simple_bind(&Person::SetName, person, _1)(string("Ralph"))
                                 simple_bind(&Person::SetName, _1, string(“Ralph"))(person)
                                 simple_bind(&Person::SetName, _1, _2)(person, string("Ralph"))
                                 simple_bind(&Person::SetName, _2, _1)(string("Ralph"), person)

2. 一个 simple_bind 表达式会 evaluate 成为一个 simple_binder object ，这是一个 functor ，如：

simple_bind(&Person::SetName, person, _1)(string("Ralph"))     --> simple_binder_obj(string("Ralph"))
simple_bind(&Person::SetName, _1, _2)(person, string("Ralph")) --> simple_binder_obj(person, string(“Ralph”))

在这一头一尾，我们其实没多少选择余地，一方面我们需要提供的用户界面已经定了，另一方面需要提供的函数调用界面也基本上固定了，要玩的 magic 也就是发生在中间。

3. 对于 placeholder ，前面已经说过，就用简单的解决方案：
template <int I>
class placeholder{};
placeholder<1> _1;
placeholder<2> _2;
...

有了这3个出发点，现在从 simple_bind 出发，首先看看 simple_bind 应该有的形式。从前面的实验中可以看出

template <typename R, typename T, typename Arg>

simple_binder<R, T, Arg>

simple_bind( R (T::*pfn)(Arg), const Arg& arg, placeholder&)

{

    return simple_binder<R, T, Arg>(pfn, arg);

}

这样的形式虽然方便，但却不具有 scalability 。因为R (T::*pfn)(Arg) 的限制太大了，首先，它只针对接受一个参数的成员函数，如果要支持多个参数，你要对每个参数数量（它有一个术语叫 arity）写一个重载，而这些不同 arity 还要跟 simple_bind 本身的 arity 做组合，结果是爆炸性的 simple_bind 数量。其次，参数 arg 和 placeholder 也太不灵活，前面已经看到，仅仅在两个参数的情况下，就有4种组合：

    simple_bind(&Person::SetName, _1, _2)(person, "Joy");

    simple_bind(&Person::SetName, _2, _1)("Joy", person);

    simple_bind(&Person::SetName, _1, "Joy")(person);

    simple_bind(&Person::SetName, person, _1)("Joy");

可想而知参数更多的时候的恐怖情景。于是我们得出结论：

由于前端的调用组合太复杂，simple_bind 的界面必须以最 generic 的方式给出，由此带来的复杂性应该留待 simple_bind 内部处理。

这是经过了实验的教训得出的结论。

何谓“最 generic”？没有比这更加 generic 的了：

template <typename F, typename A1>

simple_binder<unspecified>

simple_bind(F f, A1 a1)

{

    //...

}

即便如此，由于 C++ 至今还没有可变数量的模板参数，我们还是不能回避对每一个 arity 都有所定义，但是这已经把复杂度控制在 O(arity) 了：

template <typename F, typename A1, typename A2>

simple_binder<unspecified>

simple_bind(F f, A1 a1, A2 a2)

{

    //...

}
......

但是随之而来的就是问题：我现在把第一个参数（函数指针）类型笼统成了一个 F ，我如何知道它的返回类型、参数类型和对象类型？好在这个问题可解，其技法在 boost 里面还很常见，那就是 traits ：

template <typename T>

struct result_of

{};

template <typename R, typename T>

struct result_of<R (T::*)()>

{

    typedef R type;

};

template <typename R, typename T, typename A1>

struct result_of<R (T::*)(A1)>

{

    typedef R type;

};

template <typename R, typename T, typename A1, typename A2>

struct result_of<R (T::*)(A1, A2)>

{

    typedef R type;

};

......

它无非利用 C++ 模板元编程最常用的偏特化来“抽取”函数指针的类型内容，我们甚至无需自己写，boost 已经提供好了相应的工具，但是上面的这个 result_of 也还算清晰好用，在这个例子里面，我们就用它。

在这个方向上，思路已经比较开阔了，现在从另一个方向：simple_binder 入手来想一想。simple_binder 应该长成什么样子呢？由于 function_traits 可以帮我们得到函数返回类型，我们可以肯定 simple_binder 在构造的时候已经知道返回类型了，那么它应该是这样吗？

template <typename R/*返回值的类型*/, typename F, typename A1>

class simple_binder

template <typename R, typename F, typename A1, typename A2>

class simple_binder

如果你的想法是这样，恭喜你，一出门你就撞了南墙：class 不是 function ，除非你偏特化，它是不允许有多个模板参数“重载”的！但是很显然，这些 simple_binder 之间，谁也不是谁的偏特化。那么是不是可以利用类似 TypeList 的技术，用默认模板参数提供变相的可变参数数量模板：

template <typename R, typename F, typename A1, typename A2 = placeholder<0>, typename A3 = placeholder<0> /*...*/ >

class simple_binder
......

好，这下子 simple_bind 的定义算是完整了：

template <typename F, typename A1>

simple_binder<typename result_of<F>::type, F, A1>

simple_bind(F f, const A1& arg1)

{

//...

}

template <typename F, typename A1, typename A2>

simple_binder<typename result_of<F>::type, F, A1, A2>

simple_bind(F f, const A1& arg1, const A2& arg2)

{

    //...

}

在这个基础上，提供 simple_binder 的构造函数也是举手之劳，

    explicit simple_binder(F f, const A1& a1)

        : f_(f)

        , a1_(a1)

    {}

    explicit simple_binder(F f, const A1& a1, const A2& a2)

        : f_(f)

        , a1_(a1)

        , a2_(a2)

    {}

其中的 f_, a1_, a2_ 都是 simple_binder 的成员。simple_bind 仍然只是简单的构造一个 simple_binder ：

template <typename F, typename A1>

simple_binder<typename result_of<F>::type, F, A1>

simple_bind(F f, const A1& arg1)

{

    return simple_binder

        <

        typename result_of<F>::type,

        F,

        A1

        >

    (f, arg1);

}

template <typename F, typename A1, typename A2>

simple_binder<typename result_of<F>::type, F, A1, A2>

simple_bind(F f, const A1& arg1, const A2& arg2)

{

    return simple_binder

        <

        typename result_of<F>::type,

        F,

        A1,

        A2

        >

    (f, arg1, arg2);

}

至于真正的运算，就留给 simple_binder 和它的助手们去做。我们仍然从最简单的情况开始，研究一下调用时没有参数是什么样，例如这样的调用：

simple_bind(&Person::Name, person)()

这个调用的参数在 simple_bind 的时候已经确定，而在 simple_binder 那里只是简单调用一个0参数的 operator()，也就是：

    R operator()()

    {

        //...

    }

即便是这个东西，它代表的意义也不单纯，实际上，在有两个 placeholder 的场合，它代表了两种情况：

1. 类似 simple_bind(&Person::Name, person)()，函数实际上没有参数
2. 类似 simple_bind(&Person::SetName, person, “Joy”)(), 函数其实有一个参数

我们有没有足够的信息来确定是那种情况呢？有，答案就在 simple_binder 的模板参数 A1, A2 中。如果 A2 是 placeholder<0> ，那么就是第一种情况，否则就是第二种情况。为了能在这两种情况之间做出决策，必须加上一个助手，我们称之为 eval ：

template <typename R, typename F, typename A1, typename A2>

R eval(F f, A1 a1, A2 a2)

{

    return (a1.*f)(a2);

}

template <typename R, typename F, typename A1>

R eval(F f, A1 a1, placeholder<0>)

{

    return (a1.*f)();

}

于是乎0参数的 operator() 就成了

    R operator()()

    {

        return eval<R>(f_, a1_, a2_);

    }

参数 a2_ 会帮助我们把调用分派到两个 eval 中的一个，从而完成调用决策。

现在来考虑 1 个参数的 operator() ，它就复杂一些了：

1. 类似 bind(&Person::Name, _1)(person) ，函数其实没有参数
2. 类似 bind(&Person::SetName, _1, "Joy")(person)，函数其实有1个参数，_1 代表第一个
3. 类似 bind(&Person::SetName, person, _1)("Joy")，函数其实有1个参数，_1 代表第二个

停！！！看来在这个方向上鸣金收兵的时候到了。回顾一下这个设计：
通过提供 generic 的 simple_bind 界面以及 result_of ，我们简化了 simple_bind ；又通过 eval ，我们让 simple_binder 变得单纯起来，然而现在 eval 的复杂性开始膨胀，大有脱离我们控制的趋势。原因在哪里？

参数的复杂性。

作为一个系统，我们的这个东西其实接受两组参数，一组是由 simple_bind 接受的，混杂了 placeholder 和实际参数；另一组是由 simple_binder 的 operator() 接受的，全部都是实际参数，但是其应用的顺序需要根据 placeholder 的类型来决定。了解了这个复杂性的根源，我们的任务再次变得清晰起来：提供一个方法，以统一的方式来处理参数，降低复杂性。