脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C 语言 → C++ set 与 multiset 容器

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

 更新时间：2026年06月17日 09:55:56   作者：.千余  
这段描述概括了序列式容器与关联式容器的区别,重点介绍了set和multiset的特性、构造函数及操作接口,强调了使用效率和查找效率的不同,并指出在关联式容器中应优先使用自带的find方法,感兴趣的朋友跟随小编一起看看吧

前言

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

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

特性setmultiset
元素唯一性唯一，自动去重可重复
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 接口差异

接口setmultiset
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 容器使用指南：关联式容器入门的文章就介绍到这了,更多相关C++ set 与 multiset 容器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • C语言中access/_access函数的使用实例详解

    C语言中access/_access函数的使用实例详解

    本文通过实例代码给大家介绍了C语言中access/_access函数的使用,代码简单易懂，非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
    2019-09-09
  • OpenSSL使用AES实现文件加解密功能

    OpenSSL使用AES实现文件加解密功能

    AES是一种对称加密算法,它是目前广泛使用的加密算法之一,意味着加密和解密使用相同的密钥,这就要求密钥的安全性非常重要,因为任何拥有密钥的人都能进行加密和解密操作,本文给大家介绍了OpenSSL如何使用AES实现文件加解密功能,需要的朋友可以参考下
    2023-11-11
  • C++编译原理之求解First集合

    C++编译原理之求解First集合

    这篇文章主要介绍的是C++/编译原理求解First集合，本文将围绕该话题详细展开全文,需要的小伙伴可以参考一下
    2021-10-10
  • QT中窗口关闭自动销毁的实现示例

    QT中窗口关闭自动销毁的实现示例

    这篇文章主要介绍了QT中窗口关闭自动销毁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-05-05
  • c语言 指针零基础讲解

    c语言 指针零基础讲解

    指针是指向另一个变量的变量。意思是一个指针保存的是另一个变量的内存地址。换句话说,指针保存的并不是普通意义上的数值,而是另一个变量的地址值。一个指针保存了另一个变量的地址值,就说这个指针“指向”了那个变量
    2022-02-02
  • OpenCV边缘提取算法流程的实现(附DEMO)

    OpenCV边缘提取算法流程的实现(附DEMO)

    本文主要介绍了OpenCV边缘提取算法流程的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-08-08
  • C语言实现文件读写操作的几种常用方法

    C语言实现文件读写操作的几种常用方法

    C语言提供了一系列文件操作函数,使得我们可以通过程序对文件进行读写操作,本文主要介绍了C语言实现文件读写操作的几种常用方法,具有一定的参考价值,感兴趣的可以了解一下
    2024-03-03
  • 如何让C++函数返回值死心塌地为你工作

    如何让C++函数返回值死心塌地为你工作

    这篇文章主要介绍了如何让C++函数返回值死心塌地为你工作，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
    2018-01-01
  • C++深入刨析类与对象的使用

    C++深入刨析类与对象的使用

    类和对象是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型；变量就是可以变化的量，存储在内存中—个可以拥有在某个范围内的可变存储区域
    2022-05-05
  • C++多态的实现机制深入理解

    C++多态的实现机制深入理解

    这篇文章主要介绍了C++多态的实现机制理解的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
    2016-07-07

最新评论