从零开始学C++之STL(九):函数适配器bind2nd 、mem_fun_ref 源码分析、函数适配器应用举例

一、适配器

三种类型的适配器:

容器适配器:用来扩展7种基本容器,利用基本容器扩展形成了栈、队列和优先级队列

迭代器适配器:(反向迭代器、插入迭代器、IO流迭代器)

函数适配器:函数适配器能够将仿函数和另一个仿函数(或某个值、或某个一般函数)结合起来。

针对成员函数的函数适配器 针对一般函数的函数适配器

二、函数适配器示例

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>

using namespace std;

bool is_odd(int n)
{
    return n % 2 == 1;
}

int main(void)
{
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a + 5);

    cout << count_if(v.begin(), v.end(), is_odd) << endl;

    //计算奇数元素的个数
    // 这里的bind2nd将二元函数对象modulus转换为一元函数对象。
    //bind2nd(op, value) (param)相当于op(param, value)
    cout << count_if(v.begin(), v.end(),
                     bind2nd(modulus<int>(), 2)) << endl;


    //bind1st(op, value)(param)相当于op(value, param);
    cout << count_if(v.begin(), v.end(),
                     bind1st(less<int>(), 4)) << endl;

    return 0;
}

这里的bind2nd将二元函数对象modulus转换为一元函数对象。是如何做到的呢?跟踪源码就知道了。

首先,bind2nd 是一个模板函数,如下:

// TEMPLATE FUNCTION bind2nd
template < class _Fn2,
         class _Ty > inline
binder2nd<_Fn2> bind2nd(const _Fn2 &_Func, const _Ty &_Right)
{
    // return a binder2nd functor adapter
    typename _Fn2::second_argument_type _Val(_Right);
    return (std::binder2nd<_Fn2>(_Func, _Val));
}

将匿名对象modulus<int>() 和 2 传递进去,返回值是 std::binder2nd<_Fn2>(_Func, _Val);  即是一个模板类对象,看binder2nd 模板类

// TEMPLATE CLASS binder2nd
template<class _Fn2>
class binder2nd
    : public unary_function < typename _Fn2::first_argument_type,
      typename _Fn2::result_type >
{
    // functor adapter _Func(left, stored)
public:
    typedef unary_function < typename _Fn2::first_argument_type,
            typename _Fn2::result_type > _Base;
    typedef typename _Base::argument_type argument_type;
    typedef typename _Base::result_type result_type;

    binder2nd(const _Fn2 &_Func,
              const typename _Fn2::second_argument_type &_Right)
        : op(_Func), value(_Right)
    {
        // construct from functor and right operand
    }

    result_type operator()(const argument_type &_Left) const
    {
        // apply functor to operands
        return (op(_Left, value));
    }

    result_type operator()(argument_type &_Left) const
    {
        // apply functor to operands
        return (op(_Left, value));
    }

protected:
    _Fn2 op;    // the functor to apply
    typename _Fn2::second_argument_type value;  // the right operand
};

即构造时,binder2nd 的2个成员op 和 value 分别用modulus<int>() 和 2 初始化。接着看count_if 中的主要代码:

for (; _First != _Last; ++_First)

if (_Pred(*_First))

++_Count;

*_First  就是遍历得到的容器元素了,当满足_Pred 条件时_Count++,此时可以看成是:

std::binder2nd< modulus<int> >(modulus<int>(), 2)(*_First)  也就是调用binder2nd 类的operator() 函数,返回 return (op(_Left, value));

也就是modulus<int>()(*_First, 2);  也就是调用modulus 类的operator() 函数,如下:

// TEMPLATE STRUCT modulus
template<class _Ty>
struct modulus
        : public binary_function<_Ty, _Ty, _Ty>
{
    // functor for operator%
    _Ty operator()(const _Ty &_Left, const _Ty &_Right) const
    {
        // apply operator% to operands
        return (_Left % _Right);
    }
};

也就是如果左操作数是偶数则返回0,奇数% 2 == 1, 返回为真。最后总结,也就是count_if 计算容器中为奇数的元素个数,简单地

来说,可以理解成这样:bind2nd(op, value) (param)相当于op(param, value); 其中param 是元素值,value是需要绑定的参数,所谓

bind2nd 也即绑定第二个参数的意思,所以才说 bind2nd将二元函数对象modulus转换为一元函数对象,因为第二个参数就是2,当然

这里的第一个参数就是遍历得到的容器元素值了。

与bind2nd 类似的还有 bind1st,顾名思义是绑定第一个参数的意思,如下的表达式:

count_if(v.begin(), v.end(),  bind1st(less<int>(), 4)) ; 也就是说计算容器中大于4的元素个数。这里绑定的是左操作数。

三、函数适配器应用实例

(一)、针对成员函数的函数适配器

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>

using namespace std;

class Person
{
public:
    Person(const string &name) : name_(name) {}
    void Print() const
    {
        cout << name_ << endl;
    }
    void PrintWithPrefix(string prefix) const
    {
        cout << prefix << name_ << endl;
    }
private:
    string name_;
};

void foo(const vector<Person> &v)
{
    for_each(v.begin(), v.end(), mem_fun_ref(&Person::Print));
    for_each(v.begin(), v.end(), bind2nd(mem_fun_ref(&Person::PrintWithPrefix), "person: "));
}

void foo2(const vector<Person *> &v)
{
    for_each(v.begin(), v.end(), mem_fun(&Person::Print));
    for_each(v.begin(), v.end(), bind2nd(mem_fun(&Person::PrintWithPrefix), "person: "));
}

int main(void)
{
    vector<Person> v;
    v.push_back(Person("tom"));
    v.push_back(Person("jerry"));
    foo(v);

    vector<Person *> v2;
    v2.push_back(new Person("tom"));
    v2.push_back(new Person("jerry"));
    foo2(v2);
    return 0;
}

在foo 函数中,第一行的mem_fun_ref 将空元函数转换为一元函数对象,具体流程大家可以自己跟踪代码,实际上跟上面bind2nd 是类似的,

需要稍微说一下的是传递函数指针的情况:

template < class _Result,
         class _Ty > inline
const_mem_fun_ref_t<_Result, _Ty>
mem_fun_ref(_Result (_Ty::*_Pm)() const)
{
    // return a const_mem_fun_ref_t functor adapter
    return (std::const_mem_fun_ref_t<_Result, _Ty>(_Pm));
}

// TEMPLATE CLASS const_mem_fun_ref_t
template < class _Result,
         class _Ty >
class const_mem_fun_ref_t
    : public unary_function<_Ty, _Result>
{
    // functor adapter (*left.*pfunc)(), const *pfunc
public:
    explicit const_mem_fun_ref_t(_Result (_Ty::*_Pm)() const)
        : _Pmemfun(_Pm)
    {
        // construct from pointer
    }

    _Result operator()(const _Ty &_Left) const
    {
        // call function
        return ((_Left.*_Pmemfun)());
    }

private:
    _Result (_Ty::*_Pmemfun)() const;   // the member function pointer
};

传入的参数是一个函数指针,也就是void (Person::*_Pm) () const , 传递后 _Pm = &Print,在operator() 函数中

return ((_Left.*_Pmemfun)());   _Left 也就是遍历到的Person 类对象,先找到类的函数,然后进行调用。

第二行中mem_fun_ref 接受两个参数,明显是重载的版本,它将一元函数转换为二元函数对象,而bind2nd 再将其转化为一元函数对

象,即绑定了第二个参数为"person: ",跟踪源码可以看见这样的函数调用:

_Result operator()(_Ty &_Left, _Arg _Right) const
{
    // call function with operand
    return ((_Left.*_Pmemfun)(_Right));
}

也就是将第二个参数当作参数传递给PrintWithPrefix,所以打印出来的带有前缀person: 

而mem_fun 就类似了,只不过此次for_each 遍历得到的是对象指针,所以进行函数调用时需要用-> 操作符,如下所示:

_Result operator()(const _Ty *_Pleft) const
{
    // call function
    return ((_Pleft->*_Pmemfun)());
}

_Result operator()(const _Ty *_Pleft, _Arg _Right) const
{
    // call function with operand
    return ((_Pleft->*_Pmemfun)(_Right));
}

(二)、针对一般函数的函数适配器

例程1:

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>

using namespace std;

int main(void)
{
    char *a[] = {"", "BBB", "CCC"};
    vector<char *> v(a, a + 2);
    vector<char *>::iterator it;
    it = find_if(v.begin(), v.end(), bind2nd(ptr_fun(strcmp), ""));
    if (it != v.end())
        cout << *it << endl;

    return 0;
}

ptr_fun 将strcmp 二元函数转换为二元函数对象,bind2nd 再将其转化为一元函数对象,即绑定了第二个参数,因为strcmp 是在比较

不相等的情况返回为真,故find_if 查找的是第一个不等于空串的串位置。

例程2:

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>

using namespace std;

bool check(int elem)
{
    return elem < 3;
}

int main(void)
{
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a + 5);

    vector<int>::iterator it;
    it = find_if(v.begin(), v.end(), not1(ptr_fun(check)));
    if (it != v.end())
        cout << *it << endl;
    return 0;
}

ptr_fun 做了一次转换,not1 再转换一次,故find_if 查找的是第一个大于等于3的元素位置。

这些代码的跟踪就留给大家自己完成了,篇幅所限,不能将所有调用过程都显现出来,学习STL还是得靠大家跟踪源码,才能有更深的体会。

参考:

C++ primer 第四版 Effective C++ 3rd C++编程规范

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏全沾开发(huā)

学习zepto.js(Hello World)

学习zepto.js(Hello World) Zepto是一个轻量级的针对现代高级浏览器的JavaScript库, 它与jquery...

4168
来自专栏java一日一条

UML类图五种关系与代码的对应关系

注意1: Water类的生命期,它是当Animal类的GrounUp方法被调用的时候,才被实例化。

721
来自专栏偏前端工程师的驿站

JS魔法堂:那些困扰你的DOM集合类型

一、前言                                     大家先看看下面的js,猜猜结果会怎样吧!   可选答案:   ①. 获取id属...

1829
来自专栏Java3y

Javascript面向对象入门

什么是JavaScript? 我们可以从几个方面去说JavaScript是什么: 基于对象 javaScript中内置了许多对象供我们使用【String、Dat...

3076
来自专栏企鹅号快讯

《流畅的Python》学习笔记之字典

来源:微信公众号-四月链接: 这一篇是读书笔记。主要介绍:* 常见的字典方法* 如何处理查不到的键* 标准库中 dict 类型的变种* 散列表的工作原理 泛映射...

18710
来自专栏老九学堂

C语言这个基础知识,99%的人都了解不全面

说明:这是学C语言最基本的知识点,简单的使用不难, 但是里面的一些细节和原理就值得我们好好推敲了,想要学好C语言或者编程语言的小伙伴,真的可以好好看看哦~

880
来自专栏Android先生

VLayout适配器的万能封装

传统的RecyclerView高级应用,还是挺麻烦的,阿里开源了Vlayout,采用代理模式独立承担各式各样的布局,大大的减少了程序媛的工作量,...

1144
来自专栏Python

JavaScript基础

一 JavaScript的基础 1.1 JS的引入方式 1 直接编写 <script> alert('hello yuan') ...

2058
来自专栏闻道于事

JavaScript对象之document对象

DOM对象之document对象 DOM对象:当网页被加载时,浏览器会创建页面的文档对象模型(Document Object Model)。 HTML DOM ...

2837
来自专栏分布式系统和大数据处理

.Net中的反射(动态创建类型实例) - Part.4

在前面节中,我们先了解了反射,然后利用反射查看了类型信息,并学习了如何创建自定义特性,并利用反射来遍历它。可以说,前面三节,我们学习的都是反射是什么,在接下来的...

1113

扫码关注云+社区