stl中set指令应用 - 360文档中心

STL的基本操作指令

STL的基本操作指令list :Lists将元素按顺序储存在链表中. 与向量(vectors)相⽐, 它允许快速的插⼊和删除，但是随机访问却⽐较慢. assign() 给list赋值back() 返回最后⼀个元素begin() 返回指向第⼀个元素的迭代器clear() 删除所有元素empty() 如果list是空的则返回trueend() 返回末尾的迭代器erase() 删除⼀个元素front() 返回第⼀个元素get_allocator() 返回list的配置器insert() 插⼊⼀个元素到list中max_size() 返回list能容纳的最⼤元素数量merge() 合并两个listpop_back() 删除最后⼀个元素pop_front() 删除第⼀个元素push_back() 在list的末尾添加⼀个元素push_front() 在list的头部添加⼀个元素rbegin() 返回指向第⼀个元素的逆向迭代器remove() 从list删除元素remove_if() 按指定条件删除元素rend() 指向list末尾的逆向迭代器resize() 改变list的⼤⼩reverse() 把list的元素倒转size() 返回list中的元素个数sort() 给list排序splice() 合并两个listswap() 交换两个listunique() 删除list中重复的元素String类：1) string s; //⽣成⼀个空字符串s2) string s(str) //拷贝构造函数⽣成str的复制品3) string s(str,index) //将字符串str内“始于位置index”的部分当作字符串的初值4) string s(str,index, n) //将字符串str内“始于index且长度顶多n”的部分作为字符串的初值5) string s(cstr) //将C字符串作为s的初值6) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。

STL中set用法详解

STL中set用法详解set是STL中一种标准关联容器（vector,list,string,deque 都是序列容器，而set，multiset，map，multimap是标准关联容器），它底层使用平衡的搜索树——红黑树实现，插入删除操作时仅仅需要指针操作节点即可完成，不涉及到内存移动和拷贝，所以效率比较高。

set，顾名思义是“集合”的意思，在set中元素都是唯一的，而且默认情况下会对元素自动进行升序排列，支持集合的交(set_intersection),差(set_difference) 并(set_union)，对称差(set_symmetric_difference) 等一些集合上的操作，如果需要集合中的元素允许重复那么可以使用multiset#include<set>#include<iterator>#include&lt ;iostream>using namespace std;intmain(){set<int>eg1;//插入eg1.insert(1);eg1.insert(100);eg1.insert(5);eg1.insert(1);//元素1因为已经存在所以set中不会再次插入1eg1.insert(10);eg1.insert(9);//遍历set，可以发现元素是有序的set<int>::iterator set_iter=eg1.begin();cout<<"Set named eg1:"<<endl;for(;set_iter!=eg1.end();set_iter++) cout<<*set_iter<<" ";cout<<endl;//使用size()函数可以获得当前元素个数cout<<"Now there are"<<eg1.size()<<" elements in the seteg1"<<endl;if(eg1.find(200)==eg1.end())//find()函数可以查找元素是否存在cout<<"200 isn't in the seteg1"<<endl;set<int>eg2;for(inti=6;i<15;i++)eg2.insert(i);cout<<"Set namedeg2:"<<endl;for(set_iter=eg2.begin();set_iter!=eg2.end();s et_iter++) cout<<*set_iter<<"";cout<<endl;//获得两个set的并set<int>eg3;cout<<"Union:";set_union(eg1.begin(),e g1.end(),eg2.begin(),eg2.end(),insert_iterator<set<int> >(eg3,eg3.begin()));//注意第五个参数的形式copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," "));cout<<endl;//获得两个set的交，注意进行集合操作之前接收结果的set要调用clear()函数清空一下eg3.clear();set_intersection(eg1.begin(),eg1.end(),eg2.begin(),eg 2.end(),insert_iterator<set<int>>(eg3,eg3.begin()));cout<<"Intersection:";copy(eg3.beg in(),eg3.end(),ostream_iterator<int>(cout,""));cout<<endl;//获得两个set的差eg3.clear();set_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2 .end(),insert_iterator<set<int>>(eg3,eg3.begin()));cout<<"Difference:";copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout,""));cout<<endl;//获得两个set的对称差，也就是假设两个集合分别为A和B那么对称差为AUB-A∩B eg3.clear(); set_symmetric_difference(eg1.begin(),eg1.end(),eg2.begin(),eg2 .end(),insert_iterator<set<int> >(eg3,eg3.begin())); copy(eg3.begin(),eg3.end(),ostream_iterator<int>(cout," ")); cout<<endl;return 0;}set会对元素进行排序，那么问题也就出现了排序的规则是怎样的呢？上面的示例代码我们发现对int型的元素可以自动判断大小顺序，但是对char*就不会自动用strcmp进行判断了，更别说是用户自定义的类型了，事实上set的标准形式是set<Key, Compare, Alloc>，参数描述默认值Key集合的关键字和值的类型Compare关键字比较函数，它的参数类型key参数指定的类型，如果第一个参数小于第二个参数则返回true，否则返回falseless<Key>Allocset的分配器，用于内部内存管理alloc。

c 复习之stl(二)谈一谈关联式容器set和有序vector的使用选择问题

C 复习之STL（二）——谈一谈关联式容器set和有序vector的使用选择问题C++复习之STL（二）——谈一谈关联式容器set和有序vector的使用选择问题1.set的宣言先看看C++标准中对set的介绍：A set is a kind of associative container that supports unique keys (contains at most oneof each key value) and provides for fast retrieval of the keys themselves. Set supportsbidirectional iterators下面列举关于set的两点事实，需要注意：set对于性能有明确的保证：set::find和set::insert消耗时间级别都为logN。

所以，如果你确实需要保证插入和检索时间在logN，set可能是个不错的选择。

set底层实现通常使用red-black tree：有额外的空间和时间负担。

每个red-black tree的节点都需要存储颜色标记、指向子女和父亲的指针；插入需要树的重新平衡；查询和遍历需要指针操作。

2.另外的选择：二分查找红黑树并非提供logN级别的搜索的唯一数据结构。

很容易想到的就是在有序数集中进行binary_search，该算也提供的logN级别的时间复杂度，而且最数据结构的要求仅仅是“一个有序顺序集（该集支持某些必要操作）”,而且,常数因子比set更小。

使用set会占用更多的空间，不利于cache机制的使用，且可能造成更多的page faults。

事实胜于雄辩,下面是用一段代码来对比set提供的搜索和二分查找提供的搜索的性能,编译环境为WOW64 Release注意：检测元素是否搜索到是必须的,此处忽略之，对于push_back等的调用其实可以使用“范围函数”来完成，可能性能更好！#include <iostream>#include <set>#include <vector>#include <algorithm>#include <windows.h>int main(){using namespace std;const int MAX_ELEMENT = 1000000;const int MAX_SIZE = MAX_ELEMENT+1;const int MAX_TIMES = 10000000;set<int> intSet;vector<int> intVect;intVect.reserve(MAX_SIZE);for (int i = 0; i < MAX_SIZE; ++i){intSet.insert(i);intVect.push_back(i); //这里由于插入的特殊性，intVect元素状态是“有序”的}DWORD st1, st2;st1 = GetTickCount();for (int i = 0; i < MAX_TIMES; ++i){intSet.find(MAX_ELEMENT);intSet.find(MAX_ELEMENT/2);intSet.find(MAX_ELEMENT/15);}st2 = GetTickCount();cout << "intSet.find(...):\t" << (st2 - st1) << "ms" << endl;st1 = GetTickCount();for (int i = 0; i < MAX_TIMES; ++i){binary_search(intVect.begin(), intVect.end(),MAX_ELEMENT);binary_search(intVect.begin(), intVect.end(),MAX_ELEMENT/2);binary_search(intVect.begin(), intVect.end(),MAX_ELEMENT/15);}st2 = GetTickCount();cout << "binary_search(...):\t" << (st2 - st1)<< "ms" << endl;return 0;}运行截图:可以看到,由于缓存、缺页等各方面因素，二分查找和对于set的查找性能相差极大。

STL_的熟悉与使用

STL_的熟悉与使用STL（Standard Template Library）是C++标准库的一部分，是一套通用的模板类和函数的集合，提供了多种常用数据结构和算法的实现。

STL能够大大提高C++程序的开发效率，减少了大量重复的编程工作，同时具有高效性、可复用性和可扩展性。

熟悉和使用STL对于C++程序员来说是非常重要的，下面将介绍STL的常用组件和使用方法。

1. 容器（Containers）：STL提供了多种容器，包括向量（vector）、链表（list）、双端队列（deque）、集合（set）、映射（map）等。

容器提供了存储和管理对象的能力，可以根据需要选择适合的容器来存储数据。

例如，vector容器类似于动态数组，可以方便地插入、删除元素，而map容器允许根据关键字快速查找对象。

2. 迭代器（Iterators）：STL的迭代器提供了对容器内元素的访问和遍历，类似于指针的概念。

迭代器可以指向容器内的一些元素，并可以通过自增自减操作移动到容器的下一个或上一个元素。

STL提供了多种类型的迭代器，包括输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器等，不同类型的迭代器具有不同的功能和特性。

3. 算法（Algorithms）：STL提供了一系列常用的算法，包括排序（sort）、查找（find）、拷贝（copy）、替换（replace）等。

这些算法可以直接应用于容器上，无需开发者自己实现。

使用STL算法可以大大简化代码，提高开发效率，同时也能确保算法的正确性和高效性。

4. 函数对象（Function Objects）：STL中的函数对象类似于函数指针，可以作为参数传递给算法，用于指定特定的操作。

STL提供了一些内置的函数对象，如加法、减法、小于、等于等，同时也可以自定义函数对象。

函数对象可以方便地与算法结合使用，实现更加灵活和复杂的操作。

5. 适配器（Adapters）：STL的适配器用于将一种容器或迭代器转换为另一种容器或迭代器的形式。

stl容器set,map,vector之erase用法与返回值详细解析

stl容器set,map,vector之erase⽤法与返回值详细解析总结本⼈在⼯作中经验教训。

在使⽤ list、set 或 map遍历删除某些元素时可以这样使⽤：复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){itList = List.erase( itList);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){List.erase(itList++);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator it, next;for( it = List.begin(), next = it, next ++; it != List.end(); it = next, ++next){if( WillDelete( *it) ){List.erase(it);}}注：⽅法三更为巧妙,但需注意⽅法三是⽤前需要判断容器是否为空，否则迭代器会出问题。

我测试得出，set.erase 不返回迭代器，list返回。

vector 删除操作复制代码代码如下:std::vector <PACK_PRINT>::iterator It ;for(It=printItems.begin();It!=printItems.end();){//我是说这⾥怎么判断printItems printItems ⾥PACK_PRINT.bh =0if( It.bh ==0) //是这样吗?{//删除It=printItems.erase(It);}else{//不删除++It;}}复制代码代码如下:std::vector <PACK_PRINT> printItems;int i = 0;while(i < printItems.size()){if(printItems[i].bh == 0) //这⾥⽐如我想把 printItems 时PACK_PRINT.bh =0 的删除如何写哟。

STL set 常用操作简介

STL set 常用操作简介这是微软帮助文档中对集合（set）的解释：“描述了一个控制变长元素序列的对象（注：set 中的key和value是Key类型的，而map中的key和value是一个pair结构中的两个分量）的模板类，每一个元素包含了一个排序键（sort key）和一个值(value)。

对这个序列可以进行查找、插入、删除序列中的任意一个元素，而完成这些操作的时间同这个序列中元素个数的对数成比例关系，并且当游标指向一个已删除的元素时，删除操作无效。

”而一个经过更正的和更加实际的定义应该是：一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。

这在收集一个数据的具体值的时候是有用的。

集合中的元素按一定的顺序排列，并被作为集合中的实例。

如果你需要一个键/值对（pair）来存储数据，map是一个更好的选择。

一个集合通过一个链表来组织，在插入操作和删除操作上比向量（vector）快，但查找或添加末尾的元素时会有些慢。

下面是一个例子：//程序：set演示//目的：理解STL中的集合（set）#include ＜string＞#include ＜set＞#include ＜iostream＞using namespace std;int main(int argc, char* argv[]){set ＜string＞strset;set ＜string＞::iterator si;strset.insert("cantaloupes");strset.insert("apple");strset.insert("orange");strset.insert("banana");strset.insert("grapes");strset.insert("grapes");for (si=strset.begin(); si!=strset.end(); si++){ cout ＜＜*si ＜＜" "; }cout ＜＜endl;return 0;}// 输出：apple banana cantaloupes grapes orange//注意：输出的集合中的元素是按字母大小顺序排列的，而且每个值都不重复。

STEP7中用STL编写程序的时候,对SET的用法理解不够,帮忙看看下。

STEP7中用STL编写程序的时候，对SET 的用法理解不够，帮忙看看下。

SET
=DB1.DBX0.1
和
SET
SDB1.DBX0.1
有什么区别？
自己感觉没什么区别，结果都是DB1.DBX0.1为1，大家点拨下，这2种写法有什么不一样？对结果有什么改变没。

最佳答案
首先，就你所说的这两段代码来讲，DB1.DBX0.1都为1，所产生的结果都是一样的，对结果没有区别。

但是我想还是着重从两个方面理解一下这一块的知识：
1.SET，作用是将RLO无条件置位1，也就是无条件将RLO=1.
2.再就是对S（置位指令）和=（赋值指令）的区别进行理解。

置位（S）：如果前一条指令将RLO置为1，那么S指令
将寻址触点或线圈的信号状态置1.
赋值（=）：与RLO的状态无关，=指令把逻辑操作结果的值赋给其寻址单元（触点或线圈）.
分析两段代码：
SET//将RLO置为1
=DB1.DBX0.1//将逻辑操作结果RLO的值赋DB1.DBX0.1
SET//将RLO置为1
SDB1.DBX0.1//因为上一条指令RLO=1所以将
//DB1.DBX0.1置为1
如果单单得到DB1.DBX0.1的结果，那么没有区别，都是1；但是真正是如何得到的这个1，和表示的意义的话，还是有区别的。

就SET而言很好理解，就是无条件将RLO=1。

以上结论根据《S7-300.400语句表编程参考手册》5.7~5.9节。

C++ STL之set容器使用方法

C++ STL之Set容器的用法1 set中的元素类型 (1)2 set中构造相关函数 (2)3set中的迭代器 (3)4 set中的容量相关函数 (3)5 set中元素修改函数 (3)5.1 insert 函数 (3)5.2 erase 函数 (4)5.3 clear 函数 (5)5.4 swap 函数 (5)5.5 emplace 函数 (5)5.6 emplace_hint 函数 (5)6 set 中的比较函数体 (6)6.1 key_com 函数 (6)6.2 value_com 函数 (6)7 set的其他操作函数 (7)7.1 find 函数 (7)7.2 count 函数 (8)7.3 lower_bound 函数 (8)7.4 upper_bound 函数 (8)7.5 equal_range 函数 (9)7.6 get_allocator 函数 (10)Set容器是一个关联容器，容器中的元素互不相同，并且容器中的元素按照键值大小进行排序。

每当插入或者删除一个元素，容器都会重新排序。

Set容器有两大特点，一个是元素排序，另一个就是查询速度快（当然没有vector快）。

Set获取元素时通过键值，关联容器都这样。

Set是通过二元查找树实现的，再具体点就是红黑树。

关于这个无需多言，切记set中的iterator是指向const 元素。

以上分别为默认构造函数，范围构造函数，复制构造函数，移动构造函数，初始化列表构造函数，其中最后两个是C++11中的版本。

关于构造函数，不同的编译器可能提供的形式不一样，但是种类都是这几种。

构造函数示例：#include <iostream>#include <set>bool fncomp (int lhs, int rhs) {return lhs<rhs;}struct classcomp {bool operator() (const int& lhs, const int& rhs) const{return lhs<rhs;}};int main (){std::set<int> first; // empty set of intsint myints[]= {10,20,30,40,50};std::set<int> second (myints,myints+5); // rangestd::set<int> third (second); // a copy of secondstd::set<int> fourth (second.begin(), second.end()); //iterator ctor.std::set<int,classcomp> fifth; // class as Comparebool(*fn_pt)(int,int) = fncomp;std::set<int,bool(*)(int,int)> sixth (fn_pt); // function pointer as Comparereturn 0;}关于迭代器也没什么好说的，迭代器和前面的都一样。

STL中set的简单学习

st1.insert(20);
st1.insert(40);
//遍历数据，用迭代器遍历数据
for (it1 = st1.begin(); it1 != st1.end(); ++it1)
{
cout << *it1 << endl;
{
cout << "empty\n";
}
//查找数据，find。返回值是找到的情况的迭代器，如果没有找到，
//迭代器只想end，如果找到，为找到的数据，所以这里一定要先
//判断一下是否找到数据了。
it1 = st1.find(40); //查找数据
set<int>::iterator it1; //创建一个他对应的迭代器
//empty是判断他是否为空，而且如果要判断空，最好用这个来判断
//如果为空返回true
if (st1.empty()) //判断空,如果是空，则输出empty

STL中set的简单学习
今天我学习了STL中set的简单用法，set和map一样是一个用平衡二叉树写的模板，map可以有两个或多这个只配对，而set只有一个，当你只存放一个元素的时候，可以考虑用set,他的有点和map一样，查找很快。呵呵。因为我只用到set的一些简单的功能，所以也只学了一点点他的用法。更深入的用法还必须继续加油学习。呵呵。对了，如果要查MSDN中关于set的用法的话，关键字用set
if (it1 != st1.end()) //如果找到就输出数据
{
cout << *it1 << endl;
}

set--常见成员函数及基本用法

set--常见成员函数及基本⽤法c++ stl集合set介绍 c++ stl集合(Set)是⼀种包含已排序对象的关联容器。

set/multiset会根据待定的排序准则，⾃动将元素排序。

两者不同在于前者不允许元素重复，⽽后者允许。

c++ stl集合set介绍c++ stl集合(Set)是⼀种包含已排序对象的关联容器。

set/multiset会根据待定的排序准则，⾃动将元素排序。

两者不同在于前者不允许元素重复，⽽后者允许。

1) 不能直接改变元素值，因为那样会打乱原本正确的顺序，要改变元素值必须先删除旧元素，则插⼊新元素2) 不提供直接存取元素的任何操作函数，只能通过迭代器进⾏间接存取，⽽且从迭代器⾓度来看，元素值是常数3) 元素⽐较动作只能⽤于型别相同的容器(即元素和排序准则必须相同)set模板原型：//Key为元素(键值)类型1template<class Key, class Compare=less<Key>, class Alloc=STL_DEFAULT_ALLOCATOR(Key) >从原型可以看出，可以看出⽐较函数对象及内存分配器采⽤的是默认参数，因此如果未指定，它们将采⽤系统默认⽅式。

set的各成员函数列表如下:c++ stl容器set成员函数:begin()--返回指向第⼀个元素的迭代器c++ stl容器set成员函数:clear()--清除所有元素c++ stl容器set成员函数:count()--返回某个值元素的个数c++ stl容器set成员函数:empty()--如果集合为空，返回truec++ stl容器set成员函数:end()--返回指向最后⼀个元素的迭代器c++ stl容器set成员函数:equal_range()--返回集合中与给定值相等的上下限的两个迭代器c++ stl容器set成员函数:erase()--删除集合中的元素c++ stl容器set成员函数:find()--返回⼀个指向被查找到元素的迭代器c++ stl容器set成员函数:get_allocator()--返回集合的分配器c++ stl容器set成员函数:insert()--在集合中插⼊元素c++ stl容器set成员函数:lower_bound()--返回指向⼤于（或等于）某值的第⼀个元素的迭代器c++ stl容器set成员函数:key_comp()--返回⼀个⽤于元素间值⽐较的函数c++ stl容器set成员函数:max_size()--返回集合能容纳的元素的最⼤限值c++ stl容器set成员函数:rbegin()--返回指向集合中最后⼀个元素的反向迭代器c++ stl容器set成员函数:rend()--返回指向集合中第⼀个元素的反向迭代器c++ stl容器set成员函数:size()--集合中元素的数⽬c++ stl容器set成员函数:swap()--交换两个集合变量c++ stl容器set成员函数:upper_bound()--返回⼤于某个值元素的迭代器c++ stl容器set成员函数:value_comp()--返回⼀个⽤于⽐较元素间的值的函数常⽤操作：1.元素插⼊：insert()2.中序遍历：类似vector遍历（⽤迭代器）3.反向遍历：利⽤反向迭代器reverse_iterator。

STL中set的实现原理

STL中set的实现原理
1. set 的底层数据结构是红⿊树，⼀种⾼效的平衡检索⼆叉树
2. set 容器中每⼀个元素就是⼆叉树的每⼀个节点，对于set容器的插⼊删除操作，效率都⽐较⾼，原因是因为⼆叉树的删除插⼊元素并不需要进⾏内
存拷贝和内存移动，只是改变了指针的指向
3. 对 set 进⾏插⼊删除操作都不会引起iterator的失效，因为迭代器相当于⼀个指针指向每⼀个⼆叉树的节点，对set的插⼊删除并不会改变原有内存
中节点的改变，但是vector的插⼊删除操作⼀般会发⽣内存移动和内存拷贝，所以会发⽣迭代器的失效
4. set容器的检索速度很快，因为采⽤⼆分查找的⽅法。

set stl用法

set stl用法STL（Standard Template Library，标准模板库）中的set是一种关联容器，它包含一组唯一元素，并提供基于红黑树的排序和查找功能。

下面是set在STL中的基本用法：1.插入元素：2.cpp复制代码#include <set>std::set<int> mySet;mySet.insert(10);mySet.insert(20);mySet.insert(30);1.查找元素：2.cpp复制代码#include <set>std::set<int> mySet = {10, 20, 30};// 使用迭代器查找元素std::set<int>::iterator it = mySet.find(20);if (it != mySet.end()) {// 找到了元素20std::cout << "Found element: " << *it << std::endl;} else {// 没有找到元素20std::cout << "Element not found." << std::endl;}1.删除元素：2.cpp复制代码#include <set>std::set<int> mySet = {10, 20, 30};// 删除元素20mySet.erase(20);1.遍历元素：2.cpp复制代码#include <set>#include <iostream>std::set<int> mySet = {10, 20, 30};// 使用迭代器遍历元素for (std::set<int>::iterator it = mySet.begin(); it != mySet.end(); ++it) { std::cout << *it << " ";}std::cout << std::endl;以上是set在STL中的基本用法示例。

STL中set用法详解

STL中set用法详解 STL中set用法详解
Set 简介
• Set是STL的一种关联容器，它其中所包含的元素的值是唯一的，并且是有序的 • 插入操作和删除操作上比向（vector） vector 快，但查找或添加末尾的元素时会有些慢 • #include<set.h>
Set操作
• set<int> iset; //声明set • vector<int> vec; //用vector初始化iset iset(vec.begin(),vec.end()); • iset.insert(9); //向set中插入元素 • set<int>::iterator it; //set遍历 for( it = iset.begin(); it != iset.end(); it++) cout << *it << " ";
STL中容器的比较
• vector就是动态数组，它在堆中分配内存，元素连续存放。通过下标访问是O(1)操作，需要经常随机访问请用vector • map 映射把一个值映射成另一个值，通过键值查找的操作是O(1)，插入和删除是O(lgn) O(1) O(lgn) • set 集合, 用来判断某一个元素是不是在一个组里面，使用的比较少
本次上机完成的作业
• 找出需要用找出需要用map或set替换的或替换的vectors，替换的，替换需要考虑的因此包括代码可读性，替换需要考虑的因此包括代码可读性，程序的性能和可扩展性 • 例如 class Group 中的例如, 中的vector 可以用 map<string, Client*>类型的类型的map替换替换.以方便得到指针 • 在reasons.txt中说明替换原因中说明替换原因 • 提交所有修改过的文件

stl.set用法总结

判断当前容器是否为空。

没有元素时返回true否则false。

size_type size() const获取当前容器包含元素的个数。

size_typemax_size() const获取当前容器最大可能容量。

一般值为size_type(-1)。

key_comparekey_comp() const返回用于关键字比较的仿函数对象。

value_comparevalue_comp() consttemplate <class Key, class Compare, class Alloc>inline bool operator == (const set<Key, Compare, Alloc>& x, const set<Key, Compare, A判断两个set容器是否相等。

全局函数，非成员函数。

template <class Key, class Compare, class Alloc>inline bool operator < (const set<Key, Compare, Alloc>& x, const set<Key, Compare, Al判断容器x是否小于y。

全局函数，非成员函数。

6 -- 容器使用例子使用set容器需要注意的几个地方：(1)std::set不提供下标操作符；(2)如果只是判断元素是否存在，可以使用count函数检查返回值；(3)如果需要获取元素值，可使用迭代器。

*iterator就是该迭代器指向的值;(4)如果当前容器中的元素是自己new出来的对象指针，那么在调用clear或erase函数之前，需要自己先释放掉这部分内存。

myclass * p1 = new myclass();myclass * p2 = new myclass();myclass * p3 = new myclass();std::set set_class;set_class.insert(p1);set_class.insert(p2);set_class.insert(p3);//在调用clear之前，先依次delete对象。

[C++STL]set使用详解

[C++STL]set使⽤详解⼀、概述set 容器内的元素会被⾃动排序，set 与 map 不同，set 中的元素即是键值⼜是实值，set 不允许两个元素有相同的键值。

不能通过 set 的迭代器去修改 set 元素，原因是修改元素会破坏 set 组织。

当对容器中的元素进⾏插⼊或者删除时，操作之前的所有迭代器在操作之后依然有效。

⼆、定义及初始化使⽤之前必须加相应容器的头⽂件：#include <set> // set属于std命名域的，因此需要通过命名限定，例如using std::set;定义的代码如下：set<int> a; // 定义⼀个int类型的集合a// set<int> a(10); // error，未定义这种构造函数// set<int> a(10, 1); // error，未定义这种构造函数set<int> b(a); // 定义并⽤集合a初始化集合bset<int> b(a.begin(), a.end()); // 将集合a中的所有元素作为集合b的初始值除此之外，还可以直接使⽤数组来初始化向量：int n[] = { 1, 2, 3, 4, 5 };list<int> a(n, n + 5); // 将数组n的前5个元素作为集合a的初值三、基本操作3.1 容量函数容器⼤⼩：st.size();容器最⼤容量：st.max_size();容器判空：st.empty();查找键 key 的元素个数：st.count(key);#include <iostream>#include <set>using namespace std;int main(int argc, char* argv[]){set<int> st;for (int i = 0; i<6; i++){st.insert(i);}cout << st.size() << endl; // 输出：6cout << st.max_size() << endl; // 输出：214748364cout << st.count(2) << endl; // 输出：1if (st.empty())cout << "元素为空" << endl; // 未执⾏return 0;}3.2 添加函数在容器中插⼊元素：st.insert(const T& x);任意位置插⼊⼀个元素：st.insert(iterator it, const T& x);set<int> st;// 在容器中插⼊元素st.insert(4);// 任意位置插⼊⼀个元素set<int>::iterator it = st.begin();st.insert(it, 2);// 遍历显⽰for (it = st.begin(); it != st.end(); it++)cout << *it << " "; // 输出：2 4cout << endl;return 0;}3.3 删除函数删除容器中值为 elem 的元素：st.pop_back(const T& elem);删除it迭代器所指的元素：st.erase(iterator it);删除区间 [first,last] 之间的所有元素：st.erase(iterator first, iterator last);清空所有元素：st.clear();#include <iostream>#include <set>using namespace std;int main(int argc, char* argv[]){set<int> st;for (int i = 0; i < 8; i++)st.insert(i);// 删除容器中值为elem的元素st.erase(4);// 任意位置删除⼀个元素set<int>::iterator it = st.begin();st.erase(it);// 删除[first,last]之间的元素st.erase(st.begin(), ++st.begin());// 遍历显⽰for (it = st.begin(); it != st.end(); it++)cout << *it << " "; // 输出：2 3 5 6 7cout << endl;// 清空所有元素st.clear();// 判断set是否为空if (st.empty())cout << "集合为空" << endl; // 输出：集合为空return 0;}3.4 访问函数查找键 key 是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end()： st.find(key);set<int> st;for (int i = 0; i < 6; i++)st.insert(i);// 通过find(key)查找键值set<int>::iterator it;it = st.find(2);cout << *it << endl; // 输出：2return 0;}3.5 其他函数swap(set&, set&);lst.swap(set&);交换两个同类型容器的元素：或#include <iostream>#include <set>using namespace std;int main(int argc, char* argv[]){set<int> st1;st1.insert(1);st1.insert(2);st1.insert(3);set<int> st2;st2.insert(4);st2.insert(5);st2.insert(6);// 交换两个容器的元素st1.swap(st2);// 遍历显⽰cout << "交换后的st1: ";set<int>::iterator it;for (it = st1.begin(); it != st1.end(); it++)cout << *it << " "; // 输出：4 5 6cout << endl;// 遍历显⽰cout << "交换后的st2: ";for (it = st2.begin(); it != st2.end(); it++)cout << *it << " "; // 输出：1 2 3cout << endl;return 0;}四、迭代器与算法1. 迭代器开始迭代器指针：st.begin();st.end();末尾迭代器指针： // 指向最后⼀个元素的下⼀个位置st.cbegin();指向常量的开始迭代器指针： // 意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他⽅式修改的，⽽且指针也是可以移动的。

STL--set容器的使用详解插入、删除

STL--set容器的使用详解插入、删除set容器的使用详解其实map和set是一个爸爸 - 红黑树爸爸，只不过set力气不够，不像map那么可以拥有一个主键(key)和实键(value).它只有一个键值并且set当中不能存储相同的键值(set还具有强迫症). 其实map和set 的区别差不多就完了. 他们的相同点，他们底层都是使用红黑树构造的这使得他们的查找，插入，删除的效率都非常的高. 并且他们都是有序的，这些都非常关键！这是一个好的容器的标准.当然set的禁忌也和map一样，set不能存储无法比较大小的数据. 因为构建红黑树需要比较大小. 而且在set中存储相同的键值，新的就会覆盖久的.set的特性是，所有元素都会根据元素的键值自动被排序. 我们可以通过set的迭代器改变set的元素值吗？不行，因为set元素值就是其键值，关系到set元素的排列规则，如果任意改变set元素值，会严重破坏set组织. set的源代码之中看到，set<T>::iterator被定义为底层RB_tree的const_iterator，杜绝写入操作. 换句话说，set iterator是一种constant iterator(相对于mutable iterator).set拥有与list相同的某些性质: 当客户端对它进行元素新增操作或删除操作时，操作之前的所有迭代器，在操作完成之后都依然有效，当然那个被删除元素迭代器必然是个例外.set相关函数begin 返回一个迭代器，此迭代器指向set中的第一个元素。

cbegin 返回一个常量迭代器，此迭代器指向set中的第一个元素。

cend 返回一个迭代器，此迭代器指向set最后一个元素的下一个位置clear 清除set的所有元素。

crbegin 返回一个常量迭代器，此迭代器指向反向set中的第一个元素。

set的常见用法

set的常见⽤法set的使⽤set是什么set是⼀个内部有序且不含重复元素的容器⽤处*使得元素⾃动有序*去除重复元素set的引⼊# include <set>using namespace std;set的定义set<typename> name;//typename可以是任何类型，⽐如int、float、或者结构体、对象定义的实际例⼦set<int> name;set<float> name;set<double> name;set<node> name;//node是⼀个结构体set<typename> array[max_size];//定义⼀个set类型的数组set的使⽤set内部的元素的访问set只能通过迭代器来进⾏访问//定义迭代器的时候要填写实际的类型set<typename>::iterator it;set<int>::iterator it;set<char>::iterator it;除了vector和string外的stl容器都不⽀持*(it+i)的访问⽅式元素的插⼊# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(3);st.insert(2);st.insert(7);st.insert(1);for(set<int>::iterator it=st.begin();it!=st.end();it++){cout<<*it<<endl;}return 0;}set常见函数的使⽤insertinsert(x)将x插⼊set,并⾃动使得该元素有序且可以去重findfind(value)查找到集合中值等于value位置的迭代器# include <iostream># include <set>using namespace std;int main(void){set<int> st;for(int i=0;i<4;i++){st.insert(i);}set<int>::iterator it=st.find(3);cout<<*it<<endl;return 0;}erase()erase有两种⽤法:1.删除单个元素1)erase(it),it为要删除元素的迭代器# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(1);st.insert(2);st.insert(3);st.insert(4);st.erase(st.find(2));for(set<int>::iterator it=st.begin();it!=st.end();it++) {cout<<*it<<' ';}cout<<endl;return 0;}2)erase(value),value为要删除的值# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(1);st.insert(2);st.insert(3);st.insert(4);st.erase(4);for(set<int>::iterator it=st.begin();it!=st.end();it++) {cout<<*it<<' ';}cout<<endl;return 0;}2.删除⼀个区间内的元素# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(1);st.insert(2);st.insert(3);st.insert(4);st.erase(4);set<int>::iterator it=st.find(1);st.erase(it,st.end());for(set<int>::iterator it=st.begin();it!=st.end();it++) {cout<<*it<<' ';}cout<<endl;return 0;}size()⽤来获取集合元素数量# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(1);st.insert(2);st.insert(3);st.insert(4);st.erase(4);cout<<st.size()<<endl;return 0;}clear()清空所有元素# include <iostream># include <set>using namespace std;int main(void){set<int> st;st.insert(1);st.insert(2);st.insert(3);st.insert(4);st.clear();cout<<st.size()<<endl;return 0;}。

【C++STL】Set和Multiset

【C++STL】Set和Multiset1、结构 set和multiset会根据特定的排序原则将元素排序。

两者不同之处在于，multisets允许元素重复，⽽set不允许重复。

只要是assignable、copyable、comparable（根据某个排序准则）的型别T，都可以成为set或者multisets的元素。

如果没有特别的排序原则，采⽤默认的less，已operator < 对元素进⾏⽐较，以便完成排序。

排序准则必须遵守以下原则：必须是“反对称的”，对operator <⽽⾔，如果x < y为真，y<x为假。

必须是“可传递的”，对operator <⽽⾔，如果x<y为真，y<z为真，那么x<z也为真。

必须是“⾮⾃反的”，对operator<⽽⾔，x<x永远为假。

2、能⼒和所有的标准关联容器类似，sets和multisets通常以平衡⼆叉树完成。

⾃动排序的主要优点在于使⼆叉树搜寻元素具有良好的性能，在其搜索函数算法具有对数复杂度。

但是⾃动排序也造成了⼀个限制，不能直接改变元素值，因为这样会打乱原有的顺序，要改变元素的值，必须先删除旧元素，再插⼊新元素。

所以sets和multisets具有以下特点：不提供直接⽤来存取元素的任何操作元素通过迭代器进⾏元素的存取。

3、操作函数3.1 构造、拷贝、析构操作效果set c产⽣⼀个空的set/multiset，不含任何元素set c(op)以op为排序准则，产⽣⼀个空的set/multisetset c1(c2)产⽣某个set/multiset的副本，所有元素都被拷贝set c(beg,end)以区间[beg,end)内的所有元素产⽣⼀个set/multisetset c(beg,end, op)以op为排序准则，区间[beg,end)内的元素产⽣⼀个set/multisetc.~set()销毁所有元素，释放内存set<Elem>产⽣⼀个set，以(operator <)为排序准则set<Elem,0p>产⽣⼀个set，以op为排序准则3.2 ⾮变动性操作操作效果c.size()返回当前的元素数量c.empty ()判断⼤⼩是否为零，等同于0 == size()，效率更⾼c.max_size()返回能容纳的元素最⼤数量c1 == c2判断c1是否等于c2c1 != c2判断c1是否不等于c2(等同于!(c1==c2))c1 < c2判断c1是否⼩于c2c1 > c2判断c1是否⼤于c2c1 > c2判断c1是否⼤于c2c1 <= c2判断c1是否⼩于等于c2(等同于!(c2<c1))c1 >= c2判断c1是否⼤于等于c2 (等同于!(c1<c2))3.3 特殊的搜寻函数 sets和multisets在元素快速搜寻⽅⾯做了优化设计，提供了特殊的搜寻函数，所以应优先使⽤这些搜寻函数，可获得对数复杂度，⽽⾮STL的线性复杂度。