[C++11] function与bind

📑 简介

🐱 function

类模板std::function是一个通用的多态函数包装器。 std::function的实例可以存储，复制和调用任何可调用的目标，简而言之，是支持OP(...)操作的目标，如函数、lambda表达式、bind绑定表达式、重载operator()的类对象、类内数据成员等。包装器对象可以进行拷贝，并且包装器类型仅仅只依赖于其调用特征（call signature），而不依赖于可调用元素自身的类型。当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。

Class that can wrap any kind of callable element (such as functions and function objects) into a copyable object, and whose type depends solely on its call signature (and not on the callable element type itself).

类声明

template <class T> function;     // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;

成员函数

🐶bind

std::bind可以根据当前已有的可调用对象，构造出一个新的可调用对象。

bind可以改变函数的参数顺序、固定参数值等。

函数声明

template <class Fn, class... Args> bind (Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args> bind (Fn&& fn, Args&&... args);

📓 ​举例

🗒️例子不全，仅供参考。（其中对于类数据成员的访问使用较少）

• 普通函数构造function（含模板，以下省略模板）

  #include <functional>
  int add(int a, int b)
  {
      return a + b;
  }
  int main()
  {
      std::function<int(int, int)>funcAdd = add;
      auto sum = funcAdd(10, 30);
  
      _asm int 3;
      return 0;
  }
  

  #include <functional>
  
  template<typename T>
  T add(T a, T b)
  {
      return a + b;
  }
  int main()
  {
      std::function<int(int, int)>funcAdd = add<int>;
      auto sum = funcAdd(10, 30);
  
      _asm int 3;
      return 0;
  }
  

• 函数对象构造function

  #include <functional>
  
  struct addFunctor
  {
  public:
      int operator() (int a, int b)
      {
          return a + b;
      }
  };
  int main()
  {
      addFunctor add;
      std::function<int(int, int)> funAdd = add;
      auto sum = funAdd(10, 50);
  
      _asm int 3;
      return 0;
  }
  

• 类成员函数构造function

  #include <functional>
  
  class example
  {
  public:
      int add(int a, int b)
      {
          return a + b;
      }
  };
  int main()
  {
      example xp;
  
      std::function<int(example&, int, int)> funAdd = &example::add;
      auto sum = funAdd(xp, 10, 50);
  
      _asm int 3;
      return 0;
  }
  

• 类静态成员函数构造function

  #include <functional>
  
  class example
  {
  public:
      static int add(int a, int b)
      {
          return a + b;
      }
  };
  int main()
  {
      std::function<int(int, int)> funAdd = &example::add;
      auto sum = funAdd(10, 50);
  
      _asm int 3;
      return 0;
  }
  

• 类数据成员构造function

  #include <functional>
  
  class example
  {
  public:
      int data;
  };
  int main()
  {
      std::function<int(example&)> getData = &example::data;
  
      example xp;
      xp.data = 60;
  
      auto data = getData(xp);
  
      _asm int 3;
      return 0;
  }
  

• lambda表达式构造function

  #include <functional>
  
  int main()
  {
      std::function<int(int, int)> funAdd = [](int a, int b) {return a + b; };
      auto sum = funAdd(10, 50);
  
      _asm int 3;
      return 0;
  }
  

• bind表达式构造function

  #include <functional>
  
  class example
  {
  public:
      int add(int a, int b)
      {
          return a + b;
      }
  
      int data;
  };
  int main()
  {
      example xp;
      xp.data = 50;
  
      std::function<int(int, int)> funAdd = std::bind(&example::add, xp, std::placeholders::_1, std::placeholders::_2);
      std::function<int()> getXpData = std::bind(&example::data, xp);
  
      auto sum = funAdd(10, 50);
      auto data = getXpData();
  
      _asm int 3;
      return 0;
  }
  

Tips:

​ placeholders为std命名空间内针对bind函数使用的占位符命名空间，用来指定参数的位置。