C++11 bind

bind

bind 用来将可调用对象和参数一起进行绑定。可调用对象包括普通函数、全局函
数、静态函数、类静态函数甚至是类成员函数，参数包括普通参数和类成员。绑定后的
结果，可以使用 std::function 进行保存，并延迟调用到我们需要的时候。

绑定普通函数与参数及占位

bind 绑定顺序，也就是函数中形参的声明顺序。
placeholders::_x 中的序列是实参的顺序。

# if 1
//bind
#include <iostream>
#include <functional>

using namespace std;

double myDivide (double x, double y)
{
    return x/y;
}
int main(){

    auto myFunc = bind(myDivide, 10, 2);
    cout << myFunc() << endl;

    auto myFunc1 = bind(myDivide, 10,placeholders::_1);
    cout << myFunc1(2) << endl;
    //placeholders::_1 占位符，表示第一个参数，2表示第二个参数
    auto myFunc2 = bind(myDivide, placeholders::_2,placeholders::_1);
    cout << myFunc2(10,2) << endl;

    auto myFunc3 = bind(myDivide, placeholders::_1,placeholders::_2);
    cout << myFunc3(10,2) << endl;
    
    return 0;
}

输出
5
5
0.2
5
# endif

绑定对象与成员及占位

绑定对象及成员函数时，顺序是调用成员，对象，[参数]。成员，对象及参数不能
有缺位，缺位可用 placeholders::_x 来占位。否则编译不过。

// todo 类成员函数绑定

#include <iostream>
#include <functional>
using namespace std;
struct A{
    int x;
    double y;
};

class B{
public:
//    void func(){
//        cout << "B::func()" << endl;
//    }
    void func(int x,int y){
        cout << "void func(int x,int y)" << endl;
        cout << "x=" << x << " y=" << y << endl;
    }

};
int main() {
    A a={1,2.5};

    // 绑定到对象a的成员变量x
    auto f = bind(&A::x, a); // 绑定到对象a的成员变量x
    cout << f() << endl; // 输出1

    //B b;
    //auto f1 = bind(&B::func, b); // 绑定到对象b的成员函数func
    //f1(); // 输出B::func()
    //
    //    B b1;
    //    auto f2 = bind(&B::func, b1,10,20); // 绑定到对象b的成员函数func
    //    f2(); // 输出void func(int x,int y) x=10 y=20

    B b1;
    auto f2 = bind(&B::func, b1,placeholders::_1,placeholders::_2); // 绑定到对象b的成员函数func
    f2(3,4);
    return 0;
}

函数重载情形下的绑定

#include <iostream>
#include <functional>
using namespace std;

int add(int x, int y)
{
    cout<<"int add(int x, int y)"<<endl;
    return x + y;
}

double add(double x, double y)
{
    cout<<"double add(double x, double y)"<<endl;
    return x + y;
}

class MyPair
{
public:
    int add(int x, int y)
    {
        cout<<"MyPair:: int add(int x, int y)"<<endl;
        return x + y;
    }
    double add(double x, double y)
    {
        cout<<"MyPair:: double add(double x, double y)"<<endl;
        return x + y;
    }
};

int main(){
    auto f1= bind( (int (*)(int x, int y))add, 1, 2);
    f1(); // 输出 int add(int x, int y)

    auto f2= bind( (double (*)(double x, double y))add, 1, 2);
    f2(); // 输出 double add(double x, double y)

    MyPair p;
    auto f3= bind( (int (MyPair::*)(int x, int y))&MyPair::add, p, 1, 2);
    f3(); // 输出 MyPair:: int add(int x, int y)


    MyPair p1;
    auto f4= bind( (double (MyPair::*)(double x, double y))&MyPair::add, p1, placeholders::_1, placeholders::_2);
    f4(2,3); // 输出 MyPair:: double add(double x, double y)


    return 0;
}

bind 语义

语义小结
（1）bind 预先绑定的参数需要传具体的变量或值进去，对于预先绑定的参数，是pass-by-value 的。

（2）对于不事先绑定的参数，需要传 std::placeholders 进去，从_1 开始，依次
递增。placeholder 是 pass-by-reference 的。

（3）bind 的返回值是可调用实体，可以直接赋给 std::function 对象。

（4）对于绑定的指针、引用类型的参数，使用者需要保证在可调用实体调用之前，
这些参数是可用的。

（5）类的 this 可以通过对象或者指针来绑定。

多态之 bind +fucntion

function 本是不可以包装类成员函数，但是 bind 的可以实现类成员函数的绑定，
然后赋给 fucntion 对象，亦即实现了间接性的包装。

//todo bind + function
#include <iostream>
#include <functional>
using namespace std;

void foo()
{
    cout<<"void foo()"<<endl;
}
void func(int a)
{
    cout<<"void func(int a)"<<endl;
}

class Foo
{
public:
    void method()
    {
        cout<<"Foo::void method()"<<endl;
    }
    void method2(string s)
    {
        cout<<"Foo:void method2()"<<endl;
    }
};

class Bar
{
public:
    void method3(int a ,string s)
    {
        cout<<"Bar:void method3()"<<endl;
    }
};

std::function<void(void)> f;

int main()
{
    f=foo;
    f(); // 输出 void foo()
    f= bind(func,10);
    f(); // 输出 void func(int a)
    Foo foo;
    f= bind(&Foo::method,foo);
    f(); // 输出 Foo::void method()
    f = bind(&Foo::method2,foo,"hello");
    f(); // 输出 Foo:void method2()

    Bar bar;
    f= bind(&Bar::method3,bar,1,"world");
    f(); // 输出 Bar:void method3()
    return 0;
}