STL 算法中函数对象和谓词

函数对象和谓词定义

函数对象:

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

一元函数对象:函数参数1个; 
         二元函数对象:函数参数2个;

谓词:

谓词是一个返回bool类型的值的函数,因为函数对象是一种类型的对象,实现operator()()成员函数并返回bool类型的值,所以函数对象也是谓词。

谓词可以是一个仿函数,也可以是一个回调函数

一元谓词 函数参数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();
}

一元函数对象案例

//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 main()
{
          int a = 100;
          FuncShowElemt<int>(a); //普通的函数调用
          ShowElemt<int> showElemt; //函数对象
          showElemt(a); //函数对象调用
}

一元谓词案例

//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 main()
{
           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;
           }
}

二元函数对象案例

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 main()
{
           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);
}

二元谓词案例

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

bool MyCompare(const int &a, const int &b)
{
           return a < b;
}

void main()
{
           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");
}

预定义函数对象和函数适配器

1)预定义函数对象基本概念:标准模板库STL提前定义了很多预定义函数对象,
#include <functional> 必须包含。
//1使用预定义函数对象:
//类模板plus<> 的实现了: 不同类型的数据进行加法运算
void main()
{
           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;
           }
}

2)算术函数对象 预定义的函数对象支持加、减、乘、除、求余和取反。调用的操作符是与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);

3)关系函数对象

等于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 main()
{
           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;

}

4)逻辑函数对象

逻辑与 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);

函数适配器

C++中有三类适配器,分别是容器适配器,迭代器适配器和函数适配器,这里主要介绍函数适配器。

1)函数适配器的理论知识

2)常用函数函数适配器

标准库提供一组函数适配器,用来特殊化或者扩展一元和二元函数对象。

常用适配器是:

1绑定器(binder): binder通过把二元函数对象的一个实参绑定到一个特殊的值上,将其转换成一元函数对象。C++标准库提供两种预定义的binder适配器:bind1st和bind2nd,前者把值绑定到二元函数对象的第一个实参上,后者绑定在第二个实参上。
           2取反器(negator) : negator是一个将函数对象的值翻转的函数适配器。
                      标准库提供两个预定义的ngeator适配器:
                      not1翻转一元预定义函数对象的真值,而not2翻转二元谓词函数的真值。

常用函数适配器列表如下:

bind1st(op, value)
bind2nd(op, value)
not1(op)
not2(op)
mem_fun_ref(op)
mem_fun(op)
ptr_fun(op)

3)常用函数适配器案例

//////////////////////////////////////////////////////////////////////////
class IsGreat
{
public:
           IsGreat(int i)
           {
                      m_num = i;
           }
           bool operator()(int &num)
           {
                      if (num > m_num)
                      {
                                 return true;
                      }
                      return false;
           }
protected:
private:
           int m_num;
};

void main()
{
           vector<int> v1;
           for (int i=0; i<5; i++)
           {
                      v1.push_back(i+1);
           }
           for (vector<int>::iterator it = v1.begin(); it!=v1.end(); it ++)
           {
                      cout << *it << " "
           }
           int num1 = count(v1.begin(), v1.end(), 3);
           cout << "num1:" << num1 << endl;
           
           //通过谓词求大于2的个数
           int num2 = count_if(v1.begin(), v1.end(), IsGreat(2));
           cout << "num2:" << num2 << endl;

//通过预定义函数对象求大于2的个数 greater<int>() 有2个参数
           // param > 2
           int num3 = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 2 ) );
           cout << "num3:" << num3 << endl;

           //取模 能被2整除的数 求奇数
           int num4 = count_if(v1.begin(), v1.end(), bind2nd(modulus <int>(), 2 ) );
           cout << "奇数num4:" << num4 << endl;
           int num5 = count_if(v1.begin(), v1.end(), not1( bind2nd(modulus <int>(), 2 ) ) );
           cout << "偶数num5:" << num5 << endl;
           return
}

STL 算法中函数对象和谓词的更多相关文章

  1. STL算法中函数对象和谓词

    函数对象和谓词定义 函数对象: 重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象.一个类对象,表现出一个函数的特征,就是通过“对象名+(参数列 ...

  2. STL算法设计理念 - 函数对象和函数对象当参数和返回值

    函数对象: 重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象.一个类对象,表现出一个函数的特征,就是通过"对象名+(参数列表)&qu ...

  3. STL算法设计理念 - 函数对象和函数对象当參数和返回值

    函数对象: 重载函数调用操作符的类.其对象常称为函数对象(function object),即它们是行为类似函数的对象. 一个类对象,表现出一个函数的特征,就是通过"对象名+(參数列表)&q ...

  4. 02--STL算法(函数对象和谓词)

    一:函数对象(仿函数):实现状态记录等其他操作<相对于普通函数> 重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象. 即是重载了“ ...

  5. C++STL 函数对象和谓词

    函数对象:重载函数调用操作符的类,其对象常称为函数对象. 函数对象属于类对象,能突破函数概念,保持类的状态 谓词: 一元函数对象:函数参数1个: 二元函数对象:函数参数2个: 一元谓词 函数参数1个, ...

  6. STL 仿函数(函数对象)

    ##定义 仿函数(functor):一种具有函数性质的对象. 仿函数在C++中的新名称为函数对象(function object). 仿函数类对象像函数一样被调用,调用仿函数类对象时,实际调用的是仿函 ...

  7. STL——仿函数(函数对象)

    一.仿函数(也叫函数对象)概观 仿函数的作用主要在哪里?从第6章可以看出,STL所提供的各种算法,往往有两个版本,其中一个版本表现出最常用(或最直观)的某种运算,第二个版本则表现出最泛化的演算流程,允 ...

  8. C++STL 预定义函数对象和函数适配器

    预定义函数对象和函数适配器 预定义函数对象基本概念:标准模板库STL提前定义了很多预定义函数对象,#include <functional> 必须包含. 1使用预定义函数对象: void ...

  9. STL算法设计理念 - 函数适配器

    1)函数适配器的理论知识 2)常用函数函数适配器 标准库提供一组函数适配器,用来特殊化或者扩展一元和二元函数对象.常用适配器是: 1.绑定器(binder): binder通过把二元函数对象的一个实参 ...

随机推荐

  1. Android Service(上)

    一 Service简介 Service是Context的子类 Service是四大组件之一 用来在后台处理一些比较耗时的操作或者去执行某些需要长期运行的任务 二 注意 Service里面不能直接执行耗 ...

  2. 《杜增强讲Unity之Tanks坦克大战》3-添加坦克

    3 添加坦克 3.1 本节效果预览   3.2 另存新场景 首先打开上次的场景s1,另存为s2,放到同一个文件夹下面.   3.3 添加坦克模型 在Model文件夹下面找到Tank模型   将Tank ...

  3. log4cpp简单使用及踩到的坑

    log4cpp是log4j的一个扩展, C++开发者可用该库记录日志,可输出到终端,亦可保存到文件. 下面简单demo展示如何输出日志到输出终端. #include <iostream> ...

  4. 图形 - bootStrap4常用CSS笔记

    .rounded 图片显示圆角效果 .rounded-circle 设置椭圆形图片 .img-thumbnail 设置图片缩略图(图片有边框) .img-fluid 响应式图片 .float-righ ...

  5. sqli-labs学习笔记 DAY8

    DAY 8 sqli-lab Page-3 sqli-labs lesson 38 What is Stacked injection? https://blog.csdn.net/Fly_hps/a ...

  6. mkswap命令详解

    基础命令学习目录首页 原文链接:http://blog.51cto.com/arlen99/1743841 mkswap命令用于在一个文件或者设备上建立交换分区.在建立完之后要使用sawpon命令开始 ...

  7. MyForm_参考django的Form组建

    fork wupeiqi:https://github.com/fat39/Tyrion 组件说明:https://www.cnblogs.com/wupeiqi/p/5938916.html

  8. jenkins设置定时任务

    每次都手动的构建项目显然不够方便,有时候需要定时地执行自动化测试脚本.例如,每天晚上定时执行 pjenkins.py 文件来运行自动化测试项目. 设置定时任务 前面已经创建的 “python test ...

  9. 浅谈jQuery构造函数

    $()函数到底做的什么 jQuery在前端领域路人皆知,对于一向喜欢玩js的博主来说,虽然能力有限,但是还是很喜欢研究他的做为.那么一个简单的美元符号$与一对常见的()括号,jQuery底层到底做了哪 ...

  10. js弹出框 -搜索

    警告框alert() alert是警告框,只有一个按钮“确定”无返回值,警告框经常用于确保用户可以得到某些信息.当警告框出现后,用户需要点击确定按钮才能继续进行操作.语法:alert("文本 ...