C++11 bind和function总结

快来打我* 2022-12-09 02:38 34阅读 0赞

C++11提供了lambda表达式,bind和function,如果想要在程序中使用bind和function需要引入头文件`functional`,下面简要的介绍一下这几个利器.

举个栗子看看他们都是怎么使用的:

#include <iostream>
    #include <functional>
    #include <string>
    using namespace std;
    
    class Base {
        
        public:
            Base() = delete;
            explicit Base(const std::string& name) : m_name(name) {
        }
            void run(std::function<void(int, int)> _fn, int param1, int param2) {
        
                _fn(param1, param2);
            }
        private:
            std::string m_name;
    };
    
    void func_ii(int a, int b) {
        
        cout << a * b << "\t";
    }
    
    int main() {
        
        Base base("base");
        // lambda 使用举例
        for (unsigned int i = 1; i <= 9; i++) {
        
            for (unsigned int j = i; j <= 9; j++) {
        
                base.run([](int a, int b) -> void {
        
                    cout << a * b << "\t";       
                }, i, j);
            }
            cout << endl;
        }
        
        // function 使用举例
        std::function<void(int, int)> fn = func_ii;
        for (unsigned int i = 1; i <= 9; i++) {
        
            for (unsigned int j = i; j <= 9; j++) {
        
                base.run(fn, i, j);
            }
            cout << endl;
        }
    
        // 函数指针 使用举例
        void (*fn_ptr)(int, int) = func_ii;
        for (unsigned int i = 1; i <= 9; i++) {
        
            for (unsigned int j = i; j <= 9; j++) {
        
                // 本质上同 base.run(func_ii, i, j);
                base.run(fn_ptr, i, j);
            }
            cout << endl;
        }
    
        // bind 使用举例
        auto fn_bind = std::bind(func_ii, std::placeholders::_1, 10);
        for (unsigned int i = 1; i <= 9; i++) {
        
            for (unsigned int j = i; j <= 9; j++) {
        
                base.run(fn_bind, i, j);
            }
            cout << endl;
        }
    
        return 0;
    }

如果你能认真的阅读完上面的代码,那么lambda表达式,bind以及function的基本使用方法你应该已经基本掌握了,下面就分别介绍一下lambda表达式,bind以及function.

## 1 lambda表达式 ##

### 1.2 lambda表达式基本使用方法 ###

lambda表达式即匿名函数, 其的语法为(`除了{body}之外{}中的内容为可以不写`):

[ capture-list ] ( params ) {
         mutable }{
         exception }{
         attribute }{
         -> ret } {
         body }

其中:

*  capture-list 是需要捕获的变量列表，用逗号分隔(对于捕获列表的详细介绍见后文).
 *  params 是lambda表达式需要的参数列表，写法和函数参数一样，不过这里不支持默认参数。
 *  ret 指明了lambda表达式的返回值。通过return语句，如果编译器能够推断出返回值的类型。或者表达式没有返回值，“-> ret”可以省略。
 *  body 函数体。
 *  mutable 当捕获列表是以复制的形式捕获时，默认这些复制的值是const的，除非指定了mutable。
 *  exception 提供了异常的说明。
 *  attribute 对于attribute的描述可以参见这里：http://en.cppreference.com/w/cpp/language/attributes，这里不多说明。

### 1.1 捕获列表 ###

捕获列表的概念比较抽象,看下面的解释:

捕获值列表，是允许我们在Lambda表达式的函数体中直接使用这些值，**捕获值列表能捕获的值是所有在此作用域可以访问的值**，包括这个作用域里面的临时变量，类的可访问成员，全局变量。捕获值的方式分两种，一种是按值捕获，一种是按引用捕获。顾名思义，按值捕获是不改变原有变量的值，按引用捕获是可以在Lambda表达式中改变原有变量的值。

*  \[\] 不捕获任何变量
 *  \[&\] 以引用的方式捕获所有变量
 *  \[=\] 以复制的方式捕获所有变量
 *  \[=, &foo\] 以引用的方式捕获foo变量，但是以复制的方式捕获其他变量
 *  \[bar\] 以复制的方式捕获bar变量，不再捕获任何其他变量
 *  \[this\] 捕获this指针

## 2 function ##

类模板 std::function 是通用多态函数封装器。 std::function 的实例能存储、复制及调用任何可回调目标——函数、lambda表达式、bind表达式、其他函数对象，还可以指向成员函数指针和指向数据成员指针。std::function特别适合作为回调函数使用,可以取代函数指针的作用，它比普通函数指针更加的灵活和便利。

借用下面的代码,感受一下其使用方式:

#include <functional>
    #include <iostream>
     
    struct Foo {
        
        Foo(int num) : num_(num) {
        }
        void print_add(int i) const {
         std::cout << num_+i << '\n'; }
        int num_;
    };
     
    void print_num(int i)
    {
        
        std::cout << i << '\n';
    }
     
    struct PrintNum {
        
        void operator()(int i) const
        {
        
            std::cout << i << '\n';
        }
    };
     
    int main()
    {
        
        // 存储自由函数
        std::function<void(int)> f_display = print_num;
        f_display(-9);      // -9
     
        // 存储 lambda
        std::function<void()> f_display_42 = []() {
         print_num(42); };
        f_display_42();     // 42
     
        // 存储到 std::bind 调用的结果
        std::function<void()> f_display_31337 = std::bind(print_num, 31337);
        f_display_31337();  // 31337
     
        // 存储到成员函数的调用
        std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
        const Foo foo(314159);
        f_add_display(foo, 1);      // 314160
        f_add_display(314159, 1);   // 314160
     
        // 存储到数据成员访问器的调用
        std::function<int(Foo const&)> f_num = &Foo::num_;
        std::cout << "num_: " << f_num(foo) << '\n';    // 314159
     
        // 存储到成员函数及对象的调用
        using std::placeholders::_1;
        std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
        f_add_display2(2);      // 314161
     
        // 存储到成员函数和对象指针的调用
        std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
        f_add_display3(3);      // 314162
     
        // 存储到函数对象的调用
        std::function<void(int)> f_display_obj = PrintNum();
        f_display_obj(18);      // 18
    }

## 3 bind ##

一言以蔽之:bind就相当于对原来的函数进行封装,可以将原函数的部分参数的值确定下来,使用std::placeholders::\_x作为占位符,在bind函数中只有有占位符的参数才是其封装之后的新的参数列表.

bind本质上是一个函数模板,其定义为:

template<typename _Func, typename... _BoundArgs>
    inline typename
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    
    template<typename _Result, typename _Func, typename... _BoundArgs>
    inline
    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)

参数 f 表示可调用对象（函数对象、指向函数指针、函数的引用、指向成员函数指针或指向数据成员指针）

参数 \_\_args 表示要绑定的参数列表。未绑定参数使用命名空间 std::placeholders 的占位符 \_1, \_2, \_3… 所替换

### 3.1 几个注意事项 ###

*  调用指向非静态成员函数指针或指向非静态数据成员指针时,首参必须是引用或者指针(可以包含智能指针),指向将访问其成员的对象;
 *  允许同一个bind表达式中有多个相同的占位符(如多个\_1)

### 3.2 bind绑定成员函数 ###

bind绑定普通函数是一件很正常的事情,那么如何绑定成员函数呢?毕竟普通的成员函数是有一个隐藏的this指针作为其真正意义上的第一个参数的~用法如下:

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
    }

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

### 3.3 bind应用举例 ###

bind在普通函数/成员函数上的用法如下:

#include <iostream>
    #include <functional>
    
    void add(int n1, int n2, int n3) {
        
    	std::cout << 100 * n1 + 10 * n2 + n3 << std::endl;
    }
    
    struct Foo {
        
    	void sum(int n1, int n2) {
        
    		std::cout << n1 + n2 << std::endl;
    	}
    	int data = 10;
    };
    
    int main() {
        
    	using namespace std::placeholders;
    
    	auto f1 = std::bind(add, _1, _2, _3);
    	f1(1, 2, 3); // 123
    
    	auto f2 = std::bind(add, 1, _1, _2);
    	f2(4, 5); // 145
    
    	auto f3 = std::bind(add, _1, 9, 8);
    	f3(2); // 298
    
    	Foo foo;
    	// 实验结果证明:std::bind(&Foo::sum, foo, 19, _1);结果相同
    	auto f4 = std::bind(&Foo::sum, &foo, 19, _1);
    	f4(100); // 119
    	return 0;
    }

## 4 活学活用 ##

之前在面试中被问到一个有意思的问题:我们常常需要在程序中，调用一些用户传过来的回调函数。而在回调函数中，用户常常会需要记录一些状态，于是常常希望通过一个对象的成员函数传给过来作为回调函数。那么如何获得类成员函数的地址&或者说如何将**类的成员函数作为回调函数的参数**?

众所周知:类的非static成员函数的参数列表的第一个参数是隐藏的this指针,那么到底应该怎么做呢?这里就需要借助bind解决这个问题了,如下面的代码所示:

#include <iostream>
    #include <functional>
    #include <string>
    using namespace std;
    
    class Base {
        
        public:
            Base() = delete;
            explicit Base(const std::string& name) : m_name(name) {
        }
            void printName() {
        
                cout << this->m_name << endl;
            }
        private:
            std::string m_name;
    };
    
    void usingCallback(function<void ()> fn) {
        
        fn();
    }
    
    int main() {
        
        Base base("base");
        // bind函数中的第二个参数base必不可少
        std::function<void ()> fn_print = std::bind(&Base::printName, base);
        usingCallback(fn_print);
        return 0;
    }

不过,虽然上面的方法可以完成回调函数的任务,但是我们仍然没有获得成员函数的地址呀?在学习的过程中,我发现一个神奇的玩意:**指向成员函数的指针**!看下面的代码见识一下\[3\]:

#include <iostream>
    struct Foo {
        
        int value;
        void f() {
         std::cout << "f(" << this->value << ")\n"; }
        void g() {
         std::cout << "g(" << this->value << ")\n"; }
    };
    void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) {
        
        (foo1->*fun)();  // call fun on the object foo1
        (foo2->*fun)();  // call fun on the object foo2
    }
    int main() {
        
        Foo foo1{
        1};
        Foo foo2{
        2};
        apply(&foo1, &foo2, &Foo::f);
        apply(&foo1, &foo2, &Foo::g);
    }

*  成员函数指针的定义：void (Foo::\*fun)()，调用是传递的实参: &Foo::f；
 *  fun为类成员函数指针，所以调用是要通过解引用的方式获取成员函数\*fun,即(foo1->\*fun)();

参考资料

*  [\[1\] C++11中lambda、std::function和std:bind详解][1_ C_11_lambda_std_function_std_bind]
 *  [\[2\] c++ function和bind][2_ c_ function_bind]
 *  [\[3\] C++11 中的std::function和std::bind][3_ C_11 _std_function_std_bind]

[1_ C_11_lambda_std_function_std_bind]: https://www.jb51.net/article/104376.htm
[2_ c_ function_bind]: https://www.cnblogs.com/zuofaqi/p/10215198.html
[3_ C_11 _std_function_std_bind]: https://www.jianshu.com/p/f191e88dcc80