36STL之函数对象和谓词

最新推荐文章于 2024-02-17 00:31:55 发布
最新推荐文章于 2024-02-17 00:31:55 发布
阅读量482 收藏 1
点赞数
分类专栏： C++ 文章标签： 函数 stl

STL之函数对象和谓词

1.函数对象

重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。
这是通过重载类的operator()来实现的。
“在标准库中，函数对象被广泛地使用以获得弹性”，标准库中的很多算法都可以使用函数对象或者函数来作为自定的回调行为；

一元函数对象：函数参数1个；
二元函数对象：函数参数2个；

2.谓词

一元谓词: 函数参数1个，函数返回值是bool类型，可以作为一个判断式

二元谓词: 函数参数2个，函数返回值是bool类型

谓词可以使一个仿函数，也可以是一个回调函数。

一元谓词举例如下:
1.判断给出的string对象的长度是否小于6

bool GT6(const string &s)
{
return s.size() >= 6;
}

2.判断给出的int是否在3到8之间

bool Compare( int i )
{
return ( i >= 3 && i <= 8 );
}

二元谓词举例如下:
1.比较两个string对象，返回一个bool值，指出第一个string是否比第二个短

bool isShorter(const string &s1, const string &s2)
{
return s1.size() < s2.size();
}

3.一元函数对象案例

//1普通类 重载 函数调用操作符
template <typename T>
void FuncShowElemt(T &t)  //普通函数 不能像 仿函数那样记录状态
{
    cout << t << " ";
};

void showChar(char &t)
{
    cout << t << " ";
}

//函数模板 重载 函数调用操作符
template <typename T>
class ShowElemt
{
public:
    ShowElemt()
    {
        n = 0;
    }
    void operator()(T &t)
    {
        n++;
        cout << t << " ";
    }
    void printCount()
    {
        cout << n << endl;
    }
public:
    int n;
};

//1 函数对象 基本使用
void main11()
{
    int a = 100;
    FuncShowElemt<int>(a); //普通的函数调用

    ShowElemt<int> showElemt; //函数对象 
    showElemt(a); //函数对象调用 
}

4.一元谓词案例

//1元谓词 例子
template <typename T>
class Isdiv
{
public:
    Isdiv(const T &divisor) //
    {
        this->divisor = divisor;
    }
    bool operator()(T &t)
    {
        return (t%divisor == 0);
    }
protected:
private:
    T divisor;
};

void main13()
{
    vector<int> v2;
    for (int i=10; i<33; i++)
    {
        v2.push_back(i);
    }
    vector<int>::iterator it;
    int a = 4;
    Isdiv<int> mydiv(a);
    // _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)   //返回的是迭代器
    it = find_if(v2.begin(), v2.end(), Isdiv<int>(4));
    if (it != v2.end())
    {
        cout << "第一个被4整除的数是：" << *it << endl;
    }
}

5.二元函数对象案例

template <typename T>
struct SumAdd
{
    T operator()(T &t1, T &t2)
    {
        return t1 + t2;
    }
};

template <typename T>
void printE(T &t)
{
    for (vector<int>::iterator it = t.begin(); it!=t.end(); it++ )
    {
        cout << *it << " ";
    }
}

void printVector(vector<int> &v)
{
    for (vector<int>::iterator it = v.begin(); it!=v.end(); it++ )
    {
        cout << *it << " ";
    }
}

void  main14()
{
    vector<int> v1, v2 ;
    vector<int> v3;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);

    v2.push_back(4);
    v2.push_back(5);
    v2.push_back(6);

    v3.resize(10);

    //transform(v1.begin(), v1.end(), v2.begin(),v3.begin(), SumAdd<int>());
    /*
    template<class _InIt1,
    class _InIt2,
    class _OutIt,
    class _Fn2> inline
        _OutIt transform(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
    */
    vector<int>::iterator it = transform(v1.begin(), v1.end(), v2.begin(),v3.begin(), SumAdd<int>());
    cout << *it << endl;
    printE(v3); 
}

6.二元谓词案例

void current(int &v)
{
    cout << v << " ";
}

bool MyCompare(const int &a, const int &b)
{
    return a < b;
}
void main15()
{
    vector<int> v(10);

    for (int i=0; i<10; i++)
    {
        v[i] = rand() % 100;
    }

    for_each(v.begin(), v.end(), current);
    printf("\n");
    sort(v.begin(), v.end(), MyCompare );

    printf("\n");
    for (int i=0; i<10; i++)
    {
        printf("%d ", v[i]);
    }
    printf("\n");
}

7.综合示例代码


#include <iostream>
using namespace std;

#include "string"
#include <vector>
#include <list>
#include "set"
#include <algorithm>
#include "functional"

//函数对象 类重载了()
template <typename T>
class ShowElemt
{
public:
    ShowElemt()
    {
        n = 0;
    }
    void operator()(T &t)
    {
        n ++;
        //printN();
        cout << t << " ";
    }
    void printN()
    {
        cout << "n:" << n << endl;
    }
protected:
private:
    int n;
};


//函数模板  ==函数
template <typename T>
void FuncShowElemt(T &t)
{
    cout << t << endl;
}

//普通函数
void FuncShowElemt2(int &t)
{
    cout << t << " ";
}

//函数对象 定义 ;  函数对象和普通函数的异同 
//
void main01()
{
    int a = 10;
    ShowElemt<int> showElemt;
    showElemt(a); //函数对象的()的执行 很像一个函数 //仿函数

    FuncShowElemt<int>(a);
    FuncShowElemt2(a);
}

//函数对象是属于类对象,能突破函数的概念,能保持调用状态信息
//函数对象的好处
// for_each算法中, 函数对象做函数参数
// for_each算法中, 函数对象当返回值
void main02()
{
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(3);
    v1.push_back(5);

    for_each(v1.begin(), v1.end(), ShowElemt<int>()); //匿名函数对象 匿名仿函数
    cout << endl;
    for_each(v1.begin(), v1.end(), FuncShowElemt2); //通过回调函数  谁使用for_each 谁去填写回调函数的入口地址


    ShowElemt<int> show1;
    //函数对象 做函数参数 
    /*
        template<class _InIt,
        class _Fn1> inline
            _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
        {   // perform function for each element
            _DEBUG_RANGE(_First, _Last);
            _DEBUG_POINTER(_Func);
            return (_For_each(_Unchecked(_First), _Unchecked(_Last), _Func));
        }
    */
    //1 for_each算法的 函数对象的传递 是元素值传递 ,不是引用传递
    for_each(v1.begin(), v1.end(), show1);
    show1.printN();

    cout << "通过for_each算法的返回值看调用的次数" << endl;
    show1 = for_each(v1.begin(), v1.end(), show1);
    show1.printN();

    //结论 要点: 分清楚 stl算法返回的值是迭代器 还是 谓词（函数对象） 是stl算法入门的重要点
}

template<typename T>
class IsDiv
{
public:
    IsDiv(const T &divisor)
    {
        this->divisor = divisor;
    }
    bool operator()(T  &t)
    {
        return (t%divisor == 0);
    }

protected:
private:
    T divisor;
};

void main03()
{
    vector<int> v2;
    for (int i=10; i<33; i++)
    {
        v2.push_back(i);
    }
    int a = 4;
    IsDiv<int> myDiv(a);

    //find_if(v2.begin(), v2.end(), myDiv );

    /*
    template<class _InIt,
    class _Pr> inline
        _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
    {   // find first satisfying _Pred
        _DEBUG_RANGE(_First, _Last);
        _DEBUG_POINTER(_Pred);
        return (_Rechecked(_First,
            _Find_if(_Unchecked(_First), _Unchecked(_Last), _Pred)));
    }
    //find_if返回值是一个迭代器 
    //要点: 分清楚 stl算法返回的值是迭代器 还是 谓词（函数对象） 是stl算法入门的重要点
    */

    vector<int>::iterator it;
    it = find_if(v2.begin(), v2.end(), IsDiv<int>(a) );
    if (it == v2.end())
    {
        cout << "容器中没有被4整除的元素" << endl;
    }
    else
    {
        cout <<"第一个是被4整除的元素是:" << *it << endl;
    }

}


//二元函数对象
template <typename T>
class SumAdd
{
public:
    T operator()(T t1, T t2)
    {
        return t1 + t2;
    }
};

void main04()
{
    //v1 v2 ==> v3
    vector<int> v1, v2;
    vector<int> v3;
    v1.push_back(1);
    v1.push_back(3);
    v1.push_back(5);

    v2.push_back(2);
    v2.push_back(4);
    v2.push_back(6);

    v3.resize(10);

    /*
    template<class _InIt1,
    class _InIt2,
    class _OutIt,
    class _Fn2> inline
        _OutIt transform(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
    {   // transform [_First1, _Last1) and [_First2, ...) with _Func
        _DEBUG_RANGE(_First1, _Last1);
        _DEBUG_POINTER(_Dest);
        _DEBUG_POINTER(_Func);
        if (_First1 != _Last1)
            return (_Transform2(_Unchecked(_First1), _Unchecked(_Last1),
            _First2, _Dest, _Func,
            _Is_checked(_Dest)));
        return (_Dest);
    }

    //transform 把运算结果的 迭代器的开始位置 返回出来 
    */

    transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), SumAdd<int>() );

    for (vector<int>::iterator it=v3.begin(); it!=v3.end(); it++ )
    {
        cout << *it << " ";
    }
    cout << endl;
}


bool MyCompare(const int &a, const int &b)
{
    return a < b; //从小到大
}

void main05()
{
    vector<int> v1(10);

    for (int i=0; i<10; i++)
    {
        int tmp = rand() %100;
        v1[i] = tmp;
    }

    for (vector<int>::iterator it=v1.begin(); it!=v1.end(); it++ )
    {
        cout << *it <<" ";
    }
    cout << endl;
    for_each(v1.begin(), v1.end(), FuncShowElemt2);
    cout << endl;

    sort(v1.begin(), v1.end(), MyCompare);
    for_each(v1.begin(), v1.end(), FuncShowElemt2);
    cout << endl;
}

struct CompareNoCase
{
    bool operator()(const string &str1, const string &str2)
    {
        string str1_ ;
        str1_.resize(str1.size() );
        transform(str1.begin(), str1.end(), str1_.begin(), tolower ); //预定义函数对象 

        string str2_ ;
        str2_.resize(str2.size() );
        transform(str2.begin(), str2.end(), str2_.begin(), tolower ); //预定义函数对象 

        return (str1_ < str2_); // 从小到大进行排序
    }
};
void  main06()
{
    set<string> set1;
    set1.insert("bbb");
    set1.insert("aaa");
    set1.insert("ccc");
    set<string>::iterator it = set1.find("aAa"); //find函数 默认 区分大小写
    if (it == set1.end())
    {
        cout << " 没有 查找到 aaa " << endl;
    }
    else
    {
        cout << " 查找到 aaa " << endl;
    }

    set<string, CompareNoCase> set2;
    set2.insert("bbb");
    set2.insert("aaa");
    set2.insert("ccc");

    set<string, CompareNoCase>::iterator it2 = set2.find("aAa");
    if (it2 == set2.end())
    {
        cout << " 没有 查找到 aaa " << endl;
    }
    else
    {
        cout << " 不区分大小的的查找  查找到 aaa " << endl;
    }

}

void main1111()
{
    //main01(); //函数对象基本概念
    //main02(); //函数对象的好处 函数对象做函数参数 函数对象做返回值

    //main03(); //一元谓词
    //main04(); //二元函数对象 和二元谓词
    //main05(); //二元函数对象 和二元谓词
    main06(); //二元谓词在set集合中的应用
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

8.预定义函数对象

标准模板库STL提前定义了很多预定义函数对象，#include <functional> 必须包含。

//1使用预定义函数对象：
//类模板plus<> 实现了： 不同类型的数据进行加法运算
void main41()
{
    plus<int> intAdd;
    int x = 10;
    int y = 20;
    int z = intAdd(x, y); //等价于 x + y 
    cout << z << endl;

    plus<string> stringAdd;
    string myc = stringAdd("aaa", "bbb");
    cout << myc << endl;

    vector<string> v1;
    v1.push_back("bbb");
    v1.push_back("aaa");
    v1.push_back("ccc");
    v1.push_back("zzzz");

    //缺省情况下，sort()用底层元素类型的小于操作符以升序排列容器的元素。
    //为了降序，可以传递预定义的类模板greater,它调用底层元素类型的大于操作符：
    cout << "sort()函数排序" << endl;;
    sort(v1.begin(), v1.end(), greater<string>() ); //从大到小
    for (vector<string>::iterator it=v1.begin(); it!=v1.end(); it++ )
    {
        cout << *it << endl;
    }
}

8.1算术函数对象

预定义的函数对象支持加、减、乘、除、求余和取反。调用的操作符是与type相关联的实例

//加法：plus<Types>
plus<string> stringAdd;
sres = stringAdd(sva1,sva2);

减法：minus<Types>
乘法：multiplies<Types>
除法divides<Tpye>
求余：modulus<Tpye>
取反：negate<Type>
negate<int> intNegate;
ires = intNegate(ires);
Ires= UnaryFunc(negate<int>(),Ival1);

8.2关系函数对象

等于equal_to<Tpye>
equal_to<string> stringEqual;
sres = stringEqual(sval1,sval2);
不等于not_equal_to<Type>
大于 greater<Type>
大于等于greater_equal<Type>
小于 less<Type>
小于等于less_equal<Type>
void main42()
{
    vector<string> v1;
    v1.push_back("bbb");
    v1.push_back("aaa");
    v1.push_back("ccc");
    v1.push_back("zzzz");
    v1.push_back("ccc");
    string s1 = "ccc";
    //int num = count_if(v1.begin(),v1.end(), equal_to<string>(),s1);
    int num = count_if(v1.begin(),v1.end(),bind2nd(equal_to<string>(), s1));
    cout << num << endl;
}

8.3逻辑函数对象

逻辑与 logical_and<Type>
logical_and<int> indAnd;
ires = intAnd(ival1,ival2);
dres=BinaryFunc( logical_and<double>(),dval1,dval2);
逻辑或logical_or<Type>
逻辑非logical_not<Type>
logical_not<int> IntNot;
Ires = IntNot(ival1);
Dres=UnaryFunc( logical_not<double>,dval1);
小帅比simon
关注
专栏目录
STL算法中函数对象和谓词
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-26 333
1函数对象和谓词定义 函数对象： 重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。 这是通过重载类的operator()来实现的。 “在标准库中，函数对象被广泛地使用以获得弹性”，标准库中的很多算法都可以使用函数对象或者函数来作为自定的回调行为； 谓词： 一元函数对象：函数参数1个； 二元函数对象：函数参数2个； 一
c++入门笔记-stl函数对象/谓词/内建函数对象
weixin_43754049的博客
07-11 324
重载函数调用操作符的类 其对象常称为函数对象 函数对象使用重载的()时 行为类似函数调用 也叫仿函数本质： 函数对象（仿函数）是一个类 不是一个函数函数对象使用特点： 函数对象在使用时 可以像普通函数那样调用 可以有参数和返回值 函数对象超出了普通函数的概念 函数对象可以有自己的状态 函数对象可以作为参数传递 ......
SQL基础学习笔记--5--函数、谓词
Chenlele710147的博客
01-15 422
5.1 各种各样的函数 函数分类 算数函数 字符串函数 日期函数 转化函数 聚合函数 算数函数 +（加法） -（减法） *（乘法） /（除法） ABS （绝对值） 参数：需要取绝对值的数值 SELECT ABS(sale_price) FROM product WHERE product_name = '擦菜板' MOD（求余） 参数：被除数，除数 S...
函数对象 谓词
mamori的专栏
08-27 2321
转自http://blog.sina.com.cn/s/blog_6a8b07370100kuvg.html 在C++中，在应用程序运行阶段存在的所有实体都是对象，因此struct和class也可用作函数，这称为函数对象。注意，函数也可通过函数指针来调用，他们也是函数对象。     从概念上说，函数对象是用作函数的对象；但从实现上说，函数对象是实现了operator()的类的对
函数对象与谓词
汤小萌的博客
09-27 507
函数对象 重载函数调用操作符的类,其对象常称为函数对象(function object),即他们的行为类似函数的对象.一个类对象,表现出一个函数的特征,就是通过"对象名+(参数列表)"的方式使用一个类对象,如果没有上下文,完全可以把它看作一个函数对待. 这是通过重载类的operator()来实现的. “在标准类库中,函数对象被广泛地使用以获得弹性”,在标准库中的很多算法都可以使用函数对象或者函数来...
函数对象和谓词
weixin_44797811的博客
04-26 525
函数对象 网上对函数对象这个概念的说法有很多啊，特别是百度百科里的函数对象和仿函数，说的玄乎死了 按照我自己的理解吧，函数对象是一个既可以像正常函数使用，又可以作为参数，参与另一个函数的一种东西 函数对象又称为仿函数，是STL的组件之一。通过图片可以看出，函数对象主要服务于算法。 函数对象有四种实现方法 函数指针 lambda表达式 带有成员函数operator()的class建立的object 带有转换函数可以将自己转换为pointer to function的class所建立的object.
C++函数对象-谓词
q__y__L的博客
04-20 2738
函数对象(也叫functor），听起来或许有点陌生，但他们是c++实体，即使你没有用过，也一定见过，只是你没有意识到而已。从概念上讲，函数对象时用作函数的对象；但是从实现上来说，函数对象时实现了 operate（）的类的对象。虽然函数和函数指针也可以归为函数对象，但实现了operate（）的类的对象才能保存状态，才能用于STL。\quad我们直接看定义： - 一元函数：接受一个参数的函数，如f(x
STL之函数对象和谓词
believe_s的博客
10-10 635
1.函数对象重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。 这是通过重载类的operator()来实现的。 “在标准库中，函数对象被广泛地使用以获得弹性”，标准库中的很多算法都可以使用函数对象或者函
C++ 函数对象&谓词& 学习总结
最新发布
weixin_45231931的博客
02-17 867
template< class T > T multiplies< T > // 乘法仿函数。template< class T > T divides< T > // 除法仿函数。template< class T > T negate< T > // 取反仿函数。template< class T > T minus< T > // 减法仿函数。template< class T > T plus< T > // 加法仿函数。1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值。
STL学习之十二：函数对象和谓词
Bixiwen_liu的博客
07-29 703
本文主要介绍函数对象和谓词的示例代码。函数对象是属于类对象，能突破函数的概念 ，用以保持条用状态信息。
STL 算法中函数对象和谓词
weixin_34335458的博客
11-06 184
STL 算法中函数对象和谓词   函数对象和谓词定义 函数对象：          重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。          这是通过重载类的operator()来实现的。   ...
谓词函数
Hello world！
01-10 2111
c++谓词函数和仿函数 2012-07-09 12:54 by youxin, 335 阅读, 0 评论, 收藏, 编辑   什么谓词，其实就是一个判断式，说白了就是一个返回bool值的函数或者仿函数。（这里说明了谓词可以有2种形式）几元就是函数有几个参数，至于定义和使用，函数定义和一般的函数定义一样，仿函数就是写个类，然后重载operator()。使用就是在那些以这种需要返回bool
C++函数对象：谓词与函数对象的使用场景
在C语言中，函数对象和谓词是常见的编程概念，它们在算法和数据结构中有着广泛的应用。本文将深入介绍C语言中函数对象和谓词的概念、使用方法以及在不同场景下的应用。通过学习本文，读者将能够更加全面地理解和应用...
13、stl--函数对象和谓词
u014749668的博客
09-01 144
stl 是通过类模板，进行两次编译的，当一个复杂数据类型存储是是通过值拷贝，所有必须重新复杂数据类型的 构造 析构 拷贝构造 赋值构造函数 vector与deque的比较： 一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置却是不固定的。 二：如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。 ...
stl算法设计理念_一元函数对象和一元谓词
1
01-18 837
传智扫地僧课程学习笔记。 函数对象，一元谓词，这些才听，觉得有点陌生， 函数对象： 重载函数调用操作符的类，其对象常称为函数对象（functionobject），即它们是行为类似函数的对象。一个类对象，表现出一个函数的特征，就是通过“对象名+(参数列表)”的方式使用一个类对象，如果没有上下文，完全可以把它看作一个函数对待。 这是通过重载类的operator()来实现的。 “
第6章 函数、谓词、CASE表达式
氧小氢的博客
11-12 301
6-1 各种各样的函数 函数的种类 所谓函数，就是输入某一值得到相应输出结果的功能，输入值称为参数（parameter），输出值称为返回值。 函数大致可以分为以下几种： 算术函数（用来进行数值计算的函数） 字符串函数（用来进行字符串操作的函数） 日期函数（用来进行日期操作的函数） 转换函数（用来转换数据类型和值的函数） 聚合函数（用来进行数据聚合的函数）—— COUNT/SUM/AVG/MAX/MIN 算术函数 ABS——绝对值 ABS是绝对值的函数。绝对值（absolute v.
STL算法——谓词讲解
流楚丶格念的博客
06-20 4231
2 谓词 谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。 class GreaterThenFive { public: bool operator()(int num) { return num > 5; } }; //一元谓词 void test01() { vector<int> v; for (int i = 0; i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值