bind看这一篇就够了

bind能干啥

bind作用于函数上（包括普通函数，类成员函数等），将函数改造为一个类的对象，这个类里面实现了operator()操作符，使得这个对象能像函数一样能使用()调用。这样有什么好处呢？
首先，函数对象操作方式和函数几乎一致，不会带来新的语法难度。
其次，函数对象可以预设函数的部分参数，更加灵活。
最后，函数对象可以绑定到类的成员函数。

bind的使用方式

bind的返回值
bind的返回值是一个函数对象，在需要得到一个返回值的地方，建议使用关键字auto接收返回值，如下：

void my_plus(int a, int b) {  }
auto f_int = std::bind(my_plus, std::placeholders::_1, 10);

但是如果需要出现在形参声明中，那么就必须完整写出返回值的形式，如下：

std::function<void(int)> f_int = std::bind(my_plus, std::placeholders::_1,10);

上述写法中，void是该函数对象的操作符operator()返回值类型，这个类型应该与原函数my_plus保持一致。(int)表示该函数对象的操作符operator()的形参列表。

bind绑定到普通函数
用一个例子说明，对于给的int数组，求大于10的元素个数。

bool big_than(int a, int b) { return a > b; }
int for_each_array(std::vector<int>& vec, std::function<bool(int)> f) {
  int count = 0;
  for (auto iter = vec.begin(); iter != vec.end(); ++iter) {
    if (f(*iter)) ++count;
  }
  return count;
}

int main() {
  auto f = std::bind(big_than, std::placeholders::_1, 10);
  std::vector<int> vec = {100,100,300,2,1,3};
  int res = for_each_array(vec, f);
}

上述代码乍看没有什么优势，用函数指针也能轻易完成。但是如果需求中不仅需要求大于10的个数，还需要计算大于100的个数，那么就不得不再建立一个新函数。而使用函数对象就可以轻易满足动态的需求。只要构造一个新的函数对象即可。

参数对应关系

绑定类的静态函数
绑定静态函数和普通函数类似，仅在构造函数对象时的写法略有不同

class T
{
public:
  bool big_than(int a, int b) { return a > b; }
};
int for_each_array(std::vector<int>& vec, std::function<bool(int)> f) {
  int count = 0;
  for (auto iter = vec.begin(); iter != vec.end(); ++iter) {
    if (f(*iter)) ++count;
  }
  return count;
}

int main() {
  auto f = std::bind(&T::big_than, std::placeholders::_1, 10);
  std::vector<int> vec = {100,100,300,2,1,3};
  int res = for_each_array(vec, f);
}

绑定到非静态成员函数

class T
{
public:
  static bool big_than(int a, int b) { return a > b; }
  bool mem_big_than(int a, int b) { return a > b; }
};
int for_each_array(std::vector<int>& vec, std::function<bool(int)> f) {
  int count = 0;
  for (auto iter = vec.begin(); iter != vec.end(); ++iter) {
    if (f(*iter)) ++count;
  }
  return count;
}

int main() {
  T t;
  auto f = std::bind(&T::mem_big_than, &t, std::placeholders::_1, 10);
  std::vector<int> vec = {100,100,300,2,1,3};
  int res = for_each_array(vec, f);
}

因为非静态成员函数都是和某个对象相联系，所以在调用的时候必须有该类的对象在场，即&t。此时还能在mem_big_than中使用对象t的属性。

bind使用场景

仅仅将一个函数变形为一个函数对象并没有多大意义。重要的是可以把这个函数对象用于多变的场景，又或者根据不同的情况构造出不同的函数对象，用来解决一系列相同性质的问题。以达到复用性。
举几个例子。

对象过滤器
在某个应用场景，你有一个manager管理一个对象的数组。可能你需要把满足某些条件的对象摘取出来，单独处理。抑或是仅仅统计满足条件的对象的数量，就完全可以使用bind。比如统计学生管理类中，年龄大于18岁的学生个数。自然地，你也可以在这个管理类中新加一个处理函数，但是除了大于18岁这个条件，还可能有其他条件，或者组合条件，在实际应用中，这些条件可能比较复杂。使用bind后，处理起来更加灵活了。
回调处理函数
在某个处理函数中，遇到某种情况，可能需要在另一个类执行某些操作，且这些操作的参数依赖与处理函数中的变量。如下所示：

T *obj = get_obj();
int param = argv[0];
int ret = deal_with_param(param);
if (ret) {
  obj->failed(std::bind(some_func, std::placeholders::_1, param));
}

在执行deal_with_param时，发生了错误。需要在类T中做某些通知操作。这个通知的动作依赖于当下的参数param。这里的bind就起到了回调的作用。