boost—— 函数与回调bind

/*bind是一个boost中的非常庞大的函数家族，其根据绑定的参数个数
 * 和绑定的调用对象的类型总共可分为数十个不同形式，是标准函数
 * std::bindist和bind2nd的泛化，其支持任意的函数对象、函数、
 * 函数指针和成员函数指针，还可给任意参数绑定特定值或将标准参数
 * 发送到任意位置，其接口摘要如下：其接受的第一个参数是可调用
 * 对象f,包括函数、函数指针、函数对象和成员函数等等，最多接受9
 * 个成员函数，其返回一个被自动推导出来为f的返回值类型，在调用
 * 之前此函数对象会把之前存储的参数转发给f完成
 *
 * bind的占位符:
 * 占位符被定义为_1、_2、_3..._9位于一个匿名名字空间，占位符可以
 * 取代bind中参数的位置，在发生函数调用时才接受真正的参数。占位符
 * 的名字表示其在调用式中的顺序，而在绑定表达式没有要求，并且出现
 * 次数也没有限制。
 * 无论真实参数还是占位符均可以，绑定表达式中必须提供要求的所有参数i
 */

#if 0
bind部分摘要
namespace boost
{

// no arguments

template<class R, class F> unspecified-1 bind(F f);

template<class F> unspecified-1-1 bind(F f);

template<class R> unspecified-2 bind(R (*f) ());

// one argument

template<class R, class F, class A1> unspecified-3 bind(F f, A1 a1);

template<class F, class A1> unspecified-3-1 bind(F f, A1 a1);

template<class R, class B1, class A1> unspecified-4 bind(R (*f) (B1), A1 a1);

template<class R, class T, class A1> unspecified-5 bind(R (T::*f) (), A1 a1);

template<class R, class T, class A1> unspecified-6 bind(R (T::*f) () const, A1 a1);

template<class R, class T, class A1> unspecified-6-1 bind(R T::*f, A1 a1);

// two arguments

template<class R, class F, class A1, class A2> unspecified-7 bind(F f, A1 a1, A2 a2);

template<class F, class A1, class A2> unspecified-7-1 bind(F f, A1 a1, A2 a2);

template<class R, class B1, class B2, class A1, class A2> unspecified-8 bind(R (*f) (B1, B2), A1 a1, A2 a2);

template<class R, class T, class B1, class A1, class A2> unspecified-9 bind(R (T::*f) (B1), A1 a1, A2 a2);

template<class R, class T, class B1, class A1, class A2> unspecified-10 bind(R (T::*f) (B1) const, A1 a1, A2 a2);

// implementation defined number of additional overloads for more arguments

}

namespace
{

unspecified-placeholder-type-1 _1;

unspecified-placeholder-type-2 _2;

unspecified-placeholder-type-3 _3;

// implementation defined number of additional placeholder definitions

}
#endif
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <boost/bind.hpp>

using namespace boost;
using namespace std;

int f(int a,int b)
{
     return (a+b);
}
int g(int a,int b,int c)
{
     return (a+b+c);
}
typedef int (*f_type)(int,int);
typedef int (*g_type)(int,int,int);

class demo
{
public:
    int f(int a,int b)
    {
         return (a+b);
    }
};
struct func
{
    int operator()(int a,int b)
    {
         return (a*b);
    }       
};

int main( int argc,char **argv)
{
    /*绑定普通函数:
     * 变形,其他的类比：
     * 1.bind(f,_1,9)(x);   //f(x,9)
     * 2.bind(f,_1,_2)(x,y);    //f(x,y)
     * 3.bind(f,_2,_1)(x,y);    //f(y,x)
     * 4.bind(f,_1,_1)(x,y);    //f(x,x)
     * 5.bind(g,_1,_8,_2)(x,y); //g(x,8,y)
     * 6.bind(g,_3,_2,_2)(x,y,z);   //g(z,y,y)*/
    cout << bind(f,1,2)() << endl;
    cout << bind(g,2,3,4)() << endl;

    /*绑定函数指针*/
    f_type fp = f;
    g_type fg = g;
    int x = 1,y = 2,z = 3;
    cout << bind(fp,_1,18)(x) << endl;
    cout << bind(fg,_1,_3,_3)(x,y,z) << endl;

    /*绑定成员函数:
     * 绑定类的成员函数必须牺牲一个占位符的位置
     * 进而通过对象作为第一个参数来调用第一个成员函数
     * 因为成员函数指针不能直接调用operator(),必须绑定到
     * 一个对象或指针，通过this指针来调用
     * */
    demo a,&ra = a; //类的实例或引用
    demo *p = &a;   //指针
    //注意：在成员函数之前必须加上取地址操作符，以表明其是成员函数指针，否则编译无法通过
    cout << bind(&demo::f,a,_1,20)(80) << endl; 
    cout << bind(&demo::f,ra,_2,_1)(20,10) << endl;
    cout << bind(&demo::f,p,_1,_1)(30,30) << endl;

    /*绑定成员变量：
     * bind对类的另一个操作是public成员变量，其可以有选择地去操作一些成员变量*/
    typedef pair<int,string> pis_t;
    pis_t pp(12,"xiaoming");
    cout << bind(&pis_t::first,pp)();
    cout << bind(&pis_t::second,pp)() << endl;

    /*绑定函数对象：
     * 若函数有内部类型定义result_type，bind可以进行自动推导；
     * 否则需要在编写时增加typedef result_type工作
     * */
     cout << bind<int>(func(),_1,_2)(10,20) << endl;

     /*与ref的配合：
      * bind是采用拷贝的方式来存储对象和参数，开销较大，为了减少这种开销，我们可以搭配ref库
      * 一起使用，但是这可能会引起bind的调用延后。若调用时引用的变量或者函数对象被销毁，那么
      * 结果未知*/
     int m = 30;
     cout << bind(g,_1,cref(m),ref(m))(10) << endl;
     cout << bind<int>(ref(f),_1,_2)(10,20) << endl;



     return (0);
}