【C++】C++11之包装器

---

一、function

语法说明：

function<Ret_type(Args…)
Ret_type：返回类型
Args：参数列表

function 包装器，本质是一个类模板，可用于对可调用对象的包装，举例：

假如有三个可调用对象，分别是：函数指针、仿函数、lambda 表达式，函数指针本身书写就比较繁琐复杂，lambda 也差不多，那么此时可以用 function 包装器来包装他们，而且如果这三位的返回值、参数类型及个数都相同的话，用一个 function 包装器当参数类型，可以直接接收这三位作为实参的传递。

头文件：

#include <functional>

代码举例：

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

int Add1(int a, int b)
{
    cout << "int Add1(int a, int b): ";
    return a + b;
}

struct Add2
{
    int operator()(int a, int b)
    {
        cout << "int operator()(int a, int b): ";
        return a + b;
    }
};
int main()
{
    //包装函数指针
    function<int(int, int)> func1 = Add1;

    //包装仿函数
    function<int(int, int)> func2 = Add2();

    //包装lambda表达式
    function<int(int, int)> func3 = [](int a, int b) { cout << "[](int a, int b): "; return a + b; };

    //调用
    cout << func1(1, 2) << endl;
    cout << func2(1, 2) << endl;
    cout << func3(1, 2) << endl;
    return 0;
}

运行结果：

可以看到用包装器包装了个可调用对象后，可以直接像调用仿函数时调用其，由此可以得知包装器的底层其实就是仿函数。

---

除此之外，包装器还可以包装一个类里面的 static 成员函数和普通成员函数，如下：

代码举例：

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

class A
{
public:
    A(int val = 0)
        :_val(val)
    {}

    static int Add1(int a, int b)
    {
        return a + b;
    }

    int Add2(int a, int b)
    {
        return a + b;
    }

private:
    int _val;
};

int main()
{
    function<int(int, int)> func1 = A::Add1;
    function<int(A, int, int)> func2 = &A::Add2;

    cout << func1(1, 2) << endl;
    cout << func2(A(1), 1, 2) << endl;
    return 0;
}

包装类内的成员函数与其他稍有不同，其中包装 static 修饰的成员函数时，直接指定类域即可，但是包装类内的普通成员函数时需要取地址，但是对static 修饰的成员函数也可以用取地址：

function<int(int, int)> func1 = &A::Add1;

另外需要注意的是，在包装类内的普通成员函数时，别忘了成员函数隐含的 this 指针，所以在 function 的参数列表要加上该类的类型，在传递时可以传递匿名对象，也可以传递有对象：

//匿名
cout << func2(A(1), 1, 2) << endl;
//有名
A a(1);
cout << func2(a, 1, 2) << endl;

---

二、bind

bind（绑定）是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表，头文件和 function 一样。

语法说明：

bind (Fn&& fn, Args&&… args);
fn：一个可调用对象
args：参数列表

1、改变参数顺序

假设有这么一个场景，我们要改变参数的顺序，即我的第一个参数是要传递给第二个参数，第二个参数要传递给第一个参数，那么可以通过 bind 来实现，代码如下：

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

void Print(int a, int b)
{
    cout << a << " " << b << endl;
}

int main()
{
    Print(1, 2);
    auto newPrint = bind(Print, placeholders::_2, placeholders::_1);
    newPrint(1, 2);
    return 0;
}

运行结果：

bind 参数列表的 _1,_2,…_n 表示适配的原参数列表的参数，也就是第一个，第二个，第N个参数，语法如此，记住就好，那么这样写就表示参数列表的第一个值传递给第二个参数，参数列表的第二个值传递给第一个参数，而 _1,_2,… 都在 placeholders 这个命名空间内，是直接展开使用还是使用域作用限定符指定就看自己的习惯了。

---

2、固定某个值
还记得 function 在包装类的成员函数时需要传递一个类对象吗？是否会觉得每次都要传递这个类对象太麻烦了，可否只传递和成员函数列表相同的参数呢？是可以的，利用 bind ，代码如下：

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

class A
{
public:
    A(int val = 0)
        :_val(val)
    {}

    static int Add1(int a, int b)
    {
        return a + b;
    }

    int Add2(int a, int b)
    {
        return a + b;
    }

private:
    int _val;
};

int main()
{
    auto bind_add1 = bind(&A::Add2, A(1), placeholders::_1, placeholders::_2);
    function<int(int,int)> bind_add2 = bind(&A::Add2, A(1), placeholders::_1, placeholders::_2);

    cout << bind_add1(1, 2) << endl;
    cout << bind_add2(1, 2) << endl;
    return 0;
}

如上通过 bind 直接固定第一个参数那么此时就不需要传递类对象了，按理来说，类对象是我们要传递的第一个参数，那么往后不应该是 _2，_3 吗？但是不是的，因为绑定后，只需要传递两个参数，所以还是 _1，_2，再举个例子：

auto bind_add1 = bind(&A::Add2, placeholders::_1, 1, placeholders::_2);
cout << bind_add1(A(1), 2) << endl;

原本需要传递三个参数，分别是：类对象，int1，int2，此时固定了 int1 为1，那么传递参数时只需要传递一个类对象，和一个整数，但是此时依然是 _1,_2 ，因为绑定后，仍只需要传递两个参数。

---

总结

温故而知新。