C++语言基础：STL函数对象

• 3、STL函数对象
  • 3.1、函数对象
    • 1、函数对象概念
      • 1. 概念
        • 重载函数调用操作符的类，其对象常称为函数对象
        • 函数对象使用重载的()时，行为类似函数调用，也叫仿函数
      • 2. 本质
        • 函数对象（仿函数）是一个类，不是一个函数
    • 2、函数对象使用
      • 1. 特点
        • 1. 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
        • 2. 函数对象超出普通函数的概念，函数对象可以有自己的状态
        • 3. 函数对象可以作为参数传递
      • 2. 示例
        • //1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值

        • class MyAdd
          {
          public:
              int operator()(int v1, int v2)
              {
                  return v1 + v2;
              }
          };
          //2.函数对象超出普通函数的概念，函数对象可以有自己的状态
          class MyPrint
          {
          public:
              void operator()(string s)
              {
                  cout << s << endl;
              }
          };
          //3.函数对象可以作为参数传递
          void doPrint(MyPrint& mp, string s) {
              mp(s);
          }
          void test01()
          {
              MyAdd myAdd;
              cout << myAdd(10, 10) << endl; // 20 //1.
              MyPrint myPrint;
              myPrint("Hello world!");//Hello world!  //2.
              myPrint("Hello world!");//Hello world!
              doPrint(myPrint, "Hello C++!");//Hello c++! // 3.
          }

  • 3.2、谓词
    • 1、谓词概念
      • 1. 概念
        • 1. 返回bool类型的仿函数称为谓词
        • 2. 如果operator() 接受一个参数，那个就叫做一元谓词
        • 3. 如果operator() 接受两个参数，那个就叫做二元谓词
    • 2、一元谓词
      • 示例：返回大于5的数量

        • class GreaterFive
          {
          public:
              bool operator()(int val)
              {
                  return val > 5;
              }
          };

    • 3、二元谓词
      • 示例：从大到小排序

        • class MyCompare
          {
          public:
              bool operator()(int val, int val2)
              {
                  return val > val2;
              }
          };
          
          void printVector(vector<int>& v) {
              for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
                  cout << *it << " ";
              }
              cout << endl;
          }
          void test01()
          {
              vector<int> v;
              for (int i = 0; i < 10; i++) {
                  v.push_back(i);
              }
              printVector(v); // 0 1 2 3 4 5 6 7 8 9
              sort(v.begin(), v.end(), MyCompare());
              printVector(v); // 9 8 7 6 5 4 3 2 1 0
          }

  • 3.3、内建函数对象
    • 1、内建函数对象意义
      • 1. 概念
        • STL内建了一些函数对象
      • 2. 分类
        • （1）算术仿函数
        • （2）关系仿函数
        • （3）逻辑仿函数
      • 3. 用法
        • 这些仿函数所产生的对象，用法和一般函数完全相同
        • 使用内建函数对象，需要引入头文件 #include <functional>
    • 2、算术仿函数
      • 1. 功能描述
        • 实现四则运算
        • 其中negate是一元运算，其他都是二元运算
      • 2. 仿函数原型
        • 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 > //取反，一元运算
      • 3. 示例
    • 3、关系仿函数
      • 1. 功能描述
        • 实现关系对比
      • 2. 仿函数原型
        • 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 > //小于等于
      • 3. 示例

        • vector<int> v;
          sort(v.begin(), v.end(), greater<int>()); // 降序排列

    • 4、逻辑仿函数
      • 1. 功能描述
        • 实现逻辑运算
      • 2. 仿函数原型
        • 1. template<class T> bool logical_and< T > // 逻辑与
        • 2. template<class T> bool logical_or< T > //逻辑或
        • 3. template<class T> bool logical_not< T > //逻辑非
      • 3. 示例

        • // 逻辑非，将v容器搬运到v2中，并执行逻辑非运算
          vector<int> v;
          vector<int> v2;
          v2.resize(v.size());
          transform(v.begin(), v.end(), v2.begin(), logical_not<bool>()); // 逻辑非

• 4、STL-常用算法
  • 概述
    • 1、算法主要由头文件<algorithm> <functional> <numeri> 组成
    • 2、<algorithm>：是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历、复制、修改等等
    • 3、<functional>：体积很小，只包含几个在序列上面进行简单数学运算的模板函数
    • 4、<numeri>：定义了一些模板类，用于声明函数对象
  • 4.1、遍历
    • 1、for_each // 遍历容器
      • 1. 函数原型：for_each(iterator begin, iterator end, _func)
        • begin：开始迭代器
        • end：结束迭代器
        • _func：函数或者函数对象
    • 2、transform // 搬运容器到另一个容器中
      • 1. 函数原型：transform(iterator begin1, iterator end1, iterator begin2, _func)
        • begin1：源容器开始迭代器
        • end1：源容器结束迭代器
        • begin2：目标容器开始迭代器
        • _func：函数或者函数对象
  • 4.2、查找（支持常见数据类型以及自定义数据类型）
    • 3、find // 按值查找指定元素，找到返回指定元素的迭代器，找不到就返回迭代器end()
      • 1. 函数原型：find(iterator begin, iterator end, value)
        • begin：开始迭代器
        • end：结束迭代器
        • value：查找的元素
    • 4、find_if // 按条件查找指定元素，找到返回指定元素的迭代器，找不到就返回迭代器end()
      • 1. 函数原型：find_if (iterator begin, iterator end, _Pred)
        • begin：开始迭代器
        • end：结束迭代器
        • _Pred：函数或者谓词（返回bool类型的仿函数）
    • 5、adjacent_find// 查找相邻的重复元素，返回相邻元素的第一个位置的迭代器，找不到就返回迭代器end()
      • 1. 函数原型：adjacent_find(iterator begin, iterator end)
        • begin：开始迭代器
        • end：结束迭代器
    • 6、binary_search // 按查找指定元素，查到返回true，否则返回false。注意在无序序列中不可用
      • 1. 函数原型：find(iterator begin, iterator end, value)
        • begin：开始迭代器
        • end：结束迭代器
        • value：查找的元素
    • 7、count // 统计元素的个数
      • 1. 函数原型：count(iterator begin, iterator end, value)
        • begin：开始迭代器
        • end：结束迭代器
        • value：被统计的元素
    • 8、count_if // 按条件统计元素个数
      • 1. 函数原型：count_if(iterator begin, iterator end, _Pred)
        • begin：开始迭代器
        • end：结束迭代器
        • _Pred：函数或者谓词（返回bool类型的仿函数）
  • 4.3、排序
    • 9、sort // 对容器内元素进行排序
      • 1. 函数原型：sort(iterator begin, iterator end, _Pred)
        • begin：开始迭代器
        • end：结束迭代器
        • _Pred：可写可不写，函数或者谓词（返回bool类型的仿函数）
    • 10、random_shuffle // 洗牌，指定范围内容器随机调整次序
      • 1. 函数原型：random_shuffle (iterator begin, iterator end)
        • begin：开始迭代器
        • end：结束迭代器
    • 11、merge // 容器元素合并，并存储到另一个容器中
      • 1. 函数原型：merge (iterator begin1, iterator end1, iterator begin2, iterator end2, iterator dest)
        • begin1：容器1开始迭代器
        • end1：容器1结束迭代器
        • begin2：容器2开始迭代器
        • end2：容器2结束迭代器
        • dest：目标容器开始迭代器
    • 12、reverse // 反转指定范围的元素
      • 1. 函数原型：reverse (iterator begin, iterator end)
        • begin：开始迭代器
        • end：结束迭代器
  • 4.4、拷贝和替换
    • 13、copy // 容器指定范围的元素拷贝到另一个元素中
      • 1. 函数原型：copy (iterator begin1, iterator end1, iterator dest)
        • begin1：容器1开始迭代器
        • end1：容器1结束迭代器
        • dest：目标容器开始迭代器
    • 14、replace // 将容器内指定范围的旧元素改为新元素
      • 1. 函数原型：replace (iterator begin, iterator end, oldValue, newValue)
        • begin：开始迭代器
        • end：结束迭代器
        • oldValue：旧元素
        • newValue：新元素
    • 15、replace_if // 容器指定范围满足条件的元素替换为新元素
      • 1. 函数原型：replace_if (iterator begin, iterator end, _pred, newValue)
        • begin：开始迭代器
        • end：结束迭代器
        • _pred：函数或者谓词（返回bool类型的仿函数）
        • newValue：新元素
    • 16、swap // 互换两个容器的元素
      • 1. 函数原型：swap (container c1, container c2)
        • c1：容器1
        • c2：容器2
  • 4.5、算术生成
    • 17、accumulate // 计算容器元素累计总和
      • 1. 函数原型：accumulate (iterator begin, iterator end, value)
        • begin：开始迭代器
        • end：结束迭代器
        • value：起始值
    • 18、fill // 向容器添加元素
      • 1. 函数原型：fill (iterator begin, iterator end, value)
        • begin：开始迭代器
        • end：结束迭代器
        • value：填充值
  • 4.6、集合
    • 19、set_intersection // 求两个容器的交集，两个容器必须是有序序列
      • 1. 函数原型：set_intersection (iterator begin1, iterator end1, iterator begin2, iterator end2, iterator dest)
        • begin1：容器1开始迭代器
        • end1：容器1结束迭代器
        • begin2：容器2开始迭代器
        • end2：容器2结束迭代器
        • dest：目标容器开始迭代器
    • 20、set_union // 求两个容器的并集
      • 1. 函数原型：set_union (iterator begin1, iterator end1, iterator begin2, iterator end2, iterator dest)
        • begin1：容器1开始迭代器
        • end1：容器1结束迭代器
        • begin2：容器2开始迭代器
        • end2：容器2结束迭代器
        • dest：目标容器开始迭代器
    • 21、set_difference // 求两个容器的差集
      • 1. 函数原型：set_difference (iterator begin1, iterator end1, iterator begin2, iterator end2, iterator dest)
        • begin1：容器1开始迭代器
        • end1：容器1结束迭代器
        • begin2：容器2开始迭代器
        • end2：容器2结束迭代器
        • dest：目标容器开始迭代器