C++面向对象程序设计学习笔记（9）

pair map set

STL pair

（1）pair 的定义

头文件 <utility>
STL的 头文件中描述了一个看上去非常简单的模版类pair，用来表示一个二元组或元素对，并提供了按照字典序对元素对进行大小比较运算符模版函数。

定义一个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 ::iterator,bool>，bool标志着插入是否成功，而iterator代表插入的位置，若key_value已经在set中，则iterator表示的key_value在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