map使用

//　　　　　　　　　　　　　　　　　　　　　　　　map使用
 1 #include <iostream>
 #include "insertVal.h"
 #include "sort.h"
 using namespace std;

 void main()
 {
     ////////////三种插入方式////////////
     InsertVal insert;
     insert.insert_1();
     cout<<"-------------------"<<endl;
     insert.insert_2();
     cout<<"-------------------"<<endl;
     insert.insert_3();
     cout<<"-------------------"<<endl;
     /*以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，
     当然了第一种和第二种在效果上是完全一样的，用insert函数插入数据，
     在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，
     insert操作是插入不了数据的，但是用数组方式就不同了，它可以覆盖以
     前该关键字对应的值。*/

     //////////map的大小//////////
     map<int, int> iMap;
     iMap[] = ;
     iMap[] = ;
     iMap[] = ;
     cout<<iMap.size()<<endl;

     //////////map的遍历//////////
     //
     map<int, int>::reverse_iterator  riter;
     for(riter = iMap.rbegin(); riter != iMap.rend(); ++riter)//这里不要用后加，因为iterator是类模板，后加要返回一个无用的临时对象，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//而it++是函数重载，所以编译器无法对其进行优化，所以每遍历一个元素，你就创建并销毁了一个无用的临时对象。
     {
         cout<<riter->first<<"   "<<riter->second<<endl;
     }
     //
     map<int, int>::iterator  iter;
     for(iter = iMap.begin(); iter != iMap.end(); ++iter)
     {
         cout<<iter->first<<"   "<<iter->second<<endl;
     }
     //
     map<string, int> sMap;
     sMap["age"] = ;
     sMap["height"] = ;
     sMap["weight"] = ;
     string str[] = {"age", "height", "weight"};
     for (int i=; i<sMap.size(); i++)
     {
         auto val = sMap.at(str[i]);
         cout<<str[i]<<":"<<val<<endl;
     }

     //用count函数来判定关键字是否出现,结果返回1/0
     cout<<sMap.count("age")<<endl;

     //用find函数来定位数据出现位置，它返回的一个迭代器，
     //当数据出现时，它返回数据所在位置的迭代器，如果map
     //中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器
     auto iters = sMap.find("age");
     if(iters != sMap.end())
         cout<<iters->first<<":"<<iters->second<<endl;
     else
         cout<<"no 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中不出现这个关键字，
     auto iter_1 = sMap.lower_bound("b");
     auto iter_2 = sMap.upper_bound("b");
     auto iter_pair = sMap.equal_range("ab");

     /////////erase
     sMap.erase("age");
     sMap.erase(sMap.find("height"));
     sMap.erase(sMap.begin(), --sMap.end());//删除一个区域是前闭后开的区间

     /////////
     if(sMap.empty())
         sMap.clear();

     sortShow();
     return;
 }

其中insertVal.h:

 #ifndef INSERTVAL_H
 #define INSERTVAL_H

 #include <iostream>
 #include <map>
 #include <string>
 using namespace std;

 class InsertVal
 {
 public:
     void insert_1();
     void insert_2();
     void insert_3();
 };

 void InsertVal::insert_1()
 {
     map<int, string> mapStudent;
     mapStudent.insert(pair<int, string>(, "Mical"));
     mapStudent.insert(pair<int, string>(, "Meria"));
     mapStudent.insert(pair<int, string>(, "Sam"));
     map<int, string>::iterator  iter;
     for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
     {
         cout<<iter->first<<"号学生是："<<iter->second<<endl;
     }
 }

 void InsertVal::insert_2()
 {
     map<int, string> mapStudent;
     mapStudent.insert(map<int, string>::value_type (, "Mical"));
     mapStudent.insert(map<int, string>::value_type (, "Meria"));
     mapStudent.insert(map<int, string>::value_type (, "Sam"));
     map<int, string>::iterator  iter;
     for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
     {
         cout<<iter->first<<"号学生是："<<iter->second<<endl;
     }
 }

 void InsertVal::insert_3()
 {
     map<int, string> mapStudent;
     mapStudent[] = "Mical";
     mapStudent[] = "Meria";
     mapStudent[] = "Sam";
     map<int, string>::iterator  iter;
     for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
     {
         cout<<iter->first<<"号学生是："<<iter->second<<endl;
     }
 }

 #endif

sort.h:

#ifndef SORT_H
#define SORT_H
#include <iostream>
#include <map>
#include <string>
using namespace std;
/*
    map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的
    STL中默认是采用小于号来排序,
    在一些特殊情况，比如关键字是一个结构体，涉及到排序就会出现问题，
    因为它没有小于号操作，insert等函数在编译的时候过不去
    方法一：重载小于号。略
    方法二：仿函数的应用，这个时候结构体中没有直接的小于号重载。如下
*/

typedef struct tagStudentInfo
{
    int      nID;
    string   strName;
}StudentInfo, *PStudentInfo;  //学生信息

class 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) < ;
        return false;
    }
};

void sortShow()
{
    //用学生信息映射分数
    map<StudentInfo, int, sort>mapStudent;
    StudentInfo studentInfo;
    studentInfo.nID = ;
    studentInfo.strName = "student_one";
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, ));
    studentInfo.nID = ;
    studentInfo.strName = "student_two";
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, ));
}

#endif