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 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& vec, std::function 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 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& vec, std::function 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 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& vec, std::function 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 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就起到了回调的作用。

你可能感兴趣的:(bind看这一篇就够了)