C++11中std::function的使用

class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions,lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to data members.

There are two performance implications of using std::function that might surprise you:

(1)、When calling a std::function, it does a virtual function call.

(2)、When assigning a lambda with significant captures to a std::function, it will do a dynamic memory allocation.

类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。

通过std::function对C++中各种可调用实体(普通函数、Lambda表达式、函数指针、以及其它函数对象等)的封装，形成一个新的可调用的std::function对象，让我们不再纠结那么多的可调用实体。

std::function实现了一套类型消除机制，可以统一处理不同的函数对象类型。以前使用函数指针来完成这些，现在可以使用更安全的std::function来完成这些任务。

C++11中推出std::function是为了泛化函数对象，函数指针，引用函数，成员函数的指针，让我们可以按更统一的方式写出更加泛化的代码。

std::function对象是对C++中现有的可调用实体的一种类型安全的包裹(像函数指针这类可调用实体，是类型不安全的)。

可调用实体转换为std::function对象需要遵守以下两条原则：

(1)、std::function对象的参数能转换为可调用实体的参数；

(2)、可调用实体的返回值能转换为std::function对象的返回值(注意，所有的可调用实体的返回值都与返回void的std::function对象的返回值兼容)。

在C++中，”可调用对象”概念：(1)、是一个函数指针；(2)、是一个具有operator()成员函数的类对象(仿函数)；(3)、是一个可被转换为函数指针的类对象；(4)、是一个类成员(函数)指针。

下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

#include "function.hpp"
#include <iostream>
#include <string>
#include <functional>
#include <vector>

///////////////////////////////////////////////////////
// reference: http://en.cppreference.com/w/cpp/utility/functional/function
struct Foo {
	Foo(int num) : num_(num) {}
	void print_add(int i) const { std::cout << num_ + i << '\n'; }
	int num_;
};

void print_num(int i)
{
	std::cout << i << '\n';
}

struct PrintNum {
	void operator()(int i) const
	{
		std::cout << i << '\n';
	}
};

int test_function1()
{
	// store a free function
	std::function<void(int)> f_display = print_num;
	f_display(-9);

	// store a lambda
	std::function<void()> f_display_42 = []() { print_num(42); };
	f_display_42();

	// store the result of a call to std::bind
	std::function<void()> f_display_31337 = std::bind(print_num, 31337);
	f_display_31337();

	// store a call to a member function
	//std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
	const Foo foo(314159);
	//f_add_display(foo, 1);

	// store a call to a data member accessor
	//std::function<int(Foo const&)> f_num = &Foo::num_;
	//std::cout << "num_: " << f_num(foo) << '\n';

	// store a call to a member function and object
	using std::placeholders::_1;
	std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
	f_add_display2(2);

	// store a call to a member function and object ptr
	std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
	f_add_display3(3);

	// store a call to a function object
	std::function<void(int)> f_display_obj = PrintNum();
	f_display_obj(18);

	return 0;
}

///////////////////////////////////////////////////////////
// reference: https://oopscenities.net/2012/02/24/c11-stdfunction-and-stdbind/
void execute(const std::vector<std::function<void()>>& fs)
{
	for (auto& f : fs)
		f();
}

void plain_old_func()
{
	std::cout << "I'm an old plain function" << std::endl;
}

class functor
{
public:
	void operator()() const
	{
		std::cout << "I'm a functor" << std::endl;
	}
};

int test_function2()
{
	std::vector<std::function<void()>> x;
	x.push_back(plain_old_func);

	functor functor_instance;
	x.push_back(functor_instance);
	x.push_back([]()
	{
		std::cout << "HI, I'm a lambda expression" << std::endl;
	});

	execute(x);

	return 0;
}

///////////////////////////////////////////////////////
// reference: http://shaharmike.com/cpp/lambdas-and-functions/
void global_f() {
	std::cout << "global_f()" << std::endl;
}

struct Functor {
	void operator()() { std::cout << "Functor" << std::endl; }
};

int test_function3()
{
	std::function<void()> f;
	std::cout << "sizeof(f) == " << sizeof(f) << std::endl;

	f = global_f;
	f();

	f = [](){ std::cout << "Lambda" << std::endl; };
	f();

	Functor functor;
	f = functor;
	f();

	return 0;
}

GitHub：https://github.com/fengbingchun/Messy_Test