0
0

C++：set和map的使用

一般来说，像string、vector、list、deque、forward_list等容器，这些容器的底层逻辑机构为线性序列的数据结构，所以这些容器也叫做序列式容器，序列式容器两个位置存储的值之间一般没有紧密的关联关系，如若将其交换，依旧是序列式容器。序列式容器中的元素是按他们在容器中的存储位置保存和访问的。

与之相反，关联式容器逻辑结构通常是非线性的，两个位置有紧密的关联关系，不允许交换，因为会破坏存储结构。关联式容器中的元素是按照关键字来保存和访问的。

关联式容器有map/set系列和unordered_set/unordered_map系列。map和set的底层是红黑树（二叉搜索树），set是key搜索场景的结构，map是key/value搜索场景的结构。

set

set类的介绍

  1. template < class T,                    // set::key_type/value_type
  2.            class Compare = less<T>,    // set::key_compare/value_compare
  3.            class Alloc = allocator<T>  // set::allocator_type 空间配置器
  4.            > class set;

说明：

1.T就是set底层关键字key的类型。

2。set默认支持（不传参）是小于比较，如果有需求，可更改传入的仿函数。

3.set底层存储数据的内存是从空间配置器申请的，如果有特别需要可以自己实现内存池传入。

4.一般而言，我们只需传入第一个参数，后两个参数不需要手动传。

5.set的底层是红黑树，**增删查的效率是O(logN)**，迭代且走的是树的中序遍历，得到的结果是有序的。

  1. template < class T,                    // set::key_type/value_type
  2.            class Compare = less<T>,    // set::key_compare/value_compare
  3.            class Alloc = allocator<T>  // set::allocator_type 空间配置器
  4.            > class set;
  5.            
  6. //1.单个数据插入，如果已经存在则插入失败 
  7. pair<iterator, bool> insert(const value_type& val);
  9. //2.列表插入，已经在容器中存在的值不会插入 
  10. void insert(initializer_list<value_type> il);
  12. //3.迭代器区间插入，已经在容器中存在的值不会插入 
  13. template <class InputIterator>
  14. void insert(InputIterator first, InputIterator last);
  16. //查找val，返回val所在的迭代器，没有找到返回end() 
  17. iterator find(const value_type& val);
  19. //查找val，返回Val的个数 
  20. size_type count(const value_type& val) const;
  22. //1.删除一个迭代器位置的值 
  23. iterator erase(const_iterator position);
  25. //2.删除val，val不存在返回0，存在返回1 
  26. size_type erase(const value_type& val);
  28. //3.删除一段迭代器区间的值 
  29. iterator erase(const_iterator first, const_iterator last);
  31. //返回大于等于val位置的迭代器 
  32. iterator lower_bound(const value_type& val) const;
  34. //返回大于val位置的迭代器 
  35. iterator upper_bound(const value_type& val) const;

set是key结构, map才是key/value结构, 这里的key_type和value_type是为了保持与map一致，所以才有了value_type，在set中其实就是key，当然key_type也是key。

构造和迭代器

1.set的构造有无参默认构造、迭代器区间构造、拷贝构造和列表构造。

2.set的迭代器是双向迭代器，支持正向和反向遍历，但要注意的是，无法通过迭代器修改数据，这样会破坏搜索树的结构。

  1. void test_set1()
  2. {
  3.     vector<int> v({1,5,4,2,3,6,7,8,9});
  4.     
  5.     set<int> s1;                          //无参认构造
  6.     set<int> s2(v.begin(), v.end());      //迭代器区间构造
  7.     set<int> s3(s2);                      //拷贝构造
  8.     set<int> s = { 1,5,4,2,3,6,7,8,9 };   //列表初始化构造
  10.     //1.正向迭代器
  11.     for (auto e : s2)
  12.     {
  13.         cout << e << " ";
  14.     }
  15.     cout << endl;
  17.     
  18.     //set<int>::iterator it = s2.begin();
  19.     auto it = s2.begin();
  20.     while (it != s2.end())
  21.     {
  22.         cout << *it << " ";
  23.         ++it;
  24.     }
  25.     cout << endl;
  27.     //2.set是双向迭代器迭代器支持++/--，但是不是随机迭代器不支持+/-
  28.     it = --s2.end();
  29.     auto end = --s2.begin();
  30.     while (it != end)
  31.     {
  32.         cout << *it << " ";
  33.         --it;
  34.     }
  35.     cout << endl;
  37.     //3.反向迭代器
  38.     //auto rit = s2.rbegin();
  39.     set<int>::reverse_iterator rit = s2.rbegin();
  40.     while (rit != s2.rend())
  41.     {
  42.         cout << *rit << " ";
  43.         ++rit;    
  44.     }
  45.     cout << endl;
  47. }

增删查

set支持增删查，但不支持修改，会破坏红黑树的结构。

set不支持插入相同的数据，但是multiset支持插入相同的数据。

insert

  1. //1.单个数据插入，如果已经存在则插入失败 
  2. pair<iterator, bool> insert(const value_type& val);
  4. //2.列表插入，已经在容器中存在的值不会插入 
  5. void insert(initializer_list<value_type> il);
  7. //3.迭代器区间插入，已经在容器中存在的值不会插入 
  8. template <class InputIterator>
  9. void insert(InputIterator first, InputIterator last);

删除具体的值返回size_type而不是bool是为了与multiset保持一致，multiset含有重复数据（例如：multiset中有3个5，若要删除5，则返回值就是3） 

  1. void test_set2()
  2. {
  3.     vector<int> v({ 7,6,8 });
  5.     //1.单个数据插入，如果已经存在则插入失败 
  6.     set<int> s1;
  7.     s1.insert(3);
  8.     s1.insert(3);
  9.     s1.insert(1);
  10.     s1.insert(2);
  12.     //2.插入列表，同理如果已经存在则该数据插入失败
  13.     s1.insert({ 4, 6, 5, 4 });
  15.     //3.插入迭代器区间
  16.     s1.insert(v.begin(), v.end());
  18.     set<int> s2;
  19.     s2.insert(3);
  20.     s2.insert(2);
  21.     s2.insert(1);
  22.     s2.insert(5);
  23.     s2.insert(4);
  24.     s2.insert(5);
  26.     set<int>::iterator it = s2.begin();
  27.     while (it != s2.end())
  28.     {
  29.         cout << *it << " "; //输出1 2 3 4 5
  30.         ++it;
  31.     }
  32.     cout << endl;
  34.     //单参数支持隐式类型转换：构造tmp+用tmp拷贝构造strs1——>优化为直接构造strs1
  35.     set<string> strs1 = { "white", "blue", "black" };
  37.     //调用默认构造
  38.     set<string> strs2({ "white", "blue", "black" });
  40.     //遍历strs1比较ascll码大小顺序遍历的
  41.     for (auto& e : strs1)
  42.     {
  43.         cout << e << " ";
  45.     }
  46.     cout << endl;
  47. }

find和erase

find在算法库也有，适用于各种容器，时间复杂度为O(n)。

  1. auto pos1 = find(s.begin(), s.end(), x);

set自己的find是利用二叉搜树进行查找，时间复杂度 O(logN)

  1. auto pos2 = s.find(x);
  1. //1.删除一个迭代器位置的值 
  2. iterator erase (const_iterator position);
  4. //2.删除val，val不存在返回0，存在返回1
  5. size_type erase (const value_type& val);
  7. //3.删除⼀段迭代器区间的值 
  8. iterator erase (const_iterator first, const_iterator last);
  10. //查找val，返回val所在的迭代器，没有找到返回end() 
  11. iterator find (const value_type& val);
  13. //查找val，返回Val的个数 
  14. size_type count (const value_type& val) const;
  1. void test_set3()
  2. {
  3.     set<int> s = { 3, 2, 1, 5, 6, 7, 8, 9 , 11, 13, 12, 15, 14};
  5.     //1.迭代器删除最小值
  6.     s.erase(s.begin());
  8.     //2.删除具体的值val：底层就是find+迭代器删除
  9.     int x;
  10.     cin >> x;
  11.     int num = s.erase(x);
  12.     if(num)
  13.         cout << x << "删除成功！" << endl;
  14.     else
  15.         cout << x << "不存在！" << endl;
  17.     //3.删除一段迭代器区间的值，注意是左闭右开区间
  18.     auto first = s.find(5);
  19.     auto last = s.find(7);
  20.     s.erase(first, last);
  21.     for (auto e : s)
  22.         cout << e << " ";
  23.     cout << endl;
  25.     //find+迭代器删除
  26.     int y;
  27.     cin >> y;
  28.     //找到返回该值的迭代器，找不到返回s.end()
  29.     auto pos = s.find(y);
  30.     if (pos != s.end())
  31.         s.erase(pos);
  32.     else
  33.         cout << y << "不存在！" << endl;
  35.     //利用count间接实现快速查找
  36.     int z;
  37.     cin >> z;
  38.     if(s.count(z))
  39.         cout << z << "存在！" << endl;
  40.     else
  41.         cout << z << "不存在！" << endl;
  42. }

erase迭代器失效

  1. void test_set4()
  2. {
  3.     set<int> s = { 1, 3, 4 ,6, 5, 2 };
  4.     auto pos = s.find(4);
  5.     //pos位置的迭代器失效
  6.     //s.erase(pos);
  7.     //cout << *pos << endl; //强行访问导致程序崩溃
  8.     
  9.     //正确做法，erase会返回删除元素的下一个元素，更新pos
  10.     pos = s.erase(pos);
  11.     //4的下一个元素是5
  12.     cout << *pos << endl;
  14.     //注意，若查找的是6的话，那么删除6后迭代器pos就变成了s.end()，此时访问程序崩溃
  16. }

lower_bound与upper_bound

  1. //返回大于等于val位置的迭代器：按照搜索树的规则找
  2. iterator lower_bound(const value_type& val) const;
  4. //返回大于val位置的迭代器：按照搜索树的规则找
  5. iterator upper_bound(const value_type& val) const;
  1. void test_set5()
  2. {
  3.     set<int> s1;
  4.     for (int i = 1; i < 10; i++)
  5.     {
  6.         s1.insert(i * 10); //10 20 30 40 50 60 70 80 90
  7.     }
  8.     set<int> s2(s1);
  9.     cout << endl;
  11.     //要求：删除[30, 60]区间的值
  13.     //1.erase的迭代器区间删除左闭右开：[)
  15.     auto first = s1.find(30);
  16.     auto last = s1.find(70);
  17.     s1.erase(first, last);
  18.     for (auto e : s1)
  19.     {
  20.         cout << e << " "; //10 20 70 80 90
  21.     }
  22.     cout << endl;
  24.     //要求：删除[25, 55]区间的值,那就要找到30 60位置的迭代器，但上面的方法无效，因为find查找不到，返回的是s.end()迭代器
  26.     //此时需要用到lower_bound和upper_bound
  28.     auto itlow = s2.lower_bound(25); //返回 >= 25的迭代器：就是30位置的迭代器
  29.     auto itup = s2.upper_bound(55);  //返回 > 55的迭代器：就是60位置的迭代器
  30.     s2.erase(itlow, itup);
  31.     for (auto e : s2)
  32.     {
  33.         cout << e << " "; //10 20 60 70 80 90
  34.     }
  35.     cout << endl;
  36.     
  37. }

multiset和set的区别

multiset与set的使用基本类似，主要区别在于multiset支持冗余插入，那么insert/find/count/erase就会有所区别。

  1. void test_set6()
  2. {
  3.     //相比set不同的是，multiset是排序，但是不去重 
  4.     multiset<int> mulset = { 4,2,7,2,4,8,4,5,4,9 };
  5.     auto it = mulset.begin();
  6.     while (it != mulset.end())
  7.     {
  8.         cout << *it << " "; //输出：2 2 4 4 4 4 5 7 8 9
  9.         ++it;
  10.     }
  11.     cout << endl;
  13.     //x可能会存在多个，find查找中序的第一个 
  14.     int x;
  15.     cin >> x;
  16.     auto pos = mulset.find(x);
  17.     while (pos != mulset.end() && *pos == x)
  18.     {
  19.         cout << *pos << " ";
  20.         ++pos;
  21.     }
  22.     cout << endl;
  24.     //count会返回x的实际个数 
  25.     cout << mulset.count(x) << endl;
  27.     //erase给值时会删除所有的x 
  28.     mulset.erase(x);
  29.     for (auto e : mulset)
  30.     {
  31.         cout << e << " ";
  32.     }
  33.     cout << endl;
  34.     
  35. }

map

map类的介绍

  1. template < class Key,                                     // map::key_type
  2.            class T,                                       // map::mapped_type
  3.            class Compare = less<Key>,                     // map::key_compare
  4.            class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
  5.            > class map;

1.Key就是map底层关键字声明，T就是map底层value的类型。

2.map默认要求Key支持小于比较，如若需要，可以手动传仿函数。

3.map底层存储数据的内存是从空间配置器申请的。

4。map底层也是红黑树，增删查改的效率是O(logN) ，注意，这里的改指的是修改Value，Key是不能修改的。

pair类型介绍

  1. template <class T1, class T2>
  2. struct pair
  3. {
  4.     T1 first;
  5.     T2 second;
  7.     //无参默认构造
  8.     pair()
  9.         :first(T1())
  10.         ,second(T2())
  11.     {}
  13.     pair(const T1& a, const T2& b)
  14.         :first(a)
  15.         ,second(b)
  16.     {}
  18.     //拷贝构造
  19.     template<class U, class V>
  20.     pair(const pair<U, V>& pr)
  21.         :first(pr.first)
  22.         ,second(pr.second);
  23.     {}
  24. };
  26. //创建pair对象
  27. template <class T1, class T2>
  28. inline ::pair<T1, T2> make_pair(T1 x, T2 y)
  29. {
  30.     return pair<T1, T2>(x, y);
  31. }
  1. Member types 
  2. key_type    ->  The first template parameter (Key)    
  3. mapped_type    ->  The second template parameter (T)    
  4. value_type    ->  pair<const key_type,mapped_type>

map是key/value搜索场景的结构，key_type就是key，而mapped_type就是value，而value_type才是pair。

构造和迭代器

1.mapt的构造有无参默认构造、迭代器区间构造、拷贝构造和列表构造。

2.map支持正向和反向迭代，遍历默认是升序。

  1. //empty (1) 无参默认构造 
  2. explicit map(const key_compare& comp = key_compare(),
  3.              const allocator_type& alloc = allocator_type());
  5. //range (2) 迭代器区间构造 
  6. template <class InputIterator>
  7. map(InputIterator first, InputIterator last,
  8.     const key_compare& comp = key_compare(),
  9.     const allocator_type & = allocator_type());
  11. //copy (3) 拷贝构造 
  12. map(const map& x);
  14. //initializer list (4) initializer 列表构造 
  15. map(initializer_list<value_type> il,
  16.     const key_compare& comp = key_compare(),
  17.     const allocator_type& alloc = allocator_type());
  19. //迭代器是一个双向迭代器 
  20. iterator->a bidirectional iterator to const value_type
  22. //正向迭代器 
  23. iterator begin();
  24. iterator end();
  26. //反向迭代器 
  27. reverse_iterator rbegin();
  28. reverse_iterator rend();
  1. void test_map1()
  2. {
  3.     //无参默认构造
  4.     map<int, int> m1;
  6.     //迭代器区间构造
  7.     vector<pair<int, int>> v = { {1,1}, {2, 2}, {3, 3} };
  8.     map<int, int> m2(v.begin(), v.end());
  10.     //拷贝构造
  11.     map<int, int> m3(m2);
  13.     //列表初始化构造
  14.     map<int, int> m4 = { {1,1}, {2, 2}, {3, 3}, { 4, 4} };
  16.     //1.正向迭代器
  17.     //map<int, int>::iterator it = m4.begin();
  18.     auto it = m4.begin();
  19.     while (it != m4.end())
  20.     {
  21.         cout << it->first << " " << it->second << endl;
  22.         ++it;
  23.     }
  24.     cout << endl;
  26.     //2.反向迭代器
  27.     auto rit = m4.rbegin();
  28.     while (rit != m4.rend())
  29.     {
  30.         cout << rit->first << " " << rit->second << endl; //输出：1 2 1 2
  31.         ++rit;
  32.     }
  33.     cout << endl;
  34. }

增删查

  1. Member types 
  2. key_type    ->  The first template parameter (Key)    //key
  3. mapped_type    ->  The second template parameter (T)    //value
  4. value_type    ->  pair<const key_type,mapped_type>    //pair
  6. //单个数据插入，如果已经key存在则插入失败，key存在相等value不相等也会插入失败 
  7. pair<iterator, bool> insert(const value_type& val);
  9. //列表插入，已经在容器中存在的值不会插入
  10. void insert(initializer_list<value_type> il);
  12. //迭代器区间插入，已经在容器中存在的值不会插入
  13. template <class InputIterator>
  14. void insert(InputIterator first, InputIterator last);
  16. //查找k，返回k所在的迭代器，没有找到返回end() 
  17. iterator find(const key_type& k);
  19. //查找k，返回k的个数 
  20. size_type count(const key_type& k) const;
  22. //删除一个迭代器位置的值 
  23. iterator erase(const_iterator position);
  25. //删除k，k存在返回0，存在返回1 
  26. size_type erase(const key_type& k);
  28. //删除一段迭代器区间的值
  29. iterator erase(const_iterator first, const_iterator last);
  31. //返回大于等于k位置的迭代器
  32. iterator lower_bound(const key_type& k);
  34. //返回大于k位置的迭代器
  35. const_iterator upper_bound(const key_type& k) const;
  1. void test_map2()
  2. {
  3.     map<string, string> dict;
  5.     //插入有名对象
  6.     pair<string, string> kv1("first", "第一");
  7.     dict.insert(kv1);
  9.     //插入匿名对象
  10.     dict.insert(pair<string, string>("second", "第二"));
  12.     //利用make_pair函数返回构造的pair对象，插入
  13.     dict.insert(make_pair("third", "第三"));
  15.     //C++11支持多参数隐式类型转换成pair对象，插入
  16.     dict.insert({ "forth", "第四" });
  18.     //"forth"已经存在，插入失败
  19.     dict.insert({ "forth", "第四" });
  21.     auto it = dict.begin();
  22.     while (it != dict.end())
  23.     {
  24.         cout << (*it).first << " " << (*it).second << endl;
  25.         //map的迭代基本都使用operator->，这里省略了一个-> 
  26.         //第一个->是迭代器运算符重载，返回pair*，第二个箭头是结构指针解引用取pair数据
  27.         cout << it->first << " " << it->second << endl;
  28.         ++it;
  30.         //it->first += 'x';   //key不支持修改
  31.         //it->second += 'x'; // value支持修改
  32.     }
  33.     cout << endl;
  35.     for (auto& e : dict)
  36.     {
  37.         cout << e.first << " " << e.second << endl;
  38.     }
  39.     cout << endl;
  41.     string str;
  42.     while (cin >> str)
  43.     {
  44.         auto ret = dict.find(str);
  45.         if (ret != dict.end())
  46.         {
  47.             cout << "->" << ret->second << endl;
  48.         }
  49.         else
  50.         {
  51.             cout << "无此单词，请重新输入" << endl;
  52.         }
  53.     }
  55.     //erase与set中的erase一模一样，就不做演示了
  56. }

关于insert这个函数，它返回的是一个pair，但这pair不是map里的pair，insert返回的pair的key是map的迭代器，value是一个bool值。当你插入一个{key，value}的时候，如果插入成功，返回的pair的迭代器是指向新节点的，bool值为真；当插入相同值的时候，也就是插入失败的时候，返回的pair的迭代器指向的是与插入{key，value}的key相等的节点，bool值为假。

所以这个insert既有插入的功能也有查找的功能。

map数据修改：重载operator[]

map支持修改value，既可以通过迭代器实现，也可以通过operator[]实现的。

注意从内部实现角度，map这理把我们传统说的value值，给的是T类型，typedef为mapped_type。而value_type是红黑树结点中存储的pair键值对值。日常使用我们还是习惯将这里的T映射值叫做value。

  1. Member types
  2. key_type     ->  The first template parameter (Key)
  3. mapped_type  ->  The second template parameter (T)
  4. value_type   ->  pair<const key_type,mapped_type>
  1. //查找k，返回k所在的迭代器，没有找到返回end()，如果找到了通过iterator可以修改key对应的mapped_type(value)值
  2. iterator find(const key_type& k);
  4. //insert插入一个pair<key, T>对象 
  5. //1.如果key已经在map中，插入失败，则返回一个pair<iterator,bool>对象，
  6. //返回pair对象first是key所在结点的迭代器，second是false
  8. //2.如果key不在map中，插入成功，则返回一个pair<iterator,bool>对象，
  9. //返回pair对象first是新插入key所在结点的迭代器，second是true
  11. //也就是说无论插入成功还是失败，返回pair<iterator,bool>对象的first都会指向key所在的迭代器
  12. //那么也就意味着insert插入失败时充当了查找的功能，正是因为这一点，insert可以用来实现operator[]
  14. //需要注意的是这里有两个pair，不要混淆了，
  15. //一个是map底层红黑树节点中存的pair<key, T>，
  16. //另一个是insert返回值pair<iterator, bool>
  17. pair<iterator, bool> insert(const value_type& val);
  18. mapped_type& operator[] (const key_type& k);
  20. //operator的内部实现 
  21. mapped_type& operator[] (const key_type& k)
  22. {
  23.     //1.如果key不在map中，insert会插入key和mapped_type(value)的默认值，同时[]返回结点pair<iterator,bool>中存储
  24.     //中的迭代器中存储的mapped_type(value)值的引用，那么我们可以通过引用修改返映射值。所以[]具备了插入 + 修改功能
  25.     
  26.     //2.如果k在map中，insert会插入失败，但是insert返回pair对象的first是指向与key值相同的结点的
  27.     //迭代器，同时[]返回结点中存储mapped_type(value)值的引用，所以[]具备了查找 + 修改的功能
  29.     pair<iterator, bool> ret = insert({ k, mapped_type() });
  30.     iterator it = ret.first;
  32.     return it->second;
  33. }
  1. void test_map3()
  2. {
  3.     map<string, string> dict;
  5.     dict.insert({ "sort", "排序" });
  7.     //insert不存在：插入{"insert", string()}
  8.     dict["insert"];
  10.     //left不存在：插入+修改
  11.     dict["left"] = "左边";
  13.     //left存在：修改 将"左边"修改为"左边、剩余"
  14.     dict["left"] = "左边、剩余";
  16.     //left存在：查找,确认left在才能这么用，否则就是插入了
  17.     //输出：左边、剩余
  18.     cout << dict["left"] << endl;
  20.     //right不存在：插入
  21.     //输出：什么都没有
  22.     cout << dict["right"] << endl; 
  24. }
  1. void test_map4()
  2. {
  3.     //统计水果出现的次数 
  4.     string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
  5.                      "苹果", "香蕉", "苹果", "香蕉" };
  7.     map<string, int> cntMap;
  9.     //利用find和iterator修改功能，统计水果出现的次数 
  10.     for (const auto& str : arr)
  11.     {
  12.         //先查找水果在不在map中 
  13.         //1、不在，说明水果第一次出现，则插入{水果, 1} 
  14.         //2、在，则查找到的节点中水果对应的次数++ 
  15.         auto ret = cntMap.find(str);
  16.         if (ret == cntMap.end())
  17.             cntMap.insert({ str, 1 });
  18.         else
  19.             ret->second++;
  20.     }
  22.     //利用[]插入+修改功能，巧妙实现统计水果出现的次数 
  23.     for (auto& str : arr)
  24.     {
  25.         //先查找水果在不在map中 
  26.         //1、不在，说明水果第一次出现，则插入{水果, 1} 
  27.         //2、在，则查找到的节点中水果对应的次数++
  28.         cntMap[str]++;
  29.     }
  31.     for (auto& e : cntMap)
  32.     {
  33.         //输出苹果:6
  34.         //    西瓜:3
  35.         //    香蕉 : 2
  36.         cout << e.first << ":" << e.second << endl;
  37.     }
  38. }

multimap和map的区别

multimap和map的使用基本完全类似，主要区别点在于multimap支持关键值key冗余，而insert/find/count/erase也是key冗余有所差异，这里跟set和multiset完全一样，比如find时，有多个key，返回中序第一个。

其次就是multimap不支持[]，因为支持key冗余，[]就只能支持插入了，不能支持修改（因为key有重复，所以不知道修改哪个value）。

  1. int main()
  2. {
  3.     multimap<string, string> dict;
  5.     //插入一定成功
  6.     dict.insert({ "sort", "排序" });
  7.     dict.insert({ "sort", "排序1" });
  8.     dict.insert({ "sort", "排序2" });
  9.     dict.insert({ "sort", "排序3" });
  10.     dict.insert({ "sort", "排序" });
  11.     dict.insert({ "string", "字符串" });
  13.     //将sort全部删除
  14.     dict.erase("sort");
  16.     return 0;
  17. }

拜拜，下期再见😏

摸鱼ing😴✨🎞

标签： c++ 开发语言
本文转载自: https://blog.csdn.net/2301_80373479/article/details/143351900
版权归原作者 HZzzzzLu 所有， 如有侵权，请联系我们删除。
登录后发布评论

“C++：set和map的使用”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
setmap