C++中的Vector與map

Vector：是標準庫vector類型
使用vector，必須包含適當的頭文件

#include<vector>

定義和初始化

vector<T> v1   //v1是一個空的vector
vector<T> v2(v1) //v2中包含v1的所有元素的副本
vector<T> v2 = v1  //等價於v2(v1)

賦值

vector<string> v1{"hi"} //列表初始化，v1有一個元素
vector<string> v2("hi")   //錯誤，不能用一個字符串字面值創建vector對象
vector<string> v3{10}   //有10個默認初始化的值
vector<string> v4{10,"hi"}  //有10個值爲"hi"的元素

注意：

vector<int> ivec(10)   //10個元素，每一個元素均爲0
vector<string> svec(10) //10個元素。每一個都是空string對象
//給vector賦值用{}，涉及到vector中數量的時候用（）

Vector對象最重要的幾種操作
1. v.push_back(t) 在數組的最後添加一個值爲t的數據
2. v.size() 當前使用數據的大小
3. v.empty() 判斷vector是否爲空
4. v[n] 返回v中位置爲n的元素
5. v1=v2 把v1的元素替換爲v2元素的副本
6. v1==v2 判斷v1與v2是否相等
7. ！=、<、<=、>、>= 保持這些操作符慣有含義
添加元素

#include<vector>
vector<int> v1
for(int i = 1;i!= 100;i++)
{
    v1.push_back(i)
}

不能用下標形式添加元素

vector<int> ivec
for(decltype(ivec.size()) ix = 0;ix!= 10;ix++)
{
    ivec[ix] = ix   //嚴重錯誤，ivec不包含任何的元素
    ivec.push_back(ix)  //正確，添加一個新元素，新元素爲ix
} 

注意：只能對確知已存在的元素執行下標操作

vector<int> v1 //空的vector對象
cout<<v1[0]  //錯誤，v1不含有很合元素

vector<int> v2(10)  //含有10個元素的vector對象
cout<<v2[10]  //錯誤：v2的合法索引值是0到9

capacity和size
容器的size是指它已經保存的元素的數目，而capacity是指在不分配新的內存空間的前提下，它最多可以保存多少元素

vector<int> ivec
cout<<"ivec:size"<<ivec.size()<<"capacity"<<ivec.capacity()<<end
//size爲0，最後的實現兩個都爲0，標準庫中一個空的vector的capacity也爲0
//總結：只要操作沒有超出vector的容量，vector就不能重新分配內存空間，vector的實現策略是每次需要分配新的內存空間時將當前容量翻倍

map:map是c++的一個標準容器，她提供了很好一對一的關係，在一些程序中建立一個map可以起到事半功倍的效果
map是一種關聯容器，關聯容器支持高效的關鍵字查詢和訪問，兩個主要的關聯容器就是map和set，map中的元素是一些關鍵字-值對，關鍵字起到索引的作用，值則表示與關鍵字相關聯的數據。
1.map最基本的構造函數；

   map<string , int >mapstring;         map<int ,string >mapint;
   map<sring, char>mapstring;         map< char ,string>mapchar;
   map<char ,int>mapchar;            map<int ,char >mapint；
   //  map<char ,int>mapchar; 定義的map中，第一個是關鍵字的類型，第二個是值的類型，這個關鍵字是char類型，值是int類型

2.map添加數據；

map<int ,string> maplive;  
maplive.insert(pair<int,string>(102,"aclive"));
maplive.insert(map<int,string>::value_type(321,"hai"));
maplive[112]="April";//map中最簡單的插入添加！慎用，如果不存在，會把新元素插入

3.map中元素的查找：
find()函數返回一個迭代器指向鍵值爲key的元素，如果沒找到就返回指向map尾部的迭代器。

   map<int ,string >::iterator l_it;; 
   l_it=maplive.find(112);
   if(l_it==maplive.end())
                cout<<"we do not find 112"<<endl;
   else cout<<"wo find 112"<<endl;

4,map中元素的刪除：
如果刪除112；

   map<int ,string >::iterator l_it;;
   l_it=maplive.find(112);
   if(l_it==maplive.end())
        cout<<"we do not find 112"<<endl;
   else  maplive.erase(l_it);  //delete 112;

5,map中 swap的用法：
Map中的swap不是一個容器中的元素交換，而是兩個容器交換；
For example：

 #include <map>
  #include <iostream>

  using namespace std;

  int main( )
  {
      map <int, int> m1, m2, m3;
      map <int, int>::iterator m1_Iter;

      m1.insert ( pair <int, int>  ( 1, 10 ) );
      m1.insert ( pair <int, int>  ( 2, 20 ) );
      m1.insert ( pair <int, int>  ( 3, 30 ) );
      m2.insert ( pair <int, int>  ( 10, 100 ) );
      m2.insert ( pair <int, int>  ( 20, 200 ) );
      m3.insert ( pair <int, int>  ( 30, 300 ) );

   cout << "The original map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter->second;
      cout   << "." << endl;

   // This is the member function version of swap
   //m2 is said to be the argument map; m1 the target map
   m1.swap( m2 );

   cout << "After swapping with m2, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout  << "." << endl;
   cout << "After swapping with m2, map m2 is:";
   for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout  << "." << endl;
   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
      cout   << "." << endl;
}

6.map的sort問題：
Map中的元素是自動按key升序排序,所以不能對map用sort函數：

  #include <map>
  #include <iostream>

  using namespace std;

 int main( )
 {
   map <int, int> m1;
   map <int, int>::iterator m1_Iter;

   m1.insert ( pair <int, int>  ( 1, 20 ) );
   m1.insert ( pair <int, int>  ( 4, 40 ) );
   m1.insert ( pair <int, int>  ( 3, 60 ) );
   m1.insert ( pair <int, int>  ( 2, 50 ) );
   m1.insert ( pair <int, int>  ( 6, 40 ) );
   m1.insert ( pair <int, int>  ( 7, 30 ) );

   cout << "The original map m1 is:"<<endl;
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout <<  m1_Iter->first<<" "<<m1_Iter->second<<endl;

}
  The original map m1 is:
  1 20
  2 50
  3 60
  4 40
  6 40
  7 30

set：也是一種關聯容器
定義

set<string> s1 = {"hello","world"}

添加元素

set s1
s1.insert("hello")
s1.insert("world")

元素刪除：與插入一樣，可以高效的刪除，並自動調整使紅黑樹平衡。

set<int> s;
s.erase(2);        //刪除鍵值爲2的元素
s.clear();

5.元素檢索：find()，若找到，返回該鍵值迭代器的位置，否則，返回最後一個元素後面一個位置。

set<int> s;
set<int>::iterator it;
it=s.find(5);    //查找鍵值爲5的元素
if(it!=s.end())    //找到
       cout<<*it<<endl;
else            //未找到
       cout<<"未找到";

對set常用的操作
1.元素插入：insert()
2.中序遍歷：類似vector遍歷（用迭代器）
3.反向遍歷：利用反向迭代器reverse_iterator

    set<int> s;
    ......
    set<int>::reverse_iterator rit; //反向遍歷
    for(rit=s.rbegin();rit!=s.rend();rit++)

    set<int> s;
    ......
    set<int>::iterator rit; //正向遍歷
    for(rit=s.begin();rit!=s.end();rit++)