std::set成员函数及简要使用方法

insert pair<iterator,bool> insert(const value_type& x) 

iterator insert(iterator position, const value_type& x) 1、向集合中添加一个元素 

2、在迭代器指向的位置上放置指定的元素

count size_type count(const key_type& x) 计算元素在容器中的个数，对于std::set为1（存在）或者0（不存在）。可用于判断元素是否存在

find 查找指定

empty bool empty() 判断当前容器是否为空

size size_type size() 取得当前容器内元素个数

clear void clear() 清空当前容器

begin 声明  

end 声明  

rbegin 声明  

rend 声明  

erase void erase(iterator position) 

void erase(iterator first, iterator last) 

size_type erase(const key_type& x) 

 

begin 声明  

begin 声明  

begin 声明  

begin 声明  

begin 声明  

begin 声明  

begin 声明  

清空当前当前容器
如果当前容易中的元素是自己new出来的对象的指针，那么在调用clear函数之前，需要自己先释放掉这部分内存。比如进行如下的操作。
myclass *p1 = new myclass(); 
myclass *p2 = new myclass(); 
myclass *p3 = new myclass();
std::set<myclass *> set_class;
set_class.insert(p1); 
set_class.insert(p2); 
set_class.insert(p3);
set_class.clear();
如果程序只进行如上的步骤，那么p1、p2、p3其实没有别真正的释放，如果是在SVR中运行的话，会造成内存泄露。实际应该如下所示。
myclass *p1 = new myclass(); 
myclass *p2 = new myclass(); 
myclass *p3 = new myclass();
std::set<myclass *> set_class;
set_class.insert(p1); 
set_class.insert(p2); 
set_class.insert(p3);
for (std::set<myclass *>::iterator it = set_class.begin(); it != set_class.end(); it++) 
        delete *it;
set_class.clear();
 
对于erase操作也是如此。在删除元素之前，如有必要先自己释放内存。
 
 

获取数据
1、std::set不提供下表操作符；
2、如果只是判断元素是否存在，可以使用count函数检查返回值；
3、如果需要获取元素值，可使用迭代器。*iterator就是该迭代器指向的值。
std::set<std::string> set_limit;
set_limit.insert(“User@123”);
set_limit.insert(“User@124”);
set_limit.insert(“User@125”);
//判断"User@124”是否在集合中
if (set_limit.count(“User@124”) == 1)
cout << “User@124存在于集合中"<< std::endl;
else
cout << “User@124不在集合中" << std::endl;
//输出集合中所有的元素值
for (std::set<std::string>::iterator it = set_limit.begin(); it != set_limit.end(); it++)
cout << *it << std::endl;
注意：在获得指向set中某元素的迭代器后，只能对其做读操作，而不能做写操作。
std::set类型定义
typedef Key key_type; 
typedef Key value_type; 
typedef typename rep_type::const_pointer pointer; 
typedef typename rep_type::const_pointer const_pointer; 
typedef typename rep_type::const_reference reference; 
typedef typename rep_type::const_reference const_reference; 
typedef typename rep_type::const_iterator iterator; 
typedef typename rep_type::const_iterator const_iterator; 
typedef typename rep_type::const_reverse_iterator reverse_iterator; 
typedef typename rep_type::const_reverse_iterator const_reverse_iterator; 
typedef typename rep_type::size_type size_type; 
typedef typename rep_type::difference_type difference_type;
 
注：深入STL的源代码看，可以看到size_type的类型其实是size_t，但也有可能因实现不同而不同。
std::set使用例子
std::set的声明
std::set<std::string> set_string; //元素类型是std::string，*迭代器得到的数值类型是std::string
std::set<int> set_int; //元素类型是int，*迭代器得到的数值类型是int

应用场景：兑换物品限制每个用户只能兑换一次，保存已兑换的用户。

-------------------------------------------------------------------------------------------------------------------------------------------------------------

std::set一些例子程序

#include<set>

#include<iterator>

#include<iostream>

#include <algorithm>

using namespace std;

int main()

{

    set<int> eg1;

    eg1.insert(1);

    eg1.insert(100);

    eg1.insert(5);

    eg1.insert(1); //元素1因为已经存在所以set中不会再次插入1

    eg1.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 set eg1"<<endl;

    if(eg1.find(200)==eg1.end())//find()函数可以查找元素是否存在

        cout<<"200 isn't in the set eg1"<<endl;

 

    set<int> eg2;

    for(int i=6;i<15;i++)

        eg2.insert(i);

    cout<<"Set named eg2:"<<endl;

    for(set_iter=eg2.begin(); set_iter!=eg2.end(); set_iter++)

        cout<<*set_iter<<" ";

    cout<<endl;

    //获得两个set的并

    set<int> eg3;

    cout<<"Union(两个set的并集):";

    set_union(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;

    //获得两个set的交，注意进行集合操作之前接收结果的set要调用clear()函数清空一下

    eg3.clear();

    set_intersection(eg1.begin(),

                     eg1.end(),

                     eg2.begin(),

                     eg2.end(),

                     insert_iterator<set<int> >(eg3,eg3.begin())

                     );

    cout<<"Intersection:";

    copy(eg3.begin(),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;

}

 

下面给出一个关键字类型为char*的示例代码

#include<iostream>

#include<iterator>

#include<set>

using namespace std;

struct ltstr

{

bool operator() (const char* s1, const char* s2) const

{

   return strcmp(s1, s2) < 0;

}

};

int main()

{

const int N = 6;

const char* a
= {"isomer", "ephemeral", "prosaic", 

   "nugatory", "artichoke", "serif"};

const char* b
= {"flat", "this", "artichoke",

   "frigate", "prosaic", "isomer"};

set<const char*,ltstr> A(a, a + N);

set<const char*,ltstr> B(b, b + N);

set<const char*,ltstr> C;

cout << "Set A: ";

//copy(A.begin(), A.end(), ostream_iterator<const char*>(cout, " "));

set<const char*,ltstr>::iterator itr;

for(itr=A.begin();itr!=A.end();itr++) cout<<*itr<<" ";

cout << endl;

cout << "Set B: ";

copy(B.begin(), B.end(), ostream_iterator<const char*>(cout, " "));   

cout << endl;

cout << "Union: ";

set_union(A.begin(), A.end(), B.begin(), B.end(),

    ostream_iterator<const char*>(cout, " "),

    ltstr());   

cout << endl;

cout << "Intersection: ";

set_intersection(A.begin(), A.end(), B.begin(),B.end(),ostream_iterator<const char*>(cout," "),ltstr());

cout<<endl;

set_difference(A.begin(), A.end(), B.begin(), B.end(),inserter(C, C.begin()),ltstr());

cout << "Set C (difference of A and B): ";

copy(C.begin(), C.end(), ostream_iterator<const char*>(cout, " "));

cout <<endl;

return 0;

}

其中的ltstr也可以这样定义

class ltstr

{

        public:

        bool operator() (const char* s1,const char*s2)const

        {

                return strcmp(s1,s2)<0;

        }

};

更加通用的应用方式那就是数据类型也是由用户自定义的类来替代，比较的函数自定义，甚至可以加上二级比较，比如首先按照总分数排序，对于分数相同的按照id排序，下面是示例代码

#include<set>

#include<iostream>

using namespace std;

struct

{

                int id;

                int score;

                string name;

};

struct compare

{

        bool operator()(const Entity& e1,const Entity& e2)const   {

                if(e1.score<e2.score) return true;

                else

                        if(e1.score==e2.score)

                                if(e1.id<e2.id) return true;

                return false;

        }

};

int main()

{

        set<Entity,compare>s_test;

        Entity a,b,c;

        a.id=123;a.score=90;a.name="bill";

        b.id=121;b.score=85;b.name="mary";

        c.id=130;c.score=85;c.name="jerry";

        s_test.insert(a);s_test.insert(b);s_test.insert(c);

        set<Entity,compare>::iterator itr;

        cout<<"Score List(ordered by score):\n";

        for(itr=s_test.begin();itr!=s_test.end();itr++)

                cout<<itr->id<<"---"<<itr->name<<"---"<<itr->score<<endl;

        return 0;

}