STL set 使用小结

这是微软帮助文档中对集合（set）的解释： “描述了一个控制变长元素序列的对象（注：set中的key和value是Key类型的，而map中的key和value是一个pair结构中的两个分 量）的模板类，每一个元素包含了一个排序键（sort key）和一个值(value)。对这个序列可以进行查找、插入、删除序列中的任意一个元素，而完成这些操作的时间同这个序列中元素个数的对数成比例关 系，并且当游标指向一个已删除的元素时，删除操作无效。”
而一个经过更正的和更加实际的定义应该是：一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。这在收集一个数据的具体值的时候是有用的。集 合中的元素按一定的顺序排列，并被作为集合中的实例。如果你需要一个键/值对（pair）来存储数据，map是一个更好的选择。一个集合通过一个链表来组 织，在插入操作和删除操作上比向量（vector）快，但查找或添加末尾的元素时会有些慢。

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

int main()
{
    set<string> strset;
    set<string>::iterator iter;
    strset.insert("apple");
    strset.insert("orange");
    strset.insert("grapes");
    strset.insert("grapes");

    for(iter=strset.begin();iter!=strset.end();iter++)
    {
        cout<<*iter<<endl;
    }
  
}

输出：

apple
grapes
orange

//注意：输出的集合中的元素是按字母大小顺序排列的，而且每个值都不重复。 

如果你感兴趣的话，你可以将输出循环用下面的代码替换：

copy(strset.begin(), strset.end(), ostream_iterator＜string＞(cout, " ")); 

另一个例子：

#include<iostream>
#include<set>
using namespace std;
struct stu{
    char a[10];
    int s;

};
class stu1:greater<stu>
{
public:
    bool    operator () (stu b1,stu b2) const{
        return b1.s<b2.s;
    }
};
main()
{
    set<stu,stu1 > a;
    for(int i=0;i<3;i++){
        stu d;
        cin>>d.a>>d.s;
        a.insert(d);
    }
    set<stu,stu1 >::iterator l;
    for(l=a.begin();l!=a.end();l++){
        cout<<l->a<<" "<<l->s<<endl;
    }


}

注意:set第二个参数为仿函数，不能写成函数。

我在类中写成员函数operator()报错，不知为什么。

 

/*
set/multiset会根据待定的排序准则，自动将元素排序。两者不同在于前者不允许元素重复，而后者允许。
1) 不能直接改变元素值，因为那样会打乱原本正确的顺序，要改变元素值必须先删除旧元素，则插入新元素
2) 不提供直接存取元素的任何操作函数，只能通过迭代器进行间接存取，而且从迭代器角度来看，元素值是常数
3) 元素比较动作只能用于型别相同的容器(即元素和排序准则必须相同)
set模板原型：//Key为元素(键值)类型
template <class Key, class Compare=less<Key>, class Alloc=STL_DEFAULT_ALLOCATOR(Key) >
从原型可以看出，可以看出比较函数对象及内存分配器采用的是默认参数，因此如果未指定，它们将采用系统默认方式，
另外，利用原型，可以有效地辅助分析创建对象的几种方式
*/
#include <iostream>
#include <string>
#include <set>

using namespace std;

struct strLess
{
   bool operator() (const char *s1, const char *s2) const
   {
    return strcmp(s1, s2) < 0;
   }
};

void printSet(set<int> s)
{
copy(s.begin(), s.end(), ostream_iterator<int>(cout, ", ") );

// set<int>::iterator iter;
// for (iter = s.begin(); iter != s.end(); iter++)
//    //cout<<"set["<<iter-s.begin()<<"]="<<*iter<<", "; //Error
//    cout<<*iter<<", ";
cout<<endl;
}

void main()
{
//创建set对象，共5种方式，提示如果比较函数对象及内存分配器未出现，即表示采用的是系统默认方式
//创建空的set对象，元素类型为int，
set<int> s1; 
//创建空的set对象，元素类型char*，比较函数对象(即排序准则)为自定义strLess
set<const char*, strLess> s2( strLess); 
//利用set对象s1,拷贝生成set对象s2
set<int> s3(s1); 
//用迭代区间[&first, &last)所指的元素，创建一个set对象
int iArray[] = {13, 32, 19};
set<int> s4(iArray, iArray + 3);
//用迭代区间[&first, &last)所指的元素，及比较函数对象strLess，创建一个set对象
const char* szArray[] = {"hello", "dog", "bird" };
set<const char*, strLess> s5(szArray, szArray + 3, strLess() );

//元素插入：
//1,插入value，返回pair配对对象，可以根据.second判断是否插入成功。(提示:value不能与set容器内元素重复)
//pair<iterator, bool> insert(value)
//2,在pos位置之前插入value，返回新元素位置，但不一定能插入成功
//iterator insert(&pos, value)
//3,将迭代区间[&first, &last)内所有的元素，插入到set容器
//void insert[&first, &last)
cout<<"s1.insert() : "<<endl;
for (int i = 0; i <5 ; i++)
    s1.insert(i*10);
printSet(s1);

cout<<"s1.insert(20).second = "<<endl;;
if (s1.insert(20).second)
    cout<<"Insert OK!"<<endl;
else
    cout<<"Insert Failed!"<<endl;

cout<<"s1.insert(50).second = "<<endl;
if (s1.insert(50).second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
    cout<<"Insert Failed!"<<endl;

cout<<"pair<set<int>::iterator::iterator, bool> p;\np = s1.insert(60);\nif (p.second):"<<endl;
pair<set<int>::iterator::iterator, bool> p;
p = s1.insert(60);
if (p.second)
{cout<<"Insert OK!"<<endl; printSet(s1);}
else
   cout<<"Insert Failed!"<<endl;

//元素删除
//1,size_type erase(value) 移除set容器内元素值为value的所有元素，返回移除的元素个数
//2,void erase(&pos) 移除pos位置上的元素，无返回值
//3,void erase(&first, &last) 移除迭代区间[&first, &last)内的元素，无返回值
//4,void clear()， 移除set容器内所有元素

cout<<"\ns1.erase(70) = "<<endl;
s1.erase(70);
printSet(s1);
cout<<"s1.erase(60) = "<<endl;
s1.erase(60);
printSet(s1);

cout<<"set<int>::iterator iter = s1.begin();\ns1.erase(iter) = "<<endl;
set<int>::iterator iter = s1.begin();
s1.erase(iter);
printSet(s1);

//元素查找
//count(value)返回set对象内元素值为value的元素个数
//iterator find(value)返回value所在位置，找不到value将返回end()
//lower_bound(value),upper_bound(value), equal_range(value) 略
cout<<"\ns1.count(10) = "<<s1.count(10)<<", s1.count(80) = "<<s1.count(80)<<endl;
cout<<"s1.find(10) : ";
if (s1.find(10) != s1.end()) 
    cout<<"OK!"<<endl;
else
    cout<<"not found!"<<endl;

cout<<"s1.find(80) : ";
if (s1.find(80) != s1.end()) 
    cout<<"OK!"<<endl;
else
    cout<<"not found!"<<endl;

//其它常用函数
cout<<"\ns1.empty()="<<s1.empty()<<", s1.size()="<<s1.size()<<endl;
set<int> s9;
s9.insert(100);
cout<<"s1.swap(s9) :"<<endl;
s1.swap(s9);
cout<<"s1: "<<endl;
printSet(s1);
cout<<"s9: "<<endl;
printSet(s9);
//lower_bound,upper_bound,equal_range(略)
}


///////////////i测试结果/////////////////////////
s1.insert() :
0, 10, 20, 30, 40,
s1.insert(20).second =
Insert Failed!
s1.insert(50).second =
Insert OK!
0, 10, 20, 30, 40, 50,
pair<set<int>::iterator::iterator, bool> p;
p = s1.insert(60);
if (p.second):
Insert OK!
0, 10, 20, 30, 40, 50, 60,

s1.erase(70) =
0, 10, 20, 30, 40, 50, 60,
s1.erase(60) =
0, 10, 20, 30, 40, 50,
set<int>::iterator iter = s1.begin();
s1.erase(iter) =
10, 20, 30, 40, 50,

s1.count(10) = 1, s1.count(80) = 0
s1.find(10) : OK!
s1.find(80) : not found!

s1.empty()=0, s1.size()=5
s1.swap(s9) :
s1:
100,
s9:

 

所有的STL容器

容器（Container）的概念的出现早于模板（template），它原本是一个计算机科学领域中的一个重要概念，但在这里，它的概念和STL混合在一起了。下面是在STL中出现的7种容器：

vector（向量）——STL中标准而安全的数组。只能在vector 的“前面”增加数据。

deque（双端队列double-ended queue）——在功能上和vector相似，但是可以在前后两端向其中添加数据。 

list（列表）——游标一次只可以移动一步。如果你对链表已经很熟悉，那么STL中的list则是一个双向链表（每个节点有指向前驱和指向后继的两个指针）。

set（集合）——包含了经过排序了的数据，这些数据的值(value)必须是唯一的。

map（映射）——经过排序了的二元组的集合，map中的每个元素都是由两个值组成，其中的key（键值，一个map中的键值必须是唯一的）是在排序 或搜索时使用，它的值可以在容器中重新获取；而另一个值是该元素关联的数值。比如，除了可以ar[43] = "overripe"这样找到一个数据，map还可以通过ar["banana"] = "overripe"这样的方法找到一个数据。如果你想获得其中的元素信息，通过输入元素的全名就可以轻松实现。

multiset（多重集）——和集合（set）相似，然而其中的值不要求必须是唯一的（即可以有重复）。

multimap（多重映射）——和映射（map）相似，然而其中的键值不要求必须是唯一的（即可以有重复）。
注意：如果你阅读微软的帮助文档，你会遇到对每种容器的效率的陈述。比如：log(n*n)的插入时间。除非你要处理大量的数据，否则这些时间的影响是可 以忽略的。如果你发现你的程序有明显的滞后感或者需要处理时间攸关（time critical）的事情，你可以去了解更多有关各种容器运行效率的话题。

怎样在一个map中使用类？

Map是一个通过key（键）来获得value(值)的模板类。

另一个问题是你希望在map中使用自己的类而不是已有的数据类型，比如现在已经用过的int。建立一个“为模板准备的（template-ready）”类，你必须确保在该类中包含一些成员函数和重载操作符。下面的一些成员是必须的：

缺省的构造函数（通常为空）

拷贝构造函数

重载的”=”运算符

你应该重载尽可能多的运算符来满足特定模板的需要，比如，如果你想定义一个类作为 map中的键（key），你必须重载相关的运算符。但在这里不对重载运算符做过多讨论了。

//程序：映射自定义的类。
//目的：说明在map中怎样使用自定义的类。

#include ＜string＞
#include ＜iostream＞
#include ＜vector＞
#include ＜map＞
using namespace std;

class CStudent
{
public :
int nStudentID;
int nAge;
public :
//缺省构造函数——通常为空
CStudent() { }
// 完整的构造函数
CStudent(int nSID, int nA) { nStudentID=nSID; nAge=nA; }
//拷贝构造函数
CStudent(const CStudent& ob) 
{ 
nStudentID=ob.nStudentID; nAge=ob.nAge; }
// 重载“=”
void operator = (const CStudent& ob) 
{
nStudentID=ob.nStudentID; nAge=ob.nAge; 
}
};

int main(int argc, char* argv[])
{
map ＜string, CStudent＞ mapStudent;

mapStudent["Joe Lennon"] = CStudent(103547, 22);
mapStudent["Phil McCartney"] = CStudent(100723, 22);
mapStudent["Raoul Starr"] = CStudent(107350, 24);
mapStudent["Gordon Hamilton"] = CStudent(102330, 22);

// 通过姓名来访问Cstudent类中的成员
cout ＜＜ "The Student number for Joe Lennon is " ＜＜ 
(mapStudent["Joe Lennon"].nStudentID) ＜＜ endl;

return 0;
} 

TYPEDEF

如果你喜欢使用typedef关键字，下面是个例子：

typedef set ＜int＞ SET_INT;
typedef SET_INT::iterator SET_INT_ITER 

编写代码的一个习惯就是使用大写字母和下划线来命名数据类型。

ANSI / ISO字符串

ANSI/ISO字符串在STL容器中使用得很普遍。这是标准的字符串类，并得到了广泛地提倡，然而在缺乏格式声明的情况下就会出问题。你必须使用“＜＜”和输入输出流（iostream）代码（如dec, width等）将字符串串联起来。

参考了：http://www.cppblog.com/Plator/archive/2008/06/11/52906.html

可在必要的时候使用c_str()来重新获得字符指针。

set是关联容器。其键值就是实值，实值就是键值，不可以有重复，所以我们不能通过set的迭代器来改变set的元素的值，set拥有和list相同的特

性：当对他进行插入和删除操作的时候，操作之前的迭代器依然有效。当然删除了的那个就没效了。set的底层结构是RB-tree，所以是有序的。

   stl中特别提供了一种针对set的操作的算法：交集set_intersection，并集set_union，差集set_difference。对称差集set_symeetric_difference，这

些算法稍后会讲到。

一：set模板类的声明。

template <
   class Key, 
   class Traits=less<Key>, 
   class Allocator=allocator<Key> 
>
class set。

其中个参数的意义如下：

key：要放入set里的数据类型，可以是任何类型的数据。

Traits：这是一个仿函数（关于仿函数是什么，我后面的文章会讲到）。提供了具有比较功能的仿函数，来觉得元素在set里的排列的顺序，这是

一个可选的参数，默认的是std::less<key>，如果要自己提供这个参数，那么必须要遵循此规则：具有两个参数，返回类型为bool。

Allocator:空间配置器，这个参数是可选的，默认的是std::allocator<key>.

二：set里的基本操作

我们可以通过下面的方法来实例化一个set对象

std::set<int> s;那个s这个对象里面存贮的元素是从小到大排序的，(因为用std::less作为比较工具。)

如果要想在s里面插入数据，可以用inset函数（set没用重载[]操作，因为set本生的值和索引是相同的)

s.insert(3);s.insert(5).....

因为set是集合，那么集合本身就要求是唯一性，所以如果要像set里面插入数据和以前的数据有重合，那么插入不成功。

可以通过下面的方法来遍历set里面的元素

std::set<int>::iterator it = s.begin();
while(it!=s.end())
{
   cout<<*it++<<endl;//迭代器依次后移，直到末尾。
}

如果要查找一个元素用find函数，it = s.find(3);这样it是指向3的那个元素的。可以通过rbegin，rend来逆向遍历

std::set<int>::reverse_iterator it = s.rbegin();

while(it!=s.rend())

{cout<<*it++<<endl;}

还有其他的一些操作在这就不一一列出了。

三：与set相关的一组算法

set_intersection() :这个函数是求两个集合的交集。下面是stl里的源代码

template<class _InIt1,
class _InIt2,
class _OutIt> inline
_OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
   _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
{ // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
for (; _First1 != _Last1 && _First2 != _Last2; )
   if (*_First1 < *_First2)
    ++_First1;
   else if (*_First2 < *_First1)
    ++_First2;
   else
    *_Dest++ = *_First1++, ++_First2;
return (_Dest);
}

这是个模板函数，从上面的算法可以看出，传进去的两个容器必须是有序的。_Dest指向输出的容器，这个容器必须是预先分配好空间的，否则

会出错的,返回值指向保存结果的容器的尾端的下一个位置。eg.

set_union() :求两个集合的并集，参数要求同上。

std::set_difference（）：差集

set_symmetric_difference（）：得到的结果是第一个迭代器相对于第二个的差集并上第二个相当于第一个的差集。代码：

struct compare
{
bool operator ()(string s1,string s2)
{
   return s1>s2;
}///自定义一个仿函数
};
int main()
{
typedef std::set<string,compare> _SET;
_SET s;
s.insert(string("sfdsfd"));
s.insert(string("apple"));
s.insert(string("english"));
s.insert(string("dstd"));
cout<<"s1:"<<endl;
std::set<string,compare>::iterator it = s.begin();
while(it!=s.end())
   cout<<*it++<<"   ";
cout<<endl<<"s2:"<<endl;
_SET s2;
s2.insert(string("abc"));
s2.insert(string("apple"));
s2.insert(string("english"));
it = s2.begin();
while(it!=s2.end())
   cout<<*it++<<"   ";
cout<<endl<<endl;

string str[10];
string *end = set_intersection(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//求交集，返回值指向str最后一个元素的尾端
cout<<"result of set_intersection s1,s2:"<<endl;
   string *first = str;
   while(first<end)
    cout <<*first++<<" ";
   cout<<endl<<endl<<"result of set_union of s1,s2"<<endl;
   end = std::set_union(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//并集
   first = str;
   while(first<end)
    cout <<*first++<<" ";
   cout<<endl<<endl<<"result of set_difference of s2 relative to s1"<<endl; 
   first = str;
   end = std::set_difference(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//s2相对于s1的差集
   while(first<end)
    cout <<*first++<<" ";
   cout<<endl<<endl<<"result of set_difference of s1 relative to s2"<<endl; 
   first = str;
   end = std::set_difference(s2.begin(),s2.end(),s.begin(),s.end(),str,compare());//s1相对于s2的差集

   while(first<end)
    cout <<*first++<<" ";
   cout<<endl<<endl;
   first = str;
end = std::set_symmetric_difference(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//上面两个差集的并集
   while(first<end)
    cout <<*first++<<" ";
   cout<<endl; 
}

set<int>   s3   ;   
set<int>::iterator   iter   =   s3.begin()   ;   
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s3,iter));   
copy(s3.begin(),s3.end(),   ostream_iterator<int>(cout,"   "));

 

来源：https://www.cnblogs.com/youxin/p/3414015.html