C++中的std::bind和std::function

逃离我推掉我的手 2022-09-04 03:58 108阅读 0赞

## std::bind ##

std::bind可以将可调用对象和一组参数绑定，并且可以自定义参数绑定顺序，绑定后的结果可以直接作为可调用对象进行调用，也可以继续绑定到`std::function`，作为回调函数使用。示例代码如下：

/** * @file bind.cpp * @brief * @author DuYong * @date 2021-08-05 */
    
    #include <iostream>
    
    void foo(int param1, int param2, int param3, const int &param4, int param5) { 
      std::cout << param1 << ' ' << param2 << ' ' << param3 << ' ' << param4 << ' ' << param5 << std::endl;
      return;
    }
    
    int goo(int param) {  return param; }
    
    struct Foo { 
      void print_sum(int p1, int p2) { 
        std::cout << p1 + p2 << std::endl;
        return;
      }
    
      int data{ 10};
    };
    
    int main() { 
      using namespace std::placeholders; // 使用占位符
    
      int n = 7;
      auto f1 = std::bind(foo, _2, 42, _1, std::cref(n), n); // 参数重排序
      n = 10;
      f1(1, 2, 1001); // 2 42 1 10 7
    
      auto f2 = std::bind(foo, _3, std::bind(goo, _3), _3, 4, 5);
      f2(10, 11, 12); // 12 12 12 4 5
    
      Foo f;
      auto f3 = std::bind(&Foo::print_sum, f, 95, _1); // 绑定成员函数指针
      f3(5);                                           // 100
    
      auto f4 = std::bind(&Foo::data, _1); // 绑定数据成员
    
      std::cout << f4(f) << std::endl;                        // 10
      std::cout << f4(std::make_shared<Foo>(f)) << std::endl; // 10
      return 0;
    }

## std::function ##

**可调用对象：**

*  函数指针
 *  实现了`operator()`的类对象，即仿函数
 *  lambda表达式
 *  成员函数指针
 *  bind表达式
 *  可被转换为函数指针的类对象

`std::function`可以理解为对可调用对象进行封装，它也可以像函数一样调用，是一个函数对象，`std::function`的实例可以存储，复制以及调用任何可调用对象，存储的可调用对象称为目标，若不含目标，使用`std::function`会抛出`std::bad_function_call`异常，可以很方便地实现回调函数。

std::function<void(int)> f; // 返回值为空，参数类型为int的可调用对象

/** * @file test.cpp * @brief * @author DuYong * @date 2021-08-04 */
    
    #include <functional>
    #include <iostream>
    using std::cout;
    using std::endl;
    
    struct Foo { 
      Foo(int num) : _num(num) { }
      void print_add(int i) const { 
        cout << _num + i << endl;
        return;
      }
      int _num;
    };
    
    void print_num(int i) { 
      cout << i << endl;
      return;
    }
    
    struct PrintNum { 
      void operator()(int i) const { 
        cout << i << endl;
        return;
      }
    };
    
    int main() { 
      using namespace std::placeholders;
    
      // 存储自由函数
      std::function<void(int)> f_display = print_num;
      f_display(-9);
    
      // 存储lambda表达式
      std::function<void()> f_display_42 = []() {  print_num(42); };
      f_display_42();
    
      // 存储std::bind()调用的结果
      std::function<void()> f_display_31337 = std::bind(print_num, 31337);
      f_display_31337();
    
      // 存储成员函数
      std::function<void(const Foo &, int)> f_add_display = &Foo::print_add;
      const Foo foo(314159);
      f_add_display(foo, 1);
      f_add_display(314159, 1);
    
      // 存储到数据成员访问器的调用
      std::function<int(Foo const &)> f_num = &Foo::_num;
      cout << "_num: " << f_num(foo) << endl;
    
      // 存储到成员函数和对象的调用
      std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
      f_add_display2(2);
    
      // 存储到成员函数和对象指针的调用
      std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
      f_add_display3(3);
    
      // 存储到函数对象的调用
      std::function<void(int)> f_display_obj = PrintNum();
      f_display_obj(18);
    
      auto factorial = [](int n) { 
        // 存储一个lambda表达式递归得到阶乘
        std::function<int(int)> fac = [&](int n) {  return (n < 2) ? 1 : n * fac(n - 1); };
        //
        return fac(n);
      };
      for (int i{ 5}; i != 8; ++i) { 
        cout << i << "! = " << factorial(i) << "; ";
      }
    
      return 0;
    }

运行结果：

-9
    42
    31337
    314160
    314160
    _num: 314159
    314161
    314162
    18
    5! = 120; 6! = 720; 7! = 5040;

> 参考链接[std::function][std_function]

[std_function]: https://en.cppreference.com/w/cpp/utility/functional/function