【C++关联式容器】set

秋秋晗晗

已于 2024-02-14 20:31:46 修改

阅读量648

点赞数

分类专栏： C++容器文章标签： c++

于 2023-04-24 18:27:03 首次发布

本文链接：https://blog.csdn.net/Qiuhan_909/article/details/130344415

版权

C++容器专栏收录该内容

12 篇文章 3 订阅

订阅专栏

set

1. 关联式容器额外的类型别名

2. Member functions

2.1 constructor、destructor、operator=

2.1.1 constructor

2.1.2 destructor

2.1.3 operator=

2.2 Iterators

2.3 Capacity

2.4 Modifiers

2.5 Observers

2.6 Operations

2.7 Allocator

set

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;

set是按照特定顺序存储唯一元素的容器。

在set中，一个元素的值也是它的标识（值本身就是关键字，类型为T），并且每个值必须是唯一的。一旦在容器中，集合中的元素的值就不能被修改（元素总是不变的），但是它们可以被插入或从容器中移除。

在内部，set中的元素总是按照其内部比较对象（Compare类型）所指示的特定的严格的弱排序标准进行排序。

set容器通常比unordered_set容器通过键来访问单个元素要慢一些，但是它们允许根据子集的顺序来直接迭代。

set通常以二叉搜索树（准确地说，是红黑树）的形式实现。

set定义在头文件set和命名空间std中。

1. 关联式容器额外的类型别名

key_type	此容器类型的关键字类型
mapped_type	每个关键字关联的类型；只适用于map
value_type	对于set，与key_type相同对于map，为pair<const key_type, mapped_type>

对于set类型，key_type和value_type是一样的：set中保存的值就是关键字。在一个map中，元素是键值对。即，每个元素是一个pair对象，包含一个关键字和一个关联的值。由于我们不能改变一个元素的关键字，因此这些pair的关键字部分是const的：

set<string>::value_type vl;       // v1是一个string
set<string>::key_type v2;         // v2是一个string
map<string, int>::value_type v3;  // v3是一个pair<const string, int>
map<string, int>::key_type v4;    // v4是一个string
map<string, int>::mapped_type v5; // v5是一个int

与序列式容器一样，我们使用作用域运算符来提取一个类型的成员——例如，map<string, int>::key_type。

只有map类型（unordered_map、unordered_multimap、multimap和map）才定义了mapped_type。

2. Member functions

2.1 constructor、destructor、operator=

2.1.1 constructor

// empty (1)
explicit set(const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());
explicit set(const allocator_type& alloc);
// 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);
set(const set& x, const allocator_type& alloc);
// move (4)
set(set&& x);
set(set&& x, const allocator_type& alloc);
// initializer list (5)
set(initializer_list<value_type> il, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());

创建降序排序的空set：

#include <set>
#include <iostream>
using namespace std;

struct cmp
{
	bool operator()(const int e1, const int e2) const
	{
		return e1 > e2;
	}
};

int main()
{
	set<int, cmp> st{ 4,2,2,9,6,6,6,1,7,10 };

	for (auto& e : st)
	{
		cout << e << " ";
	}
	cout << endl;
	// 10 9 7 6 4 2 1

	return 0;
}

2.1.2 destructor

~set();

2.1.3 operator=

// copy (1)
set& operator=(const set& x);
// move (2)
set& operator=(set&& x);
// initializer list (3)
set& operator=(initializer_list<value_type> il);

2.2 Iterators

// begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
// end
iterator end() noexcept;
const_iterator end() const noexcept;
// rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
// rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
// cbegin
const_iterator cbegin() const noexcept;
// cend
const_iterator cend() const noexcept;
// crbegin
const_reverse_iterator crbegin() const noexcept;
// crend
const_reverse_iterator crend() const noexcept;

函数	功能
begin & end	begin返回一个迭代器，指向set中第一个元素 end返回一个迭代器，指向set中最后一个元素的下一个位置
rbegin & rend	rbegin返回一个反向迭代器，指向set中最后一个元素 rend返回一个反向迭代器，指向set中第一个元素的上一个位置
cbegin & cend	cbegin返回一个const迭代器，指向set中第一个元素 cend返回一个const迭代器，指向set中最后一个元素的下一个位置
crbegin & crend	crbegin返回一个const反向迭代器，指向set中最后一个元素 crend返回一个const反向迭代器，指向set中第一个元素的上一个位置

函数

功能

begin

end

begin返回一个迭代器，指向set中第一个元素

end返回一个迭代器，指向set中最后一个元素的下一个位置

rbegin

rend

rbegin返回一个反向迭代器，指向set中最后一个元素

rend返回一个反向迭代器，指向set中第一个元素的上一个位置

cbegin

cend

cbegin返回一个const迭代器，指向set中第一个元素

cend返回一个const迭代器，指向set中最后一个元素的下一个位置

crbegin

crend

crbegin返回一个const反向迭代器，指向set中最后一个元素

crend返回一个const反向迭代器，指向set中第一个元素的上一个位置

begin&end和rbegin&rend返回的迭代器指向：

const_iterator是一个指向const内容的迭代器。迭代器本身可以修改，但是它不能被用来修改它所指向的内容。

begin&end/rbegin&rend和cbegin&cend/crbegin&crend的不同：

begin&end/rbegin&rend的返回类型由对象是否是常量来决定。如果不是常量，返回iterator；如果是常量，返回const_iterator。
cbegin&cend/crbegin&crend的返回类型是const_iterator，不管对象本身是否是常量。

set的迭代器是const的。虽然set类型同时定义了iterator和const_iterator类型，但两种类型都只允许只读访问set中的元素。与不能改变一个map元素的关键字一样，一个set中的关键字也是const的。可以用一个set迭代器来读取元素的值，但不能修改。

#include <set>
#include <iostream>
using namespace std;

int main()
{
	int arr[10] = { 4,2,2,9,6,6,6,1,7,10 };
	set<int> st(arr, arr + 10);

	set<int>::iterator it = st.begin();
	while (it != st.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	// 1 2 4 6 7 9 10

	auto rit = st.rbegin();
	// set<int>::reverse_iterator rit = st.rbegin();
	while (rit != st.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	// 10 9 7 6 4 2 1

	return 0;
}

2.3 Capacity