C++进阶语法——STL 标准模板库（下）（Standard Template Library）【学习笔记（七）】-CSDN博客

阿里云国内75折回扣微信号：monov8

阿里云国际，腾讯云国际，低至75折。AWS 93折免费开户实名账号代冲值优惠多多微信号：monov8 飞机：@monov6

文章目录

- STL 代码示例

STL 代码示例

1、迭代器

迭代器可以将任意的容器抽象成一个序列可以使用迭代器遍历容器中的元素
迭代器设计的目的是为了解决容器与算法之间的耦合问题与指针类似可以通过迭代器访问容器中的元素
迭代器的声明方式为容器类型::iterator 变量名称可以理解为一个普通的指针比如
std::vector<int>::iterator it;
std::list<int>::iterator it;
std::map<int, int>::iterator it;
std::set<int>::iterator it;

代码

/*
* 迭代器示例
* 迭代器可以将任意的容器抽象成一个序列可以使用迭代器遍历容器中的元素
* 迭代器设计的目的是为了解决容器与算法之间的耦合问题与指针类似可以通过迭代器访问容器中的元素

* 迭代器的声明方式为容器类型::iterator比如

std::vector<int>::iterator it;
std::list<int>::iterator it;
std::map<int, int>::iterator it;
std::set<int>::iterator it;

*/
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <list>

// 打印vector元素
void printVec(const std::vector<int> &v)
{
    std::cout << "[";
    for (const auto &e : v)
        std::cout << e << " ";
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::vector<int> v1 {1, 2, 3, 4, 5};
    std::vector<int>::iterator it =  v1.begin(); // 指向第一个元素
    std::cout << *it << std::endl;

    it++; // 指向第二个元素
    std::cout << *it << std::endl;

    it += 2; // 指向第四个元素
    std::cout << *it << std::endl;

    it -= 2; // 指向第二个元素
    std::cout << *it << std::endl;

    it = v1.end() - 1; // 指向最后一个元素注意end()指向最后一个元素的下一个位置
    std::cout << *it << std::endl;
    
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::vector<int> v1 {1, 2, 3, 4, 5};
    auto it = v1.begin();

    while (it != v1.end())
    {
        std::cout << *it << std::endl;
        it++; // 指向下一个元素
    }

    it = v1.begin();
    while (it != v1.end())
    {
        *it = 100; // 修改元素值
        it++;
    }
    printVec(v1);

}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::vector<int> v1 {1, 2, 3, 4, 5};
    // std::vector<int>::const_iterator it = v1.begin(); // 常量迭代器只能读取元素不能修改元素
    auto it = v1.cbegin(); // 如果使用auto需要使用cbegin()函数返回一个常量迭代器

    while (it != v1.end())
    {
        std::cout << *it << std::endl;
        it++; // 指向下一个元素
    }

    it = v1.begin(); // 重新指向第一个元素
    while (it != v1.end())
    {
        // *it = 100; // 报错不能修改元素
        it++; // 指向下一个元素
    }
    
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::vector<int> v1 {1, 2, 3, 4, 5};
    auto it = v1.rbegin(); // 返回一个反向迭代器指向最后一个元素
    while (it != v1.rend()) // rend()指向第一个元素的前一个位置
    {
        std::cout << *it << std::endl;
        it++; // 指向下一个元素
    }

    std::list<std::string> l1 {"hello", "world", "c++"};
    auto it2 = l1.rbegin();
    std::cout << *it2 << std::endl;
    it2++;
    std::cout << *it2 << std::endl;

    // map 里面的元素会自动按 key 进行排序
    std::map<std::string, std::string> m1 {
        {"hello", "你好"},
        {"world", "世界"},
        {"Computer", "计算机"}
    };

    auto it3 = m1.begin();

    while (it3 != m1.end())
    {
        std::cout << it3->first << " : " << it3->second << std::endl;
        it3++;
    }

}
int main()
{
    // test1();
    // test2();
    // test3();
    test4();
    return 0;
}

2、算法

STL算法基于迭代器生成的序列
STL提供了很多算法例如查找、排序、计数、操作可以对序列进行操作
更多请查看https://zh.cppreference.com/w/cpp/algorithm
多数算法要求提供额外参数例如排序算法需要提供排序规则一般使用函数指针、lambda表达式或仿函数函数对象

代码

/*
* 算法示例
* STL算法基于迭代器生成的序列
* STL提供了很多算法例如查找、排序、计数、操作可以对序列进行操作
* 更多请查看https://zh.cppreference.com/w/cpp/algorithm
* 多数算法要求提供额外参数例如排序算法需要提供排序规则一般使用函数指针、lambda表达式或仿函数函数对象
*/

#include <iostream>
#include <vector>
#include <algorithm> // 算法头文件
#include <list>

void test1()
{
    std::cout << "test1 ======================" << std::endl;

    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int>::iterator loc = std::find(v1.begin(), v1.end(), 3); // 查找3
    std::cout << *loc << std::endl;  // 3
    std::cout << *v1.end() << std::endl; // 0
    if (loc != v1.end())
        std::cout << "找到 3" << std::endl;
    else
        std::cout << "未找到 3" << std::endl;
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 1, 2, 1};
    int counts = std::count(v1.begin(), v1.end(), 1); // 统计1的个数
    std::cout << "1的个数: " << counts << std::endl;
}

// 判断是否是偶数
bool isEven(int x)
{
    return x % 2 == 0;
}
void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8, 9};

    int counts = std::count_if(v1.begin(), v1.end(), isEven); // 使用函数指针统计偶数个数

    counts = std::count_if(v1.begin(), v1.end(), [](int x)
                           { return x % 2 == 0; }); // 使用lambda表达式统计偶数个数
    std::cout << "偶数个数: " << counts << std::endl;

    counts = std::count_if(v1.begin(), v1.end(), [](int x)
                           { return x > 6; }); // 统计大于6的个数
    std::cout << "大于6的个数: " << counts << std::endl;
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 1, 2, 1};
    for (const auto &e : v1)
        std::cout << e << " ";
    
    std::cout << std::endl;

    std::replace(v1.begin(), v1.end(), 1, 100); // 将1替换为100

    for (const auto &e : v1)
        std::cout << e << " ";
    std::cout << std::endl;
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8, 9};
    if (std::all_of(v1.begin(), v1.end(), [](int x) { return x > 5; }) ) // 所有元素都大于5
        std::cout << "所有元素都大于5" << std::endl;
    else
        std::cout << "不是所有元素都大于5" << std::endl;
    
    if (std::any_of(v1.begin(), v1.end(), [](int x) { return x > 5; }) ) // 至少有一个元素大于5
        std::cout << "有元素大于5" << std::endl;
    else
        std::cout << "没有元素大于5" << std::endl;

    if (std::none_of(v1.begin(), v1.end(), [](int x) { return x < 0; }) ) // 没有元素小于0
        std::cout << "没有元素小于0" << std::endl;
    else
        std::cout << "有元素小于0" << std::endl;

}

void test6()
{
    std::cout << "test6 ======================" << std::endl;
    std::string s1 {"hello world"};
    std::cout << s1 << std::endl;
    std::transform(s1.begin(), s1.end(), s1.begin(), ::toupper); // 转换为大写从s1的begin到end转换后的结果放到s1的begin
    std::cout << s1 << std::endl;

}
int main()
{
    test1();
    // test2();
    // test3();
    // test4();
    // test5();
    // test6();

    return 0;
}

3、array容器示例

array大小固定不可改变
在内存中是连续的
获取元素的复杂度是常数与array元素个数无关
是对原始数组的封装也可以获取原始数组的指针
如果数组大小固定尽量使用array而不是使用C++原生数组因为array可以使用标准库的算法

代码

/*
* array容器示例
* array大小固定不可改变
* 在内存中是连续的
* 获取元素的复杂度是常数与array元素个数无关
* 是对原始数组的封装也可以获取原始数组的指针
* 如果数组大小固定尽量使用array而不是使用C++原生数组因为array可以使用标准库的算法
*/

#include <iostream>
#include <array> // 使用array容器
#include <algorithm> 
#include <numeric> 

// 打印数组
void display(const std::array<int,5> &arr)
{
    std::cout << "[ ";
    for (const auto &a: arr)
        std::cout << a << " ";
    std::cout << "]" << std::endl;
}


void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    std::array<int, 5> arr2;

    display(arr1);
    display(arr2); // 未初始化值为随机值

    arr2 = {10, 20, 30, 40, 50}; // 可以直接赋值

    display(arr1);
    display(arr2); 

    std::cout << "arr1的大小" << arr1.size() << std::endl;
    std::cout << "arr2的大小" << arr2.size() << std::endl;

    arr1[0] = 1000;
    arr1.at(1) = 2000;
    display(arr1);

    std::cout << "arr1的第一个元素" << arr1.front() << std::endl;
    std::cout << "arr1的最后一个元素" << arr1.back() << std::endl;
    
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    std::array<int, 5> arr2 {10, 20, 30, 40, 50};

    display(arr1);
    display(arr2);

    arr1.fill(0);
    display(arr1);
    display(arr2);

    arr1.swap(arr2);
    display(arr1);
    display(arr2);

    
}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::array<int, 5> arr1 {1, 2, 3, 4, 5};
    int *ptr = arr1.data(); // 返回数组的首地址
    std::cout << ptr << std::endl;
    std::cout << *ptr << std::endl;
    *ptr = 1000;
    display(arr1);
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::array<int, 5> arr1 {3,1,4,2,5};
    display(arr1);
    std::sort(arr1.begin(), arr1.end());
    display(arr1);
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::array<int, 5> arr1 {3,6,4,2,5};
    std::array<int, 5>::iterator min_val = std::min_element(arr1.begin(), arr1.end());
    auto max_val = std::max_element(arr1.begin(), arr1.end());
    std::cout << "min: " << *min_val << std::endl;
    std::cout << "max: " << *max_val << std::endl;
}

void test6()
{
    std::cout << "test6 ======================" << std::endl;
    std::array<int, 5> arr1 {3,6,2,2,5};
    
    auto adjacent = std::adjacent_find(arr1.begin(), arr1.end()); // 查找相邻的两个相同的元素
    if (adjacent != arr1.end())
        std::cout << "adjacent: " << *adjacent << std::endl;
    else
        std::cout << "没有找到相邻的两个相同的元素" << std::endl;

}

void test7()
{
    std::cout << "test7 ======================" << std::endl;
    std::array<int, 5> arr1 {1,2,3,4,5};
    int sum = std::accumulate(arr1.begin(), arr1.end(), 0); // 求和
    std::cout << "sum: " << sum << std::endl;

}

void test8()
{
    std::cout << "test8 ======================" << std::endl;
    std::array<int, 10> arr1 {1,2,3,4,5,5,5,5,5,5};
    int counts = std::count(arr1.begin(), arr1.end(), 5); // 统计5的个数
    std::cout << "5一共出现了" << counts << "次" << std::endl;
}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    // test5();
    // test6();
    // test7();
    test8();
    return 0;
}

4、vector示例

vector是一个动态数组可以随意增加元素
与array一样vector在内存中是连续的对应的内存空间会随着元素的增加而增加
获取元素的复杂度是常数与vector的大小无关

在vector末尾增加、删除元素的复杂度是常数与vector的大小无关

在vector中间增加、删除元素的复杂度是线性的与vector的大小有关
可以使用迭代器和算法

代码

/*
* vector示例
* vector是一个动态数组可以随意增加元素
* 与array一样vector在内存中是连续的对应的内存空间会随着元素的增加而增加
* 获取元素的复杂度是常数与vector的大小无关
* 在vector末尾增加、删除元素的复杂度是常数与vector的大小无关
* 在vector中间增加、删除元素的复杂度是线性的与vector的大小有关
* 可以使用迭代器和算法
*/

#include <iostream>
#include <vector>
#include <algorithm>

// 打印vector的函数模板
template <typename T>
void printVector(const std::vector<T> &v)
{
    std::cout << "[";
    for (const auto &e : v)
        std::cout << e << " ";
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5};
    printVector(v1);

    v1 = {10, 20, 30, 40, 50}; // 可以直接赋值
    printVector(v1);

    std::vector<int> v2(10, 88); // 10个88
    printVector(v2);
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5};

    printVector(v1);
    std::cout << "size: " << v1.size() << std::endl;         // 大小
    std::cout << "capacity: " << v1.capacity() << std::endl; // 容量
    std::cout << "max_size: " << v1.max_size() << std::endl; // 最大容量

    v1.push_back(6); // 在尾部添加元素
    printVector(v1);
    std::cout << "size: " << v1.size() << std::endl;         // 大小
    std::cout << "capacity: " << v1.capacity() << std::endl; // 容量每超出一次容量翻倍
    std::cout << "max_size: " << v1.max_size() << std::endl; // 最大容量

    v1.shrink_to_fit(); // 释放多余的内存
    printVector(v1);
    std::cout << "size: " << v1.size() << std::endl;         // 大小
    std::cout << "capacity: " << v1.capacity() << std::endl; // 容量释放多余的内存后容量恢复到size大小
    std::cout << "max_size: " << v1.max_size() << std::endl; // 最大容量

    v1.reserve(100); // 预留100个元素的空间
    printVector(v1);
    std::cout << "size: " << v1.size() << std::endl;         // 大小
    std::cout << "capacity: " << v1.capacity() << std::endl; // 容量预留100个元素的空间后容量恢复到100直到超出100
    std::cout << "max_size: " << v1.max_size() << std::endl; // 最大容量
}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5};
    printVector(v1);
    v1[0] = 100;
    v1.at(1) = 200;
    printVector(v1);

    std::cout << "v1的第一个元素: " << v1.front() << std::endl;
    std::cout << "v1的最后一个元素: " << v1.back() << std::endl;

    v1.pop_back(); // 删除最后一个元素
    printVector(v1);
}

void test4()
{
    std::vector<int> v1{1, 2, 3, 4, 5};
    printVector(v1);

    v1.clear(); // 清空容器
    printVector(v1);

    v1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    printVector(v1);
    v1.erase(v1.begin(), v1.begin() + 3); // 删除前三个元素
    printVector(v1);

    // 删除所有偶数
    v1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int>::iterator it = v1.begin(); // 获取迭代器
    while (it != v1.end())
    {
        if (*it % 2 == 0)
            v1.erase(it);
        else
            it++;
    }
    printVector(v1);
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    // 交换两个vector
    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int> v2{10, 20, 30, 40, 50};
    printVector(v1);
    printVector(v2);

    v1.swap(v2);
    printVector(v1);
    printVector(v2);
}

void test6()
{
    std::cout << "test6 ======================" << std::endl;
    std::vector<int> v1{9, 2, 5, 4, 7, 6, 8, 1, 3};
    printVector(v1);
    std::sort(v1.begin(), v1.end()); // 排序
    printVector(v1);
}

// 判断是否为偶数
int getEven(int x)
{
    return x % 2 == 0;
}

void test7()
{
    std::cout << "test7 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int> v2{10, 20};

    printVector(v1);
    printVector(v2);

    std::copy(v1.begin(), v1.end(), std::back_inserter(v2)); // 拷贝
    printVector(v1);
    printVector(v2);

    v1 = {1, 2, 3, 4, 5};
    v2 = {10, 20};
    // std::copy_if(v1.begin(),v1.end(),std::back_inserter(v2),getEven); // 拷贝偶数
    std::copy_if(v1.begin(), v1.end(), std::back_inserter(v2), [](int x)
                 { return x % 2 == 0; }); // 使用lambda表达式
    printVector(v1);
    printVector(v2);
}

void test8()
{
    std::cout << "test8 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int> v2{10, 20, 30, 40, 50};
    std::vector<int> v3;

    std::transform(v1.begin(), v1.end(), v2.begin(), std::back_inserter(v3),
                   [](int x, int y)
                   { return x + y; }); // 加法
    // std::transform(v1.begin(), v1.end(), v2.begin(), std::back_inserter(v3), std::plus<int>()); // 使用内置的加法函数
    std::cout << "v1 + v2 = " << std::endl;
    printVector(v3);

    v3.clear(); // 清空容器
    std::transform(v1.begin(), v1.end(), v2.begin(), std::back_inserter(v3),
                   [](int x, int y)
                   { return x * y; }); // 乘法
    // std::transform(v1.begin(), v1.end(), v2.begin(), std::back_inserter(v3), std::multiplies<int>()); // 使用内置的乘法函数
    std::cout << "v1 * v2 = " << std::endl;
    printVector(v3);
}

void test9()
{
    std::cout << "test9 ======================" << std::endl;
    std::vector<int> v1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> v2{100, 200, 300, 400};
    printVector(v1);
    printVector(v2);

    auto it = std::find(v1.begin(), v1.end(), 5); // 查找5第一次出现的位置
    if (it != v1.end())
    {
        std::cout << "找到了:5 " << std::endl;
        v1.insert(it, v2.begin(), v2.end()); // 插入
    }
    else
    {
        std::cout << "没有找到" << std::endl;
    }

    printVector(v1);
}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    // test5();
    // test6();
    // test7();
    // test8();
    test9();
    return 0;
}

5、dequedouble ended queue双端数组示例

动态数组和vector类似但是deque是双端的可以在头部和尾部进行插入和删除操作
与vector不同deque在内存中是分段连续的每段内存都是连续的所以在头部和尾部插入和删除元素都很快
获取元素的复杂度是常数
在头部和尾部插入和删除元素的复杂度是常数
在中间插入和删除元素的复杂度是线性的
支持迭代器和算法

代码

/*
* dequedouble ended queue双端数组示例
* 动态数组和vector类似但是deque是双端的可以在头部和尾部进行插入和删除操作
* 与vector不同deque在内存中是分段连续的每段内存都是连续的所以在头部和尾部插入和删除元素都很快
* 获取元素的复杂度是常数
* 在头部和尾部插入和删除元素的复杂度是常数
* 在中间插入和删除元素的复杂度是线性的
* 支持迭代器和算法
*/
#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>

// 用于显示deque的函数模板
template <typename T>
void display(const std::deque<T> &d)
{
    std::cout << "[ ";
    for (const auto &item:d )
        std::cout << item << " ";
    std::cout << "]";
    std::cout << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::deque<int> d1{1, 2, 3, 4, 5};
    display(d1);

    std::deque<int> d2 (10,100);
    display(d2);
    d2[0] = 99;
    d2.at(1) = 88;
    display(d2);
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::deque<int> d1 {0,0,0,0};
    display(d1);

    d1.push_back(10);
    d1.push_back(20);
    display(d1);

    d1.push_front(100);
    d1.push_front(200);
    display(d1);

    std::cout << "第一个元素: " << d1.front() << std::endl;
    std::cout << "最后一个元素: " << d1.back() << std::endl;
    std::cout << "大小: " << d1.size() << std::endl;

    d1.pop_back();
    d1.pop_front();
    display(d1);
}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::vector<int> v1 {1,2,3,4,5,6,7,8,9,10};
    std::deque<int> d2;

    // 将vector中的偶数放入deque后奇数放入deque前
    for (const auto &item:v1)
    {
        if (item % 2 == 0)
            d2.push_back(item);
        else
            d2.push_front(item);
    }
    display(d2);
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::vector<int> v1 {1,2,3,4,5,6,7,8,9,10};
    std::deque<int> d2;

    // 将vector中的元素放到d2后
    for (const auto &item:v1)
        d2.push_back(item);
    display(d2);

    d2.clear(); // 清空deque
    // 将vector中的元素放到d2前
    for (const auto &item:v1)
        d2.push_front(item);
    display(d2);

    
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::vector<int> v1 {1,2,3,4,5,6,7,8,9,10};
    std::deque<int> d2;

    // 使用std::copy实现test4效果
    std::copy(v1.begin(), v1.end(), std::back_inserter(d2));
    display(d2);
    
    d2.clear(); // 清空deque
    std::copy(v1.begin(), v1.end(), std::front_inserter(d2));
    display(d2);
}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    test5();
    return 0;
}

6、list链表容器

动态大小
list是一个双向链表支持快速的插入和删除操作
list不支持随机访问不支持下标运算符

代码

/*
* list链表容器
* 动态大小
* list是一个双向链表支持快速的插入和删除操作
* list不支持随机访问不支持下标运算符
*/

#include <iostream>
#include <list>
#include <algorithm>


// 打印list的函数模板
template <typename T>
void printList(const std::list<T> &l)
{
    std::cout << "[";
    for (const auto &e : l)
        std::cout << e << " ";
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::list<int> l1 {1, 2, 3, 4, 5};
    printList(l1);

    std::list<std::string> l2;
    l2.push_back("hello");
    l2.push_back("world");
    printList(l2);

    std::list<int> l3;
    l3 = {1,2,3,4,5,6,7,8,9,10};
    printList(l3);

    std::list<int> l4 (10,88);
    printList(l4);


}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::list<int> l1 {1,2,3,4,5,6,7,8,9,10};
    printList(l1);

    std::cout << "第一个元素: " << l1.front() << std::endl;
    std::cout << "最后一个元素: " << l1.back() << std::endl;
    std::cout << "大小: " << l1.size() << std::endl;

    l1.clear();
    printList(l1);
    std::cout << "大小: " << l1.size() << std::endl;
}

void test3()
{
    std::cout << "test3 ======================" << std::endl;
    std::list<int> l1 {1,2,3,4,5,6,7,8,9,10};
    printList(l1);

    l1.resize(5); // 缩小到5个元素
    printList(l1);
}

void test4()
{
    std::cout << "test4 ======================" << std::endl;
    std::list<int> l1 {1,2,3,4,5,6,7,8,9,10};
    printList(l1);

    // 找到第一个5然后在5前面追加一个100
    std::list<int>::iterator it = std::find(l1.begin(), l1.end(), 5);
    if (it != l1.end())
        l1.insert(it, 100);
    printList(l1);

    std::list<int> l2 {1000, 2000, 3000};
    // 将l2中的元素插入到l1中
    l1.insert(it, l2.begin(), l2.end());
    printList(l1);

    std::advance(it, -2); // it向前移动2个位置
    std::cout << *it << std::endl;

    l1.erase(it); // 删除it指向的元素也就是2000
    printList(l1);
}

void test5()
{
    std::cout << "test5 ======================" << std::endl;
    std::list<int> l1 {3,5,2,10,7,9,8,1,4,6};
    printList(l1);
    l1.sort();
    printList(l1);
    
}
int main()
{
    // test1();
    // test2();
    // test3();
    // test4();
    test5();
    return 0;
}

7、set示例

set是一种关联式容器
根据元素的值自动排序重复元素会被自动去重
不支持随机访问不支持下标运算符
支持各种迭代器和算法

代码

/*
* set示例
* set是一种关联式容器
* 根据元素的值自动排序重复元素会被自动去重
* 不支持随机访问不支持下标运算符
* 支持各种迭代器和算法

*/
#include <iostream>
#include <set>

// 用于显示set的函数模板
template <typename T>
void printSet(const std::set<T> &s)
{
    std::cout << "[";
    for (const auto &e : s)
        std::cout << e << " ";
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::set<int> s1{1, 2, 3, 4, 5};
    printSet(s1);

    s1 = {1,1,1,2,2,2,3,3,3}; // 重复元素会被自动去重
    printSet(s1);

    s1.insert(10); 
    s1.insert(0);
    printSet(s1);

    if (s1.count(10)) // count返回1表示找到返回0表示未找到
        std::cout << "找到10" << std::endl;
    else
        std::cout << "未找到10" << std::endl;

    auto it = s1.find(10); // find返回迭代器如果找到返回迭代器指向该元素否则返回end()
    if (it != s1.end())
        std::cout << "找到" << *it << std::endl;
    
    s1.clear();
    printSet(s1);
}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::set<std::string> s1 {"A", "B", "C", "D", "E"};
    printSet(s1);

    auto result = s1.insert("F"); // insert返回一个pair第一个元素是迭代器指向插入的元素第二个元素是bool表示是否插入成功
    printSet(s1);
    std::cout << std::boolalpha; // boolalpha表示输出true/false
    std::cout << "first: " << *(result.first) << std::endl;
    std::cout << "second: " << result.second << std::endl; // 插入成功返回true


    result = s1.insert("A"); // A 已经存在插入失败但是返回的迭代器指向A
    printSet(s1);
    std::cout << std::boolalpha; // boolalpha表示输出true/false
    std::cout << "first: " << *(result.first) << std::endl;
    std::cout << "second: " << result.second << std::endl; // 插入失败返回false表示有重复元素

}

int main()
{
    // test1();
    test2();
    return 0;
}

8、map示例

map是一种关联式容器它的元素是key-value对std::pairkey是唯一的value可以重复
map中的元素是按key自动排序的
使用key访问元素

代码

/*
* map示例
* map是一种关联式容器它的元素是key-value对std::pairkey是唯一的value可以重复
* map中的元素是按key自动排序的
* 使用key访问元素

*/

#include <iostream>
#include <map>
#include <set>

// 打印map的函数模板
template <typename T1, typename T2>
void printMap(const std::map<T1, T2> &m)
{
    std::cout << "[";
    for (const auto &e : m)
        std::cout << e.first << ":" << e.second << " ";
    std::cout << "]" << std::endl;
}

// map的value是set
void printMap(const std::map<std::string, std::set<int>> &m)
{
    std::cout << "[";
    for (const auto &e : m)
    {
        std::cout << e.first << ":[ ";
        for (const auto &s : e.second)
            std::cout << s << " ";
        std::cout << "] ";
    }
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::map<std::string, int> m1 { // string是keyint是value
        {"mike", 10},
        {"jane", 20},
        {"tom", 30},
    };
    printMap(m1); // [jane:20 mike:10 tom:30 ]会自动按key排序

    m1.insert(std::pair<std::string, int>("anna", 100)); // 插入一个pair
    printMap(m1); 

    m1.insert(std::make_pair("bob", 200)); // 插入一个pair
    printMap(m1);

    m1["jim"] = 300; // 如果key不存在会自动插入一个pair如果key存在会更新value
    printMap(m1);
    m1["jim"] += 100; // 更新value
    printMap(m1);

    std::cout << "mike的计次" << m1.count("mike") << std::endl; // count返回1表示找到返回0表示未找到
    std::cout << "alice的计次" << m1.count("alice") << std::endl; 

    auto it = m1.find("jim"); // find返回迭代器如果未找到返回end()
    if (it != m1.end())
        std::cout << "找到" << it->first << "value为" << it->second << std::endl;
    else
        std::cout << "未找到jim" << std::endl;

    m1.clear(); // 清空map
    printMap(m1);

}

void test2()
{
    std::cout << "test2 ======================" << std::endl;
    std::map<std::string, std::set<int>> student_grades { // string是keyset是value
        {"mike", {100, 90}},
        {"jane", {99, 88, 77}},
        {"tom", {98, 87, 76}},
    };

    printMap(student_grades);

    student_grades["mike"].insert(80); // 插入80分
    printMap(student_grades);

    auto it = student_grades.find("jane");
    if (it != student_grades.end())
    {
        it->second.erase(88); // 删除88分
        printMap(student_grades);
    }
   
}

int main()
{
    // test1();
    test2();
    return 0;
}

9、stack 示例

stack 是一种容器适配器遵循后进先出LIFO的原则
stack 本身不是容器它是基于容器实现的如vector、list、deque等
所有的操作都在栈顶进行top
stack 本身没有迭代器

代码

/*
* stack 示例
* stack 是一种容器适配器遵循后进先出LIFO的原则
* stack 本身不是容器它是基于容器实现的如vector、list、deque等
* 所有的操作都在栈顶进行top
* stack 本身没有迭代器
*/

#include <iostream>
#include <stack>
#include <vector>
#include <list>
#include <deque>


// 显示stack的函数模板
template <typename T>
void display(std::stack<T> s)
{
    std::cout << "[";
    while (!s.empty())
    {
        T elem = s.top(); // 读取栈顶元素
        std::cout << elem << " ";
        s.pop(); // 弹出栈顶元素
    }
    std::cout << "]" << std::endl;
}
int main()
{
    std::stack<int> s;

    for (auto i: {1,2,3,4,5})
        s.push(i);
    display(s);

    s.push(100); // 压入元素
    display(s);

    s.pop(); // 弹出元素
    s.pop();

    display(s);

    // s.clear(); // 并没有clear()方法
    while (!s.empty())
        s.pop(); // 弹出所有元素
    display(s);

    s.push(10);
    display(s);

    s.top() = 100; // 修改栈顶元素
    display(s);

    return 0;
}

10、queue示例

queue是一种容器适配器遵循先进先出FIFO的原则
queue的底层容器可以是deque、list
元素只能从队尾压入从队首弹出排队
queue本身没有提供迭代器

代码

/*
* queue示例
* queue是一种容器适配器遵循先进先出FIFO的原则
* queue的底层容器可以是deque、list
* 元素只能从队尾压入从队首弹出排队
* queue本身没有提供迭代器
*/

#include <iostream>
#include <queue>

// 显示queue的函数模板
template <typename T>
void display(std::queue<T> q)
{
    std::cout << "[";
    while (!q.empty())
    {
        T elem = q.front(); // 读取队首元素
        std::cout << elem << " ";
        q.pop(); // 弹出队首元素
    }
    std::cout << "]" << std::endl;
}

int main()
{
    std::queue<int> q;
    for (auto i : {1, 2, 3, 4, 5})
        q.push(i);
    display(q);

    std::cout << "队首元素: " << q.front() << std::endl;
    std::cout << "队尾元素: " << q.back() << std::endl;

    q.push(100); // 压入元素
    display(q);

    q.pop(); // 弹出元素
    q.pop();

    display(q);

    // q.clear(); // 并没有clear()方法
    while (!q.empty())
        q.pop(); // 弹出所有元素
    display(q);

    std::cout << "size: " << q.size() << std::endl;

    q.push(10);
    q.push(20);
    q.push(30);
    display(q);

    std::cout << "第一个元素: " << q.front() << std::endl;
    std::cout << "最后一个元素: " << q.back() << std::endl;

    q.front() = 100; // 修改队首元素
    q.back() = 200; // 修改队尾元素
    display(q);

    return 0;
}

11、priority_queue 优先级队列示例

允许按照优先级来插入和删除元素
优先级最高的元素总是位于队首最大值在队首
本身没有提供迭代器

代码

/*
* priority_queue 优先级队列示例
* 允许按照优先级来插入和删除元素
* 优先级最高的元素总是位于队首最大值在队首
* 本身没有提供迭代器

*/
#include <iostream>
#include <queue>

// 显示priority_queue的函数模板
template <typename T>
void display(std::priority_queue<T> pq)
{
    std::cout << "[";
    while (!pq.empty())
    {
        T elem = pq.top(); // 读取优先级最高元素
        std::cout << elem << " ";
        pq.pop(); // 弹出优先级最高元素
    }
    std::cout << "]" << std::endl;
}

void test1()
{
    std::cout << "test1 ======================" << std::endl;
    std::priority_queue<int> pq;
    for (auto i : {3,5,8,1,2,9,4,7,6})
        pq.push(i);
    display(pq);

    std::cout << "大小: " << pq.size() << std::endl;
    std::cout << "最大值: " << pq.top() << std::endl;

    pq.pop(); // 弹出最大值
    display(pq);
}

int main()
{
    test1();
    return 0;
}