C++面向对象程序设计学习笔记（9）
pair map set
STL pair
（1）pair 的定义
头文件 <utility>
STL的
定义一个pair对象表示一个平面坐标点：
例：
pair<double, double> p;
cin >> p.first >> p.second;
或者
pair <string,double> product1 ("tomatoes",3.25);
pair模版类需要两个参数：首元素的数据类型和尾元素的数据类型。pair模版类对象有两个成员：first和second，分别表示首元素和尾元素。
例：
pair<int,int>p1;
pair<int,int>p2;
cin>>p1.first>>p1.second;
cin>>p2.first>>p2.second;
cout<<'<'<<p1.first<<','<<p1.second<<'>'<<endl;
cout<<'<'<<p2.first<<','<<p2.second<<'>'<<endl;
输出结果
<p1.first,p1.second>
<p2.first,p2.second>
（2）pair 的比较
在<utility>中已经定义了pair上的六个比较运算符：<、>、<=、>=、==、!=，其规则是先比
较first，first相等时再比较second，这符合大多数应用的逻辑。当然，也可以通过重载这几个运算符
来重新指定自⼰的比较逻辑。
例：
if(p1>p2) cout<<"p1"<<endl;
else if(p2>p1) cout<<"p2"<<endl;
else cout<<"equal"<<endl;
（3）pair 的即时生成
除了直接定义一个pair对象外，如果需要即时生成一个pair对象，也可以调用在<utility> 中定
义的一个模版函数：make_pair。make_pair需要两个参数，分别为元素对的首元素和尾元素。
例：
pair <string,double> product3;
product3 = make_pair ("shoes",20.0);
cout <<"The price of "<< product3.first <<" is $"<< product3.second <<"\n";
输出结果：
The price of shoes is $ 20.0
注：
一般make_pair都使用在需要pair做参数的位置，可以直接调用make_pair生成pair对象。
另一个使用的方面就是pair可以接受隐式的类型转换，这样可以获得更高的灵活度。但是这样会出现如下问题：
例如有如下两个定义：
std::pair<int, float>(1, 1.1);
std::make_pair(1, 1.1);
其中第一个的second变量是float类型，而make_pair函数会将sec添加链接描述ond变量都转换成double类型。
这个问题在编程是需要引起注意。
STL set
引用自 c++set 用法详解
（1）set 的定义：
头文件<set>
关于set，必须说明的是set关联式容器。set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。RB树的统计性能要好于一般平衡二叉树，所以被STL选择作为了关联容器的内部结构。
定义一个set对象：
set<int> s;
set<double> ss;
（2）set 的基本操作：
s.begin() // 返回指向第一个元素的迭代器
s.clear() // 清除所有元素
s.count() // 返回某个值元素的个数
s.empty() // 如果集合为空，返回true(真）
s.end() // 返回指向最后一个元素之后的迭代器，不是最后一个元素
s.equal_range() // 返回集合中与给定值相等的上下限的两个迭代器
s.erase() // 删除集合中的元素
s.find() // 返回一个指向被查找到元素的迭代器
s.get_allocator() // 返回集合的分配器
s.insert() // 在集合中插入元素
s.lower_bound() // 返回指向大于（或等于）某值的第一个元素的迭代器
s.key_comp() // 返回一个用于元素间值比较的函数
s.max_size() // 返回集合能容纳的元素的最大限值
s.rbegin() // 返回指向集合中最后一个元素的反向迭代器
s.rend() // 返回指向集合中第一个元素的反向迭代器
s.size() // 集合中元素的数目
s.swap() // 交换两个集合变量
s.upper_bound() // 返回大于某个值元素的迭代器
s.value_comp() // 返回一个用于比较元素间的值的函数
例：
#include <iostream>
#include <set>
using namespace std;
set<int>s;
s.insert(1);
s.insert(2);
s.insert(4);
s.insert(0);
cout<<"set 的 size 值为 ："<<s.size()<<endl;
cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
cout<<"set 中的第一个元素是 ："<<*s.begin()<<endl;
cout<<"set 中的最后一个元素是:"<<*s.end()<<endl;
if(s.empty())
{
cout<<"set 为空 ！！！"<<endl;
}
else cout<<"set 的 size 值为 ："<<s.size()<<endl;
s.clear();
if(s.empty())
{
cout<<"set 为空 ！！！"<<endl;
}
else cout<<"set 的 size 值为 ："<<s.size()<<endl;
cout<<"set 的 size 值为 ："<<s.size()<<endl;
cout<<"set 的 maxsize的值为 ："<<s.max_size()<<endl;
return 0;
}
运行结果
set 的 size 值为 ：4
set 的 maxsize的值为 ：214748364
set 中的第一个元素是 ：0
set 中的最后一个元素是:4
set 的 size 值为 ：4
set 为空 ！！！
set 的 size 值为 ：0
set 的 maxsize的值为 ：214748364
rbegin()与rend()
反向迭代器是一种反向遍历容器的迭代器。也就是，从最后一个元素到第一个元素遍历容器。反向迭代器将自增（和自减）的含义反过来了：对于反向迭代器，++ 运算将访问前一个元素，而 -- 运算则访问下一个元素。
.begin() 返回一个迭代器，它指向容器c的第一个元素
.end() 返回一个迭代器，它指向容器c的最后一个元素的下一个位置
.rbegin() 返回一个逆序迭代器，它指向容器c的最后一个元素
.rend() 返回一个逆序迭代器，它指向容器c的第一个元素前面的位置
反向迭代器用于表示范围，而所表示的范围是不对称的，这个事实可推导出一个重要的结论：使用普通的迭代器对反向迭代器进行初始化或赋值时，所得到的迭代器并不是指向原迭代器所指向的元素。
set的遍历
#include<cstdio>
#include<set>
using namespace std;
int main()
{
set<int>s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(1);
set<int>::iterator it;
for(it=s.begin();it!=s.end();it++) //使用迭代器进行遍历
{
printf("%d\n",*it);
}
return 0;
}
//输出结果 ： 1 2 3 一共插入了4个数，但是集合中只有3个数并且是有序的，可见之前说过的set集合的两个特点，有序和不重复。
小结： 还要注意begin() 和 end()函数是不检查set是否为空的，使用前最好使用empty()检验一下set是否为空.
count()
用来查找set中某个某个键值出现的次数。这个函数在set并不是很实用，因为一个键值在set只可能出现0或1次，这样就变成了判断某一键值是否在set出现过了。
例：
#include <iostream>
#include <set>
using namespace std;
int main(){
set<int> s;
s.insert(1);
s.insert(2);
s.insert(3);
s.insert(1);
cout<<"set 中 1 出现的次数是 ："<<s.count(1)<<endl;
cout<<"set 中 4 出现的次数是 ："<<s.count(4)<<endl;
return 0;
}
结果
set 中 1 出现的次数是 ： 1
set 中 4 出现的次数是 ： 0
equal_range()
返回一对定位器，分别表示第一个大于或等于给定关键值的元素和 第一个大于给定关键值的元素，这个返回值是一个pair类型，如果这一对定位器中哪个返回失败，就会等于end()的值。
例：
#include <iostream>
#include <set>
using namespace std;
int main()
{
set<int>s;
set<int>::iterator ter;
for(int i=1;i<5;i++)
s.insert(i);
pair<set<int>::const_iterator,set<int>::const_iterator> pr;
pr = s.equal_range(3);
cout<<"第一个大于等于 3 的数是 ："<<*pr.first<<endl;
cout<<"第一个大于 3的数是 ： "<<*pr.second<<endl;
return 0;
}
结果
第一个大于等于 3 的数是 ： 3
第一个大于 3的数是 ： 4
erase()
erase(iterator) ,删除定位器iterator指向的值
erase(first,second),删除定位器first和second之间的值
erase(key_value),删除键值key_value的值
例：
#include <iostream>
#include <set>
using namespace std;
int main(){
set<int> s;
set<int>::const_iterator iter;
set<int>::iterator first;
set<int>::iterator second;
for(int i = 1 ; i <= 10 ; ++i)
{
s.insert(i);
}
for(iter = s.begin() ; iter != s.end() ; ++iter)
{
cout<<*iter<<" ";
}
cout<<endl;
//第一种删除
s.erase(s.begin());
//第二种删除
first=s.begin();
second=s.begin();
second++;
second++;
s.erase(first,second);
//第三种删除
s.erase(8);
cout<<"删除后 set 中元素是 ："<<endl;
for(iter = s.begin() ; iter != s.end() ; ++iter)
{
cout<<*iter<<" ";
}
cout<<endl;
return 0;
}
结果：
1 2 3 4 5 6 7 8 9 10
删除后 set 中元素是 ：
4 5 6 7 9 10
小结：set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。
insert()
insert(key_value)
将key_value插入到set中 ，返回值是pair<set
inset(first,second)
将定位器first到second之间的元素插入到set中，返回值是void.
例：
#include <iostream>
#include <set>
using namespace std;
int main()
{
int a[] = {1,2,3};
int t;
set<int> s;
set<int>::iterator iter;
s.insert(a,a+3);
for(iter = s.begin() ; iter != s.end() ; ++iter)
{
cout<<*iter<<" ";
}
cout<<endl;
pair<set<int>::iterator,bool> pr;
cin>>t;
pr = s.insert(t);
if(!pr.second)
{
cout<<"error"<<endl;
}
for(iter = s.begin() ; iter != s.end() ; ++iter)
{
cout<<*iter<<" ";
}
cout<<endl;
return 0;
}
lower_bound&& upper_bound
lower_bound(key_value) ，返回第一个大于等于key_value的定位器
upper_bound(key_value)，返回最后一个大于等于key_value的定位器
例：
#include <iostream>
#include <set>
using namespace std;
int main()
{
set<int> s;
s.insert(1);
s.insert(3);
s.insert(4);
cout<<*s.lower_bound(2)<<endl;
cout<<*s.lower_bound(3)<<endl;
cout<<*s.upper_bound(3)<<endl;
return 0;
}
结果：
3
3
4
.find()
find(Key)的功能是返回键值为Key的元素的位置，返回值是迭代器类型
例
#include <iostream>
#include <set>
using namespace std;
int main()
{
set<int>s;
for(int i=0;i<10;i++)
s.insert(i);
set<int>::iterator it1=s.find(4);
set<int>::iterator it2=s.find(11);
if(it1!=s.end())
cout<<*(it1)<<endl;
else cout<<"error"<<endl;
if(it2!=s.end())
cout<<*(it2)<<endl;
else cout<<"error"<<endl;
return 0;
}
结果
4
error
.swap()
进行两个集合的交换
例
#include <iostream>
#include <set>
using namespace std;
int main()
{
set<int>s1;
set<int>s2;
for(int i=0;i<10;i++)
s1.insert(i);
for(int i=10;i<15;i++)
s2.insert(i);
cout<<"s1:";
for(set<int>::iterator it =s1.begin();it!=s1.end();it++)
cout<<*(it)<<" ";
cout<<endl;
cout<<"s2:";
for(set<int>::iterator it =s2.begin();it!=s2.end();it++)
cout<<*(it)<<" ";
cout<<endl;
s1.swap(s2);//进行交换
cout<<"s1:";
for(set<int>::iterator it =s1.begin();it!=s1.end();it++)
cout<<*(it)<<" ";
cout<<endl;
cout<<"s2:";
for(set<int>::iterator it =s2.begin();it!=s2.end();it++)
cout<<*(it)<<" ";
cout<<endl;
return 0;
}
结果
s1:0 1 2 3 4 5 6 7 8 9
s2:10 11 12 13 14
s1:10 11 12 13 14
s2:0 1 2 3 4 5 6 7 8 9
key_comp().value_comp()
在set中两种函数使用方法相同
不过返回类型不同
key_comp()为key_compare型
value_comp()为value_compare型
例
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
int main()
{
set<double>s;
for(int i=0;i<10;i++)
s.insert(i);
set<double>::key_compare kc1=s.key_comp();
cout<<"s1:"<<endl;
for(set<double>::iterator it=s.begin();it!=s.end();it++)
{
cout<<*(it)<<" ";
if(kc1(7,*(it))==true) break;
}
cout<<endl;
return 0;
}
结果
s1:
0 1 2 3 4 5 6 7 8
自定义比较函数
(1)元素不是结构体：
例
//自定义比较函数myComp,重载“（）”操作符
struct myComp
{
bool operator()(const your_type &a,const your_type &b)
{
return a.data-b.data>0;
}
}
set<int,myComp>s;
......
set<int,myComp>::iterator it;
(2)如果元素是结构体，可以直接将比较函数写在结构体内。
例
struct Info
{
string name;
float score;
//重载“<”操作符，自定义排序规则
bool operator < (const Info &a) const
{
//按score从大到小排列
return a.score<score;
}
}
set<Info> s;
......
set<Info>::iterator it;
例
#include<stdio.h>
#include<set>
#include<string>
using namespace std;
struct People
{
string name;
int age;
bool operator <(const People p) const //运算符重载
{
return age<p.age; //按照年龄由小到大进行排序
}
};
int main()
{
set<People>s;
s.insert((People){"张三",14});
s.insert((People){"李四",16});
s.insert((People){"王二麻子",10});
set<People>::iterator it;
for(it=s.begin();it!=s.end();it++) //使用迭代器进行遍历
{
printf("姓名：%s 年龄：%d\n",(*it).name.c_str(),(*it).age);
}
return 0;
}
结果
姓名：王二麻子 年龄：10
姓名：张三 年龄：14
姓名：李四 年龄：16
multiset是另一种类型的容器，其关键词与数据文件是同一个值，与set不同，其可包含重复的元素，其用法与set相似。
关于map
在STL的头文件中<map>中定义了模版类map和multimap，用有序二叉树表存储类型为
pair<const Key, T>的元素对序列。序列中的元素以const Key部分作为标识，map中所有元素的Key
值必须是唯一的，multimap则允许有重复的Key值。
可以将map看作是由Key标识元素的元素集合，这类容器也被称为“关联容器”，可以通过一个Key值来快速决定一个元素，因此非常适合于需要按照Key值查找元素的容器。
map模版类需要四个模版参数，第一个是键值类型，第二个是元素类型，第三个是比较算子，第四个是分配器类型。其中键值类型和元素类型是必要的。
定义map对象：
例：
map<string, int> m;
map的基本操作：
/* 向map中插入元素 */
m[key] = value; // [key]操作是map很有特色的操作,如果在map中存在键值为
key的元素对, 则返回该元素对的值域部分,否则将会创建一个键值为key的元素对,值域为默认值。
所以可以用该操作向map中插入元素对或修改已经存在的元素对的值域部分。
m.insert(make_pair(key, value)); // 也可以直接调用insert方法插入元素对,insert操作会返回一个pair,当map中没有与key相匹配的键值时,其first是指向插入元素对的迭代器,其second为true;若map中已经存在与key相等的键值时,其first是指向该元素对的迭代器,second为false。
/* 查找元素 */
int i = m[key]; // 要注意的是,当与该键值相匹配的元素对不存在时,会创建键值为key（当另一个元素是整形时，m[key]=0）的元素对。
map<string, int>::iterator it = m.find(key); // 如果map中存在与key相匹配的键值时,find操作将返
回指向该元素对的迭代器,否则,返回的迭代器等于map的end()。
/* 删除元素 */
m.erase(key); // 删除与指定key键值相匹配的元素对,并返回被删除的元素的个数。
m.erase(it); // 删除由迭代器it所指定的元素对,并返回指向下一个元素对的迭代器。
/* 其他操作 */
m.size(); // 返回元素个数
m.empty(); // 判断是否为空
m.clear(); // 清空所有元素
例：
#include<iostream>
#include<cstdio>
#include<map>
#include<utility>
using namespace std;
typedef pair<int,int>mypair;
int main()
{
map<int,int>m;
if(m.empty()) cout<<"empty"<<endl;
else cout<<"m.size:"<<m.size()<<endl;
m[1]=2;
cout<<"m1:"<<m[1]<<endl;
cout<<"m.size:"<<m.size()<<endl;
/*
cout<<m[3]<<endl;
m.insert(mypair(3,6));
cout<<m[3]<<endl;
*/ //插入失败
m.insert(mypair(3,6));
cout<<"m3:"<<m[3]<<endl;
map<int,int>::iterator it1;
pair<int,int>temp;
it1=m.find(3);
temp=*(it1);
cout<<"m3.key:"<< temp.first <<" m3.value:"<<temp.second<<endl;
m.erase(3);
cout<<"m3:"<<m[3]<<endl;
it1=m.find(1);
m.erase(it1);
cout<<"m1:"<<m[1]<<endl;
cout<<"m.size:"<<m.size()<<endl;
if(m.empty()) cout<<"empty"<<endl;
else cout<<"m.size:"<<m.size()<<endl;
m.clear();
if(m.empty()) cout<<"empty"<<endl;
else cout<<"m.size:"<<m.size()<<endl;
return 0;
}
map的其他操作
(1)
| 构造函数 | 备注 |
|---|---|
| map c/multimap c | 产生一个空的map或multimap,不包含任何因素 |
| map c (op)/multimap c(op) | 以op为排序准则,产生一个空的map/multimap |
| map c1(c2)/multimap c1(c2) | 产生某个map/multimap对象的副本，所有元素均被复制 |
| map c(beg,end)/multimap c(beg,end) | 以区间(beg,end)内的元素产生一个新的map/multimap |
| map c(beg,end,op)/multimap c(beg,end,op) | 以区间(beg,end)内的元素产生一个新的map/multimap,排序准则为op |
| map | 效果 |
|---|---|
| map<key,Elem> | 以less<>为排序准则 |
| map<key,Elem,op> | 以op为排序准则 |
| multimap同理 |
例
#include <iostream>
#include<map>
using namespace std;
typedef pair<int,double> CustomPair;
int main()
{
map<int,double> m1;
map<int,double,greater<int> >m2;
map<int,double>::iterator it1;
map<int,double,greater<int> >::iterator it2;
m1.insert(CustomPair(1,2.0));
m1.insert(CustomPair(2,3.0));
m1.insert(CustomPair(3,4.0));
cout<<"m1:"<<endl;
for(it1=m1.begin();it1!=m1.end();it1++)
{
CustomPair p1=(pair<int,double>)(*it1);
cout<<p1.first<<", ";
cout<<std::fixed<<cout.precision(2)<<p1.second<<"; "<<endl;
}
m2.insert(CustomPair(1,2.0));
m2.insert(CustomPair(2,3.0));
m2.insert(CustomPair(3,4.0));
cout<<"m2:"<<endl;
for(it2=m2.begin();it2!=m2.end();it2++)
{
CustomPair p2=(pair<int,double>)(*it2);
cout<<p2.first<<", ";
cout<<std::fixed<<cout.precision(2)<<p2.second<<"; "<<endl;
}
return 0;
}
结果：
m1:
1, 62.00;
2, 23.00;
3, 24.00;
m2:
3, 24.00;
2, 23.00;
1, 22.00;
(2)
max_size();输出最大容量
例：
int main()
{
map<int,int>m;
cout<<"max_size="<<m.max_size()<<endl;
return 0;
}
结果：
max_size=178956970
(3)个数统计与随机访问
count();
功能: 返回元素在map中出现的次数。
upper_bound()，lower_bound();
功能:
upper_bound(key)的返回值是返回指向大于key元素的迭代器；lower_bound()的返回值是返回指向key前面元素的迭代器。
例:
#include <iostream>
#include<map>
#include<algorithm>
using namespace std;
typedef pair<int,double> CustomPair;
int main()
{
map<int,double> m1;
map<int,double,greater<int> >m2;
map<int,double>::iterator it1;
map<int,double,greater<int> >::iterator it2;
CustomPair temp;
m1.insert(CustomPair(1,2.0));
m1.insert(CustomPair(2,3.0));
m1.insert(CustomPair(3,4.0));
cout<<"m1:"<<endl;
for(it1=m1.begin();it1!=m1.end();it1++)
{
CustomPair p1=(pair<int,double>)(*it1);
cout<<p1.first<<", ";
cout<<std::fixed<<cout.precision(2)<<p1.second<<"; "<<endl;
}
m2.insert(CustomPair(1,2.0));
m2.insert(CustomPair(2,3.0));
m2.insert(CustomPair(3,4.0));
cout<<"m2:"<<endl;
for(it2=m2.begin();it2!=m2.end();it2++)
{
CustomPair p2=(pair<int,double>)(*it2);
cout<<p2.first<<", ";
cout<<std::fixed<<cout.precision(2)<<p2.second<<"; "<<endl;
}
cout<<"1 in m1="<<m1.count(1)<<endl;
it1=m1.upper_bound(2);
temp=*it1;
cout<<"upper_bound(2)--->"<<temp.first<<","<<temp.second<<endl;
it1=m1.lower_bound(2);
temp=*it1;
cout<<"lower_bound(2)--->"<<temp.first<<","<<temp.second<<endl;
return 0;
}
结果：
m1:
1, 62.00
2, 23.00
3, 24.00
m2:
3, 24.00
2, 23.00
1, 22.00
1 in m1 =1
upper_bound(2)--->3,4.00
lower_bound(2)--->2,3.00
