std::bind std::function 用法

参考博客：http://blog.csdn.net/eclipser1987/article/details/24406203
示例： 一

/*   * File:   main.cpp  * Author: Vicky.H  * Email:  [e-mail]  */  #include <iostream>  #include <functional>  #include <typeinfo>  #include <string.h>  int add1(int i, int j, int k) {      return i + j + k;  }  class Utils {  public:      Utils(const char* name) {          strcpy(_name, name);      }      void sayHello(const char* name) const {          std::cout << _name << " say: hello " << name << std::endl;      }      static int getId() {          return 10001;      }       int operator()(int i, int j, int k) const {          return i + j + k;      }  private:      char _name[32];  };  /*  *   */  int main(void) {      // 绑定全局函数      auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);      // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.      std::cout << typeid(add2).name() << std::endl;      std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;      std::cout << "\n---------------------------" << std::endl;      // 绑定成员函数      Utils utils("Vicky");      auto sayHello = std::bind(&Utils::sayHello, utils/*调用者*/, std::placeholders::_1/*参数1*/);      sayHello("Jack");      auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*调用者*/, "Lucy"/*固定参数1*/);      sayHelloToLucy();      // 绑定静态成员函数      auto getId = std::bind(&Utils::getId);      std::cout << getId() << std::endl;      std::cout << "\n---------------------------" << std::endl;      // 绑定operator函数      auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);      std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;      // 注意：无法使用std::bind()绑定一个重载函数      return 0;  }  

g++ test.cc -std=c++11
输出显示：

St5_BindIFPFiiiiESt12_PlaceholderILi1EES2_ILi2EEiEEadd2(1,2) = 13---------------------------Vicky say: hello JackVicky say: hello Lucy10001---------------------------add100(1, 2) = 103

示例二

/*   * File:   main2.cpp  * Author: Vicky.H  * Email:  [e-mail]  */  #include <iostream>  #include <typeinfo>  void sayHello() {      std::cout << "Hello world !" << std::endl;  }  int sum(int i, int j, int k) {      return i + j + k;  }  template <typename T>  class Func {  public:      Func(T fun) {          if (!fun) {              throw "fun nullptr";          }          _fun = fun;      }      template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>      R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {          return _fun(a1, a2, a3, a4, a5);      }      template<typename R, typename A1, typename A2, typename A3, typename A4>      R Call(A1 a1, A2 a2, A3 a3, A4 a4) {          return _fun(a1, a2, a3, a4);      }      template<typename R, typename A1, typename A2, typename A3>      R Call(A1 a1, A2 a2, A3 a3) {          return _fun(a1, a2, a3);      }      template<typename R, typename A1, typename A2>      R Call(A1 a1, A2 a2) {          return _fun(a1, a2);      }      template<typename R, typename A1>      R Call(A1 a1) {          return _fun(a1);      }      template<typename R>      R Call() {          return _fun();      }      void Call() {          _fun();      }  private:      T _fun;  };  #include <functional>  template<typename R = void, typename... Args>  class Fn {  public:      Fn(std::function<R(Args...)> fun) : _fun(fun) {      }      R operator()(Args... args) {          return _fun(args...);      }  private:      std::function<R(Args...) > _fun;  };  /*  * 将函数注册到对象中，通过对象直接调用  */  int main(void) {      Func<void(*)() > sayHelloFunc(sayHello);      sayHelloFunc.Call();      Func<int (*)(int, int, int) > sumFunc(sum);      std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;      std::cout << "\n---------------------------" << std::endl;      Fn<> sayHelloFn(sayHello);      sayHelloFn();      Fn<int, int, int, int> sumFn(sum);      std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;      std::cout << "\n---------------------------" << std::endl;      return 0;  }  

g++ test.cc -std=c++11
输出显示

Hello world !sumFunc.Call<int>(1, 2, 3) : 6---------------------------Hello world !sumFn(1, 2, 3) : 6---------------------------

    上面的例子非常有趣，使用了2种方案，将一个函数，注册到一个对象/仿函数中，并且通过一个对象/仿函数来直接调用调用。    例子显而易见的，第2种方案更佳简洁，并且对传递参数有明确的判断，当参数类型或数量不正确的时候，编译器将导致失败。

#include <list>  #include <functional>  template<typename... Args>  class Fns  {  private:      std::list<std::function<void(Args...)> > _calls;  public:      virtual ~Fns()      {          _calls.clear();      }      void connect(std::function<void(Args...)> fct)      {          _calls.push_back(fct);      }      template<typename Object>      void connect(Object* object, void (Object::*method)(Args...))      {          _calls.push_back([object,method](Args... args){(*object.*method)(args...);});      }      template<typename Object>      void connect(Object* object, void (Object::*method)(Args...) const)      {          _calls.push_back([object,method](Args... args){(*object.*method)(args...);});      }      template<typename Object>      void connect(const Object* object, void (Object::*method)(Args...) const)      {          _calls.push_back([object,method](Args... args){(*object.*method)(args...);});      }      void emit(Args... args)      {          for(auto call : _calls)              call(args...);      }  };  

#include <cstdio>  #include "Signal.hpp"  class Foo  {  public:      void bar(int x, int y)      {          printf("Foo::bar(%d, %d)\n", x, y);      }  };  void foobar(int x, int y)  {      printf("foobar(%d, %d)\n", x, y);  }  int main(void)  {      Foo foo;      Fns<int, int> s;      // Connect a function      s.connect(foobar);      // Connect a class method      s.connect(&foo, &Foo::bar);      // Create and connect some lambda expression      s.connect([&foo](int x, int y){           printf("lambda::"); foo.bar(x, y);       });      // Emit the signal !      s.emit(4, 2);      getchar();      return 0;  

foobar(4, 2)
Foo::bar(4, 2)
lambda::Foo::bar(4, 2)