//　　　　　　　　　　　　　　　　　　　　　　　　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;

 }

 #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

#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