C++ 11 std::function和std::bind使用详解

auto closeItem = MenuItemImage::create(
                      "CloseNormal.png",
                      "CloseSelected.png",
　　　　　　　　　　　　　　　　　　　　　　　　　　CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));

// new callbacks based on C++11
#define CC_CALLBACK_0(__selector__,__target__, ...) std::bind(&__selector__,__target__, ##__VA_ARGS__)
#define CC_CALLBACK_1(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, ##__VA_ARGS__)
#define CC_CALLBACK_2(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, std::placeholders::_2, ##__VA_ARGS__)
#define CC_CALLBACK_3(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, ##__VA_ARGS__)

listener->onTouchesBegan = CC_CALLBACK_2(Layer::onTouchesBegan, this);

std::function<void(const std::vector<Touch*>&, Event*)> onTouchesBegan;

int f(int, char, double);
auto ff = bind(f, _1, 'c', 1.2);   // 绑定f()函数调用的第二个和第三个参数，返回一个新的函数对象为ff，它只带有一个int类型的参数
int x = ff(7);        　　　　// f(7, 'c', 1.2);

int f(int, char, double);
auto frev = bind(f, _3, _2, _1);    // 翻转参数顺序
int x = frev(1.2, 'c', 7);       // f(7, 'c', 1.2);

int g(int);
double g(double);

auto g1 = bind(g, _1);        　　　　 // 错误：调用哪一个g() ?
auto g2 = bind( (double(*)(double))g, _1);  // 正确，但是相当丑陋

void H(int a);
//绑定全局函数
auto f11 = std::bind(H, std::placeholders::_1);
auto的类型实际上是std::function<void(int)>

//绑定带参数的成员函数
std::function<void (char*, int)> f = std::bind(&ReadHandler::ConnectPreProcess, this, std::placeholders::_1, std::placeholders::_1);

//三元函数转换成一元函数
int f(int, char, double);
// 绑定f()函数调用的第二个和第三个参数，
// 返回一个新的函数对象为ff，它只带有一个int类型的参数
auto ff = bind(f, _1, ‘c', 1.2);  
int x = ff(7);

int Func(int x, int y);
auto bf1 = std::bind(Func, 10, std::placeholders::_1);
bf1(20); ///< same as Func(10, 20)

int HelloWorld::AddFunc( int a, int b )
{
  return a + b;
}

bool HelloWorld::init()
{

  auto bf2 = std::bind(&HelloWorld::AddFunc,this , std::placeholders::_1, std::placeholders::_2 );
  auto result1 = bf2(10, 20); ///< same as a.Func(10, 20)

  std::function< int(int)> bf3 = std::bind(&HelloWorld::AddFunc, this, std::placeholders::_1, 100);
  auto result2 = bf3(10); ///< same as a.Func(10, 100)

}

typedef std::function<float (int x, int y)> f ;// 构造一个函数对象，它能表示的是一个返回值为float，两个参数为int，int的函数 
struct int_div {    // 构造一个可以使用"()"进行调用的函数对象类型 
  float operator() (int x, int y) const { return ((float)x)/y; };
};

void HelloWorld::testing()
{
  f f1= int_div();          // 赋值 
  auto result3 = f1( 10, 2);
}

struct int_div {    // 构造一个可以使用"()"进行调用的函数对象类型 
  float operator() (int x, int y) const { return ((float)x)/y; };
  int int_div_fun( int x ){ return x; };
};
typedef std::function<int (int_div*, int)> f_2;

bool HelloWorld::init()
{
  f_2 f2 = std::mem_fn(&int_div::int_div_fun);      // 指向成员函数

  int_div int_div_object;
  int v = f2(&int_div_object, 5); // 在对象x上用参数5调用X::foo()
  std::function<int (int)> ff = std::bind( f2, &int_div_object, std::placeholders::_1);  // f的第一个参数是&x
  v = ff(5);        // 调用x.foo(5)


}

struct int_div { // 构造一个可以使用"()"进行调用的函数对象类型 
　　float operator() (int x, int y) const { return ((float)x)/y; };
　　int int_div_fun( int x ){ return x; };

　　int_div( std::function<void()>& f ):m_callback(f){};
　　void Notify()
　　{
　　　　m_callback();
　　}
　　std::function<void()> m_callback;
};

void Foo(int x, std::function<void(int)>& f)
{
  if(x%2==0)
  f(x);
}

void G(int x)
{
  cout<<x<<endl;
}

void H(int x)
{
  cout<<x+2<<endl;
}

void TestFoo()
{
  auto f = std::bind(G, std::placeholders::_1); 
  Foo(4, f);

  //在Foo函数外面更改f的行为
  f = std::bind(H, std::placeholders::_1);
  Foo(4, f);
}