STL map详细用法和make_pair函数

 

今天练习华为上机测试题，遇到了map的用法，看来博客http://blog.csdn.net/sprintfwater/article/details/8765034；感受很详细，博主的其余内容也值得学习；后面附上今天的练习题目。

 

首先make_pair

Pairs 
C++标准程序库中凡是“必须返回两个值”的函数， 也都会利用pair对象 
class
pair能够将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/va
lue)的成对元素。 
pair被定义为struct,所以可直接存取pair中的个别值.
两个pairs互相比较时， 第一个元素正具备较高的优先级. 
例： 
namespace std{ 
template <class T1, class T2> 
bool operator< (const pair<T1, T2>&x, const pair<T1, T2>&y){ 
return x.first<y.first || ((y.first<x.first)&&x.second<y.second); 
} 
}
make_pair():
无需写出型别， 就能够生成一个pair对象 
例： 
std::make_pair(42, '@'); 
而没必要费力写成： 
std::pair<int, char>(42, '@')
当有必要对一个接受pair参数的函数传递两个值时， make_pair()尤为显得方便， 
void f(std::pair<int, const char*>);
void foo{ 
f(std::make_pair(42, '@')); //pass two values as pair 
}
1 pair的应用
pair是将2个数据组合成一个数据，当须要这样的需求时就可使用pair，如stl中的map就是将key和value放在一块儿来保存。另外一个应用是，当一个函数须要返回2个数据的时候，能够选择pair。 pair的实现是一个结构体，主要的两个成员变量是first second 由于是使用struct不是class，因此能够直接使用pair的成员变量。
2 make_pair函数
template pair make_pair(T1 a, T2 b) { return pair(a, b); }
很明显，咱们可使用pair的构造函数也可使用make_pair来生成咱们须要的pair。 通常make_pair都使用在须要pair作参数的位置，能够直接调用make_pair生成pair对象很方便，代码也很清晰。 另外一个使用的方面就是pair能够接受隐式的类型转换，这样能够得到更高的灵活度。灵活度也带来了一些问题如：
std::pair<int, float>(1, 1.1);
std::make_pair(1, 1.1);
是不一样的，第一个就是float，而第2个会本身匹配成double。


map：

Map是STL的一个关联容器，它提供一对一（其中第一个能够称为关键字，每一个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，因为这个特性，它完成有可能在咱们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具备对数据自动排序的功能，因此在map内部全部的数据都是有序的，后边咱们会见识到有序的好处。
下面举例说明什么是一对一的数据映射。好比一个班级中，每一个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述，很明显学号用int描述，姓名用字符串描述(本篇文章中不用char *来描述字符串，而是采用STL中string来描述),下面给出map描述代码：
Map<int, string> mapStudent;
1.       map的构造函数
map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面咱们将接触到一些map的构造方法，这里要说下的就是，咱们一般用以下方法构造一个map：
Map<int, string> mapStudent;
2.       数据的插入
在构造map容器后，咱们就能够往里面插入数据了。这里讲三种插入数据的方法：
第一种：用insert函数插入pair数据，下面举例说明(如下代码虽然是随手写的，应该能够在VC和GCC下编译经过，你们能够运行下看什么效果，在VC下请加入这条语句，屏蔽4786警告  ＃pragma warning (disable:4786) )
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(pair<int, string>(1, “student_one”));
       mapStudent.insert(pair<int, string>(2, “student_two”));
       mapStudent.insert(pair<int, string>(3, “student_three”));
       map<int, string>::iterator  iter;
       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
第二种：用insert函数插入value_type数据，下面举例说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(map<int, string>::value_type (1, “student_one”));
       mapStudent.insert(map<int, string>::value_type (2, “student_two”));
       mapStudent.insert(map<int, string>::value_type (3, “student_three”));
       map<int, string>::iterator  iter;
       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
第三种：用数组方式插入数据，下面举例说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent[1] =  “student_one”;
       mapStudent[2] =  “student_two”;
       mapStudent[3] =  “student_three”;
       map<int, string>::iterator  iter;
       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
以上三种用法，虽然均可以实现数据的插入，可是它们是有区别的，固然了第一种和第二种在效果上是完成同样的，用insert函数插入数据，在数据的插入上涉及到集合的惟一性这个概念，即当map中有这个关键字时，insert操做是插入数据不了的，可是用数组方式就不一样了，它能够覆盖之前该关键字对应的值，用程序说明
mapStudent.insert(map<int, string>::value_type (1, “student_one”));
mapStudent.insert(map<int, string>::value_type (1, “student_two”));
上面这两条语句执行后，map中1这个关键字对应的值是“student_one”，第二条语句并无生效，那么这就涉及到咱们怎么知道insert语句是否插入成功的问题了，能够用pair来得到是否插入成功，程序以下
Pair<map<int, string>::iterator, bool> Insert_Pair;
Insert_Pair = mapStudent.insert(map<int, string>::value_type (1, “student_one”));
咱们经过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，若是插入成功的话Insert_Pair.second应该是true的，不然为false。
下面给出完成代码，演示插入成功与否问题
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
Pair<map<int, string>::iterator, bool> Insert_Pair;
       Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, “student_one”));
       If(Insert_Pair.second == true)
       {
              Cout<<”Insert Successfully”<<endl;
       }
       Else
       {
              Cout<<”Insert Failure”<<endl;
       }
       Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, “student_two”));
       If(Insert_Pair.second == true)
       {
              Cout<<”Insert Successfully”<<endl;
       }
       Else
       {
              Cout<<”Insert Failure”<<endl;
       }
       map<int, string>::iterator  iter;
       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
你们能够用以下程序，看下用数组插入在数据覆盖上的效果
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent[1] =  “student_one”;
       mapStudent[1] =  “student_two”;
       mapStudent[2] =  “student_three”;
       map<int, string>::iterator  iter;
       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
3.       map的大小
在往map里面插入了数据，咱们怎么知道当前已经插入了多少数据呢，能够用size函数，用法以下：
Int nSize = mapStudent.size();
4.       数据的遍历
这里也提供三种方法，对map进行遍历
第一种：应用前向迭代器，上面举例程序中处处都是了，略过不表
第二种：应用反相迭代器，下面举例说明，要体会效果，请自个动手运行程序
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(pair<int, string>(1, “student_one”));
       mapStudent.insert(pair<int, string>(2, “student_two”));
       mapStudent.insert(pair<int, string>(3, “student_three”));
       map<int, string>::reverse_iterator  iter;
       for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)
{
       Cout<<iter->first<<”   ”<<iter->second<<end;
}
}
第三种：用数组方式，程序说明以下
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(pair<int, string>(1, “student_one”));
       mapStudent.insert(pair<int, string>(2, “student_two”));
       mapStudent.insert(pair<int, string>(3, “student_three”));
       int nSize = mapStudent.size()
//此处有误，应该是 for(int nIndex = 1; nIndex <= nSize; nIndex++)

//by rainfish
       for(int nIndex = 0; nIndex < nSize; nIndex++)
{
       Cout<<mapStudent[nIndex]<<end;
}
}
5.       数据的查找（包括断定这个关键字是否在map中出现）
在这里咱们将体会，map在数据插入时保证有序的好处。
要断定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。
这里给出三种数据查找方法
第一种：用count函数来断定关键字是否出现，其缺点是没法定位数据出现位置,因为map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的状况，固然是返回1了
第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，若是map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，程序说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(pair<int, string>(1, “student_one”));
       mapStudent.insert(pair<int, string>(2, “student_two”));
       mapStudent.insert(pair<int, string>(3, “student_three”));
       map<int, string>::iterator iter;
       iter = mapStudent.find(1);
if(iter != mapStudent.end())
{
       Cout<<”Find, the value is ”<<iter->second<<endl;
}
Else
{
       Cout<<”Do not Find”<<endl;
}
}
第三种：这个方法用来断定数据是否出现，是显得笨了点，可是，我打算在这里讲解
Lower_bound函数用法，这个函数用来返回要查找关键字的下界(是一个迭代器)
Upper_bound函数用法，这个函数用来返回要查找关键字的上界(是一个迭代器)
例如：map中已经插入了1，2，3，4的话，若是lower_bound(2)的话，返回的2，而upper-bound（2）的话，返回的就是3
Equal_range函数返回一个pair，pair里面第一个变量是Lower_bound返回的迭代器，pair里面第二个迭代器是Upper_bound返回的迭代器，若是这两个迭代器相等的话，则说明map中不出现这个关键字，程序说明
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent[1] =  “student_one”;
       mapStudent[3] =  “student_three”;
       mapStudent[5] =  “student_five”;
       map<int, string>::iterator  iter;
iter = mapStudent.lower_bound(2);
{
       //返回的是下界3的迭代器
       Cout<<iter->second<<endl;
}
iter = mapStudent.lower_bound(3);
{
       //返回的是下界3的迭代器
       Cout<<iter->second<<endl;
}
 
iter = mapStudent.upper_bound(2);
{
       //返回的是上界3的迭代器
       Cout<<iter->second<<endl;
}
iter = mapStudent.upper_bound(3);
{
       //返回的是上界5的迭代器
       Cout<<iter->second<<endl;
}
 
Pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;
mapPair = mapStudent.equal_range(2);
if(mapPair.first == mapPair.second)
       {
       cout<<”Do not Find”<<endl;
}
Else
{
Cout<<”Find”<<endl;
}
mapPair = mapStudent.equal_range(3);
if(mapPair.first == mapPair.second)
       {
       cout<<”Do not Find”<<endl;
}
Else
{
Cout<<”Find”<<endl;
}
}
6.       数据的清空与判空
清空map中的数据能够用clear()函数，断定map中是否有数据能够用empty()函数，它返回true则说明是空map
7.       数据的删除
这里要用到erase函数，它有三个重载了的函数，下面在例子中详细说明它们的用法
#include <map>
#include <string>
#include <iostream>
Using namespace std;
Int main()
{
       Map<int, string> mapStudent;
       mapStudent.insert(pair<int, string>(1, “student_one”));
       mapStudent.insert(pair<int, string>(2, “student_two”));
       mapStudent.insert(pair<int, string>(3, “student_three”));
 
//若是你要演示输出效果，请选择如下的一种，你看到的效果会比较好
       //若是要删除1,用迭代器删除
       map<int, string>::iterator iter;
       iter = mapStudent.find(1);
       mapStudent.erase(iter);
 
       //若是要删除1，用关键字删除
       Int n = mapStudent.erase(1);//若是删除了会返回1，不然返回0
 
       //用迭代器，成片的删除
       //一下代码把整个map清空
       mapStudent.earse(mapStudent.begin(), mapStudent.end());
       //成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合
 
       //自个加上遍历代码，打印输出吧
}
8.       其余一些函数用法
这里有swap,key_comp,value_comp,get_allocator等函数，感受到这些函数在编程用的不是不少，略过不表，有兴趣的话能够自个研究
9.       排序
这里要讲的是一点比较高深的用法了,排序问题，STL中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，由于上面的关键字是int型，它自己支持小于号运算，在一些特殊状况，好比关键字是一个结构体，涉及到排序就会出现问题，由于它没有小于号操做，insert等函数在编译的时候过不去，下面给出两个方法解决这个问题
第一种：小于号重载，程序举例
#include <map>
#include <string>
Using namespace std;
Typedef struct tagStudentInfo
{
       Int      nID;
       String   strName;
}StudentInfo, *PStudentInfo;  //学生信息
 
Int main()
{
    int nSize;
       //用学生信息映射分数
       map<StudentInfo, int>mapStudent;
    map<StudentInfo, int>::iterator iter;
       StudentInfo studentInfo;
       studentInfo.nID = 1;
       studentInfo.strName = “student_one”;
       mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
       studentInfo.nID = 2;
       studentInfo.strName = “student_two”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
 
for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)
    cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;
 
}
以上程序是没法编译经过的，只要重载小于号，就OK了，以下：
Typedef struct tagStudentInfo
{
       Int      nID;
       String   strName;
       Bool operator < (tagStudentInfo const& _A) const
       {
              //这个函数指定排序策略，按nID排序，若是nID相等的话，按strName排序
              If(nID < _A.nID)  return true;
              If(nID == _A.nID) return strName.compare(_A.strName) < 0;
              Return false;
       }
}StudentInfo, *PStudentInfo;  //学生信息
第二种：仿函数的应用，这个时候结构体中没有直接的小于号重载，程序说明
#include <map>
#include <string>
Using namespace std;
Typedef struct tagStudentInfo
{
       Int      nID;
       String   strName;
}StudentInfo, *PStudentInfo;  //学生信息
 
Classs sort
{
       Public:
       Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const
       {
              If(_A.nID < _B.nID) return true;
              If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;
              Return false;
       }
};
 
Int main()
{
       //用学生信息映射分数
       Map<StudentInfo, int, sort>mapStudent;
       StudentInfo studentInfo;
       studentInfo.nID = 1;
       studentInfo.strName = “student_one”;
       mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
       studentInfo.nID = 2;
       studentInfo.strName = “student_two”;
mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
}
10.   另外
因为STL是一个统一的总体，map的不少用法都和STL中其它的东西结合在一块儿，好比在排序上，这里默认用的是小于号，即less<>，若是要从大到小排序呢，这里涉及到的东西不少，在此没法一一加以说明。
还要说明的是，map中因为它内部有序，由红黑树保证，所以不少函数执行的时间复杂度都是log2N的，若是用map函数能够实现的功能，而STL  Algorithm也能够完成该功能，建议用map自带函数，效率高一些。
下面说下，map在空间上的特性，不然，估计你用起来会有时候表现的比较郁闷，因为map的每一个数据对应红黑树上的一个节点，这个节点在不保存你的数据时，是占用16个字节的，一个父节点指针，左右孩子指针，还有一个枚举值（标示红黑的，至关于平衡二叉树中的平衡因子），我想你们应该知道，这些地方很费内存了吧，不说了……

 

//题目描述
//
//数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
//
//输入描述 :
//先输入键值对的个数
//而后输入成对的index和value值，以空格隔开
//
//
//输出描述 :
//输出合并后的键值对（多行）

//#include<iostream>
//#include<map>
//using namespace std;
//
//int main(int, char**){
//    int count;
//    cin >> count;
//    int a, b;
//    map<int, int> maps;
//    for (int i = 0; i != count; i++){
//        cin >> a >> b;
//      //用insert函数插入数据，在数据的插入上涉及到集合的惟一性这个概念，即当map中有这个关键字时，
//        //insert操做是插入数据不了的，可是用数组方式就不一样了，它能够覆盖之前该关键字对应的值，用程序说明
//        maps[a] += b;
//    }
//    typedef map<int, int>::iterator Iter;
//    for (Iter iter = maps.begin(); iter != maps.end(); iter++){
//        cout << iter->first << " " << iter->second << "\n";
//    }
////    getchar();
////    getchar();
//    return 0;
//}

#include<iostream>
#include<map>
using namespace std;
int main()

{
    int value, key;
    int n;
    while (cin>>n)
    {
        map<int, int> maps;
        for (size_t i = 0; i < n; i++)
        {
            cin >> key >> value;
            //用insert函数插入数据，在数据的插入上涉及到集合的惟一性这个概念，即当map中有这个关键字时，
            //insert操做是插入数据不了的，可是用数组方式就不一样了，它能够覆盖之前该关键字对应的值，用程序说明
            pair<map<int, int>::iterator, bool > rel = maps.insert(make_pair(key,value));   
            if (!rel.second) //若是插入key存在,即没有插入成功，则累加value
            {
                rel.first->second += value;
            }
        }
        for (auto it = maps.begin(); it !=maps.end(); it++)
        {
            cout << (*it).first << " " << (*it).second << endl;
        }
    }
    system("pause");
    return 0;
}


//#include <iostream>
//#include <map>
//#include <set>
//using namespace std;
//int main()
//{    int inSum;
//    while (cin >> inSum)
//    {
//        int key, value;
//        set<int> si;
//        map<int, int> mii;
//        while (inSum--)
//        {
//            cin >> key;
//            si.insert(key);
//            cin >> value;
//            mii[key] = mii[key] + value;
//        }
//        set<int>::iterator it;
//        for (it = si.begin(); it != si.end(); it++)
//        {
//            cout << *it << " " << mii[*it] << endl;
//        }
//    }
//    return 0;
//
//}