C++——包装器std::function与绑定器std::bind

C++——包装器std::function与绑定器std::bind

1、可调用对象的包装器

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

1.1基本用法

使用std::function必须包含一个头文件叫做functional,具体语法如下

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

示例：

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

int add(int a, int b)
{
   
    cout << a << " + " << b << " = " << a + b << endl;
    return a + b;
}

class T1
{
   
public:
    static int sub(int a, int b)
    {
   
        cout << a << " - " << b << " = " << a - b << endl;
        return a - b;
    }
    int operator()(int a, int b)
    {
   
        cout << a << " * " << b << " = " << a * b << endl;
        return a * b;
    }
};

class T2
{
   
public:
    int operator()(int a, int b)
    {
   
        cout << a << " * " << b << " = " << a * b << endl;
        return a * b;
    }
    double operator()(int a, double b)
    {
   
        cout << a << " + " << b << " = " << a + b << endl;
        return a + b;
    }
};

int main(void)
{
   
    // 绑定一个普通函数
    function<int(int, int)> f1 = add;
    // 绑定以静态类成员函数
    T1 c;
    function<int(int, int)> f2 = T1::sub;
    function<int(int, int)> f4 = c;//可自主识别对象里的仿函数
    // 绑定一个仿函数
    T2 t;
    function<double(int, double)> f3 = t;//可自主识别对象里的仿函数

    // 函数调用
    f1(9, 3);
    f2(9, 3);
    f4(9, 3);
    f3(9, 3);

    return 0;
}

可自主识别对象里的仿函数，通过测试代码可以得到结论：std::function 可以将可调用对象进行包装，得到一个统一的格式，包装完成得到的对象相当于一个函数指针，和函数指针的使用方式相同，通过包装器对象就可以完成对包装的函数的调用了。

1.2作为回调函数使用

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

class A
{
   
public:
    // 构造函数参数是一个包装器对象
    A(const function<void()>& f) : callback(f)
    {
   
    }

    void notify()
    {
   
        callback(); // 调用通过构造函数得到的函数指针
    }
private:
    function<void()> callback;
};

class B
{
   
public:
    void operator()()
    {
   
        cout << "sssssssssssssssssss!!!" << endl;
    }
};
int main(void)
{
   
    B b;
    A a(b); // 仿函数通过包装器对象进行包装
    a.notify();

    return 0;
}

通过上一个示例得到，A a(b);可自动识别出仿函数并包装作为函数参数，最终输出如下：

通过上面的例子可以看出，使用对象包装器 std::function 可以非常方便的将仿函数转换为一个函数指针，通过进行函数指针的传递，在其他函数的合适的位置就可以调用这个包装好的仿函数了。

另外，使用 std::function 作为函数的传入参数，可以将定义方式不相同的可调用对象进行统一的传递，这样大大增加了程序的灵活性。

2、 绑定器

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

将可调用对象与其参数一起绑定成一个仿函数。
将多元（参数个数为n，n>1）可调用对象转换为一元或者（n-1）元可调用对象，即只绑定部分参数。
绑定器函数使用语法格式如下：

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

示例：

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

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

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

void callFunc(int x, const function<void(int)>& f)
{
   
    if (x % 2 == 0)
    {
   
        f(x);
    }
}

void output(int x)
{
   
    cout << x << " ";
}

void output_add(int x)
{
   
    cout << x + 10 << " ";
}

int main(void)
{
   
    // 使用绑定器绑定可调用对象和参数
    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;

    return 0;
}

再看示例：

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

void output(int x, int y)
{
   
    cout << x << " " << y << endl;
}

int main(void)
{
   
    // 使用绑定器绑定可调用对象和参数, 并调用得到的仿函数
    bind(output, 1, 2)();
    bind(output, placeholders::_1, 2)(10);
    bind(output, 2, placeholders::_1)(10);

    // error, 调用时没有第二个参数
    // bind(output, 2, placeholders::_2)(10);
    // 调用时第一个参数10被吞掉了，没有被使用
    bind(output, 2, placeholders::_2)(10, 20);

    bind(output, placeholders::_1, placeholders::_2)(10, 20);
    bind(output, placeholders::_2, placeholders::_1)(10, 20);


    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Re9MwHCs-1620205717704)(C:\Users\wei\AppData\Roaming\Typora\typora-user-images\image-20210505170312242.png)]

解释：

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

可调用对象包装器 std::function 是不能实现对类成员函数指针或者类成员指针的包装的，但是通过绑定器 std::bind 的配合之后，就可以完美的解决这个问题了，再来看一个例子，然后再解释里边的细节：

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

class Test
{
   
public:
    void output(int x, int y)
    {
   
        cout << "x: " << x << ", y: " << y << endl;
    }
    int m_number = 100;
};

int main(void)
{
   
    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);
    f2() = 2333;
    cout << "t.m_number: " << t.m_number << endl;

    return 0;
}

在用绑定器绑定类成员函数或者成员变量的时候需要将它们所属的实例对象一并传递到绑定器函数内部。f1的类型是function<void(int, int)>，通过使用std::bind将Test的成员函数output的地址和对象t绑定，并转化为一个仿函数并存储到对象f1中。

使用绑定器绑定的类成员变量m_number得到的仿函数被存储到了类型为function<int&(void)>的包装器对象f2中，并且可以在需要的时候修改这个成员。其中int是绑定的类成员的类型，并且允许修改绑定的变量，因此需要指定为变量的引用，由于没有参数因此参数列表指定为void。

示例程序中是使用 function 包装器保存了 bind 返回的仿函数，如果不知道包装器的模板类型如何指定，可以直接使用 auto 进行类型的自动推导，这样使用起来会更容易一些。

参考：C++ prime plus 第六版

爱编程的大丙

转载：https://blog.csdn.net/asdasdde/article/details/116427417