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

转载 2014年07月21日 16:35:05

源地址:http://www.cnblogs.com/L-hq815/archive/2012/08/23/2652269.html

概述

函数对象是重载()运算符的类类型对象,即该类实现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()或者自己定义(如注释部分),效果是同样的。


函数对象 谓词

转自http://blog.sina.com.cn/s/blog_6a8b07370100kuvg.html 在C++中,在应用程序运行阶段存在的所有实体都是对象,因此struct和...
  • dove1984
  • dove1984
  • 2012年08月27日 12:22
  • 1822

C++函数对象-谓词

函数对象(也叫functor),听起来或许有点陌生,但他们是c++实体,即使你没有用过,也一定见过,只是你没有意识到而已。从概念上讲,函数对象时用作函数的对象;但是从实现上来说,函数对象时实现了 op...
  • q__y__L
  • q__y__L
  • 2016年04月20日 23:34
  • 1672

一元函数对象和一元谓词

谓词: 一元函数对象:函数参数1个; 二元函数对象:函数参数2个; 一元谓词 函数参数1个,函数返回值是bool类型,可以作为一个判断式 谓词可以使一个仿函数,也可以是一个回调函数。 二元谓词 函数参...
  • bbs375
  • bbs375
  • 2016年09月30日 10:07
  • 298

函数对象 谓词函数 函数适配器

函数对象:函数对象就是重载类中了operator()运算符的类类型对象,当使用该类实例调用operator函数时如同调用普通函数一样。从概念上来说,函数对象是用作函数的对象,但从实现来说,函数对象是实...
  • ChengNuoDeYongYuan
  • ChengNuoDeYongYuan
  • 2016年10月26日 19:56
  • 199

函数对象和谓词

在C++中,在应用程序运行阶段存在的所有实体都是对象,因此struct和class也可用作函数,这称为函数对象。注意,函数也可通过函数指针来调用,他们也是函数对象。     从概念上说,函数对象是用...
  • u010771437
  • u010771437
  • 2016年01月06日 11:19
  • 491

stl算法设计理念_一元函数对象和一元谓词

传智扫地僧课程学习笔记。 函数对象,一元谓词,这些才听,觉得有点陌生, 函数对象: 重载函数调用操作符的类,其对象常称为函数对象(functionobject),即它们是行为类似函...
  • qq_18973645
  • qq_18973645
  • 2017年01月18日 22:24
  • 212

STL的6大组件:容器、类属算法、迭代器、函数对象、适配器、分配器。

STL知识点。梗概。 ...
  • chenhu_doc
  • chenhu_doc
  • 2006年07月29日 22:19
  • 3051

C++中的谓词函数

标准库容器定义的操作非常少,标准库没有给容器添加大量的功能函数,而是选择提供一组算法,这些算法大都不依赖容器类型,对不同类型的容器都适用。泛型算法有一组定义在头文件,有一组定义在头文件中。      ...
  • u011608357
  • u011608357
  • 2014年01月05日 13:45
  • 1428

函数对象的函数适配器

函数对象的函数适配器标准库还提供了一组函数适配器用来特殊化或者扩展一元和二元函数对象适配器是一种特殊的类它被分成下面两类1 绑定器binder binder 通过把二元函数对象的一个实参绑定到一个特殊...
  • jemmy
  • jemmy
  • 2005年08月27日 00:46
  • 834

C++ STL 基础及应用(7) 函数对象(仿函数)

把函数作为对象是程序设计的新思维。STL 通过重载类中的 operator() 函数实现函数对象功能,不但可以对容器中的数据进行各种各样的操作,而且能够维护自己的状态。因此,与标准 C 库函数相比,函...
  • Raito__
  • Raito__
  • 2016年06月08日 14:39
  • 2154
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++STL之函数对象及谓词
举报原因:
原因补充:

(最多只允许输入30个字)