STL源码剖析（4）：六大部件之仿函数functional

仿函数作为六大部件中的最简单的，应该是最好理解的啦

导入头文件

#include <functional>

函数对象

• 重载函数调用操作符的类，其对象常称为函数对象；
• 函数对象使用重载的()类时，行为类似函数调用，也叫仿函数；

特点：

• 函数对象在使用的时，可以像普通函数那样调用，可以有返回值；
• 函数对象超出普通函数的概念，函数对象可以有自己的状态；
• 函数对象可以作为参数传递；

// 函数对象在使用的时，可以像普通函数那样调用，可以有返回值；
class MyAdd
{
public:
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }
}
void test()
{
    cout << MyAdd myadd(10,23) << endl;
}
// 函数对象超出普通函数的概念，函数对象可以有自己的状态；
class MyAdd
{
public:
    MyAdd()
    {
        this->count  = 0;
    }
    int operator()(int v1, int v2)
    {
        // return v1 + v2;
        this->count++;
    }
    int count;      // 内部自己的状态
}
// 函数对象可以作为参数传递；
void doprint(MyPrint&m)
{
    
}

谓词

• 返回bool类型的仿函数被称为谓词
• 如果operator()接受的是一个参数，那么叫做一元谓词
• 如果operator()接受的是二个参数，那么叫做二元谓词

表现形式分类

// 普通函数形式
    bool myfunc(const int x, const int y) {
        return x < y;        
    } 
    // 类对象格式
    class cls {
        public:
            bool operator()(const int x, const int y) {
                return x < y;
            }
    };
    // 对于某些算法可以使用默认仿函数
    
    // 使用内建函数对象:关系，逻辑，算术
    /* 单参数继承自unary_function;
    *   双参数继承自binary_function;
    */
    #include <functional>
    sort(v.begin(), v.end(), std::less<int>());

内建函数对象

分类：算术仿函数，关系仿函数，逻辑仿函数

用法：

这些仿函数所产生的对象，用法和一般函数完全相同
算术仿函数

// 其中negate为一元，其他为二元
加：template<class T> T plus<T>;
减：template<class T> T minus<T>;
乘：template<class T> T multiplies<T>;
除：template<class T> T divides<T>;
模取：template<class T> T modulus<T>;
取反：template<class T> T negate<T>;
// the example:negate
void test()
{
    negate<int>n;
    n(50);
}
// the second example
void test()
{
    plus<int>p;       // 默认调用的是两个相同类型的数据
    p(20, 30)
}

关系仿函数

等于：template<class T> T equal_to<T>
不等于：template<class T> T not_equal_to<T>
大于：template<class T> T greater<T>
大于等于：template<class T> T greater_equal<T>
小于：template<class T> T less<T>
小于等于：template<class T> T less_equal<T>    // less_equal<int>()

逻辑仿函数

与：template<class T> bool logical_and<T>
或：template<class T> bool logical_or<T>
否：template<class T> bool logical_no<T>

最后写一个关于仿函数的应用吧

#include <functional>
#include <vector>
#include <algorithm>
int main(void) {
  std::vector<int> v;
  v.push_back(2);
  v.push_back(5);
  v.push_back(1);
  sort(v.begin(), v.end());

// 正常情况下sort算法可以不要第三参数
/*
  template<typename _RAIter>
    inline void
    sort(_RAIter __begin, _RAIter __end,
   __gnu_parallel::sequential_tag)
    { _GLIBCXX_STD_A::sort(__begin, __end); }
*/
// 但是在此我们用第三参数comp
/*
  template<typename _RAIter, typename _Compare>
    inline void
    sort(_RAIter __begin, _RAIter __end, _Compare __comp,
   __gnu_parallel::sequential_tag)
    { _GLIBCXX_STD_A::sort<_RAIter, _Compare>(__begin, __end,
                   __comp); }
*/
  std::sort(v.begin(), v.end(), std::less<int>());
  return 0;
}
  // 也可以这么用
  // 看一个关系运算符
  equal_to<int> q;
  std::cout << q(2, 4) << std::endl;