C++ set 与 multiset 容器使用指南：关联式容器入门

首页 > 编程开发 > C类语言    日期：2026-06-18 / 浏览：次

前言

在学习了 vector、list 等序列式容器后，我们将进入 STL 的另一大类别——关联式容器。

  • 前⾯我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，这些容器统称为“序列式容器”，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间⼀般没有紧密的关联关系，⽐如交换⼀下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的
  • “关联式容器”也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是“⾮线性结构”，两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。
特性 序列式容器 关联式容器
存储逻辑 线性序列 非线性结构（树/哈希）
访问方式 按位置访问 按关键字访问
元素关系 松散，交换位置不影响结构 紧密，交换会破坏结构
典型代表 vector、list、deque set、map、unordered_set

set 与 multiset 核心特点

容器 底层结构 元素唯一性 是否有序 时间复杂度
set 红黑树 唯一 升序 O(log n)
multiset 红黑树 可重复 升序 O(log n)

1. 序列式容器 vs 关联式容器

1.1 序列式容器

前面学过的 string、vector、list、deque 等都属于序列式容器 ：

  • 逻辑结构为线性序列
  • 元素按存储位置顺序保存和访问
  • 交换两个元素，容器性质不变

1.2 关联式容器

set、map 系列和 unordered_set、unordered_map 系列属于关联式容器 ：

  • 逻辑结构通常是非线性结构（树/哈希表）
  • 元素按关键字保存和访问
  • 元素之间有紧密的关联关系

核心区别 ：数据如何存储与访问——序列式按位置，关联式按关键字。

2. set 类概述

2.1 模板声明

  • T就是 set 底层关键字的类型
  • set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数
  • set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。
  • 一般情况下，我们都不需要传后两个模版参数。
  • set底层是用红黑树实现，增删查效率是O(logN)，迭代器遍历是走的搜索树的中序，所以是有序的
template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // 比较函数（默认升序）
           class Alloc = allocator<T>      // 空间配置器
           > class set;

2.2 set 的核心特性

特性 说明
自动排序 插入元素后自动按 key 排序（默认升序）
去重 不允许存储重复的 key
不可修改 key 迭代器是 const_iterator，无法通过迭代器修改
高效操作 增删查均为 O(log n)
双向迭代器 支持 ++ 和 --，不支持随机访问

2.3 构造相关接口

// 1. 无参默认构造
set<int> s1;
// 2. 迭代器区间构造
set<int> s2(v.begin(), v.end());
// 3. 拷贝构造
set<int> s3(s2);
// 4. initializer_list 构造（C++11）
set<int> s4({1, 2, 3, 4, 5});
set<int> s5 = {1, 2, 3, 4, 5};
// 迭代器是⼀个双向迭代器
iterator -> a bidirectional iterator to const value_type
// 正向迭代器
iterator begin();
iterator end();
// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();

1. empty: ⽆参默认构造

explicit set (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());

2. range : 迭代器区间构造

template <class InputIterator>
set (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());

3. copy ：拷⻉构造

set (const set& x);

4. initializer list ：列表构造

set (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());

2.4 set的增删查相关接口

Member types
key_type -> The first template parameter (T)
value_type -> The first template parameter (T)
// 单个数据插⼊，如果已经存在则插⼊失败
pair<iterator,bool> insert (const value_type& val);
// 列表插⼊，已经在容器中存在的值不会插⼊
void insert (initializer_list<value_type> il);
// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
// 查找val，返回val所在的迭代器，没有找到返回end()
iterator find (const value_type& val);
// 查找val，返回Val的个数
size_type count (const value_type& val) const;
// 删除⼀个迭代器位置的值，返回的是下一个位置的迭代器
iterator erase (const_iterator position);
// 删除val，val不存在返回0，存在返回1
size_type erase (const value_type& val);
// 删除⼀段迭代器区间的值
iterator erase (const_iterator first, const_iterator last);
// 返回第一次出现⼤于等于val位置的迭代器
iterator lower_bound (const value_type& val) const;
// 返回第一次出现⼤于val位置的迭代器
iterator upper_bound (const value_type& val) const;

3 初始化与插入：去重 + 自动排序

3.1 单个元素插入

void test_set1()
{
    set<int> s1;
    //方式1： 单个元素插入
    s1.insert(3);
    s1.insert(1);
    s1.insert(2);
    s1.insert(5);
    s1.insert(3);   // 重复元素，不会被插入
    s1.insert(5);   // 重复元素，不会被插入
    s1.insert(6);
    // 遍历方式1：  迭代器
    auto it = s1.begin();
    while (it != s1.end())
    {
        // *it = 1;  //  不能修改！迭代器是 const_iterator
        cout << *it << " ";
        it++;
    }
    cout << endl;   // 输出：1 2 3 5 6（去重+有序）
}

3.2 初始化列表批量插入

void test_set1()
{
    // 方式2：初始化列表批量插入
    set<int> s2;
    s2.insert({3, 1, 2, 5, 3, 5, 6});
    // 遍历方式2：范围 for
    for (auto& e : s2)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 3 5 6
}

3.3 自定义排序（降序）

void test_set1()
{
    // 降序排序：使用 greater<int> 仿函数
    set<int, greater<int>> s3({3, 1, 2, 5, 3, 5, 6});
    
    for (auto& e : s3)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：6 5 3 2 1
}

代码执行

 #define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;
void test_set1()
{
    //测试set的插入与遍历（去重 + 自动排序）
    set<int> s1;
// 方式1：单个元素插入
    s1.insert(3);
    s1.insert(1);
    s1.insert(2);
    s1.insert(5);
    s1.insert(3);
    s1.insert(5);
    s1.insert(6);
    cout << "s1" << endl;
    // 遍历方式1：迭代器遍历（注意：*it不可修改）
    // 遍历结果: 去重+有序
    auto it = s1.begin();
    while (it != s1.end())
    {
        //*it1 = 1;//不能修改
        cout << *it << " ";
        it++;
    }
    cout << endl;
// 方式2：初始化列表批量插入
    set<int> s2;
    s2.insert({ 3,1,2,5,3,5,6 });
    cout << "s2" << endl;
    // 遍历方式2：范围for循环
    for (auto& e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    //若需降序排序，可指定排序仿函数：set<int, greater<int>> s -> 降序排序
    set<int, greater<int>> s3({ 3,1,2,5,3,5,6 }); //列表构造
    cout << "s3" <<endl;
    for (auto& e : s3)
    {
        cout << e << " ";
    }
    cout << endl;
}
int main()
{
    test_set1();
}

4. set 的插入、查找与删除

4.1 核心接口

接口 作用 返回值
insert(val) 插入单个元素 pair<iterator,bool>（是否成功）
find(val) 查找元素 迭代器（找不到返回 end()）
count(val) 统计元素个数 set 中返回 0 或 1
erase(val) 删除指定值 删除个数（0 或 1）
erase(pos) 删除迭代器位置 下一个位置的迭代器

4.2 查找与删除示例

 #define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;
void test_set2()
{
    set<int> s1;
    s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6
    // 1.删除最小值 
    s1.erase(s1.begin());//iterator erase (const_iterator position);
    for (auto& e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    // 2.直接删除x 
    int x;
    cin >> x;
    int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
    //size_type erase(const value_type & val);
    if (num == 0)
    {
        cout << x << "不存在！" << endl;
    }
    else
    {
        cout << x << "删除成功！" << endl;
    }
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
    // 3.直接查找在利用返回值是迭代器删除x 
    set<int> s2({ 3,1,2,5,3,5,6 });
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cin >> x;
    auto pos = s2.find(x);
    if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
    {
        s2.erase(pos);
        //cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
    }
    else
    {
        cout << x << "不存在！" << endl;
    }
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
}
int main()
{
    test_set2();
}

输入的数都存在的情况：

输入的数都不存在的情况：

4.3 find 的效率：set vs 算法库

// 算法库的 find：O(N) 线性查找
auto pos1 = find(s2.begin(), s2.end(), x);
// set 自带的 find：O(log N) 红黑树查找
auto pos2 = s2.find(x);
// 使用 count 快速判断元素是否存在
if (s2.count(x))
    cout << x << "在！" << endl;
else
    cout << x << "不在！" << endl;
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<set>
void test_set2()
{
    set<int> s1;
    s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6
    // 1.删除最小值 
    s1.erase(s1.begin());//iterator erase (const_iterator position);
    for (auto& e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    // 2.直接删除x 
    int x;
    cin >> x;
    int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
    //size_type erase(const value_type & val);
    if (num == 0)
    {
        cout << x << "不存在！" << endl;
    }
    else
    {
        cout << x << "删除成功！" << endl;
    }
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
    // 3.直接查找在利用返回值是迭代器删除x 
    set<int> s2({ 3,1,2,5,3,5,6 });
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cin >> x;
    auto pos = s2.find(x);
    if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
    {
        s2.erase(pos);
        //cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
    }
    else
    {
        cout << x << "不存在！" << endl;
    }
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
    // 算法库的查找 O(N) 
    auto pos1 = find(s2.begin(), s2.end(), x);
    // set⾃⾝实现的查找 O(logN) 
    auto pos2 = s2.find(x);
    // 利用count间接实现快速查找 
    cin >> x;
    if (s2.count(x))
    {
        cout << x << "在！" << endl;
    }
    else
    {
        cout << x << "不在！" << endl;
    }
}
int main()
{
    test_set2();
}

结论 ：对于关联式容器，优先使用容器自带的 find 方法（O(log n)），而不是算法库的 find（O(n)）。

5. set 的区间操作：lower_bound 与 upper_bound

5.1 接口说明

  • lower_bound(val) ：返回第一个 ≥ val 的迭代器
  • upper_bound(val) ：返回第一个 > val 的迭代器

5.2 区间删除示例

 #define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;
void test_set3()
{
    set<int> s;
    s.insert({3, 1, 2, 5, 3, 5, 6, 7, 9});
    // 当前 set：1 2 3 5 6 7 9
    // 需求：删除 [3, 8] 区间的元素（即 ≥3 且 ≤8）
    auto it1 = s.lower_bound(3);   // 指向 3
    auto it2 = s.upper_bound(8);   // 指向 9（第一个 >8 的元素）
    // 删除区间 [it1, it2) → 删除 3,5,6,7
    s.erase(it1, it2);
    for (auto& e : s)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 9
}
int main()
{
    test_set3();
}

图示：

6. multiset：允许重复元素的 set

6.1 multiset 与 set 的区别

特性 set multiset
元素唯一性 唯一，自动去重 可重复
insert 重复值 插入失败 插入成功
count(val) 返回 0 或 1 返回实际个数
erase(val) 删除 0 或 1 个 删除所有匹配元素
find(val) 返回唯一迭代器 返回中序第一个

6.2 multiset 示例

void test_multiset()
{
    multiset<int> s1;
    s1.insert({3, 1, 2, 5, 3, 5, 6, 3, 3});
    // 1. 遍历：有序且保留重复元素
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 3 3 3 3 5 5 6
    // 2. find：返回中序第一个匹配元素的迭代器
    int x;
    cin >> x;   // 假设输入 3
    auto pos = s1.find(x);
    // 打印所有值为 x 的元素
    while (pos != s1.end() && *pos == x)
    {
        cout << *pos << " ";
        pos++;
    }
    cout << endl;   // 输出：3 3 3 3
    // 3. count：返回实际个数
    cout << x << ":" << s1.count(x) << "个" << endl;  // 输出：3:4个
    // 4. erase(值)：删除所有匹配元素
    cout << x << "删除的个数：" << s1.erase(x) << endl;  // 输出：4
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;   // 输出：1 2 5 5 6
}
int main()
{
    test_multiset();
}

7. 总结

set 与 multiset 的核心知识点：

分类 核心内容
关联式容器 按关键字访问，底层红黑树
set 唯一 + 有序，不可修改 key
multiset 可重复 + 有序
时间复杂度 插入/删除/查找 O(log n)
区间操作 lower_bound / upper_bound 配合 erase
效率对比 set::find O(log n) vs std::find O(n)

set vs multiset 接口差异

接口 set multiset
insert 重复值 插入失败 插入成功
count(val) 返回 0/1 返回实际个数
erase(val) 删除 0/1 个 删除所有匹配元素
find(val) 返回唯一位置 返回中序第一个

使用场景

场景 推荐容器
需要去重 + 有序 set
需要有序 + 允许重复 multiset
需要快速查找 + 不关心顺序 unordered_set
需要键值对映射 map / unordered_map

本文全部代码

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <set>
using namespace std;
/*
1.序列式容器和关联式容器
    （1）前⾯我们已经接触过STL中的部分容器如：string、vector、list、deque、array、forward_list等，
这些容器统称为“序列式容器”，因为逻辑结构为线性序列的数据结构，两个位置存储的值之间⼀般没有紧密的关联关系，
⽐如交换⼀下，他依旧是序列式容器。顺序容器中的元素是按他们在容器中的存储位置来顺序保存和访问的。
    （2）“关联式容器”也是⽤来存储数据的，与序列式容器不同的是，关联式容器逻辑结构通常是“⾮线性结构”，
两个位置有紧密的关联关系，交换⼀下，他的存储结构就被破坏了。
    （3）顺序容器中的元素是按关键字来保存和访问的。
    （4）关联式容器有map/set系列和unordered_map/unordered_set系列。
    （5）map和set底层是红⿊树，红⿊树是⼀颗平衡⼆叉搜索树。
    （6）set是key搜索场景的结构，map是key/value搜索场景的结构。
2.STL容器的本质区别：数据如何存储与访问
3.set类介绍：
容器              底层结构            元素唯一性       是否有序            头文件             典型时间复杂度
set             红黑树（平衡二叉搜索树）    唯一      有序（默认升序）    <set>             插入/删除/查找：O(log n)
multiset            红黑树                 可重复     有序              <set>             插入/删除/查找：O(log n)
unordered_set       哈希表                 唯一      无序              <unordered_set>       插入/删除/查找：平均O(1)，最坏O(n)
unordered_multiset  哈希表                 可重复     无序              <unordered_set>       插入/删除/查找：平均O(1)，最坏O(n)
4.红黑树赋能的高效特性：
    - 自动排序：红黑树的中序遍历结果为有序序列，因此 set 插入元素后会自动按 key 的默认规则（less升序）排序，
    无需手动调用排序函数，如果需要按自己的需求比较可以自行实现仿函数传给第二个模板参数。
    - 去重与允许重复：set 不允许存储重复 key（multiset 支持重复 key）；
    - 不可修改 key：set 的迭代器为 const_iterator，无法通过迭代器修改 key（修改会破坏红黑树结构）；
    - 高效操作：增删查操作的时间复杂度均为O(log N)，远优于 vector 的O(N)
*/
/*
1.set的声明如下：
- T就是 set 底层关键字的类型
- set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数
- set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。
- 一般情况下，我们都不需要传后两个模版参数。
- set底层是用红黑树实现，增删查效率是O(logN)，迭代器遍历是走的搜索树的中序，所以是有序的。
template <  class T,                        // set::key_type/value_type
            class Compare = less<T>,        // set::key_compare/value_compare
            class Alloc = allocator<T>      // set::allocator_type
            > class set;
2.set构造相关接口：
// empty (1) ⽆参默认构造
explicit set (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
// range (2) 迭代器区间构造
template <class InputIterator>
set (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
// copy (3) 拷⻉构造
set (const set& x);
// initializer list (5) initializer 列表构造
set (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
// 迭代器是⼀个双向迭代器
iterator -> a bidirectional iterator to const value_type
// 正向迭代器
iterator begin();
iterator end();
// 反向迭代器
reverse_iterator rbegin();
reverse_iterator rend();
3.set的增删查相关接口：
Member types
key_type -> The first template parameter (T)
value_type -> The first template parameter (T)
// 单个数据插⼊，如果已经存在则插⼊失败
pair<iterator,bool> insert (const value_type& val);
// 列表插⼊，已经在容器中存在的值不会插⼊
void insert (initializer_list<value_type> il);
// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
// 查找val，返回val所在的迭代器，没有找到返回end()
iterator find (const value_type& val);
// 查找val，返回Val的个数
size_type count (const value_type& val) const;
// 删除⼀个迭代器位置的值，返回的是下一个位置的迭代器
iterator erase (const_iterator position);
// 删除val，val不存在返回0，存在返回1
size_type erase (const value_type& val);
// 删除⼀段迭代器区间的值
iterator erase (const_iterator first, const_iterator last);
// 返回第一次出现⼤于等于val位置的迭代器
iterator lower_bound (const value_type& val) const;
// 返回第一次出现⼤于val位置的迭代器
iterator upper_bound (const value_type& val) const;
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------接口实战------------------------------------------------------
// 1.初始化与插入：去重 + 自动排序
void test_set1()
{
    //测试set的插入与遍历（去重 + 自动排序）
    set<int> s1;
// 方式1：单个元素插入
    s1.insert(3);
    s1.insert(1);
    s1.insert(2);
    s1.insert(5);
    s1.insert(3);
    s1.insert(5);
    s1.insert(6);
    cout << "s1" << endl;
    // 遍历方式1：迭代器遍历（注意：*it不可修改）
    // 遍历结果: 去重+有序
    auto it = s1.begin();
    while (it != s1.end())
    {
        //*it1 = 1;//不能修改
        cout << *it << " ";
        it++;
    }
    cout << endl;
// 方式2：初始化列表批量插入
    set<int> s2;
    s2.insert({ 3,1,2,5,3,5,6 });
    cout << "s2" << endl;
    // 遍历方式2：范围for循环
    for (auto& e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    //若需降序排序，可指定排序仿函数：set<int, greater<int>> s -> 降序排序
    set<int, greater<int>> s3({ 3,1,2,5,3,5,6 }); //列表构造
    cout << "s3" <<endl;
    for (auto& e : s3)
    {
        cout << e << " ";
    }
    cout << endl;
}
int main()
{
    test_set1();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 2.测试set的查找与删除
void test_set2()
{
    set<int> s1;
    s1.insert({ 3,1,2,5,3,5,6 });// 去重后：1 2 3 5 6
    // 删除最小值 
    s1.erase(s1.begin());//iterator erase (const_iterator position);
    for (auto& e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    // 直接删除x 
    int x;
    cin >> x;
    int num = s1.erase(x); //删掉了几个返回值就是几，在set里就是1，没删掉就是0
    //size_type erase(const value_type & val);
    if (num == 0)
    {
        cout << x << "不存在！" << endl;
    }
    else
    {
        cout << x << "删除成功！" << endl;
    }
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
    // 直接查找在利用返回值是迭代器删除x 
    set<int> s2({ 3,1,2,5,3,5,6 });
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cin >> x;
    auto pos = s2.find(x);
    if (pos != s2.end()) //如果返回的结果是end()则说明没有找到
    {
        s2.erase(pos);
        //cout << *pos << endl; //删除后该位置的迭代器就失效了，不能再进行访问！
    }
    else
    {
        cout << x << "不存在！" << endl;
    }
    for (auto e : s2)
    {
        cout << e << " ";
    }
    cout << endl;
    cout << endl;
    //// 算法库的查找 O(N) 
    //auto pos1 = find(s2.begin(), s2.end(), x);
    //// set⾃⾝实现的查找 O(logN) 
    //auto pos2 = s2.find(x);
    //// 利用count间接实现快速查找 
    //cin >> x;
    //if (s2.count(x))
    //{
    //  cout << x << "在！" << endl;
    //}
    //else
    //{
    //  cout << x << "不在！" << endl;
    //}
}
int main()
{
    test_set2();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 3.测试set的区间操作
void test_set3()
{
    set<int> s;
    s.insert({ 3,1,2,5,3,5,6,7,9 });
    for (auto& e : s)
    {
        cout << e << " ";
    }
    cout << endl;
    // 需求：删除[3, 8]区间的元素（即 >=3 且 <=8 ）
    // lower_bound(val)：返回第一个 >= val 的迭代器（此处指向3）
    auto it1 = s.lower_bound(3);
    // upper_bound(val)：返回第一个 > val 的迭代器（此处指向9）
    auto it2 = s.upper_bound(8);
    // 按迭代器区间删除：删除[it1, it2)内的元素(左闭右开)
    s.erase(it1, it2); //所以迭代器it2位置不会删除而是删除到左边一个位置结束
    for (auto& e : s)
    {
        cout << e << " ";
    }
    cout << endl;
}
int main()
{
    test_set3();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 4.测试multiset（支持重复key）
void test_multiset()
{
    multiset<int> s1;
    // 插入重复元素（不会去重）
    s1.insert({ 3,1,2,5,3,5,6,3,3 });
    // 1. 遍历：有序并且保留重复元素
    auto it = s1.begin();
    while (it != s1.end())
    {
        //*it = 1;//不能修改
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    // 相比set不同的是，x可能会存在多个，find查找中序的第一个
    int x;
    cin >> x;
    auto pos = s1.find(x);
    //打印所有的x
    while (pos != s1.end() && *pos == x)
    {
        cout << *pos << " ";
        pos++;
    }
    cout << endl;
    // 相比set不同的是，count会返回x的实际个数 
    cout << x << ":" << s1.count(x) << "个" << endl;
    //删除：按 key 删除所有匹配元素
    // 相比set不同的是，erase给值时会删除所有的x 
    cout << x << "删除的个数：" << s1.erase(x) << endl;//删掉所有的3，并返回删掉的3的个数
    for (auto e : s1)
    {
        cout << e << " ";
    }
    cout << endl;
}
int main()
{
    test_multiset();
}

觉得上面的内容有用吗？快来点个赞吧！

点赞() 我要打赏

温馨提示 : 本站内容来自会员投稿以及互联网，所有源码及教程均为作者总结编辑，请大家在使用过程中提前做好备份，以免发生无法预知的错误，源码类教程请勿直接用于生产环境！

 可能感兴趣的文章

C++ set 与 multiset 容器使用指南：关联式容器入门

目录 前言 set 与 multiset 核心特点 1. 序列式容器 vs 关联式容器 1.1 序列式容器 1.2 关联式容器 2. set 类概述 2.1 模板声明 2.2 set 的核心特性 2.3 构造相关...

QT 实现随机验证码功能

目录 1.界面实现效果 2.简介 3.使用1.界面实现效果以下是具体的项目需要用到的效果展示，用于验证字母。2.简介自定义CaptchaMovableLabel，继承自QLabel类： 中间的4个字母，就是Ca...

C# Winform截图指定控件范围内的图像的流程步骤

目录 一、函数输入 二、函数输出 三、使用示例一、函数输入输入有两个，参数一：需要截图的容器控件，参数二：保存截图的绝对路径路径<param name="control">控件名</param> <param...

C#整合Ollama实现本地LLMs调用

前言 近两年AIGC发展的非常迅速，从刚开始的只有ChatGPT到现在的很百家争鸣。从开始的大参数模型，再到后来的小参数模型，从一开始单一的文本模型到现在的多模态模型等等。随...

用GDI+旋转多边形来绘制一个时钟摸拟小程序

效果图在头文件类中声明变量TCHAR m_dayStr[4];　　　　// 日期 TCHAR m_weekStr[4];　　// 星期 Gdiplus::Font* m_pFont;　　// 字体 Gdiplus::StringFormat m_s...

智能指针相关：enable_shared_from_this()在开发中的常见应用

类中使用shared_ptr()的问题当我们先定义一个指针，然后再用这个指针构造两个智能指针int main(){ int* pt = new int(); std::shared_ptr<int> p1(pt); std::shared_ptr<i...

WPF/C#：程序关闭的三种模式

ShutdownMode枚举类型介绍ShutdownMode是一个枚举类型，它定义了WPF应用程序的关闭方式。这个枚举类型有三个成员： OnLastWindowClose：当最后一个窗口关闭或者调用System.Window...

C#.Net筑基-基础知识

01、C#基础概念1.1、C#简介C# （读作C Sharp）是由微软公司开发的一种面向对象、类型安全、高效且简单的编程语言，最初于 2000 年发布，并随后成为 .NET 框架的一部分。所以学习C#...

C++ 函数递归详解：递归在编程竞赛中的应用

C++ 函数递归详解：递归在编程竞赛中的应用什么是递归？递归是指一个函数调用自身的一种技术。本质上，它以更小的实例解决问题，然后将其结果组合起来解决原始问题。递归的优点： 代...

C++ 函数命名中的国际化和本地化考虑因素

C++ 函数命名中的国际化和本地化考虑因素在开发多语言/多文化应用程序时，函数名称的国际化和本地化至关重要。这确保了函数名称在不同语言和文化中都是有意义和可理解的。国...

1 2 3 4 5

热门文章