C++11 std::bind

概述

std::bind函数定义在头文件functional中，是一个函数模板，它就像一个函数适配器，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

函数原型

std::bind函数有两种函数原型，定义如下：

template< class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );
 
template< class R, class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );

std::bind返回一个基于f的函数对象，其参数被绑定到args上。
f的参数要么被绑定到值，要么被绑定到placeholders（占位符，如_1, _2, …, _n）。

调用形式

调用std::bind的一般形式为：
auto newCallable = std::bind(callable, arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用newCallable时，newCallable会调用callable，并传递给它arg_list中的参数。

参数

f：一个可调用对象（可以是函数对象、函数指针、函数引用、成员函数指针、数据成员指针），它的参数将被绑定到args上。
args：绑定参数列表，参数会被值或占位符替换，其长度必须与f接收的参数个数一致。

返回类型

std::bind的返回类型是一个未指定类型T的函数对象，这个类型T满足以下条件: std::is_bind_expression::value == true

std::bind使用

2.1 std::bind绑定普通函数

#include <iostream>
#include <functional>	//for std::bind
using namespace std;

double my_divide (double x, double y) {return x/y;} 

int main()
{
	using namespace std::placeholders;	//for _1
	
  	auto fn_half = std::bind (my_divide,_1,2); 
	std::cout << fn_half(10) << '\n'; // 5
	return 0;
}

• bind的第一个参数是函数名，普通函数做实参时，会隐式转换成函数指针。因此std::bind (my_divide,_1,2)等价于std::bind (&my_divide,_1,2)；
• _1表示占位符，位于中，std::placeholders::_1；

2.2 std::bind绑定一个成员函数

#include <iostream>
#include <functional>

using namespace std;
using namespace std::placeholders;	//for _1

struct Foo {
	void print_sum(int n1, int n2)
	{
		std::cout << n1+n2 << '\n';
	}
	int data = 10;
};
int main()
{
	Foo foo;
	auto f = std::bind(&Foo::print_sum, &foo, 95, std::placeholders::_1);
	f(5); // 100
	
	return 0;
}

• bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址。
• 必须显示的指定&Foo::print_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在Foo::print_sum前添加&；
• 使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &foo；

2.3 std::bind绑定一个引用参数
默认情况下，bind的那些不是占位符的参数被拷贝到bind返回的可调用对象中。但是，与lambda类似，有时对有些绑定的参数希望以引用的方式传递，或是要绑定参数的类型无法拷贝。

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std::placeholders;
using namespace std;

ostream & print(ostream &os, const string& s, char c)
{
    os << s << c;
    return os;
}

int main()
{
    vector<string> words{"helo", "world", "this", "is", "C++11"};
    ostringstream os;
    char c = ' ';
    for_each(words.begin(), words.end(), 
                   [&os, c](const string & s){os << s << c;} );
    cout << os.str() << endl;

    ostringstream os1;
    // ostream不能拷贝，若希望传递给bind一个对象，
    // 而不拷贝它，就必须使用标准库提供的ref函数
    for_each(words.begin(), words.end(),
                   bind(print, ref(os1), _1, c));
    cout << os1.str() << endl;
}

使用std::ref可以在模板传参的时候传入引用，否则无法传递
std::cref() 用于const引用

2.3 std::bind示例

#include <iostream>
#include <functional>
 
void fn(int n1, int n2, int n3) {
	std::cout << n1 << " " << n2 << " " << n3 << std::endl;
}
 
int fn2() {
	std::cout << "fn2 has called.\n";
	return -1;
}
 
int main()
{
	using namespace std::placeholders;
	auto bind_test1 = std::bind(fn, 1, 2, 3);
	auto bind_test2 = std::bind(fn, _1, _2, _3);
	auto bind_test3 = std::bind(fn, 0, _1, _2);
	auto bind_test4 = std::bind(fn, _2, 0, _1);
 
	bind_test1();//输出1 2 3
	bind_test2(3, 8, 24);//输出3 8 24
	bind_test2(1, 2, 3, 4, 5);//输出1 2 3，4和5会被丢弃
	bind_test3(10, 24);//输出0 10 24
	bind_test3(10, fn2());//输出0 10 -1
	bind_test3(10, 24, fn2());//输出0 10 24，fn2会被调用，但其返回值会被丢弃
	bind_test4(10, 24);//输出24 0 10
	return 0;
}

参考资料：
https://www.jianshu.com/p/f191e88dcc80
https://blog.csdn.net/qq_37653144/article/details/79285221