C++11 function与bind的使用

我们先要了解闭包，什么是闭包？

1、闭包有很多种定义，一种说法是，闭包是带有上下文的函数。说白了，就是有状态的函数。更直接一些，不就是个类吗？换了个名字而已。

一个函数，带上了一个状态，就变成了闭包了。那什么叫 “带上状态” 呢？ 意思是这个闭包有属于自己的变量，这些个变量的值是创建闭包的时候设置的，并在调用闭包的时候，可以访问这些变量。

函数是代码，状态是一组变量，将代码和一组变量捆绑 (bind) ，就形成了闭包

闭包的状态捆绑，必须发生在运行时。

2、C++11中，新增加了一个std::function类模板，它是对C++中现有的可调用实体的一种类型安全的包裹。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。如下代码

#include<iostream>
#include<string>
#include<functional>
using namespace std;

//普通函数
void func()
{
	cout << __func__ << endl;
}

//2、类中静态函数
class Test
{
public:
	static int test_func(int a)
	{
		cout << __func__ << "(" << a << ")->:";
		return a;
	}
};
//3、类中的仿函数
class MyFunctor
{
public:
	int operator()(int a)
	{
		cout << __func__ << "(" << a << ")->:";
		return a;
	}
};
int main()
{
	//1、绑定普通函数
	function<void()>f1 = func;//相当于函数指针
	f1();
	//2、绑定类中静态函数	要写作用域
	function<int(int)>f2 = Test::test_func;
	cout << f2(10) << endl;//Test::test_func(10);
	//3、绑定类中的仿函数，绑定对象		我们绑定匿名对象
	function<int(int)>f3 = MyFunctor();
	cout << f3(20) << endl;
	return 0;
}

3、我们可以再看看bind与function一起使用的情况

#include<iostream>
#include<string>
#include<functional>//头文件提供原型
using namespace std;
using namespace std::placeholders;//引入命名空间减少代码量
class Test
{
public:
	void func(int x, int y)
	{
		cout << x << " " << y << endl;
	}
	int a;
};
int main()
{
	Test obj;

	//绑定成员函数
	function<void(int, int)>f1 = bind(&Test::func, &obj, _1, _2);
	f1(11, 22);

	function<int&()>f2 = bind(&Test::a, &obj);
	f2() = 111;//obj.a=111;
	cout << obj.a << endl;
	return 0;
}

只有这些吗？显然不是，我们还需要了解一个问题

4、使用std::ref()与std::cref(),来完善function，bind

#include<iostream>
#include <functional>

/*std::ref 用于包装按引用传递的值。
std::cref 用于包装按const引用传递的值。*/

/*bind()是一个函数模板，它的原理是根据已有的模板，生成一个函数，但是由于bind()不知道生成的函数执行的时候，
传递进来的参数是否还有效。所以它选择参数值传递而不是引用传递。如果想引用传递，std::ref和std::cref就派上用场了。*/
void f(int& n1, int& n2, const int& n3)
{
    std::cout << "In function: n1[" << n1 << "]    n2[" << n2 << "]    n3[" << n3 << "]" << std::endl;
    ++n1; // 增加存储于函数对象的 n1 副本
    ++n2; // 增加 main() 的 n2
    //++n3; // 编译错误
    std::cout << "In function end: n1[" << n1 << "]     n2[" << n2 << "]     n3[" << n3 << "]" << std::endl;
}

int main()
{
    int n1 = 1, n2 = 1, n3 = 1;
    std::cout << "Before function: n1[" << n1 << "]     n2[" << n2 << "]     n3[" << n3 << "]" << std::endl;
    std::function<void()> bound_f = std::bind(f, n1, std::ref(n2), std::cref(n3));
    bound_f();
    std::cout << "After function: n1[" << n1 << "]     n2[" << n2 << "]     n3[" << n3 << "]" << std::endl;

    //C++11的设计者认为std::bind和std::thread默认应该采用拷贝，如果使用者有需求，加上std::ref()即可实现按引用传递。
    //所以即使函数的第一个参数是引用，但是bin的绑定实际是拷贝，如下
    std::endl(std::cout);
    f(n1, std::ref(n2), std::cref(n3));
    std::cout << "After function: n1[" << n1 << "]     n2[" << n2 << "]     n3[" << n3 << "]" << std::endl;
}
/*n1是值传递，函数内部的修改对外面没有影响。
n2是引用传递，函数内部的修改影响外面。
n3是const引用传递，函数内部不能修改。*/

注意看注释，我们要清楚一些概念

1、C++11的设计者认为std::bind和std::thread默认应该采用拷贝，如果使用者有需求，加上std::ref()即可实现按引用传递。
所以即使函数的第一个参数是引用，但是bin的绑定实际是拷贝

2、bind()是一个函数模板，它的原理是根据已有的模板，生成一个函数，但是由于bind()不知道生成的函数执行的时候，传递进来的参数是否还有效。所以它选择参数值传递而不是引用传递。如果想引用传递，std::ref和std::cref就派上用场了

3、std::ref 用于包装按引用传递的值。
std::cref 用于包装按const引用传递的值。

注意代码注释的最后三行，去理解

/*n1是值传递，函数内部的修改对外面没有影响。
n2是引用传递，函数内部的修改影响外面。
n3是const引用传递，函数内部不能修改。*/

绑定默认是值传递！

 回忆一下，我们讲述了闭包，function，bind，ref，cref，以及常见的问题，不够全面，先清楚即可

 环境:msvc C++20，至少要达到C++11才能运行此代码。