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[1] = 11;
    iMap[2] = 22;
    iMap[3] = 33;
    cout<<iMap.size()<<endl;

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

void sortShow()
{
    //用学生信息映射分数
    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));
}

#endif