函数对象与STL算法-CSDN博客

整理的个人学习笔记，学习视频在B站，详情点击右上角版权进行查看

函数对象

函数对象概念

重载 函数调用操作符 的类，其对象常称为 函数对象
函数对象 使用重载的（）时，行为类似函数调佣，也叫 仿函数

本质

函数对象（仿函数）是一个类，不是一个函数

函数对象使用

特点

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

案例

class AddNum {
public:
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }
};

class PrtStr {
public:
    PrtStr()
    {
        this->count = 0;;
    }

    void operator()(string str)
    {
        cout << str << endl;
        this->count++;
    }

    int count;  // 类内部的状态
};

/* 1. 函数对象在使用时，可以像普通函数那样调用，可以有参数，也可以有返回值 */
void test01()
{
    AddNum ad1;
    cout << ad1(10, 11) << endl;
}

/* 2. 函数对象超出普通函数的概念，函数对象可以有自己的状态：count计数 */
void test02()
{
    PrtStr ps;
    ps("hello, world");
    ps("hello, world");
    ps("hello, world");

    /* 函数对象可以有自己的状态 */
    cout << "count: " << ps.count << endl;  /* 调用了三次 */
}


/* 3. 函数对象可以作为参数传递 */
void SelfPrt(PrtStr& ps, string str)
{
    ps(str);
}

void test03()
{
    PrtStr ps;
    SelfPrt(ps, "hello C++");
}

内建函数对象

用法：

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

算术仿函数

功能：

实现四则运算
其中 negate 是一元运算，其他都是二元运算

函数原型

template<class T> T plus<T> // 加法仿函数
template<class T> T minus<T> // 减法仿函数
template<class T> T multiplies<T> // 乘法仿函数
template<class T> T divides<T> // 除法仿函数
template<class T> T modulus<T> // 取模仿函数
template<class T> T negate<T> // 取反仿函数

案例

void test02()
{
    negate<int> n;	// 一元取反操作
    cout << n(50) << endl;	// 输出 -50

	plus<int> p;	// 二元 加法
    cout << p(10, 12) << endl;	// 输出 22
}

关系仿函数

实现关系对比

函数原型

template<class T> bool equal_to<T> // 等于
template<class T> bool not_equal_to<T> // 不等于
template<class T> bool greater<T> // 大于
template<class T> bool greater_equal<T> // 大于等于
template<class T> bool less<T> // 小于
template<class T> bool less_equal<T> // 小于等于

案例

void Prt(vector<int>& vec)
{
    for (auto i : vec) {
        cout << i << " ";
    }
    cout << endl;
}

class Cpm {
public:
    bool operator()(int a, int b)
    {
        return a > b;
    }
};

void test01()
{
    vector<int> vec;
    vec.push_back(10);
    vec.push_back(30);
    vec.push_back(20);
    Prt(vec);

    // sort(vec.begin(), vec.end(), Cpm());
    sort(vec.begin(), vec.end(), greater<int>());	// 和上述 sort 是一致的

    Prt(vec);
}

逻辑仿函数

实现逻辑运算

函数原型

template<class T> bool logical_and<T> // 逻辑与
template<class T> bool logical_or<T> // 逻辑或
template<class T> bool logical_not<T> // 逻辑非

案例

void test03()
{
    vector<bool> vec;
    vec.push_back(true);
    vec.push_back(false);
    vec.push_back(true);
    vec.push_back(false);
    vec.push_back(true);
    Prt(vec);	// 输出 1 0 1 0 1

    vector<bool> v2;
    v2.resize(vec.size());

	// transform 搬运算法，利用逻辑非将 容器 vec 搬运到 v2 当中，并执行取反操作
    transform(vec.begin(), vec.end(), v2.begin(), logical_not<bool>());
    Prt(v2);	// 输出 0 1 0 1 0
}

常用算法

概述：

算法主要是由头文件 <algorithm>，<functional>，<numeric> 组成
<algorithm> 是所有STL 文件中最大的一个，范围涉及到比较，交换，查找，编译操作，复制，修改等等
<functional> 定义了一些模板类，用以声明函数对象
<numeric> 体积很小，只包含几个序列上面进行简单数学运算的模板函数

常用遍历算法

for_each(iterator beg, iterator end, _func); // 实现遍历容器
transform(iterator source_beg, iterator source_end,iterator target_beg, _func); // 搬运容器 source 到另一个容器 target 中

案例 for_each

void Prt(int val)
{
    cout << val << " ";
}

class ClaPrt {
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

class Trans {
public:
    int operator()(int n)
    {
        return n + 10;
    }
};

void test01()
{
    vector<int> v1;
    for (int i = 0; i < 10; ++i) {
        v1.push_back(i);
    }

    for_each(v1.begin(), v1.end(), Prt);	// 普通函数调用
    cout << endl;	// 输出 0 1 2 3 4 5 6 7 8 9

    for_each(v1.begin(), v1.end(), ClaPrt());	// 仿函数（匿名函数）调用
    cout << endl;	// 输出 0 1 2 3 4 5 6 7 8 9
}

void test02()
{
    vector<int> source;
    for (int i = 10; i > 0; --i) {
        source.push_back(i);
    }

    vector<int> target;
    target.resize(source.size());	// 指定 target 大小

    transform(source.begin(), source.end(), target.begin(), Trans());	// 遍历source，赋值到target
    for_each(target.begin(), target.end(),ClaPrt());	// 遍历打印
    cout << endl;	// 输出 20 19 18 17 16 15 14 13 12 11
}

for_each 在实际开发中时最常用的遍历算法，需要熟练掌握

常用查找算法

find(iterator beg, iterator end, value); // 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器 end()
find_if(iterator beg, iterator end, _Pred); // 按条件查找元素，_Pred 函数或者谓词（返回bool类型的仿函数）
adjacent_find(iterator beg, iterator end); // 查找相邻重复元素
binary_search(iterator beg, iterator end, value); // 二分查找法, 必须在 有序的序列 中，如果是无序序列，结果是未知
count(iterator beg, iterator end, value); // 统计元素个数，使用手法参考 find
count_if(iterator beg, iterator end, _Perd); // 按条件统计元素个数，_Perd 是谓词，使用手法同 count

案例 find & find_if

class Person {
public:
     Person(string name, int age)
     {
        this->name_ = name;
        this->age_ = age;
     }

     // 重载 == 符号，底层 find 知道如何对比person数据类型
     bool operator==(const Person& p)
     {
         if (this->name_ == p.name_ && this->age_ == p.age_) {
             return true;
         } else {
             return false;
         }
     }

     string name_;
     int age_;
};

class GreatePer30 {
public:
    bool operator()(Person& p)
    {
        return p.age_ > 30;
    }
};

// find
void test03()
{
    vector<Person> per;	// 创建容器
    Person p1("mille", 10);	// 创建三个对象
    Person p2 ("Tom", 23);
    Person p3("Bob", 18);

    per.push_back(p1);	// 插入三个对象到容器中
    per.push_back(p2);
    per.push_back(p3);

    Person p("Bob", 18);	// 新建一个对象
    vector<Person>::iterator it = find(per.begin(), per.end(), p);	// 查找该对象
    if (it != per.end()) {
        cout << "find it Name: " << it->name_ << ", Age " << it->age_ << endl;
    } else {
        cout << "not find " << endl;
    }	// 输出：
}

/* find_if 自定义数据类型 */
void test05()
{
    vector<Person> v;
    Person p1("Tom", 22);
    Person p2("Sam", 23);
    Person p3("Bob", 34);

    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);

    vector<Person>::iterator it = find_if(v.begin(), v.end(), GreatePer30());
    if (it != v.end()) {
        cout << "find it , Name: " << it->name_ << ", Age: " << it->age_ << endl;
    } else {
        cout << "not find" << endl;
    }
}

常用排序算法

sort(iterator beg, iterator end, _Perd); // 对容器内元素进行排序， _Perd(谓词）— 可选参数
random_shuffle(iterator beg, iterator end); // 洗牌，指定范围内的元素随机调整次序，在调用加入 srand((unsigned int)time(nullptr)); 即可按时间洗出不同次序的序列
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); // 容器元素合并，并存储到另一个容器中， 两个容器必须都是顺序一直的有序容器，并且给 dest 容器分配够空间
reverse(iterator beg, iterator end); // 反转指定范围的元素

常用拷贝和替换算法

copy(iterator beg, iterator end, iterator dest); // 容器内指定范围的元素拷贝到另一容器中
replace(iterator beg, iterator end, oldValue, newValue); // 将容器内指定范围的旧元素修改为新元素
replace_if(iterator beg, iterator end, _pred, newValue); // 容器内指定范围满足条件的元素替换为新元素
swap(container c1, container c2); // 互换两个容器 c1, c2 的所有元素，交换的容器必须是同种类型

常用算术生成算法

算术生成算法属于小型算法，使用时包含头文件 <numeric>

accumulate(iterator beg, iterator end, value); // 计算容器元素累计总和， value 是起始累加值，可选参数或者默认为0
fill(iterator beg, iterator end, value); // 向容器中添加元素, value 是需要填充的值

常用集合算法

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); // 求两个容器的交集，两个容器必须有序，目标容器大小是两个容器中的最小值，set_intersection 返回值是交集中最后一个元素的位置
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); // 求两个容器的并集, 两个容器必须有序, 具体使用方式参考 set_intersection
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); // 求两个容器的差集（是另一个元素中没有的元素，并且是有方向的，a→b 和 b→a 的差集是不一样的）具体使用方式参考上两个