devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++提高笔记（六）---STL函数对象、STL常用算法（遍历、查找）

作者：木道寻08 | 2024-07-12 06:06:38

赞

踩

C++提高笔记（六）---STL函数对象、STL常用算法（遍历、查找）

1、STL-函数对象

1.1函数对象

1.1.1函数对象概念

概念：

重载函数调用操作符的类，其对象常称为函数对象

函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：函数对象(仿函数)是一个类，不是一个函数

1.1.2 函数对象使用

特点：

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值

函数对象超出普通函数的概念，函数对象内部可以有自己的状态

函数对象可以作为参数传递

  1. #include <iostream>
  2. using namespace std;
  3. #include<string>
  4. //函数对象（仿函数）
  5. //函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
  6. //函数对象超出普通函数的概念，函数对象内部可以有自己的状态
  7. //函数对象可以作为参数传递
  8. class MyAdd
  9. {
  10. public:
  11.     int operator()(int v1, int v2)
  12.     {
  13.         return v1 + v2;
  14.     }
  15. };
  16. //1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
  17. void test01()
  18. {
  19.     MyAdd myadd;
  20.     cout << myadd(10, 10) << endl;
  21. }
  22. //2、函数对象超出普通函数的概念，函数对象内部可以有自己的状态
  23. class MyPrint
  24. {
  25. public:
  26.     MyPrint()
  27.     {
  28.         this->count = 0;
  29.     }
  30.     void operator()(string text)
  31.     {
  32.         cout << text << endl;
  33.         this->count++;
  34.     }
  35.     int count;//内部自己状态
  36. };
  37. void test02()
  38. {
  39.     MyPrint myprint;
  40.     myprint("hello world!");
  41.     myprint("hello world!");
  42.     myprint("hello world!");
  43.     myprint("hello world!");
  44.     cout << "MyPrint调用的次数：" << myprint.count << endl;
  45. }
  46. //3、函数对象可以作为参数传递
  47. void doPrint(MyPrint& mp, string text)
  48. {
  49.     mp(text);
  50. }
  51. void test03()
  52. {
  53.     MyPrint myprint;
  54.     doPrint(myprint, "hello C++");
  55. }
  56.  
  57. int main()
  58. {
  59.     test01();
  60.     test02();
  61.     test03();
  62.     system("pause");
  63.     return 0;
  64. }

输出结果：

  1. 20
  2. hello world!
  3. hello world!
  4. hello world!
  5. hello world!
  6. MyPrint调用的次数：4
  7. hello C++
  8. 请按任意键继续. . .

1.2谓词

1.2.1谓词对象

概念：

        返回bool类型的仿函数称为谓词

        如果operator（）接受一个参数，那么叫做一元谓词

        如果operator（）接受二个参数，那么叫做二元谓词

1.2.2一元谓词

  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //仿函数 返回值类型是bool数据类型  称为谓词
  6. //如果operator（）接受一个参数，那么叫做一元谓词
  7. class GreaterFive
  8. {
  9. public:
  10.     bool operator()(int val)
  11.     {
  12.         return val > 5;
  13.     }
  14. };
  15.  
  16. void test01()
  17. {
  18.     vector<int>v;
  19.     for (int i = 0; i < 10; i++)
  20.     {
  21.         v.push_back(i);
  22.     }
  23.     //查找容器中 是否有大于5的数字
  24.     //GreaterFive() 匿名函数对象
  25.     vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
  26.     if (it == v.end())
  27.     {
  28.         cout << "未找到" << endl;
  29.     }
  30.     else
  31.     {
  32.         cout << "找到了大于5的数字为：" << *it << endl;
  33.     }
  34. }
  35.  
  36. int main()
  37. {
  38.     test01();
  39.     system("pause");
  40.     return 0;
  41. }

输出结果：

  1. 找到了大于5的数字为：6
  2. 请按任意键继续. . .

1.2.3二元谓词

  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //仿函数 返回值类型是bool数据类型  称为谓词
  6. //二元谓词
  7. class MyCompare
  8. {
  9. public:
  10.     bool operator()(int v1,int v2)
  11.     {
  12.         return v1 > v2;
  13.     }
  14. };
  15.  
  16. void test01()
  17. {
  18.     vector<int>v;
  19.     v.push_back(30);
  20.     v.push_back(20);
  21.     v.push_back(50);
  22.     v.push_back(10);
  23.     v.push_back(40);
  24.     sort(v.begin(), v.end());//默认升序
  25.     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
  26.     {
  27.         cout << *it << " ";
  28.     }
  29.     cout << endl;
  30.     //使用函数对象，改变算法策略，变为降序
  31.     sort(v.begin(), v.end(), MyCompare());
  32.     cout << "---------------------------" << endl;
  33.     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
  34.     {
  35.         cout << *it << " ";
  36.     }
  37.     cout << endl;
  38. }
  39.  
  40. int main()
  41. {
  42.     test01();
  43.     system("pause");
  44.     return 0;
  45. }

输出结果：

  1. 10 20 30 40 50
  2. ---------------------------
  3. 50 40 30 20 10
  4. 请按任意键继续. . .

 1.3内建函数对象

1.3.1内建函数对象意义

概念：STL内建了一些函数对象

分类：
                算术仿函数
                关系仿函数
                逻辑仿函数

用法：这些仿函数所产生的对象，用法和一般函数完全相同。使用内建函数对象，需要引入头文件#include<functional>

1.3.2算术仿函数

功能描述：实现四则运算。其中negate是一元运算，其他都是二元运算

仿函数原型：

  1. template<class T>T plus<T>       //加法仿函数
  2. template<class T>T minus<T>      //减法仿函数
  3. template<class T>T multiplies<T> //乘法仿函数
  4. template<class T>T divides<T>    //除法仿函数
  5. template<class T>T modulus<T>    //取模仿函数
  6. template<class T>T negate<T>     //取反仿函数
  1. #include <iostream>
  2. using namespace std;
  3. #include<functional>//内建函数对象头文件
  4. //内建函数对象 算术仿函数
  5. //template<class T>T plus<T>       //加法仿函数
  6. //template<class T>T minus<T>      //减法仿函数
  7. //template<class T>T multiplies<T> //乘法仿函数
  8. //template<class T>T divides<T>    //除法仿函数
  9. //template<class T>T modulus<T>    //取模仿函数
  10. //template<class T>T negate<T>     //取反仿函数
  11.         
  12. //negate 一元仿函数 取反仿函数
  13. void test01()
  14. {
  15.     negate<int>n;
  16.     cout << n(50) << endl;
  17. }
  18. //plus 二元仿函数 加法
  19. void test02()
  20. {
  21.     plus<int>p;//默认传入同种数据类型，不能传入不同种数据类型
  22.     cout << p(10, 20) << endl;
  23. }
  24. int main()
  25. {
  26.     test01();
  27.     test02();
  28.     system("pause");
  29.     return 0;
  30. }

输出结果：

  1. -50
  2. 30
  3. 请按任意键继续. . .

1.3.3关系仿函数

功能描述：实现关系对比

仿函数原型：（最常用的是大于）

  1. template<class T> bool equal_to<T>      //等于
  2. template<class T> bool not_equal _to<T> //不等于
  3. template<class T> bool greater<T>       //大于
  4. template<class T> bool greater_equal<T> //大于等于
  5. template<class T> bool less<T>          //小于
  6. template<class T> bool less_equal<T>    //小于等于
  1. #include <iostream>
  2. using namespace std;
  3. #include<functional>//内建函数对象头文件
  4. #include<vector>
  5. #include<algorithm>
  6. //内建函数对象 关系仿函数
  7. //template<class T> bool equal_to<T>      //等于
  8. //template<class T> bool not_equal _to<T> //不等于
  9. //template<class T> bool greater<T>       //大于
  10. //template<class T> bool greater_equal<T> //大于等于
  11. //template<class T> bool less<T>          //小于
  12. //template<class T> bool less_equal<T>    //小于等于
  13.                 
  14. //大于 greater                
  15. class MyCompare
  16. {
  17. public:
  18.     bool operator()(int v1, int v2)
  19.     {
  20.         return v1 > v2;
  21.     }
  22. };
  23. void test01()
  24. {
  25.     vector<int>v;
  26.     v.push_back(10);
  27.     v.push_back(30);
  28.     v.push_back(40);
  29.     v.push_back(50);
  30.     v.push_back(20);
  31.     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
  32.     {
  33.         cout << *it << " ";
  34.     }
  35.     cout << endl;
  36.     //降序
  37.     //sort(v.begin(), v.end(), MyCompare()); //自己重载仿函数
  38.     sort(v.begin(), v.end(), greater<int>());//内建函数对象（仿函数）greater，效果一致
  39.     for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
  40.     {
  41.         cout << *it << " ";
  42.     }
  43.     cout << endl;
  44. }
  45.  
  46. int main()
  47. {
  48.     test01();
  49.     system("pause");
  50.     return 0;
  51. }

输出结果：

  1. 10 30 40 50 20
  2. 50 40 30 20 10
  3. 请按任意键继续. . .

1.3.4逻辑仿函数

功能描述：实现逻辑运算

函数原型：

  1. template<class T> bool logical_and<T> //逻辑与
  2. template<class T> bool 1ogical_or<T>  //逻辑或
  3. template<class T> bool logical_not<T> //逻辑非
  1. #include <iostream>
  2. using namespace std;
  3. #include<functional>//内建函数对象头文件
  4. #include<vector>
  5. #include<algorithm>
  6. //内建函数对象 关系仿函数
  7. //template<class T> bool logical_and<T> //逻辑与
  8. //template<class T> bool 1ogical_or<T>  //逻辑或
  9. //template<class T> bool logical_not<T> //逻辑非
  10.        
  11. //逻辑非 logical_not                
  12. void test01()
  13. {
  14.     vector<bool>v;
  15.     v.push_back(true);
  16.     v.push_back(false);
  17.     v.push_back(true);
  18.     v.push_back(false);
  19.     for (vector<bool>::iterator it = v.begin(); it != v.end(); it++)
  20.     {
  21.         cout << *it << " ";
  22.     }
  23.     cout << endl;
  24.     //利用逻辑非，将容器v搬运到容器v2中，并执行取反的操作
  25.     vector<bool>v2;
  26.     v2.resize(v.size());
  27.     transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
  28.     for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
  29.     {
  30.         cout << *it << " ";
  31.     }
  32.     cout << endl;
  33. }
  34.  
  35. int main()
  36. {
  37.     test01();
  38.     system("pause");
  39.     return 0;
  40. }

输出结果：

  1. 1 0 1 0
  2. 0 1 0 1
  3. 请按任意键继续. . .

2、STL-常用算法

概述：

算法主要是由头文件<algorithm><functional><numeric>组成

<algorithm>是所有STL头文件中最大的一个,范围涉及到比较,交换,查找,遍历操作,复制,修改等

<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数

<functional>定义了一些模板类，用以声明函数对象

2.1 常用遍历算法

学习目标：掌握常用的遍历算法

算法简介：

  1. for_each  //遍历容器
  2. transform //搬运容器到另一个容器中

2.1.1 for_each

功能描述：实现遍历容器

函数原型：

  1. for_each(iterator beg, iterator end, _func); 
  2. // 遍历算法 遍历容器元素
  3. // beg 开始迭代器
  4. // end 结束迭代器
  5. // _func函数或者函数对象
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //常用遍历算法 for_each
  6. //普通函数
  7. void print01(int val)
  8. {
  9.     cout << val << " ";
  10. }
  11. //仿函数
  12. class print02
  13. {
  14. public:
  15.     void operator()(int val)
  16.     {
  17.         cout << val << " ";
  18.     }
  19. };
  20. void test01()
  21. {
  22.     vector<int>v;
  23.     for (int i = 0; i < 10; i++)
  24.     {
  25.         v.push_back(i);
  26.     }
  27.     for_each(v.begin(), v.end(), print01);//普通函数放函数名
  28.     cout << endl;
  29.     for_each(v.begin(), v.end(), print02());//仿函数要放函数对象，加（）
  30.     cout << endl;
  31. }
  32.  
  33. int main()
  34. {
  35.     test01();
  36.     system("pause");
  37.     return 0;
  38. }

输出结果：

  1. 0 1 2 3 4 5 6 7 8 9
  2. 0 1 2 3 4 5 6 7 8 9
  3. 请按任意键继续. . .

总结：for_each在实际开发中是最常用遍历方法，需要熟练掌握 

2.1.2 transform

功能描述：搬运容器到另一个容器中

函数原型：

  1. transform(iterator begl,iterator end1,iterator beg2,_func);
  2. //beg1 源容器开始迭代器
  3. //end1 源容器结束迭代器
  4. //beg2 目标容器开始迭代器
  5. //_func 函数或者函数对象
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //常用遍历算法 transform
  6. //仿函数
  7. class Transform
  8. {
  9. public:
  10.     int operator()(int v)
  11.     {
  12.         return v + 10;
  13.     }
  14. };
  15.  
  16. class MyPrint
  17. {
  18. public:
  19.     void operator()(int v)
  20.     {
  21.         cout << v << " ";
  22.     }
  23. };
  24.  
  25. void test01()
  26. {
  27.     vector<int>v;
  28.     for (int i = 0; i < 10; i++)
  29.     {
  30.         v.push_back(i);
  31.     }
  32.     vector<int>vTarget;//目标容器
  33.     vTarget.resize(v.size());//目标容器 需要提前开辟空间，否则搬运不成功
  34.     transform(v.begin(), v.end(), vTarget.begin(), Transform());//可以在最后一个函数对搬运的数据进行运算或者改变 例如这次加10
  35.     for_each(vTarget.begin(), vTarget.end(), MyPrint());//仿函数要放函数对象，加（）
  36.     cout << endl;
  37. }
  38.  
  39. int main()
  40. {
  41.     test01();
  42.     system("pause");
  43.     return 0;
  44. }

输出结果：

  1. 10 11 12 13 14 15 16 17 18 19
  2. 请按任意键继续. . .

2.2常用查找算法

学习目标：掌握常用的查找算法

算法简介：

  1. find          //查找元素
  2. find_if       //按条件查找元素
  3. adjacent_find //查找相邻重复元素
  4. binary_search //二分查找法
  5. count         //统计元素个数
  6. count_if      //按条件统计元素个数

2.2.1 find

功能描述：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

  1. find(iterator beg, iterator end, value);
  2. // 按值查找元素，找到返回指定校置迭代器，找不到返回结束迭代器位置
  3. // beg 开始迭代器
  4. // end 结束迭代器
  5. // value 查找的元素
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<string>
  5. #include<algorithm>
  6. //常用查找算法 find
  7. //查找 内置数据类型
  8. void test01()
  9. {
  10.     vector<int>v;
  11.     for (int i = 0; i < 10; i++)
  12.     {
  13.         v.push_back(i);
  14.     }
  15.     vector<int>::iterator pos = find(v.begin(), v.end(), 5);
  16.     if (pos == v.end())
  17.     {
  18.         cout << "没有找到！" << endl;
  19.     }
  20.     else
  21.     {
  22.         cout << "找到：" << *pos << endl;
  23.     }
  24. }
  25.  
  26. class Person
  27. {
  28. public:
  29.     Person(string name, int age)
  30.     {
  31.         this->m_Name = name;
  32.         this->m_Age = age;
  33.     }
  34.     //重载== 底层find知道如何对比Person数据类型
  35.     bool operator==(const Person& p)
  36.     {
  37.         if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
  38.         {
  39.             return true;
  40.         }
  41.         else
  42.         {
  43.             return false;
  44.         }
  45.     }
  46.  
  47.     string m_Name;
  48.     int m_Age;
  49. };
  50.  
  51. //查找 自定义数据类型
  52. void test02()
  53. {
  54.     vector<Person>v;
  55.     //创建数据
  56.     Person p1("aaa", 10);
  57.     Person p2("bbb", 20);
  58.     Person p3("ccc", 30);
  59.     Person p4("ddd", 40);
  60.     Person pp("bbb", 20);//查找有无与此人相同的人
  61.     //放入到容器中
  62.     v.push_back(p1);
  63.     v.push_back(p2);
  64.     v.push_back(p3);
  65.     v.push_back(p4);
  66.     //查找
  67.     vector<Person>::iterator pos = find(v.begin(), v.end(), pp);
  68.     if (pos == v.end())
  69.     {
  70.         cout << "没有找到！" << endl;
  71.     }
  72.     else
  73.     {
  74.         cout << "找到此人 姓名：" << pos->m_Name << " 年龄：" << pos->m_Age << endl;
  75.     }
  76. }
  77.  
  78. int main()
  79. {
  80.     test01();
  81.     test02();
  82.     system("pause");
  83.     return 0;
  84. }

输出结果：

  1. 找到：5
  2. 找到此人 姓名：bbb 年龄：20
  3. 请按任意键继续. . .

2.2.2 find_if

功能描述：按条件查找元素

函数原型：

  1. find_if(iterator beg,iterator end,_Pred);
  2. // 按值查找元素，找到返回指定位置选代器，找不到返回结束迭代器位置
  3. // beg 开始迭代器
  4. // end 结束迭代器
  5. //_Pred 函数或者谓词(返回bool类型的仿函数)
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<string>
  5. #include<algorithm>
  6. //常用查找算法 find_if
  7. //1、查找 内置数据类型
  8. class GreaterFive
  9. {
  10. public:
  11.     bool operator()(int val)
  12.     {
  13.         return val > 5;
  14.     }
  15. };
  16.  
  17. void test01()
  18. {
  19.     vector<int>v;
  20.     for (int i = 0; i < 10; i++)
  21.     {
  22.         v.push_back(i);
  23.     }
  24.     vector<int>::iterator pos = find_if(v.begin(), v.end(), GreaterFive());
  25.     if (pos == v.end())
  26.     {
  27.         cout << "没有找到！" << endl;
  28.     }
  29.     else
  30.     {
  31.         cout << "找到大于5的数字 为：" << *pos << endl;
  32.     }
  33. }
  34.  
  35. class Person
  36. {
  37. public:
  38.     Person(string name, int age)
  39.     {
  40.         this->m_Name = name;
  41.         this->m_Age = age;
  42.     }
  43.     string m_Name;
  44.     int m_Age;
  45. };
  46.  
  47. class Greater20
  48. {
  49. public:
  50.     bool operator()(Person& p)
  51.     {
  52.         return p.m_Age > 20;
  53.     }
  54. };
  55.  
  56. //2、查找 自定义数据类型
  57. void test02()
  58. {
  59.     vector<Person>v;
  60.     //创建数据
  61.     Person p1("aaa", 10);
  62.     Person p2("bbb", 20);
  63.     Person p3("ccc", 30);
  64.     Person p4("ddd", 40);
  65.     Person pp("bbb", 20);//查找有无与此人相同的人
  66.     //放入到容器中
  67.     v.push_back(p1);
  68.     v.push_back(p2);
  69.     v.push_back(p3);
  70.     v.push_back(p4);
  71.     //查找年龄大于20的人
  72.     vector<Person>::iterator pos = find_if(v.begin(), v.end(), Greater20());
  73.     if (pos == v.end())
  74.     {
  75.         cout << "没有找到！" << endl;
  76.     }
  77.     else
  78.     {
  79.         cout << "找到此人 姓名：" << pos->m_Name << " 年龄：" << pos->m_Age << endl;
  80.     }
  81. }
  82.  
  83. int main()
  84. {
  85.     test01();
  86.     test02();
  87.     system("pause");
  88.     return 0;
  89. }

输出结果：

  1. 找到大于5的数字 为：6
  2. 找到此人 姓名：ccc 年龄：30
  3. 请按任意键继续. . .

2.2.3 adjacent_find

功能描述：查找相邻重复元素

函数原型：

  1. adjacent_find(iterator beg, iterator end);
  2. // 查找相邻重复元素,返回相邻元素的第一个位置的选代器
  3. // beg 开始迭代器
  4. // end 结束迭代器
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //常用查找算法 adjacent_find
  6. void test01()
  7. {
  8.     vector<int>v;
  9.     v.push_back(0);
  10.     v.push_back(2);
  11.     v.push_back(0);
  12.     v.push_back(3);
  13.     v.push_back(1);
  14.     v.push_back(4);
  15.     v.push_back(3);
  16.     v.push_back(3);
  17.     vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
  18.     if (pos == v.end())
  19.     {
  20.         cout << "没有找到相邻重复元素！" << endl;
  21.     }
  22.     else
  23.     {
  24.         cout << "找到相邻重复元素：" << *pos << endl;
  25.     }
  26. }
  27.  
  28. int main()
  29. {
  30.     test01();
  31.     system("pause");
  32.     return 0;
  33. }

输出结果：

  1. 找到相邻重复元素：3
  2. 请按任意键继续. . .

2.2.4 binary_search

功能描述：查找指定元素是否存在  注意: 在无序序列中不可用

函数原型：

  1. bool binary_search(iterator beg, iterator end, value);
  2. // 查找指定的元素，查到返回true 否则false
  3. // 注意: 在无序序列中不可用
  4. // beg 开始迭代器
  5. // end 结束迭代器
  6. // value 查找的元素n
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<algorithm>
  5. //常用查找算法 binary_search
  6. void test01()
  7. {
  8.     vector<int>v;
  9.     for (int i = 0; i < 10; i++)
  10.     {
  11.         v.push_back(i);
  12.     }
  13.     //查找容器中是否有9 元素
  14.     //注意: 在无序序列中不可用
  15.     //如果是无序序列，结果未知
  16.     //必须要有序
  17.     bool ret = binary_search(v.begin(), v.end(), 9);
  18.     if (ret)
  19.     {
  20.         cout << "找到了元素！" << endl;
  21.     }
  22.     else
  23.     {
  24.         cout << "未找到！" << endl;
  25.     }
  26. }
  27.  
  28. int main()
  29. {
  30.     test01();
  31.     system("pause");
  32.     return 0;
  33. }

输出结果：

  1. 找到了元素！
  2. 请按任意键继续. . .

2.2.5 count

功能描述：统计元素个数

注意：统计自定义数据类型时，需要配合重载operator==

函数原型：

  1. count(iterator beg, iterator end, value);
  2. // 统计元素出现次数
  3. // beg 开始迭代器
  4. // end 结束迭代器
  5. // value 统计的元素
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<string>
  5. #include<algorithm>
  6. //常用查找算法 count
  7. //1、统计内置数据类型
  8. void test01()
  9. {
  10.     vector<int>v;
  11.     v.push_back(10);
  12.     v.push_back(40);
  13.     v.push_back(30);
  14.     v.push_back(40);
  15.     v.push_back(20);
  16.     v.push_back(40);
  17.    
  18.     int num = count(v.begin(), v.end(), 40);
  19.     cout << "40元素个数为：" << num << endl;
  20. }
  21. //2、统计自定义数据类型
  22. class Person
  23. {
  24. public:
  25.     Person(string name, int age)
  26.     {
  27.         this->m_Name = name;
  28.         this->m_Age = age;
  29.     }
  30.     //需要加const，防止用户修改Person
  31.     //否则会报错
  32.     bool operator==(const Person& p)
  33.     {
  34.         if (this->m_Age == p.m_Age)
  35.         {
  36.             return true;
  37.         }
  38.         else
  39.         {
  40.             return false;
  41.         }
  42.     }
  43.     string m_Name;
  44.     int m_Age;
  45. };
  46.  
  47. void test02()
  48. {
  49.     vector<Person>v;
  50.     Person p1("刘备", 35);
  51.     Person p2("关羽", 35);
  52.     Person p3("张飞", 35);
  53.     Person p4("赵云", 30);
  54.     Person p5("曹操", 40);
  55.     //将人员插入到容器中
  56.     v.push_back(p1);
  57.     v.push_back(p2);
  58.     v.push_back(p3);
  59.     v.push_back(p4);
  60.     v.push_back(p5);
  61.     Person p("诸葛亮", 35);
  62.     int num = count(v.begin(), v.end(), p);
  63.     cout << "与诸葛亮同岁数的人员个数为：" << num << endl;
  64. }
  65.  
  66. int main()
  67. {
  68.     test01();
  69.     test02();
  70.     system("pause");
  71.     return 0;
  72. }

输出结果：

  1. 40元素个数为：3
  2. 与诸葛亮同岁数的人员个数为：3
  3. 请按任意键继续. . .

2.2.6 count_if

功能描述：按条件统计元素个数

函数原型：

  1. count_if(iterator beg, iterator end, _pred);
  2. // 按条件统计元素出现次数
  3. // beg 开始迭代器
  4. // end 结束迭代器
  5. // _Pred 谓词
  1. #include <iostream>
  2. using namespace std;
  3. #include<vector>
  4. #include<string>
  5. #include<algorithm>
  6. //常用查找算法 count_if
  7. //1、统计内置数据类型
  8. class Greater20
  9. {
  10. public:
  11.     bool operator()(int val)
  12.     {
  13.         return val > 20;
  14.     }
  15. };
  16. void test01()
  17. {
  18.     vector<int>v;
  19.     v.push_back(10);
  20.     v.push_back(40);
  21.     v.push_back(30);
  22.     v.push_back(20);
  23.     v.push_back(40);
  24.     v.push_back(20);
  25.    
  26.     int num = count_if(v.begin(), v.end(), Greater20());
  27.     cout << "大于20的元素个数为：" << num << endl;
  28. }
  29. //2、统计自定义数据类型
  30. class Person
  31. {
  32. public:
  33.     Person(string name, int age)
  34.     {
  35.         this->m_Name = name;
  36.         this->m_Age = age;
  37.     }
  38.     //需要加const，防止用户修改Person
  39.     //否则会报错
  40.     bool operator==(const Person& p)
  41.     {
  42.         if (this->m_Age == p.m_Age)
  43.         {
  44.             return true;
  45.         }
  46.         else
  47.         {
  48.             return false;
  49.         }
  50.     }
  51.     string m_Name;
  52.     int m_Age;
  53. };
  54.  
  55. class AgeGreater20
  56. {
  57. public:
  58.     bool operator()(const Person& p)
  59.     {
  60.         return p.m_Age > 20;
  61.     }
  62. };
  63.  
  64. void test02()
  65. {
  66.     vector<Person>v;
  67.     Person p1("刘备", 35);
  68.     Person p2("关羽", 35);
  69.     Person p3("张飞", 35);
  70.     Person p4("赵云", 40);
  71.     Person p5("曹操", 20);
  72.     //将人员插入到容器中
  73.     v.push_back(p1);
  74.     v.push_back(p2);
  75.     v.push_back(p3);
  76.     v.push_back(p4);
  77.     v.push_back(p5);
  78.     int num = count_if(v.begin(), v.end(), AgeGreater20());
  79.     cout << "大于20岁的人员个数为：" << num << endl;
  80. }
  81.  
  82. int main()
  83. {
  84.     test01();
  85.     test02();
  86.     system("pause");
  87.     return 0;
  88. }

输出结果：

  1. 大于20的元素个数为：3
  2. 大于20岁的人员个数为：4
  3. 请按任意键继续. . .
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/812855
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号