#include <map>#include <string>#include <iostream>using std :: cout ;using std :: endl ;using std :: string ;using std :: map ;int main()
{//定义map对象，当前没有任何元素map<string,float> m ;//插入元素，按键值的由小到大放入黑白树中m["Jack"] = 98.5 ;m["Bomi"] = 96.0 ;m["Kate"] = 97.5 ;//先前遍历元素map<string,float> :: iterator it ;for(it = m.begin() ; it != m.end() ; it ++){cout << (*it).first << " : " << (*it).second << endl ;}return 0 ;
}

#include <string>2#include <map>3#include <iostream>45using std :: cout ;6using std :: endl ;7using std :: string ;8using std :: map ;9
10int main()
11{
12    //定义map对象，当前没有任何元素
13    map<int, char> m ;
14
15    //赋值：字符映射数字
16    m[0] = '0' ;
17    m[1] = '1' ;
18    m[2] = '2' ;
19    m[3] = '3' ;
20    m[4] = '4' ;
21    m[5] = '5' ;
22    m[6] = '6' ;
23    m[7] = '7' ;
24    m[8] = '8' ;
25    m[9] = '9' ;
26    /**//*上面的10条赋值语句可采用下面这个循环简化代码编写
27    for(int j = 0 ; j < 10 ; j++)
28    {
29            m[j] = '0' + j ;
30    }
31    */
32    int n = 7 ;
33    string s = "The number is " ;
34    cout << s + m[n] << endl ;
35    return 0 ;
36}
37
运行结果：The number is 7

1. vector<int>::iterator表示矢量容器vector<int>的迭代器

1. for(vector<int>::iterator iter = number.begin(); iter<number.end(); iter++)//这里的iterator iter算是一个指针了
2. cout << " " << *iter;

1. for(vector<int>::size_type i=0; i<number.size(); i++)
2. cout << " " << number[i]

1. <span style="font-size:18px;">#include <deque>
2. deque<int> data;//创建双端队列容器对象
3. deque<int>::iterator iter;//书序迭代器
4. deque<int>::reverse_iterator riter;//逆序迭代器。
5. //iter和riter是不同的类型</span>

  //创建映射容器  map<person, string> phonebook;  //创建要存储的对象
pair<person, string> entry = pair<person, string>(person("mel", "Gibson"), "213 345 567");  //插入对象
phonebook.insert(entry);//只要映射中没有相同的键，就可以插入entry  //访问对象
string number = phonebook[person("mel", "Gibson")];//如果这个键不存在，会默认将这个键插入  //如果不想在找不到的时候插入，可以先查找然后再检索
person key = person("mel", "Gibson");
map<person, string>::iterator iter = phonebook.find(key);//创建迭代器，就认为是指针就好了  if(iter != phonebook.end())  string  number = iter->second;

1. <span style="font-size:18px;">//定义容器
2. stack<person> people;
3. //基于列表来定义堆栈
4. stack<string, list<string>> names;</span>

#include <iostream>
#include <vector>
#include <numeric>
#include <sstream>  using namespace std;    int main()
{  //定义矢量容器  vector<int> numbers;  cout << "请输入整数值，以字母结束:";  //定义输入流迭代器。注意两个不同  //1、numberInput(cin)是指定迭代器指向流cin  //2、numbersEnd没有指定，是默认的，默认构造了一个end_of_stream的迭代器，它等价于调用end()  istream_iterator<int> numbersInput(cin), numbersEnd;  //用户输入，直到输入的不是int类型或者终止时结束。   while(numbersInput != numbersEnd)  numbers.push_back(*numbersInput++);  cout << "打印输出：" << numbers.at(3) << endl;  //如何指定输入流呢？  //确定字符串  string data("2.1 3.6 36.5 26 34 25 2.9 63.8");  //指定data为输入流input。需要头文件<sstream>  istringstream input(data);  //定义迭代器  istream_iterator<double> begin(input), end;  //计算数值和。  //acculumate为头文件<numeric>下定义的函数。  //第一个参数是开始迭代器，第二个是终止迭代器(最后一个值的下一个)。第三个是和的初值，注意必须用0.0，用它确定数据类型是double  cout << "打印数据的总和：" << accumulate(begin, end, 0.0) << endl;
}

#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;}}

#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;}}

#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 rainfishfor(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）的话，返回的就是3Equal_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则说明是空map7.       数据的删除这里要用到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));}