std::function is a type erasure object. That means it erases the details of how some operations happen, and provides a uniform run time interface to them. For std::function, the primary operations are copy/move, destruction, and ‘invocation’ with operator() — the ‘function like call operator’.


  • std::function 是一个 可调用对象包装器 ，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。
  • 定义格式：std::function<函数类型>。
  • std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。它比普通函数指针更加的灵活和便利。

指定好参数和返回类型后，便可以接收所有同等类型的函数或是类。

  1. #include <iostream>
  2. #include <functional> //function bind
  4. using namespace std;
  6. function<bool(int, int)> fun; //声明一个function类型，接受两个int，返回bool
  8. bool compare_com(int a, int b) //普通函数
  9. {
  10.     return a > b;
  11. }
  13. auto compare_lambda = [](int a, int b) { return a > b; }; //lambda表达式
  15. class compare_class
  16. {
  17. public:
  18.     bool operator()(int a, int b) //仿函数
  19.     {
  20.         return a > b;
  21.     }
  22. };
  24. class compare
  25. {
  26. public:
  27.     bool compare_member(int a, int b) //类的成员函数
  28.     {
  29.         return a > b;
  30.     }
  31.     static bool compare_static_member(int a, int b) //类的静态成员函数
  32.     {
  33.         return a > b;
  34.     }
  35. };
  37. int main()
  38. {
  39.     fun = compare_com;
  40.     cout << fun(1, 2) << endl; //结果 0
  42.     fun = compare_lambda;
  43.     cout << fun(2, 1) << endl; //结果 1
  45.     fun = compare_class();
  46.     cout << fun(3, 1) << endl; //结果 1
  48.     fun = compare::compare_static_member;
  49.     cout << fun(1, 3) << endl; //结果 0
  51.     //类的成员函数需要使用bind，并且需要实例化对象，成员函数要加&
  52.     compare temp;
  53.     fun = std::bind(&compare::compare_member, temp, placeholders::_1, placeholders::_2);
  54.     cout << fun(1, 2) << endl; //结果 0
  55. }

std::bind is for partial function application
std::bind 是局部函数应用

可将std::bind函数看作一个 通用的函数适配器 ，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
std::bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。std::bind主要有以下两个作用：

  • 将可调用对象和其参数绑定成一个防函数；
  • 只绑定部分参数，减少可调用对象传入的参数。
    1. f(a, b, c)
    2. //如果只是需要填充其中两个函数的话，类似于g(a, b) := f(a, 4, b)
    3. auto g = bind(f, _1, 4, _2) //g(newa, newb) newa-> _1, newb-> _2 类似于f(newa, 4, newb)
    4. auto g = bind(f, _2, 4, _1) //g(newa, newb) newa-> _1, newb-> _2 类似于f(nweb, 4, newa)

Reference

https://www.jianshu.com/p/4ea00ee0dabd?utm_campaign=maleskine&utm_content=note&utm_medium=writer_share&utm_source=weibo
https://www.jianshu.com/p/f191e88dcc80