C++11 学习笔记 std::function和bind绑定器

一.std::function

      C++中的可调用对象虽然具有比较统一操作形式(除了类成员指针之外,都是后面加括号进行调用),但定义方法五花八门。为了统一泛化函数对象,函数指针,引用函数,成员函数的指针的各种操作,让我们可以按更统一的方式写出更加泛化的代码,C++11推出了std::function。

  std::function是可调用对象的包装器。它是一个类模板,可以容纳除了类成员(函数)指针之外的所有可调用对象。通过指定它的模板参数,它可以用统一的方式处理函数,函数对象,函数指针,并允许保存和延迟执行它们。

#1include 
 #include 
 
 using namespace std;
 
 void func(void){
     cout << __FUNCTION__ << "(" << a << ") ->: ";
 }
 
 class Foo
 {
 public:
     static int foo_func(int a){
         cout << __FUNCTION__ << "(" << a << ") ->: ";
         return a;
     }
 };
 
 class bar
 {
 public:
     int operator()(int a){
         cout << __FUNCTION << "(" << a << ") ->: ";
         return a;
     }
 };
 
 int main(){
     //绑定一个普通函数
     std::function fry = func;
     fr1();
 
     
     //绑定一个类的静态成员函数
     std::function fr2 = Foo::foo_func;
     cout << fr2(123) << endl;
     
     //绑定一个仿函数
     Bar bar;
     fr2 = bar;
     cout << fr2(123) <

std::function的使用方法:我们给std::function填入合适的函数签名(即一个函数类型,只需要包括返回值和参数表)之后,它就变成了一个可以容纳所有这一类调用方式的“函数包装器”。

 

 #include 
 #include 
 
 using namespace std;
 
 class A
 {
 public:
     A(const std::function& f){
         :callback_(f){}
     
     void notify(void){
         callback_();
     }
 private:
     std::function callback_;
 };
 
 class Foo
 {
 public:
     void operator()(void){
         cout << __FUNCTION__<< endl;
     }
 };
 
 int main(){
     Foo foo;
     A aa(foo);
     aa.notify();
     
     return 0;
 }

  从上面的例子看,std::function可以取代函数指针的作用。因为它可以保存函数延迟执行,所以比较适合作为回调函数,也可以把它看做类似于C#中特殊的委托(只有一个成员的委托)。

 #include 
 #include 
 
 using namespace std;
 
 void call_when_even(int x, const std::function& f){
     if(!(x & 1)){
         f(x);
     }
 }
 
 void output(int x){
     cout << x <<" ";
 }
 
 int main(void){
     for(int i=0;i<10;i++){    
         call_when_even(i, output);
     }
     cout<

std::function还可以作为函数入参,这样可以在函数外部控制函数的内部行为了,让我们的函数变得更加灵活。

 

二.std::bind绑定器

  std::bind用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用std::function进行保存,并延迟调用到任何我们需要的时候。通俗来讲,它主要有两大作用:

  1).将可调用对象与其参数一起绑定成一个仿函数。

  2).将多元(参数个数为n,n>1)可调用对象转成一元或者(n-1)元可调用对象,即只绑定部分参数。

  function模板类和bind模板函数,都可以实现类似函数指针的功能,但却却比函数指针更加灵活,特别是函数指向类的非静态成员函数时。

  1).std::function可以绑定到全局函数/类静态成员函数(类静态成员函数与全局函数没有区别)。

  2).绑定到类的非静态成员函数,则需要使用std::bind。

 #include 
 #include 
 
 using namespace std;
 
 void call_when_even(int x, const std::function& f){
     if(!(x & 1)){
         f(x);
     }
 }
 
 void output(int x){
     cout << x << " ";
 }
 
 void output_add_2(int x){
     cout << x +2 << " ";
 }
 
 int main(){
     {
         auto fr = std::bind(output, std::placeholders::_1);
         for(int i=0;i<10;i++){
            call_when_even(i, fr);
         }
         cout << endl;
     }
     
     {
         auto fr = std::bind(output_add_2, std::placeholders::_1);
         for(int i=0;i<10;i++){
             call_when_even(i, fr);
         }
         cout << endl;
     }
 
     return 0;
 }

  "std::placeholders::_1"是一个占位符对象,用于表示当函数output(output_add_2)通过函数fr进行调用时,函数fr的第一个参数在函数output(output_add_2)的参数列表中的位置。

 

  下面是两个样例:

 #include 
 #include 
 
 using namespace std;
 
 class A
 {
 public:
     int i_=0;
 
     void output(int x, int y){
         cout << x << " " << y < fr = std::bind(&A::output, &a, std::placeholders::_1,std::placeholders::_2);
     fr(1,2);
 
     std::function fr_i = std::bind(&A::i_, &a);
     fr_i() = 123;
     cout << a.i_ << endl;
 
     return 0;
 }

 //使用组合bind函数,找出集合中大于5小于10的元素个数
 #include 
 #include 
 
 using namespace std;
 
 auto f = std::bind(std::logical_and(),std::bind(std::greater(),_1,5),std::bind(std::less_equal(),  _1, 10));
 
 int main(){
      set se={1,2,3,4,5,6,7,8,9};
     int count = std::count_if(se.begin(), se.end(), f);
     cout << count <


std::bind需要注意的一些事项:(http://www.cnblogs.com/slysky/p/3822640.html)

1).std::bind预先绑定的参数需要传具体的变量或值进去,对于预先绑定的参数,是pass-by-value的

2).对于不事先绑定的参数,需要传std::placeholders进去,从_1开始,依次递增。placeholder是pass-by-reference的

3).bind的返回值是可调用实体,可以直接赋给std::function对象

4).对于绑定的指针、引用类型的参数,使用者需要保证在可调用实体调用之前,这些参数是可用的

5).类的this可以通过对象或者指针来绑定

你可能感兴趣的:(C++11)