浅谈std::function

前言

std::function是C++11提供的一个关于函数调用的模板类，以支持函数式编程。在cpp里面，它常用来绑定回调函数，绑定？是的，它经常结合std::bind来使用。下面介绍下它的常用用法以及一些可能会遇到的坑。

常用用法

• 绑定普通全局函数，静态函数。
• 绑定类的静态函数。
• 绑定类的成员函数，通过类对象。
• 绑定类的成员函数，通过类指针。
• 绑定类的成员函数，通过智能指针对象。
• 绑定类的成员函数，有入参，参数通过占位符绑定到函数对象，调用时输入参数，模板需声明入参。
• 绑定类的成员函数，有入参，参数直接绑定到函数对象，调用时不用输入，直接调用，模板不用声明入参。

具体看下demo源码：

#include <iostream>
#include <sstream>
#include <functional>
#include <chrono>
#include <ctime>
#include <memory>
#include <sys/types.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <exception>
#include <string>
#include <unordered_map>
#include <map>
#include <vector>
#include <cstring>
#include <future>
#include <time.h>
#include <random>
#include <regex>
#include <cstring>
#include <string>

typedef std::function<void()> NoInputTask;
typedef std::function<int(int)> InputTask;

class Demo { //有必要，可继承std::enable_shared_from_this模板类
public:
  Demo() = default;
  ~Demo() = default;
  void asyncCallBack() {
    std::cout << "i am asyncCallBack()" << std::endl;
  }

  static void staticAsyncCallBack() {
    std::cout << "i am staticAsyncCallBack()" << std::endl;
  }

  int inputTest(int i) {
    std::cout << "i am inputTest() i " << i << std::endl;
    return 1;
  }

private:
  int a_;
};

void test() {
  std::cout << "i am test()" << std::endl;
}

int main(int argc, char* argv[])
{
  //绑定普通函数,无返回值，无入参
  NoInputTask f1(test);
  if (f1)
    f1();

  //绑定类静态函数，无返回值，无入参
  NoInputTask f2(&Demo::staticAsyncCallBack);
  if (f2)
    f2();

  //绑定类的成员函数，通过类对象，无返回值，无入参
  Demo d1;
  NoInputTask f3(std::bind(&Demo::asyncCallBack, d1));
  if (f3)
    f3();

  //绑定类的成员函数，通过类指针，无返回值，无入参
  Demo* d2 = new Demo();
  NoInputTask f4(std::bind(&Demo::asyncCallBack, d2));
  if (f4)
    f4();

  //绑定类的成员函数，通过智能指针对象，无返回值，无入参
  std::shared_ptr<Demo> d3(new Demo());
  NoInputTask f5(std::bind(&Demo::asyncCallBack, d3));
  if (f5)
    f5();

  //有返回值，有入参，需要绑定占位符，参数在调用时输入
  Demo d4;
  InputTask f6(std::bind(&Demo::inputTest, d4, std::placeholders::_1));
  if (f6) {
    int ret = f6(44);
    std::cout << "f6 ret " << ret << std::endl;
  }

  //有返回值，有入参，但是入参不声明，直接绑定到函数对象，调用时直接调用即可
  Demo d5;
  std::function<int(void)> f7(std::bind(&Demo::inputTest, d5, 55));
  if (f7) {
    int ret = f7();
    std::cout << "f7 ret " << ret << std::endl;
  }

  return 0;
}

运行结果如下：

可能的坑

前面我们总结了std::function的一些用法，在日常使用中不会有太大的问题。但是，服务端开发的时候，更多的用法是做异步回调，此时对象的生命周期就不由我们控制了。

在异步回调中，上面方式中最常用、最可靠的用法是使用智能指针包裹对象，并绑定到函数对象中。而且，如果有必要，对象还需要继承std::enable_shared_from_this模板类，在对象成员函数中绑定新的异步回调的时候，使用shared_from_this可以延长对象的生命周期。

另外，函数调用时，更安全的做法是使用一个临时函数对象拷贝要调用的函数对象，然后调用临时函数对象。

结尾

• 行文至此，关于std::function的介绍就到此结束了。
• 如果觉得还不错，你的点赞关注加收藏便是笔者继续更新的最大动力哦^_^。
• 关联文章。
  • 浅谈C++智能指针