【boost学习】之boost::bind

最新推荐文章于 2018-12-19 14:38:34 发布

华秋实

最新推荐文章于 2018-12-19 14:38:34 发布

阅读量811

点赞数

分类专栏： boost

boost 专栏收录该内容

26 篇文章 3 订阅

订阅专栏

Purpose（目的）

原来文档中的purpose完全就是教程了，事实上，bind主要用于改造函数，比如，一个地方需要一个无参的函数，你只有一个以int为参数的函数，并且你知道此时int一直为1就可以了，你怎么办？传统方法，直接实现一个函数，然后以1调用以前的那个int为参数的函数。如下：

void  Fun1(int  i) {
    printf(" %d /n " , i);
}

void  FunWeNeed() {
    Fun1(1 );
}

int  main()
{
    FunWeNeed();
    

    return  0 ;
};

当然，这个例子太扯了，我们只需要直接用Fun1(1)调用就可以了，但是bind的目的就是如此，只不过现实中因为各种各样的原因，你的确需要改造函数。再比如下面的情况，你有一个原来写好的函数，接受一个以无参函数为参数，那么，你的Fun1就没有办法派上用场了，那么，传统上，怎么办？如下：

typedef   void  FunWeNeed_t(void );

void  CallFun( FunWeNeed_t f) {
    f();
}

void  Fun1(int  i) {
    printf(" %d /n " , i);
}

void  FunWeNeed() {
    Fun1(1 );
}

int  main()
{

//  CallFun(Fun1);          // this line can't compile 
    CallFun(FunWeNeed);

    return  0 ;
};

Ok，你不得不写新的函数以满足需求，因为你没有简单的办法改变一个函数的参数。

给个bind的解决方案吧。

#include <boost/bind.hpp> 
#include <boost/function.hpp> 

void  CallFun( boost::function<void (void )> f) {
    f();
}

void  Fun1(int  i) {
    printf(" %d /n " , i);
}

void  FunWeNeed() {
    Fun1(1 );
}

int  main()
{

    CallFun(boost::bind(Fun1, 1 ));         // this line can't compile 
    CallFun(FunWeNeed);

    return  0 ;
};

需要注意的是，此时不能再使用函数指针了，bind的天生合作伙伴是function,而function是支持函数指针的（如上例所示）。目的将的很多了，下面看看用法吧（不是什么问题）。

普通函数
最有意思的是，你甚至能用bind来扩充原有函数的参数，见下例：

#include <iostream> 
#include <boost/bind.hpp> 
#include <boost/function.hpp> 
using  namespace  std;
using  namespace  boost;

void  f(int  a, int  b)
{
    cout <<"Argument 1 is "  <<a <<endl;
}

void  g(int  a, int  b, int  c)
{
    cout <<"sum is "  <<a+b+c <<endl;
    cout <<"arg 1: "  <<a <<endl;
    cout <<"arg 2: "  <<b <<endl;
    cout <<"arg 3: "  <<c <<endl;
    cout <<"---------------------------"  <<endl;
}


int  main()
{

    function<void (int ,int )>  f1= bind(f, _2, _1);                 // 调整参数1，2的位置 
    f1(1 , 2 );

    function<void (int )> sum1 = bind(g, _1, _1, _1);        // 3个参数变1个 
    sum1(10 );

    function<void (int , int )> sum2 = bind(g, _2, _2, _2);       // 3个参数变2个，仅用一个 
    sum2(10 , 20 );

    function<void (int , int , int )> sum3 = bind(g, _3, _3, _3);      // 3个参数还是3个，但是仅用1个
    sum3(10 , 20 , 30 );

    function<void (int , int , int , int )> sum4 = bind(g, _4, _4, _4);     // 3个参数变4个，但是仅用1个 
    sum4(10 , 20 , 30 , 40 );

    return  0 ;
};

输出结果：

Argument 1 is 2
sum is 30
arg 1: 10
arg 2: 10
arg 3: 10
---------------------------
sum is 60
arg 1: 20
arg 2: 20
arg 3: 20
---------------------------
sum is 90
arg 1: 30
arg 2: 30
arg 3: 30
---------------------------
sum is 120
arg 1: 40
arg 2: 40
arg 3: 40
---------------------------

函数对象
注意用法中很重要的一条：通常情况下，生成的函数对象的 operator() 的返回类型必须显式指定（没有 typeof 操作符，返回类型无法推导）。（来自Boost文档）

#include <boost/bind.hpp> 
#include <boost/function.hpp> 
using  namespace  std;
using  namespace  boost;

struct  F
{
    int  operator ()(int  a, int  b) { return  a - b; }
    bool  operator ()(long  a, long  b) { return  a == b; }
};




int  main()
{
    F f;

    int  x = 104 ;

    function< int (int ) > fun1 = bind<int >(f, _1, _1);      // f(x, x), i.e. zero 

    cout <<fun1(1 );

    function< bool (long ) > fun2 = bind<bool >(f, _1, _1);       // f(x, x), i.e. zero 

    cout <<fun2(1 );

    return  0 ;
};

其他的也就很简单了。

成员指针
例子来源于boost文档。

#include <iostream> 
#include <boost/bind.hpp> 
#include <boost/function.hpp> 
#include <boost/smart_ptr.hpp> 
using  namespace  std;
using  namespace  boost;

struct  X
{
    void  f(int  a) {
        cout <<a <<endl;
    }
};


int  main()
{
    X x;

    shared_ptr<X> p(new  X);

    int  i = 1 ;

    bind(&X::f, ref(x), _1)(i);     // x.f(i) 
    bind(&X::f, &x, _1)(i);         //(&x)->f(i) 
    bind(&X::f, x, _1)(i);          // (internal copy of x).f(i) 
    bind(&X::f, p, _1)(i);          // (internal copy of p)->f(i) 

    return  0 ;
}

可见bind的强大，支持自己拷贝需要的对象，支持引用，甚至，支持智能指针。

最后一个例子，结合标准库容器及算法的例子，这才是展示bind的强大的地方。

还是来自于boost文档。

class  image;
class  animation
{
public :

    void  advance(int  ms);
    bool  inactive() const ;
    void  render(image & target) const ;
};

std::vector<animation> anims;

template <class  C, class  P> void  erase_if(C & c, P pred)
{
    c.erase(std::remove_if(c.begin(), c.end(), pred), c.end());
}

void  update(int  ms)
{
    std::for_each(anims.begin(), anims.end(), boost::bind(&animation::advance, _1, ms));
    erase_if(anims, boost::mem_fn(&animation::inactive));
}

void  render(image & target)
{
    std::for_each(anims.begin(), anims.end(), boost::bind(&animation::render, _1, boost::ref(target)));
}

例子展示了erase_if,for_each算法中使用bind的方法。

【转自：http://blog.csdn.net/vagrxie/article/details/5509454】

个人总结一下：

（1）bind构造普通函数

（2）bind函数调整参数

（3）bind函数对象（表明返回类型）

（4）bind类的成员函数