STL容器之＜set＞

时间：2021-04-08 01:14:39

文章目录

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

set介绍

  1. 关联式容器。
  2. 元素是唯一的，即是值又是键。
  3. 元素不能直接修改，需要先删除在插入。
  4. 支持双向迭代器。
  5. 在插入、删除和搜索时间复杂度为log(n)。

头文件

#include <map>

模块类定义

template<typename _Key, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<_Key> >
    class set{};

_Key：表示存储的键数据类型
_Compare：表示按照键的排序方式。
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

对象构造

/*默认构造函数*/
std::set<int> set1;
/*构造一个set指定排序方式*/
std::set<int> set2(std::greater<int>());
/*拷贝构造函数*/
std::set<int> set3(set1);
/*移动构造函数*/
std::set<int> set4(std::move(set1));
/*初始化列表*/
std::set<int> set5({5,4,3,2,1});
/*初始化列表+排序方式*/
std::set<int> set6({5,4,3,2,1}, std::less<int>());
/*迭代器指定范围构造*/
std::set<int> set7(set6.begin(),set6.end());
/*迭代器指定范围+排序方式*/
std::set<int> set8(set7.begin(), set7.end(), std::less<int>());

初始化

/*初始化列表初始化元素*/
set1 = {1,3,5,4,2};

元素访问

不支持at()函数和下标运算符访问元素

元素插入和删除

函数 返回值 功能
clear() 无 清空所有元素
erase() 迭代器或删除元素数量 清除指定位置的一个元素、通过迭代器指定范围内的元素或通过键删除值
emplace() 键值对 插入元素。插入成功时第一个元素是指向新插入元素的迭代器，失败时第一个元素是指向以存在元素的迭代器，第二个元素表示插入结果，true成功，false失败。
emplace_hint() 迭代器 插入成功返回新插入元素的迭代器，插入失败时返回已存在元素的迭代器
insert() 键值对、迭代器、无 1）在指定位置插入1个元素。2）复制通过迭代器指定范围的元素。3）通过初始化列表插入元素。4）直接插入元素。 
/*直接构造并插入元素*/
auto ret1 = set1.emplace(10);
std::cout << "result:"<<std::boolalpha<<ret1.second<<std::endl;
std::cout << "value:"<<*(ret1.first)<<std::endl;
/*直接构造元素并插入指定位置*/
auto ret2 = set1.emplace_hint(++set1.begin(),6);
std::cout << "value:"<<*(ret2)<<std::endl;
/*直接构造并在指定位置插入元素*/
auto ret1 = map1.emplace_hint(map1.begin(),1,66);
std::cout << "ret1.first:"<<ret1->first<<" ret1.second:"<<ret1->second<<std::endl;
/*插入元素*/
auto ret3 = set1.insert(8);
std::cout << "result:"<<std::boolalpha<<ret3.second<<std::endl;
std::cout << "value:"<<*(ret3.first)<<std::endl;
/*使用移动函数插入元素*/
int iValue = 7;
auto ret4 = set1.insert(std::move(iValue));
std::cout << "result:"<<std::boolalpha<<ret4.second<<std::endl;
std::cout << "value:"<<*(ret4.first)<<std::endl;
/*指定位置插入元素*/
auto ret5 = set1.insert(++set1.begin(), 12);
std::cout << "value:"<<*(ret5)<<std::endl;
/*使用移动函数在指定位置插入元素*/
int iValue1 = 13;
auto ret6 = set1.insert(--set1.end(), std::move(iValue1));
std::cout << "value:"<<*(ret5)<<std::endl;
/*使用迭代器插入元素*/
set3.insert(++set1.begin(), --set1.end());
/*使用初始化列表插入元素*/
set4.insert({1,2,5,4,8,3});
/*删除指定位置的元素*/
auto ret7 = set4.erase(++set4.begin());
std::cout << "value:"<<*(ret7)<<std::endl;
/*删除指定范围的元素*/
auto ret8 = set4.erase(++set4.begin(), --set4.end());
std::cout << "value:" << *(ret8) << std::endl;
/*按值删除元素*/
int iValue3 = set1.erase(1);
std::cout << "value:" << iValue3 << std::endl;
/*清空元素*/
set3.clear();

元素查找

函数 返回值 功能
count() std::size_t 返回给定键对应元素的数量
find() 迭代器 查找指定键对应元素的位置,未找到则返回end()
lower_bound() 迭代器 查找第一个大于或等于给定键的元素的位置,未找到则返回end()
upper_bound() 迭代器 查找第一个大于给定键的元素的位置，未找到返回end()
equal_range() 迭代器 获取给定键的lower_bound和upper_bound 
/*查找指定值的数量*/
std::cout << "count:" << set1.count(5) << std::endl;
/*查找指定值的位置*/
auto ret9 = set1.find(4);
std::cout << "value:" << *(ret9) << std::endl;
/*查找第一个大于等于给定键的元素的位置*/
auto ret10 = set1.lower_bound(3);
std::cout << "value:"<<*(ret10)<<std::endl;
/*查找第一个大于给定键的元素的位置*/
auto ret11 = set1.upper_bound(2);
std::cout << "value:"<<*(ret11)<<std::endl;
/*分别返回lower_bound和upper_bound*/
auto ret12 = set1.equal_range(1);
std::cout << "lower_bound value:"<<*(ret12.first)<<std::endl;
std::cout << "upper_bound value:"<<*(ret12.second)<<std::endl;

容器大小

函数 返回值 功能
size() std::size_t 获取当前容器中的元素数量
empty() bool 判断当前容器是否为空，为空返回true，否则返回false
max_size() std::size_t 返回容器的最大容量 
/*判断元素的数量*/
std::cout<<set1.size()<<std::endl;
/*判断容器最大能容纳的元素的数量*/
std::cout<<set1.max_size()<<std::endl;
/*判断容器是否为空*/
std::cout<<set1.empty()<<std::endl;/*判断队列中元素数量*/

迭代器

类型 功能
iterator 正向访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator 常量正向访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator 逆向访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator 常量逆向访问迭代器。从后向前访问元素，只能读取不能修改
函数 返回值 功能
begin() 正向访问迭代器 返回指向set对象首元素所在位置的迭代器
end() 正向访问迭代器 返回指向set对象末尾元素的下一个位置的迭代器
cbegin() 常量正向访问迭代器 返回指向set对象首元素所在位置的常量迭代器
cend() 常量正向访问迭代器 返回指向set对象末尾元素的下一个位置的迭代器
rbegin() 逆向访问迭代器 返回指向set对象末尾元素位置的迭代器
rend() 逆向访问迭代器 返回指向set对象首元素的前一个位置的迭代器
crbegin() 常量逆向访问迭代器 返回指向set对象末尾元素位置的常量迭代器
crend() 常量逆向访问迭代器 返回指向set对象首元素的前一个位置的常量迭代器 
std::set<int> setTest({1,3,2,6,4,5,8,10,9,7});
/*正向随机访问迭代器，并打印输出（1 2 3 4 5 6 7 8 9 10）*/
std::set<int>::iterator itr;
for (itr = setTest.begin(); itr != setTest.end(); itr++)
{
    /* 不允许修改元素值 */
    //*itr += 10; 
    /* 访问元素 */
    std::cout<<*(itr)<<" ";
}
std::cout<<std::endl;
/*常量正向随机访问迭代器，并打印输出（1 2 3 4 5 6 7 8 9 10）*/
std::set<int>::const_iterator cItr;
for (cItr = setTest.cbegin(); cItr != setTest.cend(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout <<*(cItr)<<" ";
}
std::cout<<std::endl;
/*逆向随机访问迭代器，并打印输出（10 9 8 7 6 5 4 3 2 1）*/
std::set<int>::reverse_iterator rItr;
for (rItr= setTest.rbegin(); rItr!= setTest.rend(); rItr++)
{
    /* 不允许修改元素值 */
    //*rItr += 100; 
    /* 访问元素 */
    std::cout <<" " << *(rItr);
}
std::cout<<std::endl;

/*常量逆向随机访问迭代器，并打印输出（10 9 8 7 6 5 4 3 2 1）*/
std::set<int>::const_reverse_iterator crItr;
for (crItr= setTest.crbegin(); crItr!= setTest.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout <<" "<<*crItr;
}
std::cout << std::endl;

其他函数

函数名 返回值 功能
swap() 无 交换两个容器的元素 
/*交互两个容器元素的值,无返回值*/
std::set<int> setSwap1 = {1,2,3,4,5};
std::set<int> setSwap2 = {6,7,8,9,10};
/*方式1， setSwap1={6,7,8,9,10}, setSwap2={1,2,3,4,5}*/
setSwap1.swap(setSwap2);
/*setSwap1={1,2,3,4,5}, setSwap2={6,7,8,9,10}*/
std::swap(setSwap1,setSwap2);
标签：

相关文章