• C++笔记打卡第22天(仿函数）

    1.函数对象

    • 重载函数调用操作符的类，其对象称为函数对象
    • 函数对象使用重载的()时，行为类似函数调用，也称为仿函数
    • 函数对象(仿函数)是一个类，不是一个函数

    使用时的特点：

    • 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
    • 函数对象超出普通函数的概念，函数对象可以有自己的状态
    • 函数对象可以作为参数传递
    1. // 1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
    2. class MyAdd
    3. {
    4. public:
    5.     int operator()(int v1, int v2)
    6.     {
    7.         return v1 + v2;
    8.     }
    9. };
    10. void test01()
    11. {
    12.     MyAdd myadd;
    13.     cout << myadd(10, 20) << endl;
    14. }
    15.  
    16. // 2.函数对象超出普通函数的概念，函数对象可以有自己的状态
    17. class MyPrint
    18. {
    19. public:
    20.     MyPrint()
    21.     {
    22.         this->count = 0;
    23.     }
    24.     void operator()(string text)
    25.     {
    26.         cout << text << endl;
    27.         this->count++;
    28.     }
    29.     int count;  // 记录调用次数
    30. };
    31.  
    32. void test02()
    33. {
    34.     MyPrint mp;
    35.     mp("Hello");
    36.     cout << mp.count << endl;
    37. }
    38.  
    39. // 3.函数对象可以作为参数传递
    40. void doPrint(MyPrint &mp, string text)
    41. {
    42.     mp(text);
    43. }
    44. void test03()
    45. {
    46.     MyPrint mp;
    47.     doPrint(mp, "hello");
    48. }

    2.谓词

    • 返回bool类型的仿函数称为谓词
    • 如果operator()接受一个参数，叫做一元谓词
    • 如果operator()接受两个参数，叫做二元谓词
    1. // 一元谓词
    2. class GreaterFive
    3. {
    4. public:
    5.     bool operator()(int num)
    6.     {
    7.         return num > 5;
    8.     }
    9. };
    10.  
    11. void test01()
    12. {
    13.     vector<int> v;
    14.     for(int i=0; i<10; i++)
    15.     {
    16.         v.push_back(i);
    17.     }
    18.     // 查找容器中是否有大于5的数字
    19.     // GreaterFive()是一个匿名的函数对象
    20.     // 返回值是一个迭代器
    21.     vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    22.     if(it == v.end())
    23.     {
    24.         cout << "未找到" << endl;
    25.     }
    26.     else
    27.     {
    28.         cout << "找到" << *it << endl;
    29.     }
    30. }
    1. // 二元谓词
    2. class MyCompare
    3. {
    4. public:
    5.     bool operator()(int num1, int num2)
    6.     {
    7.         return num1 > num2;
    8.     }
    9. };
    10.  
    11. void test01()
    12. {
    13.     vector<int> v;
    14.     v.push_back(10);
    15.     v.push_back(30);
    16.     v.push_back(20);
    17.     v.push_back(60);
    18.     v.push_back(50);
    19.  
    20.     sort(v.begin(), v.end());
    21.     for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    22.     {
    23.         cout << *it << " ";
    24.     }
    25.     cout << endl;
    26.  
    27.     // 使用仿函数，可以改变排序规则为降序
    28.     sort(v.begin(), v.end(), MyCompare());
    29.     for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    30.     {
    31.         cout << *it << " ";
    32.     }
    33.     cout << endl;
    34. }

    3.内建函数

    • STL内建了一些函数对象（仿函数）

    分类：

    • 算术仿函数
    • 关系仿函数
    • 逻辑仿函数

    用法：

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

    4.算术仿函数

    • template T plus; 加法仿函数
    • template T minus; 减法仿函数
    • template T multiplies; 乘法仿函数
    • template T divides; 除法仿函数
    • template T modulus; 取模仿函数
    • template T negate; 取反仿函数
    1. #include
    2.  
    3. // negate 一元仿函数 取反仿函数
    4. void test01()
    5. {
    6.     negate<int> n;
    7.     cout << n(50) << endl; // -50
    8. }
    9.  
    10. // plus 二元仿函数 加法
    11. void test02()
    12. {
    13.     plus<int> p;
    14.     cout << p(10, 20) << endl;
    15. }

    5.关系仿函数

    • template bool equal_to #等于
    • template bool not_equal_to #不等于
    • template bool greater 大于
    • template bool greater_equal_ 大于等于
    • template bool less 小于
    • template bool less_equal 小于等于
    1. #include
    2.  
    3. class MyCompare
    4. {
    5. public:
    6.     bool operator()(int num1, int num2)
    7.     {
    8.         return num1 > num2;
    9.     }
    10. };
    11.  
    12. void test01()
    13. {
    14.     vector<int> v;
    15.     v.push_back(10);
    16.     v.push_back(30);
    17.     v.push_back(40);
    18.     v.push_back(20);
    19.     v.push_back(50);
    20.  
    21.     for(vector<int>::iterator it=v.begin(); it != v.end(); it++)
    22.     {
    23.         cout << *it << " ";
    24.     }
    25.     cout << endl;
    26.  
    27.     // 降序
    28.     // 等价于sort(v.begin(), v.end(), MyCompare());
    29.     // greater()是内建函数对象（仿函数）
    30.     sort(v.begin(), v.end(), greater<int>());
    31.     for(vector<int>::iterator it=v.begin(); it != v.end(); it++)
    32.     {
    33.         cout << *it << " ";
    34.     }
    35.     cout << endl;
    36. }

    6.逻辑仿函数

    • template bool logical_and; 逻辑与
    • template bool logical_or; 逻辑或
    • template bool logical_not; 逻辑非
    1. void test01()
    2. {
    3.     vector<bool> v;
    4.     v.push_back(true);
    5.     v.push_back(false);
    6.     v.push_back(true);
    7.     v.push_back(false);
    8.  
    9.     for(vector<bool>::iterator it=v.begin(); it!=v.end(); it++)
    10.     {
    11.         cout << *it << " ";
    12.     }
    13.     cout << endl;  // 1 0 1 0
    14.  
    15.     // 利用逻辑非 将容器v搬运到容器v2中，并执行取反操作
    16.     vector<bool> v2;
    17.     v2.resize(v.size());  // 必须提前开辟空间，指定大小
    18.  
    19.     transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
    20.  
    21.      for(vector<bool>::iterator it=v2.begin(); it!=v2.end(); it++)
    22.     {
    23.         cout << *it << " ";
    24.     }
    25.     cout << endl; // 0 1 0 1
    26. }

    7.STL常用算法

    • 算法主要是由头文件组成
    • 是所有STL文件中最大的一个，范围涉及到比较、交换、查找、遍历、复制、修改等等
    • 体积很小，只包括几个在序列上面进行简单数学运算的模版函数
    • 定义了一些模版类，用以声明函数对象

    8.常用遍历算法

    • for_each：遍历容器

      1. // 普通函数
      2. void print01(int val)
      3. {
      4.     cout << val << endl;
      5. }
      6.  
      7. // 仿函数
      8. class print02
      9. {
      10. public:
      11.     void operator()(int val)
      12.     {
      13.         cout << val << endl;
      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.     
      25.     for_each(v.begin(), v.end(), print01);
      26.     cout << endl;
      27.  
      28.     for_each(v.begin(), v.end(), print02());
      29.     cout << endl;  
      30. }

    • transform：搬运容器到另一个容器中

      1. class Transform
      2. {
      3. public:
      4.     int operator()(int val)
      5.     {
      6.         return val;
      7.     }
      8. };
      9.  
      10. class Myprint
      11. {
      12. public:
      13.     void operator()(int val)
      14.     {
      15.         cout << val << " ";
      16.     }
      17. };
      18.  
      19. void test01()
      20. {
      21.     vector<int> v;
      22.     for(int i=0; i<10; i++)
      23.     {
      24.         v.push_back(i);
      25.     }
      26.  
      27.     vector<int> v2;  // 目标容器
      28.     v2.resize(v.size());  // 目标容器需要提前开辟空间
      29.     transform(v.begin(), v.end(), v2.begin(), Transform());
      30.     for_each(v2.begin(), v2.end(), Myprint());
      31.     cout << endl;
      32. }

    9.常用查找算法

    • find：查找元素**（返回值是一个迭代器）**

      1. // 查内置数据类型
      2. void test01()
      3. {
      4.     vector<int> v;
      5.     for(int i=0; i<10; i++)
      6.     {
      7.         v.push_back(i);
      8.     }
      9.     vector<int>::iterator it = find(v.begin(), v.end(), 5);
      10.     if(it == v.end())
      11.     {
      12.         cout << "找不到" << endl;
      13.     }
      14.     else
      15.     {
      16.         cout << "找到" << *it << endl;
      17.     }
      18. }
      1. class Person
      2. {
      3. public:
      4.     Person(string name, int age)
      5.     {
      6.         this->m_name = name;
      7.         this->m_age = age;
      8.     }
      9.     // 重载== 让底层find知道如何对比person数据类型
      10.     bool operator==(const Person &p)
      11.     {
      12.         if(p.m_name == this->m_name || p.m_age == this->m_age)
      13.         {
      14.             return true;
      15.         }
      16.         return false;
      17.     }
      18.     string m_name;
      19.     int m_age;
      20. };
      21.  
      22. // 查自定义数据类型
      23. void test02()
      24. {
      25.     vector v;
      26.     Person p1("Alice", 18);
      27.     Person p2("Bob", 16);
      28.     Person p3("Cycal", 20);
      29.     Person p4("Davil", 19);
      30.     v.push_back(p1);
      31.     v.push_back(p2);
      32.     v.push_back(p3);
      33.     v.push_back(p4);
      34.     
      35.     Person pp("Bob", 16);
      36.     vector::iterator it = find(v.begin(), v.end(), pp);
      37.     if(it == v.end())
      38.     {
      39.         cout << "找不到" << endl;
      40.     }
      41.     else
      42.     {
      43.         cout << "找到" << it->m_name << " " << it->m_age << endl;
      44.     }
      45. }

    • find_if：按条件查找元素

      1. class GreaterFive
      2. {
      3. public:
      4.     bool operator()(int val)
      5.     {
      6.         return val > 5;
      7.     }
      8. };
      9.  
      10. // 查内置数据类型
      11. void test01()
      12. {
      13.     vector<int> v;
      14.     for(int i=0; i<10; i++)
      15.     {
      16.         v.push_back(i);
      17.     }
      18.     vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
      19.     if(it == v.end())
      20.     {
      21.         cout << "找不到" << endl;
      22.     }
      23.     else
      24.     {
      25.         cout << "找到" << *it << endl;
      26.     }
      27. }
      1. class Person
      2. {
      3. public:
      4.     Person(string name, int age)
      5.     {
      6.         this->m_name = name;
      7.         this->m_age = age;
      8.     }
      9.     // 重载== 让底层find知道如何对比person数据类型
      10.     bool operator==(const Person &p)
      11.     {
      12.         if(p.m_name == this->m_name || p.m_age == this->m_age)
      13.         {
      14.             return true;
      15.         }
      16.         return false;
      17.     }
      18.     string m_name;
      19.     int m_age;
      20. };
      21.  
      22. class Greater20
      23. {
      24. public:
      25.     bool operator()(Person p)
      26.     {
      27.         return p.m_age > 20;
      28.     }
      29. };
      30.  
      31. // 查自定义数据类型
      32. void test02()
      33. {
      34.     vector v;
      35.     Person p1("Alice", 18);
      36.     Person p2("Bob", 16);
      37.     Person p3("Cycal", 22);
      38.     Person p4("Davil", 19);
      39.     v.push_back(p1);
      40.     v.push_back(p2);
      41.     v.push_back(p3);
      42.     v.push_back(p4);
      43.  
      44.     vector::iterator it = find_if(v.begin(), v.end(), Greater20());
      45.     if(it == v.end())
      46.     {
      47.         cout << "找不到" << endl;
      48.     }
      49.     else
      50.     {
      51.         cout << "找到" << it->m_name << " " << it->m_age << endl;
      52.     }
      53. }

    • adjacent_find：查找相邻重复元素

      1. void test01()
      2. {
      3.     vector<int> v;
      4.     v.push_back(0);
      5.     v.push_back(2);
      6.     v.push_back(1);
      7.     v.push_back(1);
      8.     v.push_back(3);
      9.     v.push_back(0);
      10.     v.push_back(2);
      11.     v.push_back(1);
      12.  
      13.     vector<int>::iterator it = adjacent_find(v.begin(), v.end());
      14.     if(it == v.end())
      15.     {
      16.         cout << "找不到相邻重复元素" << endl;
      17.     }
      18.     else
      19.     {
      20.         cout << "找到相邻重复元素" << *it << endl;
      21.     }
      22. }

    • binary_search：二分查找法（查找指定元素，查到返回true，查不到返回false）（在无序序列中不能使用）

      1. void test01()
      2. {
      3.     vector<int> v;
      4.     for(int i=0; i<10; i++)
      5.     {
      6.         v.push_back(i);
      7.     }
      8.     bool tag = binary_search(v.begin(), v.end(), 9);
      9.     if(tag == true)
      10.     {
      11.         cout << "找到了" << endl;
      12.     }
      13.     else
      14.     {
      15.         cout << "找不到" << endl;
      16.     }    
      17. }

    • count：统计元素个数

      1. // 统计内置数据类型
      2. void test01()
      3. {
      4.     vector<int> v;
      5.     for(int i=0; i<10; i++)
      6.     {
      7.         v.push_back(i);
      8.     }
      9.     int num = count(v.begin(), v.end(), 2);
      10.     cout << num << endl;    
      11. }
      1. class Person
      2. {
      3. public:
      4.     Person(string name, int age)
      5.     {
      6.         this->m_name = name;
      7.         this->m_age = age;
      8.     }
      9.  
      10.     // 重载== 让底层find知道如何对比person数据类型
      11.     bool operator==(const Person &p)
      12.     {
      13.         if(p.m_age == this->m_age)
      14.         {
      15.             return true;
      16.         }
      17.         return false;
      18.     }
      19.     string m_name;
      20.     int m_age;
      21. };
      22.  
      23. // 统计自定义数据类型
      24. void test02()
      25. {
      26.     vector v;
      27.     Person p1("Alice", 18);
      28.     Person p2("Bob", 16);
      29.     Person p3("Cycal", 22);
      30.     Person p4("Davil", 16);
      31.     v.push_back(p1);
      32.     v.push_back(p2);
      33.     v.push_back(p3);
      34.     v.push_back(p4);   
      35.     
      36.     Person pp("Tim", 16);
      37.     int num = count(v.begin(), v.end(), pp);
      38.     cout << num << endl;
      39. }

    • count_if：按条件统计元素个数

      1. class GreaterFive
      2. {
      3. public:
      4.     bool operator()(int val)
      5.     {
      6.         return val > 5;
      7.     }
      8. };
      9.  
      10. // 查内置数据类型
      11. void test01()
      12. {
      13.     vector<int> v;
      14.     for(int i=0; i<10; i++)
      15.     {
      16.         v.push_back(i);
      17.     }
      18.     int count = count_if(v.begin(), v.end(), GreaterFive());
      19.     cout << count << endl;
      20. }
      1. class Person
      2. {
      3. public:
      4.     Person(string name, int age)
      5.     {
      6.         this->m_name = name;
      7.         this->m_age = age;
      8.     }
      9.     string m_name;
      10.     int m_age;
      11. };
      12.  
      13. class MyCompare
      14. {
      15. public:
      16.     bool operator()(const Person &p)
      17.     {
      18.         return p.m_age > 18;
      19.     }
      20. };
      21.  
      22. // 查自定义数据类型
      23. void test02()
      24. {
      25.     vector v;
      26.     Person p1("Alice", 18);
      27.     Person p2("Bob", 16);
      28.     Person p3("Cycal", 20);
      29.     Person p4("Davil", 19);
      30.     v.push_back(p1);
      31.     v.push_back(p2);
      32.     v.push_back(p3);
      33.     v.push_back(p4);
      34.     
      35.     int count = count_if(v.begin(), v.end(), MyCompare());
      36.     cout << count << endl;
      37. }

  • 相关阅读:
    qt中QFileSystemModel和QStringListModel使用
    【PyTorch】深度学习实践之线性模型Linear Model
    java8新特性-stream流漫谈
    人脸自动贴国旗
    AgileConfig-1.7.0 发布，支持 SSO
    使用 Amazon Bedrock 和 Amazon SageMaker，开启全新的生成式 AI “工作年”！
    思维模型 首因效应
    WiFi网络分析工具Airtool for Mac
    【前端】JavaScript
    ATK-ESP8266使用说明（STM32-F4）
  • 原文地址：https://blog.csdn.net/weixin_57139639/article/details/138164735