STL的pair學習, map學習

http://blog.csdn.net/calvin_zcx/article/details/6072286

http://www.linuxidc.com/Linux/2014-10/107621.htm

頭文件  : <utility>

pair 的  <、>、<=、>=、==、!= 的比較規則  :  先比較first，first相等時再比較second   _{(能夠經過重載這幾個運算符來從新指定本身的比較邏輯)}

pair的初始化:   pair<string, int> prt;        pair<string, int>pr2("hello", 5);   pair<string, int> pr3 = make_pair<string, int>("haha", 4);    pair<stirng, int>pr4 = make_pair("lll",3);

pair和vector交互:  pair<string, vector<int>> student;

pair訪問元素:   pair<int, int> a(1,2);

                     cout<<"first="<<a.first<<"------"<<"second="<<a.second;

pair使用typedef技巧:   typedef pair<string, int>   nameInfo;

                                 nameInfo info("lucy", 4);

pair與標準輸入流:   pair<string, string> input;

                          while(cin>>input.first>>input.second){ cout<<"info is"<<input.first<<":"<<input.second<<endl;}

　　　　　　　　　　(abc[enter]d---->info is abc:d)

pair的隱式轉換:      pair能夠接受隱式的類型轉換，這樣能夠得到更高的靈活度。可是這樣會出現以下問題：例若有以下兩個定義：

　　　　　　　　　　pair<int, float>(1, 1.1);
　　　　　　　　　　make_pair(1, 1.1);                 make_pair函數會將second變量都轉換成double類型.這個問題在編程是須要引發注意。

　　　　　　　　　　make_pair<int, float>(1,1.1);   若是想指定是float的能夠像這樣指明類型.

vector套用pair的一個小例子:

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

繼續學習map

http://www.360doc.com/content/12/0417/16/3349869_204420932.shtml

http://www.cnblogs.com/kevintian/articles/1277700.html

map的介紹

首先是map的模板頭的學習

 

map內部存儲機制實際是以紅黑樹爲基礎，紅黑樹在插入節點時，必須依照大小比對以後在一個合適的位置上執行插入動做。因此做爲關鍵字，起碼必須有「<」這個比較操做符。咱們知道，int，float，enum，size_t等等簡單關鍵字，都有內置的比較函數，與map搭配不管是插入仍是查找，都沒什麼問題。可是做爲複雜數據類型，若是沒有明肯定義「<」比較操做符，就不能與map直接搭配使用，除非咱們本身定義第三個參數。

在選擇map的關鍵字時，注意如下兩點，同時這兩點也是改錯的方法：

a） 關鍵字明肯定義「<」比較操做符

b） 沒有「<」比較操做符，自定義仿函數替代第三個參數Compare，該仿函數實現「()」操做符，提供比較功能。插入時各節點順序以該仿函數爲綱。

        

若是TwoNum類提供了 bool operator < (const TwoNum& a) 函數的話,能夠不用定義Compare類.main裏面的map在聲明myMap的時候能夠寫成 map<TwoNum, int> .  而若是TwoNum類沒提供對於<運算符的重載的話,那麼必須提供一個類,這個類裏面重載了()運算符.而()運算符負責對TwoNum進行比較.

可是單純的重載<符合是錯誤的.例以下例:

   

接來下學習一下map增長元素:

 

(1). 用insert函數插入pair數據	1 map<int, string> mapStu; 2 mapStu.insert(pair<int, string>(1,"student_lilei")); 3 mapStu.insert(pair<int, string>(2, "student_zhanffei"));	第一種方法和第二種方法效果上徹底相同. 用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。
(2).用insert函數插入value_type數據 (	1 map<int, string> mapStu; 2 mapStu.insert(map<int, string>::value_type(1,"stu_lilei")); 3 mapStu.insert(map<int, string>::value_type(2,"stu_lucy"));
3).用數組方式插入數據	1 map<int, string> mapStu; 2 mapStu[1] = "stu_lilei"; 3 mapStu[2] = "stu_lucy";

//注意 用 下標的方式[]插入的的時候若是這個key不存在,那麼會經歷的步驟是
//1.建立key和key對應的空的value
//2.把真正的value賦值給這個key
class A
{
public:
A(){}
int i = 0;
};

A a;
a.i = 3;
map[1] = a;

上面的具體過程是
(1) 1不在map中  建立一個 1:A() {注意空的A對象}
(2) 1在map中了 把a賦值給key是1的value
這樣就存在一個性能問題 由於你是先構建A()而後再作了一次賦值,這樣的結果是若是類對象比較複雜的話,性能就不如用insert好了..切記注意啊.

寫個小例子:

    

 繼續深刻的學習map

http://blog.csdn.net/zhoujiaxq/article/details/9786551

映射和多重映射基於某一類型Key的鍵集的存在，提供對T類型的數據進行快速和高效的檢索。對map而言，鍵只是指存儲在容器中的某一成員。Map不支持副本鍵，multimap支持副本鍵。Map和multimap對象包涵了鍵和各個鍵有關的值，鍵和值的數據類型是不相同的，這與set不一樣。set中的key和value是Key類型的，而map中的key和value是一個pair結構中的兩個份量。

map的構造函數

1 Template<class T1, class T2>
2 map(); //默認構造函數
3 map(const map& m); //拷貝構造函數
4 map(iterator begin, iterator end); //區間構造函數
5 map(iterator begin, iterator end, const traits& _compare); //帶比較謂詞的構造函數
6 map(iterator begin, iterator end, const traits& _compare, const allocator& all); //帶分配器

map的嵌套定義

map<string, map<string, long> > //注意,最後的兩個>直接有個空格

map的訪問

map支持下標運算符operator[], 能夠用訪問普通數組的方式來訪問map,可是[]裏面的值不能是下標0,1,2,3,4而是key值 : value = map[key]

查找並獲取map中元素

(1)直接用key獲取   value = map[key]  . 這樣作的風險是:若是這個key不存在的話,會自動插入一個實力,value值爲初始化值

(2)使用find()或者count()方法來探視某個key是否存在

1 if (map.find(key) != map.end())
2 
3 {
4 cout<<''找到啦"<<end;
5 }

從map中刪除元素

1 //刪除某個key-value
2 iterator erase(iterator it);
3 size_type erase(const Key& key);
4 iterator erase(iterator first, iterator last);
5 
6 //刪除全部元素
7 clear();
8 map.erase(map.begin(), map.end());

map中swap的用法

 1 //map中的swap不是一個容器中的元素交換,而是兩個容器交換
 2 
 3 #include <map>
 4 #include <iostream>
 5 using namespace std;
 6 int main(int argc, char** argv)
 7 {
 8     map<int, int> m1, m2;
 9     map<int, int>::iterator iter;
10     m1.insert(pair<int,int>(1,10));
11 
12     m1[2] = 20;
13     m1.insert(make_pair<int, int>(3,30));
14     m1.insert(make_pair(4,40));
15 
16     m2[10] = 100;
17     m2[20] = 200;
18 
19     m1.swap(m2);
20 
21     cout<<"new m1:"<<endl<<endl;
22     for (iter = m1.begin(); iter != m1.end(); iter++)
23     {
24         cout<<iter->first<<":"<<iter->second<<endl;
25     }
26 
27     cout<<"new m2:"<<endl;
28     for (iter = m2.begin(); iter != m2.end(); iter++)
29     {
30         cout<<iter->first<<":"<<iter->second<<endl;
31     }
32     return 0;
33 }

map按照value進行排序的sort問題 http://blog.csdn.net/flybywind/article/details/7536311

 咱們知道對map用key進行排序的話比較容易,可是若是碰到了須要對map按照value進行排序的時候怎麼辦麼?

1 //STL的sort函數原型
2 #include <algorithm>
3 using namespace std;
4 
5 template <class RandomAccessIterator>
6     void sort (RandomAccessIterator first, RandomAccessIterator last);
7 
8 template <class RandomAccessIterator,  class Compare>
9     void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

顯然sort函數須要一個隨機迭代器, 而這對於map對象來講是不可能的.因此咱們必須把key-value抽取出來,放到一個vector對象裏才行.

 1 #include<algorithm>
 2 #include<iostream>
 3 #include<map>
 4 #include<vector>
 5 #include<utility>
 6 
 7 using namespace std;
 8 
 9 typedef pair<int, int> key_value;
10 
11 bool comp(key_value pair1, key_value pair2)
12 {   
13     return pair1.second < pair2.second;
14 }
15 
16 void printVec( key_value pair1)
17 {
18     cout<<pair1.first<<":"<<pair1.second<<endl;
19 }
20 
21 int main()
22 {
23     map< int, int, std::less<int> > test;
24     test[1] = 1;
25     test[2] = 3;
26     test[3] = 2;
27     test[4] = 4;
28     test[5] = 5;
29 
30     vector<key_value> key_values;
31     for (auto iter = test.rbegin(); iter != test.rend(); iter++)
32     {
33         int key = iter->first;
34         int value = iter->second;
35         //key_values.push_back( make_pair<int,int>(key, value) );
36         key_values.push_back( make_pair(key, value) );
37     }
38 
39     cout<<"before sort"<<endl;
40     for_each(key_values.begin(), key_values.end(), printVec);
41 
42     sort(key_values.begin(), key_values.end(), comp);
43 
44     cout<<"after sort"<<endl;
45     for_each(key_values.begin(), key_values.end(), printVec);
46 
47     return 0;
48 }