STL标准库-仿函数与仿函数适配器

技术在于交流、沟通，本文为博主原创文章转载请注明出处并保持作品的完整性

概要:

1.仿函数

2.bind2nd()

3.not1()

4.bind()

---

 

仿函数的实现:声明一个类,重载它的operator call ("()"操作符)

template
class lineFeed
{
public:
    void operator()(const T &x)
    {
        cout<endl;
    }
};

仿函数只为算法服务,但是像上面这种声明方式,虽然在有些时候可以使用,但是却不能融入STL,因为有可能在"仿函数适配器"上出现编译错误,下面我们来看看STL中的仿函数.

仿函数的使用可以看一下我的上一节博客,虽然都没有继承自 binary_function,unary_function...

STL中的仿函数大致可以分为三个类

 1.算数类

  template
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };



  template
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };
  ...

 2.逻辑运算类

  template
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };

  template
    struct logical_not : public unary_function<_Tp, bool>
    {
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };

...

3.相对关系类

  template
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };
...

 

我们会看到所有的STL仿函数都需要继承binary_function(两个参数)或者unary_function(一个参数),只有继承自这两种父类,你声明的仿函数才可以融入STL

上面提及到仿函数适配器, 如果不继承上面这两种类, 在执行到某个阶段会报错.

下面是binary_function<>与unary_function<>的源码

binary_function,发现binary_function<>

  template
    struct binary_function
    {
      /// @c first_argument_type is the type of the first argument
      typedef _Arg1     first_argument_type; 

      /// @c second_argument_type is the type of the second argument
      typedef _Arg2     second_argument_type;

      /// @c result_type is the return type
      typedef _Result     result_type;
    };

 

unary_function

  template
    struct unary_function
    {
      /// @c argument_type is the type of the argument
      typedef _Arg     argument_type;   

      /// @c result_type is the return type
      typedef _Result     result_type;  
    };

那么为什么没有继承自这两个类,会报错呢?我们看上面的源码,他们的内部都有typedef,这几个typedef是为了提取算法传进变量,以供仿函数适配器使用,如果你没有继承这两种类,那么在算法调用仿函数时,仿函数适配器提取不出这几个变量,那么就会报错.

写仿函数,一定要继承上面这两个类.

 

---

 

仿函数适配器

下面介绍几个仿函数用的适配器函数

1.bind2nd().它的作用是绑定仿函数的第二参数

它本身就是一个仿函数的适配器,它的作用是为我简化binder2nd(),因为binder2nd()的参数类型比较复杂,我们在调用的时候回很不方便.

先看一个测试函数

namespace wzj007 {
    void test_Function()
    {
        vector<int> myVector = {10,20,40,70,90,100};
        cout << count_if(myVector.begin(), myVector.end(),bind2nd(less<int>(),40));//返回vector中value小于40的个数
    }
}

现在解释一下bind2nd()函数的作用: 它将40 这个变量绑定在less()函数的第二参数上,less函数返回第一参数是否小于第二参数,那么绑定后的less()函数就应该返回 传入的参数是否小于40

小于40的value有10,20.那么输出的结果应该是2.那么具体是怎么绑定上的呢

我们先看一下less()的源码

template <class T> struct less {
  bool operator() (const T& x, const T& y) const {return x<y;}
  typedef T first_argument_type;
  typedef T second_argument_type;
  typedef bool result_type;
};

 

他也是一个仿函数,但是却发现它没有继承自binary_function,因为他自己声明了那三种typedef,他需要两个两个参数,x和y,返回 x是否小于y.

那么 bind2nd(less(),40) 他的含义就应该是 比较传进参数x,是否小于40(y); 

下面我们来看一下是怎么绑定上的

 这是bind2nd()的源代码

  template
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;//这有一个typedef 它提取出operation的第二参数,同时可以检测第二参数类型
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    } 

 

 这个binder2nd()的源码,binder2nd()是一个仿函数,他的作用是绑定仿函数的的第二参数

template
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
                typename _Operation::result_type>
    {
    protected:
      _Operation op;//取出传进的仿函数
      typename _Operation::second_argument_type value;//取出第二参数,同时可检测第二参数类型

    public:
      binder2nd(const _Operation& __x,
        const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }//构造函数(在bind2nd()函数中调用),初始化自身成员变量 op,value

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }//重载operator() 在函数count_if()中被调用

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 109.  Missing binders for non-const sequence elements
      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }//非const
    } _GLIBCXX_DEPRECATED;

 这是count_if()的源码

template <class Inputerator, class Outputerator, class Predicate>
typename iterator_traits::difference_type;
count_if(Inputerator first, Inputerator last, Predicate pred)
{
    typename iterator_traits::difference_type;
    for( ; first != last; ++first)
        if(pred(*first)) //这个地方会调用函数pred(*first), 重上面我们可以看到 pred绑定的函数是binder2nd()中的 operator()函数,那么此时的pred就应该是less函数
            ++n;
    return n;
}

 

现在band1st()的含义我们应该可以猜到了吧.

---

 

not1()将函数的返回值取否

他也是一种仿函数适配器,简化我们调用unary_negate()

    void test_Function_bind2nd()
    {
        vector<int> myVector = {10,20,40,70,90,100};
        cout << count_if(myVector.begin(), myVector.end(),not1(bind2nd(less<int>(),40)));//
    }

 

调用not1()之前返回的是小于40的value有几个,那么取否后就应该是不小于40的value有几个: 4个(40,70,90,100)

看一下是怎么关联上的

not1()源码

  template
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }//调用unary_negate()的构造函数

 

 

 

 unary_negate()源码

  template
    class unary_negate
    : public unary_functionbool>
    {
    protected:
      _Predicate _M_pred;

    public:
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }//not1()调用构造函数初始化成员变量

      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }//取反 count_if()调用其operator()
    };

 

 

---

 

bind() C++11的绑定函数

这些函数是C++11的一些变更函数,原来的函数仍然可以使用,从上面可以看出 bind2nd改名为bind();

那么bind()具体怎么使用呢

这份代码是我在http://www.cplusplus.com上拷下来的

namespace wzj008 {

    // a function: (also works with function object: std::divides my_divide;)
    double my_divide (double x, double y) {return x/y;}

    struct MyPair {
        double a,b;
        double multiply() {return a*b;}
    };
    void test_Function_bind()
    {
        using namespace std::placeholders;    // 使用placehloders _1(第一参数占位符), _2(第二参数占位符) ,_3(第三参数占位符)...

        // binding functions:
        auto fn_five = std::bind (my_divide,10,2);               // returns 10/2   将10 绑定在my_divide()函数的第一参数上, 2绑定在my_divide()函数的第二参数上 10/2 = 5
        std::cout << fn_five() << '\n';                          // 5

        auto fn_half = std::bind (my_divide,_1,2);               // returns x/2    使用占位符_1 即将my_divide()函数的第一参数绑定为传入参数, 2绑定为my_divide()函数的第二参数
        std::cout << fn_half(10) << '\n';                        // 5 　　　　　　　　10/2 = 5

        auto fn_invert = std::bind (my_divide,_2,_1);            // returns y/x    使用占位符_2 即_2为函数my_divide()的第二参数, _1为my_divide()的第一参数
        std::cout << fn_invert(10,2) << '\n';                    // 0.2　　　　　　　10(_2)为第二参数    2(_1)第一参数    2/10 = 0.2

        auto fn_rounding = std::bind<int> (my_divide,_1,_2);     // returns int(x/y) 将fn_rounding()绑定为my_divide()函数
        std::cout << fn_rounding(10,3) << '\n';                  // 3

        MyPair ten_two {10,2};　　　　　　　　　　　　　　　　　　　　　//绑定成员变量

        // binding members:
        auto bound_member_fn = std::bind (&MyPair::multiply,_1); // returns x.multiply() 
        std::cout << bound_member_fn(ten_two) << '\n';           // 20  将传进参数ten_two{10,2} 的10和2 分别赋给 a和b(a = 10, b = 2)  10 * 2 = 20

        auto bound_member_data = std::bind (&MyPair::a,ten_two); // returns ten_two.a   给a赋值  a = 10;
        std::cout << bound_member_data() << '\n';                // 10
    }
}

参考侯捷<>