C++ std::bind函数适配器

矫情吗；* 2023-07-18 12:44 101阅读 0赞

# 0.初识 #

C++11 提供了一个名为std::bind的函数模板，可用于生成可调用对象的转发调用包装器，相当于是个通用函数适配器（旧版本的bind1st/bind2nd已被弃用），可以适配任意的可调用对象，包括函数指针、函数引用、成员函数指针和函数对象。它接受一个可调用对象，生成一个新的可调用对象来适配原来的参数列表。

bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。bind绑定完成后，返回一个函数对象，它内部保存了原可调用对象的拷贝，具有operator()，返回值类型被自动推导为原可调用对象的返回值类型。调用时，这个函数对象将把之前存储的参数转发给原可调用对象完成调用。

# 1.绑定普通函数 #

一般形式如下：

auto newCallable = std::bind(callable, arg_list);

第一个参数为要绑定的可调用对象，后跟参数列表（参数列表同可调用对象的参数列表匹配）。参数列表中可包含名字形如  \_n （n为整数）的占位符，n表示生成的可调用对象中参数的位置。占位符位于std::placeholders命名空间。

#include <iostream>
    #include <functional>
    
    //相加
    int add(int a, int b)
    {
    	std::cout << "a:" << a << "\tb:" << b << std::endl;
    	return a + b;
    }
    
    void test_bind()
    {
    	//第一个参数是函数名，普通函数做实参时，会隐式转换成函数指针,相当于&add
    	//std::placeholders::_1占位符相当于保留了第一个参数
    	auto func_add_10 = std::bind(add, std::placeholders::_1, 10);
    	int result = func_add_10(100); //等于100+10
    	std::cout << "func_add_10(100):" << result << std::endl;
    
    	//对参数重排序
    	using namespace std::placeholders;
    	auto func_add = std::bind(add, _2, _1); //参数位置对换了
    	result = func_add(100, 10);
    	std::cout << "func_add(100,10):" << result << std::endl;
    }

输出：

![20200327125145263.png][]

# 2.绑定引用参数 #

bind会拷贝其参数，如果我们传递给bind一个对象而又不拷贝他，就必须使用标准库的red函数。ref函数返回一个对象，包含给定的引用，此对象是可以拷贝的。标准库中还有一个cref函数，返回一个保存const引用的对象。

#include <iostream>
    #include <functional>
    #include <vector>
    #include <algorithm>
    #include <sstream>
    using namespace std::placeholders;
    using namespace std;
    
    ostream& print(ostream& os, const string& s, char c)
    {
        os << s << c;
        return os;
    }
    
    int main()
    {
        vector<string> words{ "helo", "world", "this", "is", "C++11" };
        ostringstream os;
        char c = ' ';
        for_each(words.begin(), words.end(),
            [&os, c](const string& s) {os << s << c; });
        cout << os.str() << endl;
    
        ostringstream os1;
        // ostream不能拷贝，若希望传递给bind一个对象，
        // 而不拷贝它，就必须使用标准库提供的ref函数
        for_each(words.begin(), words.end(),
            bind(print, ref(os1), _1, c));
        cout << os1.str() << endl;
    
        system("pause");
        return 0;
    }

# 3.绑定类成员函数 #

bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址。

struct Foo {
        void print_sum(int n1, int n2)
        {
            std::cout << n1+n2 << '\n';
        }
        int data = 10;
    };
    int main() 
    {
        Foo foo;
        auto f = std::bind(&Foo::print_sum, &foo, 95, std::placeholders::_1);
        f(5); // 100
    }

注意：必须显示的指定&Foo::print\_sum，因为编译器不会将对象的成员函数隐式转换成函数指针，所以必须在Foo::print\_sum前添加&取地址符；使用对象成员函数的指针时，必须要知道该指针属于哪个对象，因此第二个参数为对象的地址 &foo；

# 4.其他示例 #

示例来自在线手册：

#include <random>
    #include <iostream>
    #include <memory>
    #include <functional>
    
    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;
    }
    
    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...
    
        // 演示参数重排序和按引用传递
        int n = 7;
        // （ _1 与 _2 来自 std::placeholders ，并表示将来会传递给 f1 的参数）
        auto f1 = std::bind(f, _2, 42, _1, std::cref(n), n);
        n = 10;
        f1(1, 2, 1001); // 1 为 _1 所绑定， 2 为 _2 所绑定，不使用 1001
                        // 进行到 f(2, 42, 1, n, 7) 的调用
    
        // 嵌套 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); 的调用
    
        // 常见使用情况：以分布绑定 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';
    
        // 绑定指向成员函数指针
        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';
    
        system("pause");
        return 0;
    }

输出：

![20200327132612796.png][]

# 5.参考 #

参考书籍：《C++ Primer》中文第五版

参考文档：[https://zh.cppreference.com/w/cpp/utility/functional/bind][https_zh.cppreference.com_w_cpp_utility_functional_bind]

参考博客：[https://www.jianshu.com/p/f191e88dcc80][https_www.jianshu.com_p_f191e88dcc80]

参考博客：[https://www.cnblogs.com/sick-vld/p/10769187.html][https_www.cnblogs.com_sick-vld_p_10769187.html]

[20200327125145263.png]: /images/20230528/dad163f2ed364a0f8b521f346df8ced8.png
[20200327132612796.png]: /images/20230528/7dd7e466b1874f1397fa3c20727e9e92.png
[https_zh.cppreference.com_w_cpp_utility_functional_bind]: https://zh.cppreference.com/w/cpp/utility/functional/bind
[https_www.jianshu.com_p_f191e88dcc80]: https://www.jianshu.com/p/f191e88dcc80
[https_www.cnblogs.com_sick-vld_p_10769187.html]: https://www.cnblogs.com/sick-vld/p/10769187.html