C++STL之函数对象及谓词

概述

函数对象是重载()运算符的类类型对象，即该类实现operator()()函数。STL将一组标准的函数对象定义为模板，，可以使用它们来创建一个函数对象，其中overload()运算符函数使用我们的对象类型。如：STL定义模板less<T>。如果将该模板实例化为less<myNumber>，我们就有了一个函数对象类型，实现operator()()来对myNumber类型的对象进行大小比较。

很多算法使用函数对象来指定要进行的二元运算，或者指定谓词来确定进行特定运算。谓词是一个返回bool类型的值的函数，因为函数对象是一种类型的对象，实现operator()()成员函数并返回bool类型的值，所以函数对象也是谓词。

谓词有两个版本，分别是需要两个操作数的二元谓词和需要一个操作数的一元谓词。后文将会看到具体的应用。

应用

list中的remove_if()函数基于应用一元谓词的结果来删除列表中的元素，它返回一个bool型的值true或false。如果向一个元素应用谓词的值为true，就会从列表中删除该元素。通常我们会自己来定义自己的谓词做我们想做的事情。这就需要为函数对象定义想采用的自己的类模板，STL定义用在这种上下文中的unary_function(T,R)基础模板，定义如下：

template < class _Arg, class _Result > 
struct unary_function
{
    // base class for unary function
    typedef _Arg argument_type;
    typedef _Result result_type;
};

用个具体的实例来展示用法。

//functionObject.h
#pragma once
#include <functional>

template <class T> class is_negative: public std::unary_function<T, bool>
{
public:
    result_type operator()(T& value)
    {
        return value < 0;
    }
};

template < class T> 
class is_large: public std::unary_function<T,bool>
{
public:
    result_type operator()(T &value)
    {
        //return value > 10;
        if (value > 10)
        {
            return true;
        }
        else
            return false;
    }
};

template < class T> 
class is_odd : public std::unary_function<T,bool>
{
public:
    result_type operator()(argument_type &value)
    {
        if ((value % 2) == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
};

#include <iostream>
#include <list>
#include "function_object.h"
#include <functional>

using std::cin;
using std::cout;
using std::endl;
using std::list;
using std::greater;

// Template function to list the contents of a list
template <class T>
void listlist(list<T>& data)
{
    for(list<T>::iterator iter = data.begin() ; iter != data.end() ; iter++)
        cout << *iter << "  ";
    cout << endl;
}

// Template function to read data from cin and store it in a list
template<class T>
void loadlist(list<T>& data)
{
    T value = T();
    while(cin >> value , value != T())  //Read non-zero values
        data.push_back(value);
}

int main()
{
    // Process integers
    list<int> numbers;
    cout << "Enter non-zero integers separated by spaces. Enter 0 to end." 
        << endl;
    loadlist(numbers);
    cout << "The list contains:" << endl;
    listlist(numbers);

    numbers.remove_if(is_odd<int>());
    cout << "After applying the remove_if(is_odd()) function the list contains:" 
        << endl;
    listlist(numbers);

    numbers.remove_if(is_negative<int>()); 
    cout << "After applying the remove_if() function the list contains:" 
        << endl;
    listlist(numbers);

    // Process floating-point values
    list<double> values;
    cout << endl 
        << "Enter non-zero values separated by spaces. Enter 0 to end." 
        << endl;
    loadlist(values);
    cout << "The list contains:" << endl;
    listlist(values);
    
    values.remove_if(is_negative<double>());        
    cout << "After applying the remove_if() function the list contains:" << endl;
    listlist(values);

    // Another list to use in merge
    list<double> morevalues;
    cout << endl 
        << "Enter non-zero values separated by spaces. Enter 0 to end." 
        << endl;
    loadlist(morevalues);
    cout << "The list contains:" << endl;
    listlist(morevalues);
    values.remove_if(is_negative<double>());        
    cout << "After applying the remove_if() function the list contains:" << endl;
    listlist(morevalues);

    // Merge the last two lists
    values.sort(greater<double>());
    morevalues.sort(greater<double>());
    values.merge(morevalues, greater<double>());
    listlist(values);

    return 0;
}

Functional头文件定义了一个可扩展的模板集合，用来创建可用于算法和容器的函数对象。常见的有：

全部用于创建二元谓词

函数模板对象	说明
less<T>	表示T类型的<运算。如less<string>()定义一个比较string类型的函数对象。
less_equal<T>	同上，表示<=运算。
equal<T>	同上，表示=运算。
not_equal<T>	同上，表示！=运算。
greater_equal<T>	同上，表示>=运算。
greater<T>	同上，表示>运算。
not2<B>	它是B类型的二元谓词的负值。

 

二元谓词的创建基本同一元谓词，但是用不同的模板而已。

template<class _Arg1,
class _Arg2,
class _Result>
struct binary_function
{    // base class for binary functions
    typedef _Arg1 first_argument_type;
    typedef _Arg2 second_argument_type;
    typedef _Result result_type;
};

例如：

class personValue:binary_function<Person, Person,bool>
{
    result_type operator()(const first_argument_type &p1,
                           const second_argument_type &p2) const
    {
        return p1 > p2;

    }
};

实际运用：

主要应用于优先级队列，简单介绍优先级队列。默认情况下，优先级队列适配器类使用的基础容器为vector<T>。可以选择不同的序列容器作为基础，并选择一个备用的函数对象确定元素的优先级。如：

priority_queue<int,vector<int>,greater<int> > numbers;

这条语句基于vector<int>容器定义优先级队列，用greater<int>类型的函数对象插入元素。这个优先级队列中的元素将以降序排列，顶部为最小的元素。3 个模板形参是元素类型、要作为基础的容器、要用来排列元素顺序的谓词类型。

如想想应用默认的谓词（在这种情况下将是less<T>），则可以省略第三个参数。否则必须显示地定义。

实例：

include <iostream>
#include <vector>
#include <queue>
#include <functional>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::priority_queue;
using std::greater;
using std::binary_function;
class com:binary_function<int,int,bool>
{
public:
    result_type operator()(first_argument_type &p1,
         second_argument_type &p2) const
    {
        return p1>p2;
    }
};
//class com
//{
//public:
//    bool operator()(int &p1,int &p2)const
//    {
//        return p1<p2;
//    }
//};
int main()
{
    priority_queue<int,vector<int>,com > numbers;
    int num;
    cout<<"input numbers 0 to end"<<endl;
    while(1)
    {
        cin>>num;
        if (0 == num)
        {
            break;
        }
        numbers.push(num);
    }
    cout << endl << "There are " << numbers.size()
        << " numbers in the queue." 
        << endl << endl;
    while(!(numbers.empty()))
    {
        cout<<numbers.top()<<"  ";
        numbers.pop();
    }
    return 0;
}

我们将第三个参数的模板类型改成了我们自己的函数对象。可以通过继承binary_function()或者自己定义（如注释部分），效果是同样的。