STL 中的" 集合类" 的定义使用

 

 

#include   <set>
#include   <iostream>
using   namespace   std;
typedef   set <double,   less <double> ,   allocator <double>   >   set_type;
ostream&   operator < <(ostream&   out,   const   set_type&   s)
{
copy(s.begin(),   s.end(),ostream_iterator <set_type::value_type,char> (cout, "   "));
return   out;
}
int   main(void)
{
//   create   a   set   of   doubles
set_type       sd;
int                   i;
for   (i   =   0;   i   <   10;   ++i)   {
//   insert   values
sd.insert(i);
}

//   print   out   the   set
cout   < <   sd   < <   endl   < <   endl;
//   now   let’s   erase   half   of   the   elements   in   the   set
int   half   =   sd.size()   > >   1;
set_type::iterator   sdi   =   sd.begin();
advance(sdi,half);
sd.erase(sd.begin(),sdi);
//   print   it   out   again
cout   < <   sd   < <   endl   < <   endl;
//   Make   another   set   and   an   empty   result   set
set_type   sd2,   sdResult;
for   (i   =   1;   i   <   9;   i++)
sd2.insert(i+5);
cout   < <   sd2   < <   endl;
//   Try   a   couple   of   set   algorithms
set_union(sd.begin(),sd.end(),sd2.begin(),sd2.end(),

    inserter(sdResult,sdResult.begin()));
cout   < <   "Union: "   < <   endl   < <   sdResult   < <   endl;
sdResult.erase(sdResult.begin(),sdResult.end());
set_intersection(sd.begin(),sd.end(),
  sd2.begin(),sd2.end(),
  inserter(sdResult,sdResult.begin()));
cout   < <   "Intersection: "   < <   endl   < <   sdResult   < <   endl;
return   0;
}

Program   Output

0   1   2   3   4   5   6   7   8   9
5   6   7   8   9
6   7   8   9   10   11   12   13
Union:
5   6   7   8   9   10   11   12   13
Intersection:
6   7   8   9

 

#include   <iostream>
#include   <set>
using   namespace   std;
int   main(int   argc,   char*   argv[])
{
                set <int>   myset;
                for(int   i=1;i <=10;i++)
                myset.insert(i);
                set <int> ::iterator   it;
                for(it=myset.begin();it!=myset.end();++it)
                cout < <*it;
                return   0;
}

 

C++ Sets(集合)
    set和map一样属于关联容器，set是集合，map是映射。若元素类型为int,double,string就会自动进行(默认是升序)排序(使用平衡二叉树来实现),使用自定义类型而未定义比较运算符就不能自动排序了。set容器不支持随机访问。

函数列表：
begin()返回指向第一个元素的迭代器
clear()清除所有元素
count()返回某个值元素的个数
empty()如果集合为空，返回true
end()返回指向最后一个元素的迭代器
equal_range()返回集合中与给定值相等的上下限的两个迭代器
erase()删除集合中的元素
find()返回一个指向被查找到元素的迭代器
get_allocator()返回集合的分配器
insert()在集合中插入元素
lower_bound()返回指向大于（或等于）某值的第一个元素的迭代器
key_comp()返回一个用于元素间值比较的函数
max_size()返回集合能容纳的元素的最大限值
rbegin()返回指向集合中最后一个元素的反向迭代器
rend()返回指向集合中第一个元素的反向迭代器
size()集合中元素的数目
swap()交换两个集合变量
upper_bound()返回大于某个值元素的迭代器
value_comp()返回一个用于比较元素间的值的函数

////////////////////////////////////////////////////////////////////////////////////
构造函数
explicit set(const Pred& comp = Pred(), const A& al = A());
set(const set& x);
set(const value_type *first, const value_type *last,
    const Pred& comp = Pred(), const A& al = A());
实际中可能使用的形式：
1.set c 定一一个空的set对象。
2.set c(op) 定一一个空的set对象，指定排序规则。
3.set c(set& other) 定义一个set对象，拷贝所有的other元素到c中。
4.set c(begin, end, op) 定义一个set对象，拷贝所有的从begin到end的元素到c中，并指定op进行排队。
5.set c(begin, end) 定义一个set对应，初始化c从begin到end。

begin
语法:
iterator begin();
返回指向当前集合中第一个元素的迭代器。
clear
语法:
void clear();
清除当前集合中的所有元素。
count
语法:
size_type count( const key_type &key );
返回当前集合中出现的某个值的元素的数目。
empty
语法:
bool empty();
如果当前集合为空，返回true；否则返回false。
end
语法:
const_iterator end();
返回指向当前集合中最后一个元素的迭代器。
equal_range
语法:
pair equal_range( const key_type &key );
返回集合中与给定值相等的上下限的两个迭代器。
erase
语法:
void erase( iterator i );
void erase( iterator start, iterator end );
size_type erase( const key_type &key );
说明：
1. 删除i元素；
2. 删除从start开始到end结束的元素；
3. 删除等于key值的所有元素（返回被删除的元素的个数）。
find
语法:
iterator find( const key_type &key );
在当前集合中查找等于key值的元素，并返回指向该元素的迭代器。如果没有找到,则返回end()。
get_allocator
语法:
allocator_type get_allocator();
返回当前集合的分配器。
insert
语法:
iterator insert( iterator i, const TYPE &val );
void insert( input_iterator start, input_iterator end );
pair insert( const TYPE &val );
说明：
1. 在迭代器i前插入val；
2. 将迭代器start开始到end结束返回内的元素插入到集合中；
3. 在当前集合中插入val元素，并返回指向该元素的迭代器和一个布尔值来说明val是否成功的被插入了。(应该注意的是在集合(Sets)中不能插入两个相同的元素。)
示例：
#include <iostream>
#include <set>
#include<string>
using namespace std;
typedef struct tagStudentInfo
{
       int      nID;
       string   strName;
       bool operator <(tagStudentInfo const& _A) const//升序排列
       {
          //这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序
           if(nID<_A.nID) return true;
           if(nID == _A.nID) return strName.compare(_A.strName) < 0;
           return false;
       }
}StudentInfo,*PStudentInfo; //学生信息

void main()
{

    set<StudentInfo>setStudent;
    StudentInfo stuInfo;
    stuInfo.nID = 1;
    stuInfo.strName="student_one";
    pair<set<StudentInfo>::iterator,bool>set_ptr;
set_ptr=setStudent.insert(stuInfo);
   
    stuInfo.nID=1;
    stuInfo.strName="student_one";
    set_ptr=setStudent.insert(stuInfo);
    if(!set_ptr.second){ cout<<"don`t insert!"<<endl; }
   
    stuInfo.nID=2;
    stuInfo.strName="student_two";
    set_ptr=setStudent.insert(stuInfo);
    if(!set_ptr.second){ cout<<"don`t insert 2!"<<endl; }
set<StudentInfo>::iterator p=setStudent.begin();
    for(p;p!=setStudent.end();p++)
{
     cout<<(*p).nID<<" "<<(*p).strName<<endl;
}
}
输出结果：
        don`t insert!
        1 student_one
        2 student_two

lower_bound
语法:
iterator lower_bound( const key_type &key );
返回一个指向小于或者等于key值的第一个元素的迭代器
key_comp
语法:
key_compare key_comp();
返回一个用于元素间值比较的函数对象。
max_size
语法:
size_type max_size();
返回当前集合能容纳元素的最大限值。
rbegin
语法:
reverse_iterator rbegin();
返回指向当前集合中最后一个元素的反向迭代器。
rend
语法:
reverse_iterator rend();
返回指向集合中第一个元素的反向迭代器。
size
语法:
size_type size();
返回当前集合中元素的数目。
swap
语法:
void swap( set &object );
交换当前集合和object集合中的元素。
upper_bound
语法:
iterator upper_bound( const key_type &key );
在当前集合中返回一个指向大于Key值的元素的迭代器。
value_comp
语法:
value_compare value_comp();
返回一个用于比较元素间的值的函数对象。
set的集合功能(须#include<algorithm>):
1.两个有序集的并.
set_union(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s,s.begin()));
三个set对象，分别为s1,s2,s.set_union的功能是将s1的某个序列(比如[s1.begin(),s1.end()))与s2的某个序列(比如[s2.begin(),s2.end()))合并，然后把合并序列插入到s中。

2.两个有序集的交.
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s,s.begin()));

3.两个有序集的差.
set_difference (s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s,s.begin()));