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

文章目录

    • STL 代码示例
      • 1、迭代器
      • 2、算法
      • 3、array容器示例
      • 4、vector示例
      • 5、deque（double ended queue，双端数组）示例
      • 6、list（链表）容器
      • 7、set示例
      • 8、map示例
      • 9、stack 示例
      • 10、queue示例
      • 11、priority_queue （优先级队列）示例

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); // 查找3std::cout << *loc << std::endl;  // 3std::cout << *v1.end() << std::endl; // 0if (loc != v1.end())std::cout << "找到 3" << std::endl;elsestd::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替换为100for (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; }) ) // 所有元素都大于5std::cout << "所有元素都大于5" << std::endl;elsestd::cout << "不是所有元素都大于5" << std::endl;if (std::any_of(v1.begin(), v1.end(), [](int x) { return x > 5; }) ) // 至少有一个元素大于5std::cout << "有元素大于5" << std::endl;elsestd::cout << "没有元素大于5" << std::endl;if (std::none_of(v1.begin(), v1.end(), [](int x) { return x < 0; }) ) // 没有元素小于0std::cout << "没有元素小于0" << std::endl;elsestd::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的beginstd::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;elsestd::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个88printVector(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，直到超出100std::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);elseit++;}printVector(v1);
}void test5()
{std::cout << "test5 ======================" << std::endl;// 交换两个vectorstd::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、deque（double ended queue，双端数组）示例

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

代码：

/*
* deque（double 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);elsed2.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(); // 清空dequestd::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前面追加一个100std::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指向的元素，也就是2000printList(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;elsestd::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/falsestd::cout << "first: " << *(result.first) << std::endl;std::cout << "second: " << result.second << std::endl; // 插入成功，返回trueresult = s1.insert("A"); // A 已经存在，插入失败，但是返回的迭代器指向AprintSet(s1);std::cout << std::boolalpha; // boolalpha表示输出true/falsestd::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::pair），key是唯一的，value可以重复
  • map中的元素是按key自动排序的
  • 使用key访问元素

代码：

/*
* map示例
* map是一种关联式容器，它的元素是key-value对（std::pair），key是唯一的，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是key，int是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)); // 插入一个pairprintMap(m1); m1.insert(std::make_pair("bob", 200)); // 插入一个pairprintMap(m1);m1["jim"] = 300; // 如果key不存在，会自动插入一个pair，如果key存在，会更新valueprintMap(m1);m1["jim"] += 100; // 更新valueprintMap(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;elsestd::cout << "未找到jim" << std::endl;m1.clear(); // 清空mapprintMap(m1);}void test2()
{std::cout << "test2 ======================" << std::endl;std::map<std::string, std::set<int>> student_grades { // string是key，set是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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/128612.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

FFmpeg系列索引

FFmpeg系列索引

第一章 初识FFmpeg https://blog.csdn.net/huantianxidi/article/details/134130159 第二章 ffplay是什么 https://blog.csdn.net/huantianxidi/article/details/134151043
阅读更多...
图像特征Vol.1：计算机视觉特征度量|第二弹：【统计区域度量】

图像特征Vol.1：计算机视觉特征度量|第二弹：【统计区域度量】

目录 一、前言二、统计区域度量2.1&#xff1a;图像矩特征2.1.1&#xff1a;原始矩/几何矩2.1.2&#xff1a;中心距2.1.3&#xff1a;归一化的中心矩2.1.4&#xff1a;不变矩——Hu矩2.1.5&#xff1a;OpenCv实现矩特征及其应用 2.2&#xff1a;点度量特征2.3&#xff1a;全局直…
阅读更多...
在 GORM 中定义模型

在 GORM 中定义模型

为实现与数据库的无缝交互而打造有效模型的全面指南 在使用 GORM 进行数据库管理时&#xff0c;定义模型是基础。模型是您的应用程序的面向对象结构与数据库的关系世界之间的桥梁。本文深入探讨了在 GORM 中打造有效模型的艺术&#xff0c;探讨如何创建结构化的 Go 结构体&…
阅读更多...
从零开始的目标检测和关键点检测（三）：训练一个Glue的RTMPose模型

从零开始的目标检测和关键点检测（三）：训练一个Glue的RTMPose模型

从零开始的目标检测和关键点检测&#xff08;三&#xff09;&#xff1a;训练一个Glue的RTMPose模型 一、重写config文件二、开始训练三、ncnn部署 从零开始的目标检测和关键点检测&#xff08;一&#xff09;&#xff1a;用labelme标注数据集 从零开始的目标检测和关键点检测…
阅读更多...
若依微服务集成Mybatis-plus详细教程

若依微服务集成Mybatis-plus详细教程

本章教程，主要介绍，若依开源框架微服务版本，如何集成Mybatis-plus。 目录 一、引入依赖 1、在根pom.xml中的properties里加入Mybatis-plus版本 2、在根pom.xml中引入Mybatis-plus依赖
阅读更多...
C++学习

C++学习

一、C基本介绍 1.1 C是什么 C是一种通用的、高级的编程语言&#xff0c;它是C语言的扩展和改进版本。C由Bjarne Stroustrup博士在20世纪80年代初开发&#xff0c;旨在为程序员提供更多的功能和工具&#xff0c;以便更轻松地编写复杂的软件程序。 拜一拜祖师爷&#xff0c;保佑在…
阅读更多...
左移测试，如何确保安全合规还能实现高度自动化？

左移测试，如何确保安全合规还能实现高度自动化？

「云原生安全既是一种全新安全理念&#xff0c;也是实现云战略的前提。 基于蚂蚁集团内部多年实践&#xff0c;云原生PaaS平台SOFAStack发布完整的软件供应链安全产品及解决方案&#xff0c;包括静态代码扫描Pinpoint&#xff0c;软件成分分析SCA&#xff0c;交互式安全测试IA…
阅读更多...
二、GRE VPN

二、GRE VPN

GRE VPN 1、GRE介绍2、GRE基本原理3、GRE报文格式4、报文在GRE中传输过程5、价值6、Keepalive检测7、GRE应用8、配置GRE隧道8.1、配置绑定GRE协议的接口8.2、配置Tunnel接口8.3、配置Tunnel路由 9、GRE配置举例9.1、GRE静态路由示例9.1.1、路由器运行动态路由协议实现互通9.1.2…
阅读更多...
NEFU数字图像处理（3）图像分割

NEFU数字图像处理（3）图像分割

一、图像分割的基本概念 1.1专有名词 前景和背景 在图像分割中&#xff0c;我们通常需要将图像分为前景和背景两个部分。前景是指图像中我们感兴趣、要分割出来的部分&#xff0c;背景是指和前景不相关的部分。例如&#xff0c;对于一张人物照片&#xff0c;人物就是前景&…
阅读更多...
mysql迁移data目录(Linux-Centos)

mysql迁移data目录(Linux-Centos)

随着时间的推移&#xff0c;mysql的数据量越越大&#xff0c;使用yum默认安装的目录为系统盘 /var/lib/mysql&#xff0c;现重新挂载了一个硬盘&#xff0c;需要做数据目录的迁移到 /mnt/data/。以解决占用系统盘过高情况。 1.强烈建议这种操作。镜像一个一样的Centos系统&…
阅读更多...
系统架构设计师-第18章-安全架构设计理论与实践-软考学习笔记

系统架构设计师-第18章-安全架构设计理论与实践-软考学习笔记

安全架构概述 信息的可用性、元略性、机密性、可控性和不可抵赖性等安全保障显得尤为重要&#xff0c;而满足这些诉求&#xff0c;离不开好的架构设计. 信息安全面临的威胁 常见的安全威胁有以下几种. (1)信息泄露 (2) 破坏信息的元整性: 数据被非授极地进行增删、修改成破坏…
阅读更多...
MyBatis无法读取XML中的Method的乌龙事件

MyBatis无法读取XML中的Method的乌龙事件

事件背景 同事反馈&#xff0c;相同的jar包&#xff0c;在多人本地的电脑、多台服务器中&#xff0c;都是可以正常启动的&#xff0c;只有在其中一台服务器&#xff0c;简称它为A&#xff0c;无法启动&#xff0c;因为启动后的初始化操作中有一个调用mybatis方法的操作&#x…
阅读更多...
11.Linux系统：定时任务备份mysql数据库为文件并传输到其他服务器

11.Linux系统：定时任务备份mysql数据库为文件并传输到其他服务器

1. 创建脚本 mysql_dumps.sh内容如下&#xff1a; #!/bin/bash # 查找名称为“mysql_mysql”的容器id CONTAINER_IDdocker ps -a | grep "mysql_mysql" | awk {print $1} | head -n 1 MYSQL_USERNAME"root" MYSQL_PASSWORD"root" FILENAME_SU…
阅读更多...
【CSDN 每日一练 ★★☆】【动态规划】最小路径和

【CSDN 每日一练 ★★☆】【动态规划】最小路径和

【CSDN 每日一练 ★★☆】【动态规划】最小路径和 动态规划 题目 给定一个包含非负整数的 m x n 网格 grid &#xff0c;请找出一条从左上角到右下角的路径&#xff0c;使得路径上的数字总和为最小。 说明&#xff1a;每次只能向下或者向右移动一步。 示例 示例 1&#x…
阅读更多...
我的云栖大会之旅：见证云计算创新的15年

我的云栖大会之旅：见证云计算创新的15年

云栖大会&#xff0c;曾经是一次不可思议的科技之旅&#xff0c;却如今已见证了我对云计算世界的15年关注和发展。第一次踏上云栖大会之旅&#xff0c;我记得是在2009年。那时的云计算还是一个新生事物&#xff0c;而云栖大会正是其中的奠基石。 我清楚地记得那个炎热的夏天&am…
阅读更多...
ant-design-vue select选择框无法显示placehoder

ant-design-vue select选择框无法显示placehoder

将绑定的对应值设置成undefined <a-selectv-model:value"formState.classification"option-filter-prop"children"allow-clearplaceholder"商户分类"><a-select-optionv-for"item of Object.values(Const.POINTMERCHNANDISE.TYPE…
阅读更多...
R -- 体验 stringdist

R -- 体验 stringdist

文章目录 安装使用stringdist :返回列表example stringdistmatrix &#xff1a;返回矩阵example amatch & ain延伸&#xff1a;距离计算公式Hamming distanceLongest Common Substring distanceLevenshtein distance (weighted)The optimal string alignment distance dosa…
阅读更多...
“解耦表示学习”+“交互作用（效应）+权衡 (Trade-off)”是什么？

“解耦表示学习”+“交互作用（效应）+权衡 (Trade-off)”是什么？

一、解耦表示学习 一个例子说明问题&#xff1a; 假设我们有一组人脸图像。图像中的每张人脸都可能由多种因子组成&#xff0c;如面部表情、发型、眼镜、性别等。解耦表示学习的目标是找到一种表示方法&#xff0c;其中每一部分的表示只对应于一个因子&#xff0c;如一个特征…
阅读更多...
UDP服务端和客户端通信代码开发流程

UDP服务端和客户端通信代码开发流程

一、UDP通信 TCP&#xff1a;传输控制协议&#xff0c;面向连接的&#xff0c;稳定的&#xff0c;可靠的&#xff0c;安全的数据集流传递 稳定和可靠:丢包重传 数据有序:序号和确认序号 流量控制:稳定窗口 UDP&#xff1a;用户数据报协议 面向无连接的,不稳定的,不可靠,不安…
阅读更多...
JMeter的使用，傻瓜式学习【上】

JMeter的使用，傻瓜式学习【上】

目录 前言 1、JMeter元件及基本使用作用域&#xff08;简述&#xff09; 1.1、基本元件 1.2、作用域的原则 1.3、元件执行顺序 2、JMeter三个重要组件 2.1、线程组 案例&#xff1a; 2.2、HTTP请求 2.3、查看结果树 响应体中&#xff0c;中文乱码解决方案&#xff1…
阅读更多...
最新文章

Copyright @ 2022~2023