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()或者自己定义(如注释部分),效果是同样的。


相关文章推荐

36STL之函数对象和谓词

STL之函数对象和谓词STL之函数对象和谓词 函数对象 谓词 一元函数对象案例 一元谓词案例 二元函数对象案例 二元谓词案例 综合示例代码 预定义函数对象 1算术函数对象 2关系函数对象 3逻辑函数对...

C++: 谓词函数、函数对象(仿函数)、回调函数总结

谓词函数:predicate function。什么是谓词,其实就是一个判断式,说白了就是一个返回bool值的函数。(这里说明了谓词可以有2种形式)几元就是函数有几个参数,至于定义和使用,函数定义和一...

浅析STL 谓词 + 仿函数 + 函数指针(c)

一:起因 (0)提到C++ STL,首先被人想到的是它的三大组件:Containers(容器), Iterators(迭代器), Algorithms(算法)。容器为用户提供了常用的数据结构(如,ve...

Common Lisp-对象相等性 函数或谓词包括:eq、eql、equal、equalp、=

Common Lisp-对象相等性 相等的函数或谓词包括:eq、eql、equal、equalp 在Lisp中,symbols(符号)是独一无二的,是指在计算机内存中,给定某个名字,只有一个s...

C++ STL/ (12) 函数对象适配器

我们在前一节介绍了函数对象的概念,本节介绍基于函数对象的一个概念–函数对象适配器。在讲函数对象适配器之前,我们来讲一讲普通函数,函数对象和函数对象适配器的关系。 普通函数是对程序功能的一种封装。这种...

函数对象 谓词

转自http://blog.sina.com.cn/s/blog_6a8b07370100kuvg.html 在C++中,在应用程序运行阶段存在的所有实体都是对象,因此struct和...

C++ STL 学习笔记 函数对象

函数对象c++中函数名后的()称为函数调用运算符。函数调用运算符也可以重载,如果某个类重载了函数调用运算符,则该类的实例就是一个函数对象。函数对象本身并不是很有用,但他们使得算法操作的参数化策略成为可...

C++ STL/ (11) 函数对象

我们在介绍容器set的时候就涉及到了函数对象这个概念,本节就是在原来的基础之上,系统深入的谈一谈STL中的函数对象。 函数对象的基本概念函数对象本质上是一个类而不是一个函数 函数对象重载了运算符(),...

C++必知必会之(20)STL函数对象

1、STL使我们能够轻松快捷地编写复杂的代码,既标准又高度优化: std::vector names; //..... std::sort( names.begin( ),  names.end( )...

C++中的谓词函数

标准库容器定义的操作非常少,标准库没有给容器添加大量的功能函数,而是选择提供一组算法,这些算法大都不依赖容器类型,对不同类型的容器都适用。泛型算法有一组定义在头文件,有一组定义在头文件中。      ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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