std::funcion 和 std::bind 学习笔记

学习笔记"/>

std::funcion 和 std::bind 学习笔记

仿函数

如果类重载了函数调用运算符()，则我们可以像使用函数一样使用该类的对象。此时类的对象可以将具有类似函数的⾏为，我们称这些对象为函数对象（Function Object）或者仿函数（Functor）。
这样的类同时也能存储状态，所以比普通函数更加灵活。

struct absInt {int operator() (int val) const { // 成员函数名为operator()return val < 0 ? -val : val;}
};
int i = -42;
absInt absObj;
int ui = absObj.operator()(i);  // 将 i 传递给 absObj.operator()
ui = absObj(i);		// 简化写法
// 调用对象实际上是在运行重载的调用运算符。

类的构造函数和类的重载小括号函数，调用起来是一样的。
区别方法：调用前有类名，就调用构造函数，否则调用重载的小括号函数

class obj {
public:obj(int val) {cout << "构造函数调用\n";}void operator() (int val) const {cout << "函数运算符()调用\n";}~obj() {}
};
obj A(10);
A(10);

总的来说，只要对象所属的类，重载了 ()，那么这个类的对象就变成了可调用对象（函数对象），它变得可以像函数一样使用。

可调用对象

可调用对象的几种类型：

函数指针

int print(int a, double b) { return 0; }
// 定义函数指针
int (*func)(int, double) = &print;

具有operator()成员函数的类对象（仿函数）

struct Test{void operator()(string msg){ // 重载操作符()cout << "msg: " << msg << endl;}
}
Test t;
t("11111");	// 仿函数

可被转换为函数指针的类对象

using func_ptr = void(*)(int, string); // func_ptr为void类型的函数指针，函数参数为(int, string)
struct Test{static void print(int a, string b){ // 静态成员函数属于类，而不属于对象cout << "name: " << b << ", age: " << a << endl;}// 将类对象转换为函数指针operator func_ptr(){return print;}
};
Test t;
t(19, "Monkey D. Luffy");// 对象转换为函数指针, 并调用

可调用对象包装器

std::function 是可调用对象的包装器。它是一个类模板，可以容纳除了类成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象（仿函数）、函数指针，并允许保存和延迟执行它们。
在实际编程时，主要有以下场景：

• 绑定一个函数（普通函数或者静态函数）
• 实现回调函数
• 作为函数入参

所需头文件：<functional>
函数原型：

#include <functional>
std::function<返回值类型(参数类型列表)> diy_name = 可调用对象;

实例：

int add(int a, int b){return a + b;
}
class T1{
public:static int sub(int a, int b){return a - b;}
};
class T2{
public:int operator()(int a, int b){return a * b;}
};function<int(int, int)> f1 = add;// 绑定一个普通函数
function<int(int, int)> f2 = T1::sub;// 绑定以静态类成员函数
T2 t;
function<int(int, int)> f3 = t;// 绑定一个仿函数
// 函数调用
f1(9, 3);
f2(9, 3);
f3(9, 3);

std::function 可以将可调用对象进行包装，得到一个统一的格式，包装完成得到的对象相当于一个函数指针，和函数指针的使用方式相同，通过包装器对象就可以完成对包装的函数的调用了。

作为回调函数使用

什么是回调函数？

百度百科定义：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

把一段可执行的代码像参数传递那样传给其他代码，而这段代码会在某个时刻被调用执行，这就叫做回调。

因为回调函数本身就是通过函数指针实现的，使用对象包装器可以取代函数指针的作用。

实例：

class A{
public:// 仿函数传入构造函数，f绑定仿函数，这时f就相当于函数指针// 用f对callback进行初始化A(const function<void(string)>& f) : callback(f) {}void notify(const string &s){callback(s); // 调用通过构造函数得到的函数指针，回调函数}
private:function<void(string)> callback;
};
class B{
public:void operator() (const string &s){cout << s << endl;}
};
B b;     // 创建一个仿函数b
A a(b); // 仿函数通过包装器对象进行包装
a.notify("1111");
// a对象里的 callback 相当于函数指针，指向仿函数b

通过上面的例子可以看出，使用对象包装器std::function可以非常方便的将仿函数转换为一个函数指针，通过进行函数指针的传递，在其他函数的合适的位置就可以调用这个包装好的仿函数了。
另外，使用std::function作为函数的传入参数，可以将定义方式不相同的可调用对象进行统一的传递，这样大大增加了程序的灵活性。

绑定器

std::bind 用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用std::function进行保存，并延迟调用到任何我们需要的时候。通俗来讲，它主要有两大作用：

• 将可调用对象与其参数一起绑定成一个仿函数。
• 将多元（参数个数为n，n>1）可调用对象转换为一元或者（n-1）元可调用对象，即只绑定部分参数。

绑定器函数使用语法格式：

// 绑定非类成员函数/变量
auto f = std::bind(可调用对象地址, 绑定的参数/占位符);
// 绑定类成员函/变量
auto f = std::bind(类函数/成员地址, 类实例对象地址, 绑定的参数/占位符);

绑定普通函数

实例：

void callFunc(int x, const function<void(int)>& show) {if (x % 2 == 0) show(x); // show接收传入的bind绑定的结果
}
void output(int x) { cout << x << " "; }
void output_add(int x) { cout << x + 10 << " "; }// 使用绑定器绑定可调用对象和参数
auto f1 = bind(output, placeholders::_1);
for (int i = 0; i < 10; ++i){callFunc(i, f1);
}cout << endl;auto f2 = bind(output_add, placeholders::_1);
for (int i = 0; i < 10; ++i){callFunc(i, f2);
}cout << endl;

在上面的程序中，使用了std::bind绑定器，在函数外部通过绑定不同的函数，控制了最后执行的结果。std::bind绑定器返回的是一个仿函数类型，得到的返回值可以直接赋值给一个std::function，在使用的时候我们并不需要关心绑定器的返回值类型，使用auto进行自动类型推导就可以了。

placeholders::_1是一个占位符，代表这个位置将在函数调用时被传入的第一个参数所替代。同样还有其他的占位符 placeholders::_2、placeholders::_3、placeholders::_4、placeholders::_5 等……

关于占位符的实例：

void output(int x, int y){cout << x << " " << y << endl;
}// 运行结果
// 使用绑定器绑定可调用对象和参数
// 在后边加上 ()，就可以直接调用得到的仿函数     
bind(output, 1, 2)();                   				// 1 2
bind(output, placeholders::_1, 2)(10);  				// 10 2
bind(output, 2, placeholders::_1)(10);  				// 2 10// error, 调用时没有第二个参数
// bind(output, 2, placeholders::_2)(10);  // 调用时第一个参数10被吞掉了，没有被使用
bind(output, 2, placeholders::_2)(10, 20);                  // 2 10
bind(output, placeholders::_1, placeholders::_2)(10, 20);   // 10 20
bind(output, placeholders::_2, placeholders::_1)(10, 20);   // 20 10

通过测试可以看到，std::bind可以直接绑定函数的所有参数，也可以仅绑定部分参数。在绑定部分参数的时候，通过使用std::placeholders来决定空位参数将会属于调用发生时的第几个参数。

绑定类成员函数指针或者类成员

可调用对象包装器std::function是不能实现对类成员函数指针或者类成员指针的包装的，但是通过绑定器std::bind的配合之后，就可以完美的解决这个问题了。

class Test{
public:void output(int x, int y){cout << "x: " << x << ", y: " << y << endl;}int m_number = 100;
};Test t;
// 绑定类成员函数
function<void(int, int)> f1 = bind(&Test::output, &t, placeholders::_1, placeholders::_2);// 绑定类成员变量(公共)
function<int&(void)> f2 = bind(&Test::m_number, &t);// 调用
f1(520, 1314);	//  相当于t对象类成员函数output的函数指针
f2() = 2333; 	//  相当于t对象类成员m_number的引用
cout << "t.m_number: " << t.m_number << endl;  // 输出为t.m_number: 2333