C++ set 初学基础

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
参数
Key
Compare
allocator
set 的参数说明
含义
存储在 set 容器中的关键字的数据类型
它能提供比较两个元素的函数来决定它们在 set 容器中的相
对位置。它是可选的,它的默认值是 less<key>
它代表存储管理设备。它是可选的,它的默认值为
allocator<Key>
set 容器有以下的特点:
(1)它是一个相关联的容器,它的大小可以改变,它能根据关键字值来提高读取数据的能力。
(2)它提供一个双向的定位器来读写取数据。
(3)它已经根据关键字和一个比较函数来排好序。
(4)它的每一个元素的关键字是惟一的,因此每一个值至多与一个元素对应。
(5)它是一个简单的容器,因为它的元素的值就是它的关键字。
(6)它是一个模板类,因为它提供一个一般且具有独立性的容器。
成员变量:
set 的成员变量说明如表 2 所示。
表2
set 的成员变量说明
成员变量
Allocator_type
const_iterator
功能说明
对象分配器
提供一个双向的定位器,它能读取 set 中的一个常元
※
1
※
续表 2
成员变量
功能说明
const_pointer 它能提供到一个常元的指针
const_reference 一个常元地址
const_reverse_iterator 提供一个双向的定位器,使得能够在 set 容器中读取
                                                                任意一个常值元素
difference_type 它提供 set 容器中由定位器所指定的范围内的元素的
                                                         个数
                                                            提供一个双向入口定位器,使得能够在 set 中读取或
                                                                                                     者修改元素
                                                                                                              它是提供两个元素的关键字的次序关系的函数
                                                                                                                                                     它描述每一个元素的关键字
                                                                                                                                                                            提供一个指向 set 中的某元素的指针
                                                                                                                                                                                                       提供在 set 容器中的一个常元的地址
                                                                                                                                                                                                                                  在反向的 set 容器中提供一个双向的入口定位器,使
                                                                                                                                                                                                                                                                           得能够读取或者修改元素
Iterator
Key_compare
Key_type
Pointer
Reference
Reverse_iterator
Size_type
value_compare
value_type
set 容器中元素个数
指传供一个能比较两个元素相对次序的函数
存储的数据类型
下面介绍 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;
※
2
※
//打印出第一个元素
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();
if(ctr.empty()
)
cout<<"The container
else
cout<<"The container
//清空 set 容器
//set 容器为空时
is empty"<<endl;
//set 容器为非空时
is not empty"<<endl;
return 0;
}
运行结果:
※
3
※
运行结果如图 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
程序运行结果
※
4
※
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 函数用于测试一个定位器是否已达到它的尾部。
※
5
※
函数返回值:
返回一个指向 最后一个元素后面的双向定位器地址。当 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
功能:
返回一对定位器,它们分别指向第一个大于或等于给定的关键字的元素和第一个比给定的关键
※
6
※
字大的元素。
语法:
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: ";
※
7
※
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 容器的末尾。
※
8
※
第三个函数返回被删除的元素的个数。
示例:
/***************************************************
程序编号: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
程序运行结果
※
9
※
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;
※ 10 ※
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;
※ 11 ※
}
运行结果:
运行结果如图 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
_Val
_First
_Last
含义
第一个被插入到 set 的元素的位置
插入的参数的值
第一个被插入的位置
第一个不被插入的位置
如果能在_Where 后面迅速地插入,那么只要很短的时间。
第三个成员函数将范围为[ _First,_Last ]中的元素插入。
函数返回值:
第一个函数返回一对值,当插入成功时,bool=true,当要插入的元素的关键字与已有的参数的
值相同,则 bool=false,而 iterator 指向插入的位置或者已存在的元素的位置。
第二个函数返回指向插入的位置的定位器。
示例:
/***************************************************
程序编号:10
程序功能说明:利用 insert 函数给 ctr 赋值。
***************************************************/
#include <set>
※
12
※
#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);
cout<<endl;
retrn 0;
//调用子程序,把 ctr 打印出来
}
运行结果:
运行结果如图 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 容器中的元素进行排序的比较对象。
※
13
※
示例:
/***************************************************
程序编号: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 容
器的结束的定位器。
※ 14 ※
示例:
/***************************************************
程序编号: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
※
程序运行结果
15
※
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
※
16
※
);
说明:
_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
※
17
※
);
说明:
_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
);
※
18
※
说明:
_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 容器。
※
19
※
两个 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 容器的大小比较是基于第一个不相同的元素的大小比较。
函数返回值:
※
20
※
当_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。
※
21
※
示例:
/***************************************************
程序编号: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
※
22
※
程序功能说明:打印出正向和反向的 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 容器的最后元素后面的定位器。
※
23
※
语法:
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;
}
※
24
※
运行结果:
运行结果如图 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 函数的参数说明。
※
25
※
表5
set 函数的参数说明
参数
_Al
_Comp
_Right
_First
_Last
含义
一个分配器类
一个用于比较的函数,它的默认值为 compare
一个 set 的拷贝
被拷贝的第一个元素的位置
不被拷贝的第一个元素的位置
所有的构造函数都存储一个分配器和初始化 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;
}
运行结果:
※
26
※
运行结果如图 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 容器的元素。
※
27
※
语法:
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;
}
运行结果:
※
28
※
运行结果如图 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 赋值
※
29
※
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;
※
30
※
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
※
程序运行结果
31
※