【C++】函数对象/STL算法_stl count 函数对象-优快云博客

本文链接：https://blog.youkuaiyun.com/uytguytgf/article/details/128347233

本文详细介绍了C++中的函数对象（仿函数），包括谓词、内建函数对象如算术、关系和逻辑仿函数，并展示了它们的使用。此外，还探讨了STL中的常见算法，如遍历、查找、排序、拷贝、替换、算术生成和集合操作，每个算法都通过实例进行了演示，帮助读者深入理解C++ STL的运用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

一、函数对象（仿函数）
二、STL常用算法

一、函数对象（仿函数）

运算符重载()的类，其对象常称为函数对象（仿函数）

MyAdd myAdd;

//创建对象调用方式：
myAdd(10, 10)；

// 匿名对象调用，不创建专门的对象来调用
MyAdd()(10, 10);

特点：

函数对象在使用时，可以像普通函数那样调用, 可以有参数、返回值
函数对象可以作为参数传递

// 1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class MyAdd
{
public:
    int operator()(int v1, int v2)
    {
        return v1 + v2;
    }
};

void test01()
{
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl; 
}

// 2、函数对象可以有自己的状态
class MyPrint
{
public:
    MyPrint()
    {
        this->count = 0;
    }
    void operator()(string test)
    {
        cout << test << endl;
        this->count++; // 统计使用次数
    }

    int count; // 内部自己的状态  普通函数不是类，无法记录
};
void test02()
{
    MyPrint myPrint;
    myPrint("hello world");
    myPrint("hello world");
    myPrint("hello world");
    cout << "myPrint调用次数为: " << myPrint.count << endl;
}

// 3、函数对象可以作为参数传递
void doPrint(MyPrint &mp, string test)
{
    mp(test);
}

void test03()
{
    MyPrint myPrint;
    doPrint(myPrint, "Hello C++");
}

int main()
{

    test01();
    test02();
    test03();

    system("pause");

    return 0;
}

1 谓词（返回`bool`类型的仿函数称为谓词）

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
作用：判断是否存在满足某种条件的记录
谓词在STL中被广泛使用。标准关联容器的比较函数是谓词，谓词函数通常作为参数传递给find_if等算法

一元谓词

// 1.一元谓词
class GreaterFive
{
public:
    bool operator()(int val)
    {
        return val > 5;
    }
};

void test01()
{

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

    // 查找容器中有没有大于5的数字 （find_if（first,last,谓词））
    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive()); // GreaterFive()匿名函数对象
    if (it == v.end())
    {
        cout << "没找到!" << endl;
    }
    else
    {
        cout << "找到:" << *it << endl;
    }
}

int main()
{

    test01();
    system("pause");
    return 0;
}

二元谓词

// 二元谓词
class MyCompare
{
public:
    bool operator()(int num1, int num2)
    {
        return num1 > num2;
    }
};

void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);

    // 默认从小到大
    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    cout << "----------------------------" << endl;

    // 使用函数对象，改变算法策略，变为排序规则从大到小
    sort(v.begin(), v.end(), MyCompare());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{

    test01();
    system("pause");
    return 0;
}

2 内建函数对象

内建函数对象头文件：#include <functional>

2.1 算术仿函数

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

plus<int> p;  p(10, 20)  //加法仿函数
minus<int>                    //减法仿函数
multiplies<int>               //乘法仿函数
divides<int>                  //除法仿函数
modulus<int>                  //取模仿函数
negate<int> n;  n(50)    //取反仿函数

#include <functional> //内建函数对象头文件

// negate 一元仿函数  取反仿函数
void test01()
{
    negate<int> n;
    cout << n(50) << endl;
}

// plus  二元仿函数  加法仿函数
void test02()
{
    plus<int> p;
    cout << p(10, 20) << endl;
}

int main()
{

    test01();
    test02();

    system("pause");

    return 0;
}

2.2 关系仿函数

关系仿函数中最常用的就是greater<>大于

// 返回bool
equal_to<int>              //等于
not_equal_to<int>          //不等于
greater<int>               //大于
greater_equal<int>         //大于等于
less<int>                  //小于
less_equal<int>           //小于等于

sort(v.begin(), v.end(), greater<int>());

#include <functional>
#include <vector>
#include <algorithm>

class MyCompare
{
public:
    bool operator()(int v1, int v2)
    {
        return v1 > v2;
    }
};
void test01()
{
    vector<int> v;

    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(40);
    v.push_back(20);

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    // 自己实现仿函数
    // sort(v.begin(), v.end(), MyCompare());
    // STL内建仿函数  大于仿函数
    sort(v.begin(), v.end(), greater<int>());

    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{

    test01();
    system("pause");
    return 0;
}

2.3 逻辑仿函数

// 返回bool
logical_and<bool>     //逻辑与
logical_or<bool>      //逻辑或
logical_not<bool>()； //逻辑非
transform(v.begin(), v.end(), v2.begin(), logical_not<bool>()); // 逻辑非 将v容器搬运到v2中，并执行逻辑非运算

include <vector>
#include <functional>
#include <algorithm>

// 逻辑非 logical_not
void test01()
{
    vector<bool> v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);

    for (vector<bool>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;

    // 逻辑非  将v容器搬运到v2中，并执行逻辑非运算
    vector<bool> v2;

    v2.resize(v.size()); // 先开辟空间

    transform(v.begin(), v.end(), v2.begin(), logical_not<bool>()); // 搬运算法
    for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

二、STL常用算法

1 常用遍历算法

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

1.1 for_each（遍历容器）

for_each(v.begin(), v.end(), print01);   // 函数
for_each(v.begin(), v.end(), print02()); // 函数对象
// 遍历容器元素，beg 开始迭代器，end 结束迭代器，普通函数或者仿函数（函数对象）

#include <algorithm>
#include <vector>

// 常用的遍历算法for_each
void print01(int val)
{
    cout << val << " ";
}
// 函数对象
class print02
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

// for_each算法基本用法
void test01()
{

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

    // 遍历算法
    for_each(v.begin(), v.end(), print01);
    // 函数
    cout << endl;

    for_each(v.begin(), v.end(), print02());
    // 函数对象
    cout << endl;
}

int main()
{

    test01();
    system("pause");
    return 0;
}

1.2 transform（搬运容器到另一个容器中）

搬运容器到另一个容器中
搬运的目标容器必须要提前开辟空间

transform(v.begin(), v.end(), vTarget.begin(), TransForm());
//beg1 源容器开始迭代器，end1 源容器结束迭代器，
//beg2 目标容器开始迭代器，普通函数或者仿函数（函数对象），可以逻辑运算后搬运

#include <vector>
#include <algorithm>

// 常用遍历算法  搬运 transform
class TransForm
{
public:
    int operator()(int val) // 可以在这里做逻辑运算
    {
        return val;
    }
};

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

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

    vector<int> vTarget; // 目标容器

    vTarget.resize(v.size()); // 目标容器必需要提前开辟空间

    transform(v.begin(), v.end(), vTarget.begin(), TransForm());

    for_each(vTarget.begin(), vTarget.end(), MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

2 常用查找算法

find                  //查找元素
find_if               //按条件查找元素
adjacent_find         //查找相邻重复元素
binary_search         //二分查找法
count                 //统计元素个数
count_if              //按条件统计元素个数

2.1 find（查找元素）

查找指定元素，找到，返回指定元素的迭代器；找不到，返回结束迭代器end()

vector<int>::iterator it = find(v.begin(), v.end(), 5);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器，end 结束迭代器，value 查找的元素

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    // 重载==
    bool operator==(const Person &p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        return false;
    }

public:
    string m_Name;
    int m_Age;
};

// 查找 自定义数据类型
void test02()
{

    vector<Person> v;

    // 创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);

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

    vector<Person>::iterator it = find(v.begin(), v.end(), p2);
    if (it == v.end())
    {
        cout << "没有找到!" << endl;
    }
    else
    {
        cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    }
}
int main()
{
    test01();
    system("pause");
    return 0;
}

2.2 find_if（按条件查找元素）

vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器， end 结束迭代器，_Pred 函数或者谓词

// 常用查找算法find_if
// 1、内置数据类型
class GreaterFive
{
public:
    bool operator()(int val)
    {
        return val > 5;
    }
};

void test01()
{

    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i + 1);
    }

    vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
    if (it == v.end())
    {
        cout << "没有找到!" << endl;
    }
    else
    {
        cout << "找到大于5的数字:" << *it << endl;
    }
}

// 2、查找自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

public:
    string m_Name;
    int m_Age;
};

class Greater20
{
public:
    bool operator()(Person &p)
    {
        return p.m_Age > 20;
    }
};

void test02()
{

    vector<Person> v;

    // 创建数据
    Person p1("aaa", 10);
    Person p2("bbb", 20);
    Person p3("ccc", 30);
    Person p4("ddd", 40);

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

    // 找年龄大于20的人
    vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
    if (it == v.end())
    {
        cout << "没有找到!" << endl;
    }
    else
    {
        cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
    }
}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;

2.3 adjacent_find（查找相邻重复元素）

vector<int>::iterator it = adjacent_find(v.begin(), v.end());
// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
// beg 开始迭代器，end 结束迭代器

void test01()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(5);
    v.push_back(2);
    v.push_back(4);
    v.push_back(4);
    v.push_back(3);

    // 查找相邻重复元素
    vector<int>::iterator it = adjacent_find(v.begin(), v.end());
    if (it == v.end())
    {
        cout << "找不到!" << endl;
    }
    else
    {
        cout << "找到相邻重复元素为:" << *it << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}

2.4 binary_search（二分查找）（必须有序）

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

bool ret = binary_search(v.begin(), v.end(), 9);
// 查找指定的元素，查到 返回true 否则false
// beg 开始迭代器， end 结束迭代器，value 查找的元素

// 常用查找算法binary_search
void test01()
{
    vector<int> v;

    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    // 二分查找
    // 注意：容器必须是有序的序列  如果是无序序列，结果未知！
    bool ret = binary_search(v.begin(), v.end(), 9);
    if (ret)
    {
        cout << "找到了" << endl;
    }
    else
    {
        cout << "未找到" << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}

2.5 count（统计元素个数）

int num = count(v.begin(), v.end(), 4);
// 统计元素出现次数， beg 开始迭代器，end 结束迭代器，value 统计的元素

// 常用查找算法 count
// 1、统计内置数据类型
void test01()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(5);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);

    int num = count(v.begin(), v.end(), 4);

    cout << "4的个数为: " << num << endl;
}

// 2、统计自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    bool operator==(const Person &p)
    {
        if (this->m_Age == p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    int m_Age;
};

void test02()
{
    vector<Person> v;

    Person p1("刘备", 35);
    Person p2("关羽", 35);
    Person p3("张飞", 35);
    Person p4("赵云", 30);
    Person p5("曹操", 25);

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

    Person p("诸葛亮", 35);

    int num = count(v.begin(), v.end(), p);
    cout << "num = " << num << endl;
}
int main()
{
    test01();
    test02();
    system("pause");

    return 0;
}

2.6 count_if（按条件统计元素个数）

int num = count_if(v.begin(), v.end(), Greater4());
// 按条件统计元素出现次数，beg 开始迭代器，end 结束迭代器，_Pred 谓词（返回bool类型）

// 常用的查找算法 count_if
class Greater4
{
public:
    bool operator()(int val)
    {
        return val >= 4;
    }
};

// 内置数据类型
void test01()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(5);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);

    int num = count_if(v.begin(), v.end(), Greater4());

    cout << "大于4的个数为: " << num << endl;
}

// 自定义数据类型
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

class AgeLess35
{
public:
    bool operator()(const Person &p)
    {
        return p.m_Age < 35;
    }
};
void test02()
{
    vector<Person> v;

    Person p1("刘备", 35);
    Person p2("关羽", 35);
    Person p3("张飞", 35);
    Person p4("赵云", 30);
    Person p5("曹操", 25);

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

    int num = count_if(v.begin(), v.end(), AgeLess35());
    cout << "小于35岁的个数:" << num << endl;
}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

3 常用排序算法

sort                  //对容器内元素进行排序
random_shuffle        //洗牌 指定范围内的元素随机调整次序
merge                 // 容器元素合并，并存储到另一容器中
reverse               // 反转指定范围的元素

3.1 sort（对容器内元素进行排序）

sort(v.begin(), v.end()); //默认从小到大排序
//等价 sort(v.begin(), v.end(), less<int>()) （开头是小）

sort(v.begin(), v.end(), greater<int>()); //从大到小排序 （开头是大）
// beg 开始迭代器， end 结束迭代器， _Pred 谓词

// 常用排序算法 sort
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);

    // sort默认从小到大排序
    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;

    // 从大到小排序
    sort(v.begin(), v.end(), greater<int>()); // 内建函数对象
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

3.2 random_shuffle（指定范围内的元素随机调整次序）

总结：random_shuffle洗牌算法比较实用，使用时记得加随机数种子
srand((unsigned int)time(NULL)); 不加的话每次打乱结果相同

//洗牌 指定范围内的元素随机调整次序 , beg 开始迭代器，end 结束迭代器
random_shuffle(v.begin(), v.end()); //洗牌

#include <algorithm>
#include <vector>
#include <ctime>

// 常用排序算法 random_shuffle
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    srand((unsigned int)time(NULL)); // 不加的话每次打乱结果相同
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;

    // 打乱顺序
    random_shuffle(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

3.3 merge（合并且存储到另一容器中）（两个容器必须是有序的）

两个容器必须是有序的
目标容器需要提前开辟空间

//两个容器元素合并，并存储到另一容器中
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
// beg1 容器1开始迭代器，end1 容器1结束迭代器
// beg2 容器2开始迭代器，end2 容器2结束迭代器
// vtarget.begin() 目标容器开始迭代器

// 常用排序算法 merge
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

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

    vector<int> vtarget;
    // 目标容器需要提前开辟空间
    vtarget.resize(v1.size() + v2.size()); // 默认值以0代替
    // 合并  需要两个有序序列
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
    for_each(vtarget.begin(), vtarget.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

3.4 reverse（反转指定范围的元素）

//将容器内元素进行反转
reverse(v.begin(), v.end());
// beg 开始迭代器 ，end 结束迭代器

// 常用排序算法 reverse
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int> v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);

    cout << "反转前： " << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;

    cout << "反转后： " << endl;

    reverse(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

4 常用拷贝和替换算法

copy             // 容器内指定范围的元素拷贝到另一容器中
replace         // 将容器内指定范围的旧元素修改为新元素
replace_if      // 容器内指定范围满足条件的元素替换为新元素
swap            // 互换两个容器的元素

4.1 copy（容器内指定范围的元素拷贝到另一容器中）

容器内指定范围的元素拷贝到另一容器中
利用copy算法在拷贝时，目标容器记得提前开辟空间

copy(v1.begin(), v1.end(), v2.begin());
// beg 开始迭代器，end 结束迭代器
// dest 目标起始迭代器

// 常用拷贝和替换算法 copy
class myPrint // 用函数也可以
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int> v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i + 1);
    }
    vector<int> v2;
    v2.resize(v1.size());
    copy(v1.begin(), v1.end(), v2.begin());

    for_each(v2.begin(), v2.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

4.2 replace（将容器内指定范围的旧元素修改为新元素）

replace(v.begin(), v.end(), 20, 2000); //将容器中的20 替换成 2000
//beg 开始迭代器，end 结束迭代器

// 常用拷贝和替换算法 replace
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(20);
    v.push_back(40);
    v.push_back(50);
    v.push_back(10);
    v.push_back(20);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;

    // 将容器中的20 替换成 2000
    cout << "替换后：" << endl;
    replace(v.begin(), v.end(), 20, 2000);
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

4.3 replace_if（容器内指定范围满足条件的元素替换为新元素）

replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);  //将容器中大于等于的30 替换成 3000
// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器，end 结束迭代器， _pred 谓词，newvalue 替换的新元素

// 常用拷贝和替换算法 replace_if
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

class ReplaceGreater30
{
public:
    bool operator()(int val)
    {
        return val >= 30;
    }
};

void test01()
{
    vector<int> v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(20);
    v.push_back(40);
    v.push_back(50);
    v.push_back(10);
    v.push_back(20);

    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;

    // 将容器中大于等于的30 替换成 3000
    cout << "替换后：" << endl;
    replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

4.4 swap（互换两个容器的元素）

swap交换容器时，注意交换的容器要同种类型

swap(v1, v2);
// 互换两个容器的元素，c1容器1，c2容器2

// 常用拷贝和替换算法 swap
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

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

    cout << "交换前： " << endl;
    for_each(v1.begin(), v1.end(), myPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), myPrint());
    cout << endl;

    cout << "交换后： " << endl;
    swap(v1, v2);
    for_each(v1.begin(), v1.end(), myPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

5 常用算术生成算法

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

accumulate      // 计算容器元素累计总和
fill           // 向容器中添加元素

5.1 accumulate（计算区间内容器元素累计总和）

int total = accumulate(v.begin(), v.end(), 10);  //10为起始累加值
// 计算容器元素值累计总和，beg 开始迭代器，end 结束迭代器，value 起始值

#include <numeric>
#include <vector>

// 常用算术生成算法
// 计算区间内 容器元素累计总和  accumulate
void test01()
{
    vector<int> v;
    for (int i = 0; i <= 100; i++)
    {
        v.push_back(i);
    }
    // 参数3，起始累加值
    int total = accumulate(v.begin(), v.end(), 10);

    cout << "total = " << total << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

5.2 fill（向容器中填充指定的元素）

fill(v.begin(), v.end(), 100);
// beg 开始迭代器，end 结束迭代器，value 填充的值

#include <numeric>
#include <vector>
#include <algorithm>

// 常用算数生成算法 fill 填充
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{

    vector<int> v;
    v.resize(10);

    // 后期重新填充
    fill(v.begin(), v.end(), 100);

    for_each(v.begin(), v.end(), myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

6 常用集合算法

set_intersection         // 求两个容器的交集
set_union                // 求两个容器的并集
set_difference           // 求两个容器的差集

6.1 set_intersection（求两个容器的交集）

注意：两个集合必须是有序序列
目标容器开辟空间需要从两个容器中取小值

vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
//返回目标容器的最后一个元素的迭代器地址
// beg1 容器1开始迭代器，end1 容器1结束迭代器
// beg2 容器2开始迭代器，end2 容器2结束迭代器
// vTarget.begin() 目标容器开始迭代器

#include <vector>
#include <algorithm> //min

// 常用集合算法  set_intersection
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    // 原容器必须是有序序列
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     // 0~9
        v2.push_back(i + 5); // 5~14
    }

    vector<int> vTarget;

    // 取两个里面较小的值给目标容器开辟空间
    vTarget.resize(min(v1.size(), v2.size()));

    // 返回目标容器的最后一个元素的迭代器地址
    vector<int>::iterator itEnd =
        set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin()); // 返回最后位置的迭代器

    //  for_each(vTarget.begin(), vTarget.end(), myPrint());这种会有0填满容器 因为开辟的容量可能会大一些
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

6.2 set_union（求两个集合的并集）

注意：两个集合必须是有序序列
目标容器开辟空间需要两个容器相加

vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
// set_union返回值是并集中最后一个元素的位置
// beg1 容器1开始迭代器，end1 容器1结束迭代器
// beg2 容器2开始迭代器，end2 容器2结束迭代器
// vTarget.begin() 目标容器开始迭代器

#include <vector>
#include <algorithm>

// 常用集合算法 set_union
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

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

    vector<int> vTarget;
    // 取两个容器的和给目标容器开辟空间
    vTarget.resize(v1.size() + v2.size());

    // 返回目标容器的最后一个元素的迭代器地址
    vector<int>::iterator itEnd =
        set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

6.3 set_difference（求两个集合的差集）

注意：两个集合必须是有序序列
目标容器开辟空间需要从两个容器取较大值

vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
// set_difference返回值是差集中最后一个元素的位置
// beg1 容器1开始迭代器，end1 容器1结束迭代器
// beg2 容器2开始迭代器，end2 容器2结束迭代器
// dest 目标容器开始迭代器

#include <vector>
#include <algorithm>

// 常用集合算法 set_difference
class myPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

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

    vector<int> vTarget;
    // 取两个里面较大的值给目标容器开辟空间
    vTarget.resize(max(v1.size(), v2.size()));

    // 返回目标容器的最后一个元素的迭代器地址
    cout << "v1与v2的差集为: " << endl;
    vector<int>::iterator itEnd =
        set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;

    cout << "v2与v1的差集为: " << endl;
    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    for_each(vTarget.begin(), itEnd, myPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}