随笔-89  评论-944  文章-0  trackbacks-0

一直比较好奇 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

调用时的参数匹配过程如下:

image

我们暂且把第二列中的参数表称为 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 的实现中是合并的,这是阅读时的很大干扰源。所以刚才把他们拆了讲,但愿能写明白些。

好久没发了,请各位指教。

posted on 2012-04-21 15:01 溪流 阅读(2680) 评论(5)  编辑 收藏 引用

评论:
# re: 山寨一个 Boost.Bind[未登录] 2012-04-23 17:03 | sand
很好,很清晰  回复  更多评论
  
# re: 山寨一个 Boost.Bind[未登录] 2012-04-28 18:07 | a
类似TypeList  回复  更多评论
  
# re: 山寨一个 Boost.Bind[未登录] 2012-09-13 22:54 | me
hao  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理