C/C++编程：std::bind参数绑定

冷不防 2022-11-12 04:23 214阅读 0赞

# 为什么需要参数绑定 #

引入lambda表达式的原因：

*  像算法传递谓词时，由于一般的函数无法传递参数以外的信息，函数对象又比较麻烦，所以引入了lambda表达式

但是lambda表达式也有缺点：

*  在类似功能多次使用的时候，每次定义lambda表达式也会比较麻烦

因此，C++11标准库又引入了新特性：**参数绑定bind**

# 怎么用 #

继续用lambda表达式中用过的例子，如果希望找到第一个长度小于2的string，可以使用以下代码：

bool istarget(const string& s){
        
        return s.size() < 2;
    }
    vector<string> v{
        "This","is", "a", "predicate", "."};
    auto found = find_if(v.begin(), v.end(), istarget);
    cout << *found << endl;

如果我们希望在istarget中选择string时使用变量而不是固定的2的时候，一般的函数就不能满足需求了（虽然使用全局变量算是一个选项）。除了和函数对象和lambda表达式以外，还可以使用标准库bind函数来实现，其步骤如下：

## 根据需求定义比较函数 ##

在本例中，就是定义一个接受选择对象string对象和最小长度参数的istarget函数:

bool istarget(const string& s, int sz){
        
        return s.size() < sz;
    }

## 使用参数绑定新的可调用对象 ##

C++11标准库提供了一个bind函数，按照C++11 Primer的说法，可以将`bind`函数看着一个通用的**函数适配器**，它接受一个新的可调用对象来“适应”原对象的参数列表。调用bind的一半形式为：

auto newCallable = bind(callable, arg_list);

也就是说：

auto isTarget = bind(istarget, std::placeholders::_1, 2);

## 使用定义的可调用对象 ##

auto found = find_if(v.begin(), v.end(), isTarget);
        cout << *found << endl;

istarget函数定义一次之后，可以使用bind函数适应各种算法的要求，从而实现了实现一次定义，多次使用的目标

如此，**可调用对象**就算凑齐了：函数，函数对象，lambada表达式，参数绑定。

接下来我们看看标准库中怎么说。

# std::bind #

头文件：

#include <functional>

![在这里插入图片描述][20210415173016450.png]

函数模板bind生成f的**转发调用包装器**。调用此包装器等价于绑定到 args 的参数调用 f

参数：

*  f - 可调用 (Callable) 对象（函数对象、指向函数指针、到函数引用、指向成员函数指针或指向数据成员指针）
 *  args - 要绑定的参数列表，未绑定参数为命名空间 std::placeholders 的占位符 \_1, \_2, \_3… 所替换

返回值：

*  未指定类型 T 的函数对象，满足 std::is\_bind\_expression`<`T>::value == true

异常：

# 示例 #

#include <random>
    #include <iostream>
    #include <memory>
    #include <functional>
    
    using namespace std;
    
    void f(int n1, int n2, int n3, const int& n4, int n5)
    {
        
        std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
    }
    int main() {
        
        // 演示参数重排序和按引用传递
        int n = 7;
        // （  来自 std::placeholders::_1 与std::placeholders::_2 表示将来会传递给 f1 的参数）
        auto f1 = std::bind(f, std::placeholders::_2, 42, std::placeholders::_1, std::cref(n), n);
        n = 10;
        f1(1, 2, 1001); // 1 为 _1 所绑定， 2 为 _2 所绑定，不使用 1001
        // 进行到 f(2, 42, 1, n, 7) 的调用
        
        return 0;
    }

![在这里插入图片描述][20210415173832791.png]

#include <random>
    #include <iostream>
    #include <memory>
    #include <functional>
    
    using namespace std;
    
    void f(int n1, int n2, int n3, const int& n4, int n5)
    {
        
        std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
    }
    
    int g(int n1)
    {
        
        return n1;
    }
    int main() {
        
        using namespace std::placeholders;  // 对于 _1, _2, _3...
    
        // 嵌套 bind 子表达式共享占位符
        auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
        f2(10, 11, 12); // 进行到 f(12, g(12), 12, 4, 5); 的调用
    
        return 0;
    }

![在这里插入图片描述][20210415173955634.png]

#include <random>
    #include <iostream>
    #include <memory>
    #include <functional>
    
    using namespace std;
    
    int main() {
        
        // 常见使用情况：以分布绑定 RNG
        std::default_random_engine e;
        std::uniform_int_distribution<> d(0, 10);
        std::function<int()> rnd = std::bind(d, e); // e 的一个副本存储于 rnd
        for(int n=0; n<10; ++n)
            std::cout << rnd() << ' ';
        std::cout << '\n';
    
        return 0;
    }

第1、2、3… 调用都是相同的  
![在这里插入图片描述][20210415174112464.png]

#include <random>
    #include <iostream>
    #include <memory>
    #include <functional>
    
    using namespace std;
    struct Foo {
        
        void print_sum(int n1, int n2)
        {
        
            std::cout << n1+n2 << '\n';
        }
        int data = 10;
    };
    int main() {
        
        using namespace std::placeholders;  // 对于 _1, _2, _3...
        // 绑定指向成员函数指针
        Foo foo;
        auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
        f3(5);
    
        // 绑定指向数据成员指针
        auto f4 = std::bind(&Foo::data, _1);
        std::cout << f4(foo) << '\n';
    
        // 智能指针亦能用于调用被引用对象的成员
        std::cout << f4(std::make_shared<Foo>(foo)) << '\n';
                 // << f4(std::make_unique<Foo>(foo)) << '\n';
        return 0;
    }

![在这里插入图片描述][20210415174433202.png]

[20210415173016450.png]: /images/20221022/42bd076615704124877954e7ce029d9f.png
[20210415173832791.png]: /images/20221022/fe0877f5e67c41eda6efccccaec2b9b7.png
[20210415173955634.png]: /images/20221022/3750909b68234ad8b5c4782a1f72ac35.png
[20210415174112464.png]: /images/20221022/1e20d99dfcdd40d293de3a7f364baef9.png
[20210415174433202.png]: /images/20221022/01fcbff95f074f31bb1c49804208ed93.png