C++11 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);

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

使用仿函数进行排序

class MyCompare{
public: // 重载的 () 要public
	bool operator()(vector<int> &v1, vector<int> &v2){ // 参数使用引用
		if (v1[0] == v2[0]) return v1[1] > v2[1];  //最高优先级相同时，按第二优先级排序
        return v1[0] > v2[0];
	}
};

int main() {
    vector<vector<int>> a = {{3,5,2},{3,8,1},{8,9,3}};
    sort(a.begin(), a.end(), MyCompare()); // 放入sort时要加()
    for (auto s : a) {
        cout<<s[0]<<s[1]<<s[2]<<endl;
    }
    return 0;
}

可调用对象

可调用对象的几种类型：

函数指针

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