std::bind是函数模板（是一个函数）；
使用std::bind可以将可调用对象和参数一起绑定，绑定后的结果使用std::function进行保存，并延迟调用到任何我们需要的时候。
std::bind返回一个基于f的函数对象，其参数被绑定到args上。
f的参数要么被绑定到值，要么被绑定到placeholders（占位符，如_1, _2, ..., _n）。
即;可将std::bind函数看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
std::bind通常有两大作用：
将可调用对象与参数一起绑定为另一个std::function供调用
将n元可调用对象转成m(m < n)元可调用对象，绑定一部分参数。(即减少可调用对象传入的参数)。这里需要使用std::placeholders
比如：
int testfunc(int a, char c, float f)
{
cout << a << endl;
cout << c << endl;
cout << f << endl;
return a;
}
auto bindfunc1 = bind(testfunc, std::placeholders::_1, 'a', 100.1);
bindfunc1(10);
或者
auto bindfunc3 = bind(testfunc, std::placeholders::_2, std::placeholders::_3, std::placeholders::_1);
bindfunc3(100.1, 30, 'c');
可以看到，在bind的时候，第一个位置是testfunc，除了这个，参数的第一个位置为占位符std::placeholders::_2，这就表示，调用bindfunc3的时候，它的第二个参数和testfunc的第一个参数匹配，以此类推。
1.std::bind绑定普通函数
double my_divide (double x, double y) {return x/y;}
auto fn_half = std::bind (my_divide,_1,2);
std::cout << fn_half(10) << '\n'; // 5
bind的第一个参数是函数名，普通函数做实参时，会隐式转换成函数指针。因此std::bind (my_divide,_1,2)等价于std::bind (&my_divide,_1,2)；
_1表示占位符，位于
2.bind绑定类成员函数时
struct foo {
void print_sum(int n1, int n2)
{
std::cout << n1 n2 << '\n';
}
int data = 10;
};
int main()
{
foo foo;
auto f = std::bind(&foo::print_sum, &foo, 95, std::placeholders::_1);
f(5); // 100
}
bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址。
必须显示的指定&foo::print_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在foo::print_sum前添加&；
使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &foo；
3.绑定一个引用参数
std::bind的参数是以 拷贝的方式，使用 std::ref 的方式可以实现参数在std::bind的引用。
4.指向成员函数的指针
#include
struct foo {
int value;
void f() { std::cout << "f(" << this->value << ")\n"; }
void g() { std::cout << "g(" << this->value << ")\n"; }
};
void apply(foo* foo1, foo* foo2, void (foo::*fun)()) {
(foo1->*fun)(); // call fun on the object foo1
(foo2->*fun)(); // call fun on the object foo2
}
int main() {
foo foo1{1};
foo foo2{2};
apply(&foo1, &foo2, &foo::f);
apply(&foo1, &foo2, &foo::g);
} - 成员函数指针的定义：void (foo::*fun)()，调用是传递的实参: &foo::f；
- fun为类成员函数指针，所以调用是要通过解引用的方式获取成员函数*fun,即
(foo1->*fun)();