C++学习之路： 函数适配器

引言：

函数适配器也是种模板技术， 通过绑定把函数绑定到适配器上实现函数调用， 并且可以修改参数，和移动参数的位置。功能强大

在这里简单介绍一下这种强大的工具

 

1. 对于普通函数， 直接把它的类型 <返回值 （参数1， 参数2，.......）> 如此填入 适配器当做函数类型即可

　　function<返回值 （参数1， 参数2，.......）>  pf = &func ;

　　这样定义， pf就变成了func函数， 可以通过下例一样调用。

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

void foo(const string &s)
{
    cout << s << endl;
}


int main(int argc, const char *argv[])
{
    void (*pFunc) (const string &) = &foo;
    pFunc("bar");

    function<void (const string&)> f = &foo;
    f("bar");
    

    return 0;
}

 

2) 双参数普通函数的例子

与上例没什么不同， 不过多了个参数。

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

void foo(int i, double d)
{
    cout << i << d << endl;
}


int main(int argc, const char *argv[])
{
    function<void (int, double)> f = &foo;
    f(12, 4.5);
    

    return 0;
}

 

3. 对于类内部的成员函数， 如果没有实例我们就无法访问其成员函数 所以我们必须采用一种强大的工具----》 bind

这里介绍下bind 的接口，   这个bind 不是linux下 绑定套接字的那个bind， 不要混淆， bind返回值是一个函数适配器，  参数bind（参数1：要绑定的函数， 参数2：第一个参数要适配的位置或者要填充的常量， 参数3：第2个参数要适配的位置或者要填充的常量， 第3个参数要适配的位置或者要填充的常量）

 

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

class Foo
{
    public:
        void foo(int i) { cout << i << endl; }        

        static void bar(double d) { cout << d << endl; }

};

int main(int argc, const char *argv[])
{
    //mem_fun void (*)(Foo *, int)
    Foo f;
    (mem_fun(&Foo::foo))(&f, 123); 

    function<void (int)> pf = bind(&Foo::foo, 
                                   &f, 
                                   std::placeholders::_1);
    pf(345);

    function<void (Foo*, int)> pf2 = bind(&Foo::foo,
                                          std::placeholders::_1,
                                          std::placeholders::_2);

    pf2(&f, 456);

    function<void (int, Foo*)> pf3 = bind(&Foo::foo,
                    std::placeholders::_2,
                    std::placeholders::_1);

    pf3(567, &f);



    return 0;
}

4.对于非类的成员函数同样也可以使用bind来绑定 来达到缺省 参数， 参数调换位置的目的

 

我们可以通过几个小练习来熟悉一下bind的接口。

#include <iostream>
#include <string>
#include <vector>
#include <functional>
using namespace std;
using namespace std::placeholders;

void test(int i, double d, const string &s)
{
    cout << "i = " << i << " d = " << d << " s = " << s << endl;
}
int main(int argc, const char *argv[])
{
    function<void (int, double, const string&)> f1 = &test;
    f1(12, 3.14, "foo");

    //1.void (*)(int, double)
    function<void (int, double)> f2 = 
            std::bind(&test,
                      _1,
                      _2,
                      "foo");

    //2.void (*)(double, int, const string &)
    function<void (double, int, const string &)> f3 = 
        std::bind(&test,
                  _2,
                  _1,
                  _3);

    //3.void (*)(const string &, int)
    function<void (const string &, int)> f4 = 
        std::bind(&test,
                  _2,
                  3.4,
                  _1);


    //4. void (*) (const string &, int, double)
    function<void (const string&, int, double)> f5
        = std::bind(&test,
                    _2,
                    _3,
                    _1);
    
    //5. void (*)(int)
    function<void (int)> f6 = 
        bind(&test,
             _1,
             3.4,
             "bar");

    //6 void(*)(const string &)
    function<void (const string &)> f7 =
        bind(&test,
             12,
             4.5,
             _1);

    //7. void (*)()
    function<void()> f8 = 
        bind(&test,
             12,
             4.5,
             "bar");
}

 

 

通过以上7个小练习，相信对于简单的函数适配器已经可以应付了。

 

完毕