tempSet.find() 是 O(log n )//不是木有时间的- =
Set容器里面删除一个给定的值
A.erase（要删除的值）
for(it=b.begin();it!=b.end();it++)
{
if(find(a.begin(),a.end(),*it)!=a.end())
a.erase(*it); //删除a中 *it 的元素 但是删除以后 这个指针就指向一个不知道什么的东西 可以多加个变量来代替（int now = *it; a.erase(now); ）
}
这里的find 这几个参数是 finf( 从a的头开始找,找到a的尾, 找里面有没有*it 的值)
**** 这个第一第二个参数默认为头尾 可以不写
Set默认排序是小到大
#include<set>
using namespace std;
===
返回第一个元素的定位器（iterator）的地址。
#include<set>
using namespace std;
int main()
{
set <char> ctr ; //定义一个char 的set容器
set <char>::iterator cp; //定义一个set 里的指针
ctr.insert（'a'）; //插入元素
ctr.insert（'b'）;
cp=ctr.begin(); //指向到ctr 的开始位置
Ctr.clear(); //清空set 容器
i = ctr.size () ; //返回容器的大小
If(ctr.empty()) //空即是真
//set 容器为空时
cout<<"The container is empty"<<endl;
int i;
i=ctr.count('a'); //求出关键字为字符'a'的元素的个数
Ctr.erase(cp); //删除 ctr 的cp 位置的元素
ctr.erase(*cp) ; //删除 *cp 这个元素
ctr.erase(first,last) //删除 first到last 之间的数
set <int>：：reverse_iterator rcp; //定义一个指向最后元素的指针 则rcp++ 就是往回走
注意这两点
这样可以反向使用set
｛
cp = ctr. find('a') ; // 寻找与'a' 一样的元素 一样就返回指向这个元素的地址，否则返
回 ctr.end();
求出与给定的关键字相等的元素的定位器。
找到该元素时，返回一个指向关键字为_Key 的元素的定位器，否则返回一个指向set 容器的结
束的定位器。
｝
set<char> ctr2; //比较2个容器是否一致
｛
if（ctr1==ctr2） //当ctr1 与ctr2 相同时 是为真
cout<<"They are equal"<<endl;
else //当ctr1 与ct2 不同时
cout<<"They are not equal"<<endl;
两个 set 容器的大小比较是基于第一个不相同的元素的大小比较。
函数返回值：
当_Left>=_Right 时，返回True，否则返回False。
｝
======================================================================
※ 1 ※
C++ 中的set 容器
内容提要：在标准模板库（STL）中提供了很多的容器,它们是存储对象的对象。本文主要介绍
STL 中的关联容器——set 容器，内容包括set：：begin、set：：clear、set：：count、set：：empty、set：：
end 等26 种函数。本容器是以模板的形式设计的，能应用于广泛的数据类型。
关键字：begin、clear、count 、empty、end、find、insert
引言：set 是一个容器，它用于储存数据并且能从一个数据集合中取出数据。它的每个元素的值
必须惟一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。
正文：
1 set 容器
set 容器简介：
set 是一个容器，它用于储存数据并且能从一个数据集合中取出数据。它的每个元素的值必须惟
一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。
需加载的头文件：
#include<set>
using namespace std;
模板原型：
template <
class Key,
class Compare=less<Key>,
class Allocator=allocator<Key>
>
说明：
表 1 为set 的参数说明。
表 1 set 的参数说明
参数 含义
Key 存储在set 容器中的关键字的数据类型
Compare 它能提供比较两个元素的函数来决定它们在set 容器中的相
对位置。它是可选的，它的默认值是less<key>
allocator 它代表存储管理设备。它是可选的， 它的默认值为
allocator<Key>
set 容器有以下的特点：
（1）它是一个相关联的容器，它的大小可以改变，它能根据关键字值来提高读取数据的能力。
（2）它提供一个双向的定位器来读写取数据。
（3）它已经根据关键字和一个比较函数来排好序。
（4）它的每一个元素的关键字是惟一的，因此每一个值至多与一个元素对应。
（5）它是一个简单的容器，因为它的元素的值就是它的关键字。
（6）它是一个模板类，因为它提供一个一般且具有独立性的容器。
成员变量：
set 的成员变量说明如表2 所示。
表 2 set 的成员变量说明
成员变量功能说明
Allocator_type 对象分配器
const_iterator 提供一个双向的定位器，它能读取set 中的一个常元
※ 2 ※
续表2
成员变量功能说明
const_pointer 它能提供到一个常元的指针
const_reference 一个常元地址
const_reverse_iterator 提供一个双向的定位器，使得能够在set 容器中读取
任意一个常值元素
difference_type 它提供set 容器中由定位器所指定的范围内的元素的
个数
Iterator 提供一个双向入口定位器，使得能够在set 中读取或
者修改元素
Key_compare 它是提供两个元素的关键字的次序关系的函数
Key_type 它描述每一个元素的关键字
Pointer 提供一个指向set 中的某元素的指针
Reference 提供在set 容器中的一个常元的地址
Reverse_iterator 在反向的set 容器中提供一个双向的入口定位器，使
得能够读取或者修改元素
Size_type set 容器中元素个数
value_compare 指传供一个能比较两个元素相对次序的函数
value_type 存储的数据类型
下面介绍set 的成员函数。
1.1 set：：begin
功能：
返回第一个元素的定位器（iterator）的地址。
语法：
const_iterator begin() const;
iterator begin();
说明：
当返回的第一个元素的地址值为一个常值定位器（_iterator），则set 不会被修改。
当返回的第一个元素的地址值为一个定位器（iterator），则set 可被修改。
函数返回值：
返回一个指向第一个元素的双向定位器地址。
示例：
/***************************************************
程序编号：1
程序功能说明：用begin 来定位到ctr 的开始位置，并打印出该元素。
***************************************************/
#include <set>
#include <iostream>
int main()
{
using namespace std;
set <char> ctr;
set <char>::iterator cp;
ctr.insert（'a'）;
ctr.insert（'b'）;
cp=ctr.begin（）; //定位到ctr 的开始位置
cout<<"The first element is："<<*cp<<endl;
※ 3 ※
//打印出第一个元素
return 0;
}
运行结果：
运行结果如图1 所示。
图1 程序运行结果
1.2 set：：clear
功能：
将一个set 容器的全部元素删除。
语法：
void clear（）;
说明：
clear 会删除set 容器的全部元素。
函数返回值：
无。
示例：
/***************************************************
程序编号：2
程序功能说明：先创建一个set 容器，再用clear 函数清空，最后打印是否为空的信息。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr;
ctr.insert（'a'）;
ctr.insert（'b'）;
ctr.insert（'c'）;
ctr.clear（）; //清空set 容器
if（ctr.empty（）） //set 容器为空时
cout<<"The container is empty"<<endl;
else //set 容器为非空时
cout<<"The container is not empty"<<endl;
return 0;
}
运行结果：
※ 4 ※
运行结果如图2 所示。
图2 程序运行结果
1.3 set：：count
功能：
返回对应某个关键字的元素的个数。
语法：
size_type count（
const Key& _Key
） const;
说明：
_Key 是要进行匹配的关键字的值。
函数返回值：
返回关键字为_Key 的元素的个数。
示例：
/***************************************************
程序编号：3
程序功能说明：先创建一个set 容器，再用count 函数求出关键字为1 的元素的个数。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr;
ctr.insert（'a'）;
ctr.insert（'b'）;
ctr.insert（'a'）;
int i;
i=ctr.count（'a'）; //求出关键字为字符'a'的元素的个数
if（i==0）
cout<<"There is no such key!"<<endl;
else
cout<<"The number of key is： "<<i<<endl;
return 0; }
运行结果：
运行结果如图3 所示。
图3 程序运行结果
※ 5 ※
1.4 set：：empty
功能：
测试一个set 容器是否为空。
语法：
bool empty（） const;
说明：
empty 函数用于测试一个set 容器是否为空。
函数返回值：
当容器set 为空时，返回true，否则返回false。
示例：
/***************************************************
程序编号：4
程序功能说明：先创建一个set 容器，打印是否为空的信息。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr;
if（ctr.empty（））
//set 容器为空时
cout<<"The container is empty"<<endl;
else
//set 容器为非空时
cout<<"The container is not empty"<<endl;
return 0;
}
运行结果：
运行结果如图4 所示。
图4 程序运行结果
1.5 set：：end
功能：
返回最后一个元素后面的定位器（iterator）的地址。
语法：
const_iterator end（）const;
iterator end（）;
说明：
end 函数用于测试一个定位器是否已达到它的尾部。
※ 6 ※
函数返回值：
返回一个指向最后一个元素后面的双向定位器地址。当set 容器为空时，结果没定义。
示例：
/***************************************************
程序编号：5
程序功能说明：先初始化一个set，再打印其中的内容，最后显示出最后一个元素的值。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：const_iterator cp;
int i;
for（i=0;i<3;i++）ctr.insert（i）;
//给ctr 赋值
cout<<"The ctr is： ";
print（ctr）; //调用子程序来打印ctr 的内容
cout<<endl<<"The last element is： ";
cp=ctr.end（）; //让cp 指向最后一个元素的位置
cp--;
cout<<*cp<<endl; //显示最后一个元素的值
return 0;
}
运行结果：
运行结果如图5 所示。
图5 程序运行结果
1.6 set：：equal_range
功能：
返回一对定位器，它们分别指向第一个大于或等于给定的关键字的元素和第一个比给定的关键字大的元素。
语法：
pair <const_iterator, const_iterator> equal_range （
const Key& _Key
） const;
pair <iterator, iterator> equal_range （
const Key& _Key
） const;
说明：
_Key 是一个用于排序的关键字。
函数返回值：
返回一对定位器。
要从第一个定位器中取得数据，可用pr.first。
从第二个定位器中取得数据，则用pr.second。
示例：
/***************************************************
程序编号：6
程序功能说明：先初始化一个set，再打印其中的内容，最后打印出关键字>=2 及>2 的元素。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
pair <set <int>：：const_iterator, set <int>：：const_iterator> p;
int i;
for（i=0;i<=3;i++）ctr.insert（i）;
//给ctr 赋值
cout<<"The ctr is： ";
print（ctr）; //调用子程序来打印ctr 的内容
cout<<endl;
p=ctr.equal_range（2）;
if（p.first!=ctr.end（））
{
cout<<"The first element which key >= 2 is： ";
※ 8 ※
cout<<*p.first; //调用子程序来打印一项
cout<<endl;
}
if（p.second!=ctr.end（））
{
cout<<"The first element which key > 2 is： ";
cout<<*p.second;
cout<<endl;
}
return 0;
}
运行结果：
运行结果如图6 所示。
图6 程序运行结果
1.7 set：：erase
功能：
将一个或一定范围的元素删除。
语法：
iterator erase（
iterator _Where
）;
iterator erase（
iterator _First,
iterator _Last
）;
size_type erase（
const key_type& _Key
）;
说明：
表 3 为erase 的参数说明。
表 3 erase 的参数说明
参数 含义
_Where 表示要删除的元素的位置
_First 第一个被删除的元素的位置
_Last 第一个不被删除的元素的位置
_Key 从set 容器中删除的元素的关键字的值
注意：它不会抛出任何的exception。
函数返回值：
前两个函数返回一个指向第一个没被删除的元素的双向定位器，如果不存在这样的元素，则返回set 容器的末尾。
第三个函数返回被删除的元素的个数。
示例：
/***************************************************
程序编号：7
程序功能说明：用erase 函数将ctr 的第二个元素删除。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
#define len 5
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：iterator cp;
int i;
for（i=0;i<len;i++）ctr.insert（i）;
//下面先给ctr 赋值
cout<<"ctr is：";
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
cout<<"After erase the second element ctr is：";
cp=ctr.begin（）;
cp++;
ctr.erase（cp）; //擦除ctr 的cp 位置的元素
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
return 0;
}
运行结果：
运行结果如图7 所示。
图7 程序运行结果
1.8 set：：find
功能：
求出与给定的关键字相等的元素的定位器。
语法：
iterator find（
const Key& _Key
）;
const_iterator find（
const Key& _Key
） const;
说明：
_Key 是要进行搜索的关键字的值。
该函数会返回一个指向关键字为_Key 的元素的定位器。
当返回的第一个元素的地址值为一个常值定位器（_iterator），则set 可通过它不会被修改。
当返回的第一个元素的地址值为一个定位器（iterator），则set 可通过它被修改。
函数返回值：
找到该元素时，返回一个指向关键字为_Key 的元素的定位器，否则返回一个指向set 容器的结
束的定位器。
示例：
/***************************************************
程序编号：8
程序功能说明：用将key=2 的元素打印出来。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
#define len 5
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：iterator cp;
int i;
for（i=0;i<len;i++）ctr.insert（i）;
//下面先给ctr 赋值
cout<<"ctr is：";
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
cp=ctr.find（2）; //查找key=2 的元素
if（cp!=ctr.end（）） //找到时，打印出来
{
cout<<"The element whose key = 2 is：";
cout<<*cp;
cout<<endl;
}
else //找不到时
cout<<"There is no element whose key = 2"<<endl;
return 0;
}
运行结果：
运行结果如图8 所示。
图8 程序运行结果
1.9 set：：get_allocator
功能：
返回一个构造该set 容器的allocator 的一个副本。
语法：
Allocator get_allocator（） const;
说明：
容器 set 的allocator 指明一个类的存储管理。默认的allocator 能提供STL 容器高效的运行。
函数返回值：
返回该容器的allocator。
示例：
/***************************************************
程序编号：9
程序功能说明：用ctr 的allocator 来创建ctr2。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int main（）
{
set <char> ctr;
ctr.insert（'a'）;
set <char> ctr2（less<char>（）,ctr.get_allocator（））;
cout<<"ctr2's size is： "<<ctr2.size<<endl;
return 0;
※ 12 ※
}
运行结果：
运行结果如图9 所示。
图9 程序运行结果
1.10 set：：insert
功能：
将一个元素或者一定数量的元素插入到set 的特定位置中。
语法：
pair <iterator, bool> insert（
const value_type& _Val
）;
iterator insert（
iterator _Where,
const value_type& _Val
）;
template<class InputIterator>
void insert（
InputIterator _First,
InputIterator _Last
）;
说明：
表 4 为insert 的参数说明。
表 4 insert 的参数说明
参数 含义
_Where 第一个被插入到set 的元素的位置
_Val 插入的参数的值
_First 第一个被插入的位置
_Last 第一个不被插入的位置
如果能在_Where 后面迅速地插入，那么只要很短的时间。
第三个成员函数将范围为[ _First,_Last ]中的元素插入。
函数返回值：
第一个函数返回一对值，当插入成功时，bool=true，当要插入的元素的关键字与已有的参数的
值相同，则bool=false，而iterator 指向插入的位置或者已存在的元素的位置。
第二个函数返回指向插入的位置的定位器。
示例：
/***************************************************
程序编号：10
程序功能说明：利用insert 函数给ctr 赋值。
***************************************************/
#include <set>
※ 13 ※
#include <iostream>
using namespace std;
#define len 5
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：iterator cp;
int i;
for（i=0;i<len;i++）ctr.insert（i,i）;
//下面先给ctr 赋值
cout<<"ctr is：";
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
retrn 0;
}
运行结果：
运行结果如图10 所示。
图 10 程序运行结果
1.11 set：：key_comp
功能：
取得一个比较对象的副本来对set 容器中的元素进行排序。
语法：
key_compare key_comp（） const;
说明：
存储对象定义了一个成员函数：
bool operator（const Key& _Left, const Key& _Right）;
当_Left 严格在_Right 的前面时，返回true，否则返回false。
函数返回值：
取得一个对set 容器中的元素进行排序的比较对象。
※ 14 ※
示例：
/***************************************************
程序编号：11
程序功能说明：先取得一个key_compare 对象，再用此对象来比较1 和2。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int main（）
{
set <int> ctr;
set <int, less<int> >：：key_compare kc = ctr.key_comp（） ;
if（kc（ 1, 2 ））
{
cout<<"kc（1,2） is true"<<endl;
}
else
{
cout<<"kc（1,2） is false"<<endl;
}
return 0;
}
运行结果：
运行结果如图11 所示。
图 11 程序运行结果
1.12 set：：lower_bound
功能：
求出指向第一个关键字的值是大于等于一个给定值的元素的定位器。
语法：
iterator lower_bound（
const Key& _Key
）;
const_iterator lower_bound（
const Key& _Key
） const;
说明：
_Key 是一个用于排序的关键字。
函数返回值：
返回一个指向第一个关键字的值是大于等于一个给定值的元素的定位器，或者返回指向set 容
器的结束的定位器。
※ 15 ※
示例：
/***************************************************
程序编号：12
程序功能说明：先初始化一个set，再打印其中的内容，最后将关键字大于等于2 的元素打印出
来。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>::const_iterator cp;
int i;
for（i=0;i<=3;i++）ctr.insert（i,i）;
//给ctr 赋值
cout<<"The ctr is： ";
print（ctr）; //调用子程序来打印ctr 的内容
cout<<endl;
cp=ctr.lower_bound（2）;
if（cp!=ctr.end（））
{
cout<<"The first element which key >= 2 is： ";
cout<<*cp; //调用子程序来打印一项
cout<<endl;
}
return 0;
}
运行结果：
运行结果如图12 所示。
图 12 程序运行结果
※ 16 ※
1.13 set：：max_size
功能：
计算 set 容器的最大长度。
语法：
size_type max_size（） const;
说明：
max_size 会返回set 容器的最大长度。
函数返回值：
返回 set 容器可能的最大长度。
示例：
/***************************************************
程序编号：13
程序功能说明：求出一个set 容器的可能最大的长度。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
#define len 5
int main（）
{
set <int> ctr;
set <int>：：size_type st;
int i;
for（i=0;i<len;i++）ctr.insert（i）; //先给ctr 赋值
cout<<"the max_size of ctr is：";
st=ctr.max_size（）;
cout<<st<<endl;
return 0;
}
运行结果：
运行结果如图13 所示。
图 13 程序运行结果
1.14 set：：operator!=
功能：
测试该set 容器的左边与右边是否相同。
语法：
bool operator!=（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
※ 17 ※
）;
说明：
_Left 和_Right 是待比较的两个set 容器。
两个 set 容器相等，当且仅当它们的元素个数相等，且同一个位置上的值相等。
函数返回值：
当_Left 和_Right 不同时，返回True，否则返回False。
示例：
/***************************************************
程序编号：14
程序功能说明：比较两个set 容器是否相等。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++）
{
ctr1.insert（'a'+i）;
ctr2.insert（'A'+i）;
}
if（ctr1!=ctr2） //当ctr1 与ct2 不同时
cout<<"They are not equal"<<endl;
else //当ctr1 与ctr2 相同时
cout<<"They are equal"<<endl;
return 0;
}
运行结果：
运行结果如图14 所示。
图 14 程序运行结果
1.15 set：：operator<
功能：
测试左边的set 容器是否小于右边。
语法：
bool operator<（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
※ 18 ※
）;
说明：
_Left 和_Right 是待比较的两个set 容器。
两个 set 容器的大小比较是基于第一个不相同的元素的大小比较。
函数返回值：
当_Left<_Right 时，返回True，否则返回False。
示例：
/***************************************************
程序编号：15
程序功能说明：比较ctr1 与ctr2 的大小。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++） //下面给ctr1 和ctr2 赋值
{
ctr1.insert（'a'+i）;
ctr2.insert（'A'+i）;
}
if（ctr1<ctr2）
cout<<"ctr1<ctr2"<<endl;
else
cout<<"ctr1>=ctr2"<<endl;
return 0;
}
运行结果：
运行结果如图15 所示。
图 15 程序运行结果
1.16 set：：operator<=
功能：
测试左边的set 容器是否小于或等于右边。
语法：
bool operator<=（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
）;
※ 19 ※
说明：
_Left 和_Right 是待比较的两个set 容器。
两个 set 容器的大小比较是基于第一个不相同的元素的大小。
函数返回值：
当_Left<=_Right 时，返回True，否则返回 False。
示例：
/***************************************************
程序编号：16
程序功能说明：比较ctr1 与ctr2 的大小。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++）
{
ctr1.insert（'a'+i）;
ctr2.insert（'A'+i）;
}
if（ctr1<=ctr2）
cout<<"ctr1<=ctr2"<<endl;
else
cout<<"ctr1>ctr2"<<endl;
return 0;
}
运行结果：
运行结果如图16 所示。
图 16 程序运行结果
1.17 set：：operator==
功能：
测试左边的set 容器与右边是否相同。
语法：
bool operator==（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
）;
说明：
_Left 和_Right 是待比较的两个set 容器。
※ 20 ※
两个 set 容器相等当且仅当它们的元素个数相等且同一个位置上的值相等。
函数返回值：
当_Left 和_Right 相同时，返回True，否则返回False。
示例：
/***************************************************
程序编号：17
程序功能说明：比较两个数是否相等。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++）
{
ctr1.insert（'a'+i）;
ctr2.insert（'A'+i）;
}
if（ctr1==ctr2） //当ctr1 与ctr2 相同时
cout<<"They are equal"<<endl;
else //当ctr1 与ct2 不同时
cout<<"They are not equal"<<endl;
return 0; }
运行结果：
运行结果如图17 所示。
图 17 程序运行结果
1.18 set：：operator>
功能：
测试左边的set 容器是否大于右边。
语法：
bool operator>（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
）
说明：
_Left 和_Right 是待比较的两个set 容器。
两个 set 容器的大小比较是基于第一个不相同的元素的大小比较。
函数返回值：
※ 21 ※
当_Left>_Right 时，返回True，否则返回False。
示例：
/***************************************************
程序编号：18
程序功能说明：比较ctr1 与ctr2 的大小。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++）
{
ctr1.insert（i,'a'+i）;
ctr2.insert（i,'A'+i）;
}
if（ctr1>ctr2）
cout<<"ctr1>ctr2"<<endl;
else
cout<<"ctr1<=ctr2"<<endl;
return 0;
}
运行结果：
运行结果如图18 所示。
图 18 程序运行结果
1.19 set：：operator>=
功能：
测试左边的set 容器是否大于或等于右边。
语法：
bool operator>=（
const set <Key, Type, Traits, Allocator>& _Left,
const set <Key, Type, Traits, Allocator>& _Right
）;
说明：
_Left 和_Right 是待比较的两个set 容器。
两个 set 容器的大小比较是基于第一个不相同的元素的大小比较。
函数返回值：
当_Left>=_Right 时，返回True，否则返回False。
※ 22 ※
示例：
/***************************************************
程序编号：19
程序功能说明：比较ctr1 与ctr2 的大小。
***************************************************/
#include <set>
#include <iostream>
int main（）
{
using namespace std;
set <char> ctr1,ctr2;
int i;
for（i=0;i<3;i++）
{
ctr1.insert（'a'+i）;
ctr2.insert（'A'+i）;
}
if（ctr1>=ctr2）
cout<<"ctr1>=ctr2"<<endl;
else
cout<<"ctr1<ctr2"<<endl;
return 0; }
运行结果：
运行结果如图19 所示。
图 19 程序运行结果
1.20 set：：rbegin
功能：
返回一个指向反向set 容器的第一个元素的定位器。
语法：
const_reverse_iterator rbegin（）const;
reverse_iterator rbegin（）;
说明：
rbegin 与反向set 容器一起使用，它的作用与set 容器中的begin 一样。
当返回值为一个const_reverse_iterator，则set 容器不会被修改。
当返回值为一个reverse _iterator，则set 容器可被修改。
函数返回值：
返回一个指向反向set 容器的第一个元素的反向双向定位器。
示例：
/***************************************************
程序编号：20
※ 23 ※
程序功能说明：打印出正向和反向的set 容器。
***************************************************/
#include <set>
#include <iostream>
#define len 5
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：iterator cp;
set <int>：：reverse_iterator rcp;
int i;
for（i=0;i<len;i++）ctr.insert（i）;
//下面先给ctr 赋值
cout<<"ctr is：";
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
cout<<"Its reverse is：";
for（rcp=ctr.rbegin（）;rcp!=ctr.rend（）;rcp++）
//打印出反向set 容器
cout<<*rcp<<" ";
cout<<endl;
return 0;
}
运行结果：
运行结果如图20 所示。
图 20 程序运行结果
1.21 set：：rend
功能：
返回一个指向反向set 容器的最后元素后面的定位器。
※ 24 ※
语法：
const_reverse_iterator rend（） const;
reverse_iterator rend（）;
说明：
rend 与反向set 容器一起使用，它的作用与set 容器中的end 一样。
当返回值为一个const _reverse _iterator，则set 不会被修改。
当返回值为一个reverse _iterator，则set 可被修改。
函数返回值：
返回一个指向反向set 容器中的最后一个元素后面的反向双向定位器。
示例：
/***************************************************
程序编号：21
程序功能说明：打印出正向和反向的set 容器。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
#define len 5
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：iterator cp;
set <int>：：reverse_iterator rcp;
int i;
for（i=0;i<len;i++）ctr.insert（i）;
//下面先给ctr 赋值
cout<<"ctr is：";
print（ctr）; //调用子程序，把ctr 打印出来
cout<<endl;
cout<<"Its reverse is：";
for（rcp=ctr.rbegin（）;rcp!=ctr.rend（）;rcp++）
//打印出反向set 容器
cout<<*rcp<<" ";
cout<<endl;
return 0;
}
※ 25 ※
运行结果：
运行结果如图21 所示。
图 21 程序运行结果
1.22 set：：set
功能：
set 的构造函数。
语法：
set（）;
explicit set （
const Compare& _Comp
）;
explicit set （
const Compare& _Comp,
const Allocator& _Al
）;
set（
const _ set & _Right
）;
template<class InputIterator>
set （
InputIterator _First,
InputIterator _Last
）;
template<class InputIterator>
set （
InputIterator _First,
InputIterator _Last,
const Compare& _Comp
）;
template<class InputIterator>
set （
InputIterator _First,
InputIterator _Last,
const Compare& _Comp,
const Allocator& _Al
）;
说明：
表 5 为set 函数的参数说明。
※ 26 ※
表 5 set 函数的参数说明
参数 含义
_Al 一个分配器类
_Comp 一个用于比较的函数，它的默认值为compare
_Right 一个set 的拷贝
_First 被拷贝的第一个元素的位置
_Last 不被拷贝的第一个元素的位置
所有的构造函数都存储一个分配器和初始化set 容器。
所有的构造函数都存储一个Traits 类型的函数对象，它用于对set 容器的元素进行排序。
头三个构造函数创建一个空的初始set 容器。
第四个构造函数创建一个_Right 容器的副本。
后三个构造函数拷贝在范围_First~_Last 内的一个set 容器。
函数返回值：
无。
示例：
/***************************************************
程序编号：22
程序功能说明：先定义一个ctr1 的set 容器，再构造一个与ctr1 相同的容器。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr1; //创建一个有两个为字母为'a'的set
int i;
for（i=0;i<=3;i++）ctr1.insert（i）;
//给ctr1 赋值
set <int> ctr2（ctr1）; //创建一个以ctr1 相同的set 容器
cout<<"The ctr2 is： ";
print（ctr2）; //打印ctr2 的内容
cout<<endl;
return 0;
}
运行结果：
※ 27 ※
运行结果如图22 所示。
图 22 程序运行结果
1.23 set：：size
功能：
计算 set 容器的元素的个数。
语法：
size_type size（） const;
说明：
size 函数会计算出set 容器的元素的个数。
函数返回值：
当前 set 容器的长度。
示例：
/***************************************************
程序编号：23
程序功能说明：求出set 容器的长度。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
#define len 5
int main（）
{
set <int> ctr;
int i;
for（i=0;i<len;i++）ctr.insert（i）; //下面先给ctr 赋值
cout<<"The current set's length is： ";
cout<<ctr.size（）<<endl;
return 0;
}
运行结果：
运行结果如图23 所示。
图 23 程序运行结果
1.24 set：：swap
功能：
交换两个set 容器的元素。
※ 28 ※
语法：
void swap（
set& _Right
）;
说明：
_Right 是与目标容器交换元素的set 容器。
函数返回值：
无。
示例：
/***************************************************
程序编号：24
程序功能说明：让ctr1 与ctr2 交换。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr1, ctr2;
set <int>：：const_iterator cp;
int i;
for（i=0;i<3;i++） //下面先给ctr1 和ctr2 赋值
{
ctr1.insert（i）;
ctr2.insert（i+10）;
}
cout<<"Before exchange with ctr2 the ctr1 is：";
print（ctr1）; //调用子程序，把ctr1 打印出来
cout<<endl;
cout<<"After exchange with ctr2 the ctr1 is：";
ctr1.swap（ctr2）; //让ctr1 的内容与ctr2 交换
print（ctr1）; //调用子程序，把ctr1 打印出来
cout<<endl;
return 0;
}
运行结果：
※ 29 ※
运行结果如图24 所示。
图 24 程序运行结果
1.25 set：：upper_bound
功能：
求出指向第一个关键字的值是大于一个给定值的元素的定位器。
语法：
iterator upper_bound（
const Key& _Key
）;
const_iterator upper_bound（
const Key& _Key
） const;
说明：
_Key 是一个用于排序的关键字。
函数返回值：
返回一个指向第一个关键字的值是大于一个给定值的元素的定位器，或者返回指向set 容器的
结束的定位器。
示例：
/***************************************************
程序编号：25
程序功能说明：先初始化一个set，再打印其中的内容，最后将关键字比2 大的元素打印出来。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int print（set <int> c） //用于打印一个set
{
set <int>：：const_iterator cp;
for（cp=c.begin（）;cp!=c.end（）;cp++）
//让cp 从c 的开始到结束打印cp 对应的值
cout<<*cp<<" ";
return 0;
}
int main（）
{
set <int> ctr;
set <int>：：const_iterator cp;
int i;
for（i=0;i<=3;i++）ctr.insert（i）;
//给ctr 赋值
※ 30 ※
cout<<"The ctr is： ";
print（ctr）; //调用子程序来打印ctr 的内容
cout<<endl;
cp=ctr.upper_bound（2）;
if（cp!=ctr.end（））
{
cout<<"The first element which key > 2 is： ";
cout<<*cp; //调用子程序来打印一项
cout<<endl;
}
return 0;
}
运行结果：
运行结果如图25 所示。
图 25 程序运行结果
1.26 set：：value_comp
功能：
返回一个能确定元素的次序的函数。
语法：
value_compare value_comp（） const;
说明：
它是根椐关键字的值key 来确定元素的次序关系的。
函数返回值：
返回一个能确定元素的次序的函数。
示例：
/***************************************************
程序编号：26
程序功能说明：先取得一个key_value 函数，再用此函数来比较元素1 和元素2。
***************************************************/
#include <set>
#include <iostream>
using namespace std;
int main（）
{
set <int> ctr;
set <int, less<int> >：：value_compare vc = ctr.value_comp（） ;
set <int>：： iterator cp1,cp2,cp3;
pair< set<int>：：iterator, bool > cpr1, cpr2;
int i;
※ 31 ※
for（i=0;i<3;i++） //给ctr 赋值
ctr.insert（i）;
cpr1.first=ctr.begin（）;
cpr2.first=ctr.begin（）;
cpr2.first++;
if（vc（*cpr1.first,*cpr2.first））
cout<<"element 1 is precedes element 2"<<endl;
else
cout<<"element 1 does not precede element 2"<<endl;
return 0;
}
运行结果：
运行结果如图26 所示。
图 26 程序运行结果
663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
