vector的使用方法

來自：http://blog.csdn.net/ghevinn/article/details/21722243

vector是C++標準模板庫中的部分內容，它是一個多功能的，能夠操作多種數據結構和算法的模板類和函數庫。vector之所以被認爲是一個容器，是因爲它能夠像容器一樣存放各種類型的對象，簡單地說，vector是一個能夠存放任意類型的動態數組，能夠增加和壓縮數據。

爲了可以使用vector，必須在你的頭文件中包含下面的代碼：

#include <vector>

vector屬於std命名域的，因此需要通過命名限定，如下完成你的代碼：

using std::vector;

vector<int>   m_vInts;  //定義變量

或者連在一起，使用全名：

std::vector<int>   m_vInts;

建議使用全局的命名域方式：using namespace std;

vector相關操作：

成員函數	函數表述
c.assign(beg,end)  c.assign(n,elem)	將[beg; end)區間中的數據賦值給c。將n個elem的拷貝賦值給c。
c.at(idx)	傳回索引idx所指的數據，如果idx越界，拋出out_of_range。
c.back()	傳回最後一個數據，不檢查這個數據是否存在。
c.capacity()	返回容器中數據個數。
c.clear()	移除容器中所有數據。
c.empty()	判斷容器是否爲空。
c.end()	指向迭代器中的最後一個數據地址。
c.erase(pos)	刪除pos位置的數據，傳回下一個數據的位置。
c.erase(beg,end)	刪除[beg,end)區間的數據，傳回下一個數據的位置。
c.front()	傳回第一個數據。
get_allocator	使用構造函數返回一個拷貝。
c.insert(pos,elem)	在pos位置插入一個elem拷貝，傳回新數據位置。
c.insert(pos,n,elem)	在pos位置插入n個elem數據。無返回值。
c.insert(pos,beg,end)	在pos位置插入在[beg,end)區間的數據。無返回值。
c.max_size()	返回容器中最大數據的數量。
c.pop_back()	刪除最後一個數據。
c.push_back(elem)	在尾部加入一個數據。
c.rbegin()	傳回一個逆向隊列的第一個數據。
c.rend()	傳回一個逆向隊列的最後一個數據的下一個位置。
c.resize(num)	重新指定隊列的長度。
c.reserve()	保留適當的容量。
c.size()	返回容器中實際數據的個數。
c1.swap(c2) swap(c1,c2)	將c1和c2元素互換。
vector<Elem>	創建一個空的vector。
cvector<Elem> c1(c2)	複製一個vector。
vector <Elem> c(n)	創建一個vector，含有n個數據，數據均已缺省構造產生。
vector <Elem> c(n, elem)	創建一個含有n個elem拷貝的vector。
vector<Elem> c(beg,end)	創建一個以[beg;end)區間的vector。
c.~ vector <Elem>()	銷燬所有數據，釋放內存。
operator[]	返回容器中指定位置的一個引用。

 

vector容器提供了多種創建方法，下面介紹幾種常用的。

創建一個vector	說明
vector<Widget> vWidgets;	創建一個Widget類型的空的vector對象
vector<Widget> vWidgets(500);	創建一個包含500個Widget類型數據的vector
vector<Widget>vWidgets(500, Widget(0));	創建一個包含500個Widget類型數據的vector，並且都初始化爲0
vector<Widget> vWidgetsFromAnother(vWidgets);	創建一個Widget的拷貝

 

向vector添加若干個數據

    vector添加數據的缺省方法是push_back()。push_back()函數表示將數據添加到vector的尾部，並按需要來分配內存。例如：向vector<Widget>中添加10個數據，需要如下編寫代碼：

for(int i= 0;i<10; i++)  {  vWidgets.push_back(Widget(i));  }

獲取vector中指定位置的數據

    vector裏面的數據是動態分配的，使用push_back()的一系列分配空間常常決定於文件或一些數據源。如果想知道vector存放了多少數據，可以使用empty()。獲取vector的大小，可以使用size()。例如，如果想獲取一個vector v的大小，但不知道它是否爲空，或者已經包含了數據，如果爲空想設置爲-1，你可以使用下面的代碼實現：

int nSize = v.empty() ? -1 : static_cast<int>(v.size());

訪問vector中的數據

使用兩種方法來訪問vector。

1、   vector::at()

2、   vector::operator[]

operator[]主要是爲了與C語言進行兼容。它可以像C語言數組一樣操作。但at()是我們的首選，因爲at()進行了邊界檢查，如果訪問超過了vector的範圍，將拋出一個例外。由於operator[]容易造成一些錯誤，所有我們很少用它，下面進行驗證一下：

分析下面的代碼：

vector<int> v;

v.reserve(10);

for(int i=0; i<7; i++) {

v.push_back(i);

}

try {int iVal1 = v[7];

// not bounds checked - will not throw

int iVal2 = v.at(7);

// bounds checked - will throw if out of range

} catch(const exception& e) {

cout << e.what();

}

刪除vector中的數據

    vector能夠非常容易地添加數據，也能很方便地取出數據，同樣vector提供了erase()，pop_back()，clear()來刪除數據，當刪除數據時，應該知道要刪除尾部的數據，或者是刪除所有數據，還是個別的數據。

Remove_if()算法 如果要使用remove_if()，需要在頭文件中包含如下代碼：：

#include <algorithm>

     Remove_if()有三個參數：

1、   iterator _First：指向第一個數據的迭代指針。

2、   iterator _Last：指向最後一個數據的迭代指針。

3、   predicate _Pred：一個可以對迭代操作的條件函數。

實例代碼：

//vector的用法
//1.vector 的數據的存入和輸出：

#include<stdio.h>
#include<vector>
#include <iostream>

using namespace std;

void main()

{

   int i = 0;

    vector<int> v;

    for( i = 0; i < 10; i++ )

   {

             v.push_back( i );//把元素一個一個存入到vector中

   }

    /* v.clear()*/ 對存入的數據清空


   for( i = 0; i < v.size(); i++ )//v.size() 表示vector存入元素的個數

   {

          cout << v[ i ] << " "; //把每個元素顯示出來

   }

   cont << endl;

}

//注：你也可以用v.begin()和v.end() 來得到vector開始的和結束的元素地址的指針位置。你也可以這樣做：

vector<int>::iterator iter; /*iterator 抽象了指針的絕大部分基本特徵*/


for( iter = v.begin(); iter != v.end(); iter++ )

{
    cout << *iter << endl;
}

//2. 對於二維vector的定義。

//1)定義一個10個vector元素，並對每個vector符值1-10。

#include<stdio.h>
#include<vector>
#include <iostream>

using namespace std;

void main()
{
int i = 0, j = 0;

//定義一個二維的動態數組，有10行，每一行是一個用一個vector存儲這一行的數據。

//所以每一行的長度是可以變化的。之所以用到vector<int>(0)是對vector初始化，否則不能對vector存入元素。
vector< vector<int> > Array( 10, vector<int>(0) );

for( j = 0; j < 10; j++ )
{
for ( i = 0; i < 9; i++ )
{
   Array[ j ].push_back( i );
}
}

for( j = 0; j < 10; j++ )
{
for( i = 0; i < Array[ j ].size(); i++ )
{
   cout << Array[ j ][ i ] << " ";
}
cout<< endl;
}
}

//2)定義一個行列都是變化的數組。

#include<stdio.h>
#include<vector>
#include <iostream>

using namespace std;

void main()
{
int i = 0, j = 0;

vector< vector<int> > Array;
vector< int > line;
for( j = 0; j < 10; j++ )
{
Array.push_back( line );//要對每一個vector初始化，否則不能存入元素。
for ( i = 0; i < 9; i++ )
{
   Array[ j ].push_back( i );
}
}

for( j = 0; j < 10; j++ )
{
for( i = 0; i < Array[ j ].size(); i++ )
{
   cout << Array[ j ][ i ] << " ";
}
cout<< endl;
}
}



//使用 vettor erase 指定元素


#include "iostream"
#include "vector"

using namespace std;

int   main()
{
    vector<int>   arr;
    arr.push_back(6);
    arr.push_back(8);
    arr.push_back(3);
    arr.push_back(8);

    for(vector<int>::iterator it=arr.begin(); it!=arr.end(); )
    {
        if(* it == 8)
        {
            it = arr.erase(it);
        }
        else
        {
            ++it;
        }
    }

    cout << "After remove 8:\n";

    for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it)
    {
        cout << * it << " ";
    }
    cout << endl;
}





#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

void main()
{
int iarray[]={0,1,2,3,4,5,6,6,6,7,8};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
int iarray1[]={6,6};
vector<int> ivector1(iarray1,iarray1+sizeof(iarray1)/sizeof(int));
int iarray2[]={5,6};
vector<int> ivector2(iarray2,iarray2+sizeof(iarray2)/sizeof(int));
int iarray3[]={0,1,2,3,4,5,7,7,7,9,7};
vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));

//找出ivector之中相鄰元素值相等的第一個元素
cout<<*adjacent_find(ivector.begin(),ivector.end())<<endl;

//找出ivector之中元素值爲6的元素個數
cout<<count(ivector.begin(),ivector.end(),6)<<endl;

//找出ivector之中小於7的元素個數
cout<<count_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),7))<<endl;

//找出ivector之中元素值爲4的第一個元素所在位置的元素
cout<<*find(ivector.begin(),ivector.end(),4)<<endl;

//找出ivector之中大於2的第一個元素所在位置的元素
cout<<*find_if(ivector.begin(),ivector.end(),bind2nd(greater<int>(),2))
<<endl;

//找出ivector之中子序列ivector1所出現的最後一個位置，再往後3個位置的元素
cout<<*(find_end(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end())+3)<<endl;

//找出ivector之中子序列ivector1所出現的第一個位置，再往後3個位置的元素
cout<<*(find_first_of(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end())+3)<<endl;

//子序列ivector2在ivector中出現的起點位置元素
cout<<*search(ivector.begin(),ivector.end(),ivector2.begin(),ivector2.end())
<<endl;

//查找連續出現3個6的起點位置元素
cout<<*search_n(ivector.begin(),ivector.end(),3,6,equal_to<int>())<<endl;

//判斷兩個區間ivector和ivector3相等否(0爲假，1爲真）
cout << equal(ivector.begin(), ivector.end(), ivector3.begin()) << endl;

//查找區間ivector3在ivector中不匹配點的位置
pair<int*,int*>result=mismatch(ivector.begin(),ivector.end(),ivector3.begin());
cout<< result.first - ivector.begin() << endl;
}

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

class even_by_two{             //類定義形式的函數對象
public:
int operator()() const
{return _x+=2;}
private:
static int _x;
};
int even_by_two::_x=0;       //靜態數據成員初始化

void main()
{
int iarray[]={0,1,2,3,4,5,6,6,6,7,8};
int iarray1[]={0,1,2,3,4,4,5,5,6,6,6,6,6,7,8};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));
vector<int> ivector1(iarray+6,iarray+8);
vector<int> ivector2(iarray1,iarray1+sizeof(iarray1)/sizeof(int));
ostream_iterator< int > output( cout, " " ); //定義流迭代器用於輸出數據

//迭代遍歷ivector1區間，對每一個元素進行even_by_two操作
    generate(ivector1.begin(),ivector1.end(),even_by_two());
copy(ivector1.begin(),ivector1.end(),output);
cout<<endl;

//迭代遍歷ivector的指定區間（起點和長度），對每一個元素進行even_by_two操作
    generate_n(ivector.begin(),3,even_by_two());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//刪除元素6
    remove(ivector.begin(),ivector.end(),6);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//刪除(實際並未從原序列中刪除）元素6，結果置於另一個區間
    vector<int> ivector3(12);
remove_copy(ivector.begin(),ivector.end(),ivector3.begin(),6);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;

//刪除(實際並未從原序列中刪除）小於6的元素
remove_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),6));
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//刪除(實際並未從原序列中刪除)小於7的元素，結果置於另一個區間，
remove_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),
bind2nd(less<int>(),7));
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;

//將所有的元素值6，改爲元素值3
replace(ivector.begin(),ivector.end(),6,3);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//將所有的元素值3，改爲元素值5,結果放置到另一個區間
replace_copy(ivector.begin(),ivector.end(),ivector3.begin(),3,5);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;

//將所有小於5的元素值，改爲元素值2
replace_if(ivector.begin(),ivector.end(),bind2nd(less<int>(),5),2);
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//將所有的元素值8，改爲元素值9,結果放置到另一個區間
replace_copy_if(ivector.begin(),ivector.end(),ivector3.begin(),
bind2nd(equal_to<int>(),8),9);
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;

//逆向重排每一個元素
reverse(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//逆向重排每一個元素,結果置於另一個區間
reverse_copy(ivector.begin(),ivector.end(),ivector3.begin());
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;

//旋轉（互換元素）[first,middle), 和[middle,end)
rotate(ivector.begin(),ivector.begin()+4,ivector.end());
copy(ivector.begin(),ivector.end(),output);
cout<<endl;

//旋轉（互換元素）[first,middle], 和[middle,end]，結果置於另一個區間，
rotate_copy(ivector.begin(),ivector.begin()+5,ivector.end(),
ivector3.begin());
copy(ivector3.begin(),ivector3.end(),output);
cout<<endl;
}

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

void main()
{
int iarray[]={26,17,15,22,23,33,32,40};
vector<int> ivector(iarray,iarray+sizeof(iarray)/sizeof(int));

// 查找並輸出最大、最小值元素
cout<<*max_element(ivector.begin(),ivector.end())<<endl;
cout<<*min_element(ivector.begin(),ivector.end())<<endl;

//將ivector.begin()+4-ivector.begin()各元素排序，
//放進[ivector.begin(),ivector.begin()+4]區間。剩餘元素不保證維持原來相對次序
partial_sort(ivector.begin(),ivector.begin()+3,ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//局部排序並複製到別處
vector<int> ivector1(5);
partial_sort_copy(ivector.begin(),ivector.end(),ivector1.begin(),
ivector1.end());
copy(ivector1.begin(),ivector1.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//排序，缺省爲遞增。
sort(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//將指定元素插入到區間內不影響區間原來排序的最低、最高位置
cout<<*lower_bound(ivector.begin(),ivector.end(),24)<<endl;
cout<<*upper_bound(ivector.begin(),ivector.end(),24)<<endl;

//對於有序區間，可以用二分查找方法尋找某個元素
    cout<<binary_search(ivector.begin(),ivector.end(),33)<<endl;
    cout<<binary_search(ivector.begin(),ivector.end(),34)<<endl;

//下一個排列組合
next_permutation(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//上一個排列組合
prev_permutation(ivector.begin(),ivector.end());
copy(ivector.begin(),ivector.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//合併兩個序列ivector和ivector1，並將結果放到ivector2中
vector<int> ivector2(13);
merge(ivector.begin(),ivector.end(),ivector1.begin(),ivector1.end(),
ivector2.begin());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//將小於*(ivector.begin()+5)的元素放置在該元素之左
//其餘置於該元素之右。不保證維持原有的相對位置
nth_element(ivector2.begin(),ivector2.begin()+5,ivector2.end());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//排序，並保持原來相對位置
stable_sort(ivector2.begin(),ivector2.end());
copy(ivector2.begin(),ivector2.end(),ostream_iterator<int>(cout," "));
cout<<endl;

//針對一個有序區間，找出其中一個子區間，其中每個元素都與某特定元素值相同
pair<vector<int>::iterator,vector<int>::iterator> pairIte;
pairIte=equal_range(ivector2.begin(),ivector2.end(),22);
cout<<*(pairIte.first)<<endl;
cout<<*(pairIte.second)<<endl;

//合併兩個有序序列，然後就地替換
int iarray3[] = { 1, 3, 5, 7, 2, 4, 6, 8 };
vector<int> ivector3(iarray3,iarray3+sizeof(iarray3)/sizeof(int));
inplace_merge(ivector3.begin(), ivector3.begin()+ 4, ivector3.end());
copy(ivector3.begin(),ivector3.end(), ostream_iterator<int>(cout, " "));
cout<<endl;

//以字典順序比較序列ivector3和ivector4
int iarray4[] = { 1, 3, 5, 7,1, 5, 9, 3 };
vector<int> ivector4(iarray4,iarray4+sizeof(iarray4)/sizeof(int));
cout<< lexicographical_compare(ivector3.begin(),ivector3.end(),
ivector4.begin(),ivector4.end()) << endl

}

====================================================================

vector容器類型
   vector容器是一個模板類，可以存放任何類型的對象（但必須是同一類對象）。vector對象可以在運行時高效地添加元素，並且vector中元素是連續存儲的。
vector的構造
 
函數原型：
template<typename T>
   explicit vector();                                 // 默認構造函數，vector對象爲空
   explicit vector(size_type n, const T& v = T());    // 創建有n個元素的vector對象
   vector(const vector& x);
   vector(const_iterator first, const_iterator last);

注：vector容器內存放的所有對象都是經過初始化的。如果沒有指定存儲對象的初始值，那麼對於內置類型將用0初始化，對於類類型將調用其默認構造函數進行初始化（如果有其它構造函數而沒有默認構造函數，那麼此時必須提供元素初始值才能放入容器中）。
 
舉例：
vector<string> v1;         // 創建空容器，其對象類型爲string類
vector<string> v2(10);     // 創建有10個具有初始值（即空串）的string類對象的容器
vector<string> v3(5, "hello"); // 創建有5個值爲“hello”的string類對象的容器
vector<string> v4(v3.begin(), v3.end());  // v4是與v3相同的容器（完全複製）
 
vector的操作（下面的函數都是成員函數）
 
bool empty() const;                    // 如果爲容器爲空，返回true；否則返回false
size_type max_size() const;            // 返回容器能容納的最大元素個數
size_type size() const;                // 返回容器中元素個數  
size_type capacity() const;            // 容器能夠存儲的元素個數，有：capacity() >= size()  
void reserve(size_type n);             // 確保capacity() >= n
void resize(size_type n, T x = T());   // 確保返回後，有：size() == n；如果之前size()<n，那麼用元素x的值補全。
 
reference front();                     // 返回容器中第一個元素的引用（容器必須非空）
const_reference front() const;                   
reference back();                      // 返回容器中最後一個元素的引用（容器必須非空）
const_reference back() const;
 
reference operator[](size_type pos);   // 返回下標爲pos的元素的引用（下標從0開始；如果下標不正確，則屬於未定義行爲。
const_reference operator[](size_type pos) const; 
reference at(size_type pos);           // 返回下標爲pos的元素的引用；如果下標不正確，則拋出異常out_of_range
const_reference at(size_type pos) const;
            
void push_back(const T& x);            // 向容器末尾添加一個元素          
void pop_back();                       // 彈出容器中最後一個元素（容器必須非空）
 
// 注：下面的插入和刪除操作將發生元素的移動（爲了保持連續存儲的性質），所以之前的迭代器可能失效
iterator insert(iterator it, const T& x = T());        // 在插入點元素之前插入元素（或者說在插入點插入元素）
void insert(iterator it, size_type n, const T& x);     // 注意迭代器可能不再有效（可能重新分配空間）
void insert(iterator it, const_iterator first, const_iterator last);
 
iterator erase(iterator it);           // 刪除指定元素，並返回刪除元素後一個元素的位置（如果無元素，返回end()）
iterator erase(iterator first, iterator last); // 注意：刪除元素後，刪除點之後的元素對應的迭代器不再有效。
 
void clear() const;                    // 清空容器，相當於調用erase( begin(), end())
 
void assign(size_type n, const T& x = T());   // 賦值，用指定元素序列替換容器內所有元素
void assign(const_iterator first, const_iterator last);
 
const_iterator begin() const;          // 迭代序列
iterator begin();
const_iterator end() const;
iterator end();
 
const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
const_reverse_iterator rend() const; 
reverse_iterator rend();
 
vector對象的比較（非成員函數）
 
   針對vector對象的比較有六個比較運算符：operator==、operator!=、operator<、operator<=、operator>、operator>=。
 
   其中，對於operator==和operator!=，如果vector對象擁有相同的元素個數，並且對應位置的元素全部相等，則兩個vector對象相等；否則不等。
   對於operator<、operator<=、operator>、operator>=，採用字典排序策略比較。

注：其實只需要實現operator==和operator!=就可以了，其它可以根據這兩個實現。因爲，operator!= (lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs < lhs)，operator>(lhs, rhs) 就是 (rhs < lhs)，operator>=（lhs, rhs) 就是 !(lhs, rhs)。
 
vector類的迭代器

   vector類的迭代器除了支持通用的前綴自增運算符外，還支持算術運算：it + n、it - n、it2 - it1。注意it2 - it1返回值爲difference_type（signed類型）。
 
   注意，任何改變容器大小的操作都可能造成以前的迭代器失效。
 
應用示例
 
#include <iostream>
#include <cassert>
#include <vector>

using namespace std;

int main()
{
    vector<string> v(5, "hello");
    vector<string> v2(v.begin(), v.end());
    
    assert(v == v2);
    
    cout<<"> Before operation"<<endl;
    for(vector<string>::const_iterator it = v.begin(); it < v.end(); ++it)
        cout<<*it<<endl;
    
    v.insert(v.begin() + 3, 4, "hello, world");
    cout<<"> After insert"<<endl;
    for(vector<string>::size_type i = 0; i < v.size(); ++i)
        cout<<v[i]<<endl;
    
    vector<string>::iterator it = v.erase(v.begin() + 3, v.begin() + 6);
    assert(*it == "hello, world");
    cout<<"> After erase"<<endl;
    for(vector<string>::size_type i = 0; i != v.size(); ++i)
        cout<<v[i]<<endl;
    
    assert(v.begin() + v.size() == v.end());
    assert(v.end() - v.size() == v.begin());
    assert(v.begin() - v.end() == -vector<string>::difference_type(v.size()));
    
    return 0;
}
程序說明：上面程序中用了三個循環輸出容器中的元素，每個循環的遍歷方式是不一樣的。特別需要說明的是，第二個循環在條件判斷中使用了size() 函數，而不是在循環之前先保存在變量中再使用。之所以這樣做，有兩個原因：其一，如果將來在修改程序時，在循環中修改了容器元素個數，這個循環仍然能很好 地工作，而如果先保存size()函數值就不正確了；其二，由於這些小函數（其實現只需要一條返回語句）基本上都被聲明爲inline，所以不需要考慮效率問題。
在網上找的 還有很多 建議你還是買一本stl看看裏面有更詳細的內容 而且比較基礎

============================================================

begin()       返回第一個元素的迭代器 (iterator)

end()          返回最末元素的迭代器 (iterator) (譯註:實指向最末元素的下一個位置)

 

注:這兩個就相當於指針,可以把他們返回的值賦給一個聲明的 iterator (迭代器),這個迭代器可以 ++  -- 的操作,還可以直接加一個數字

 

例1:

std::vector<int> a(10);
 std::vector<int>::iterator it;
 int i = 0;
 for (it = a.begin(); it != a.end(); it++)
 {
  *it = i;
  i++;
 }

 cout<<*(a.begin()+4)<<endl; // 輸出的爲:4

 cout<<*(a.end()-2)<<endl; // 輸出的爲:8

 

注:a 中的值從第0爲到第10維分別是: 0,1,2,3,4,5,6,7,8,9;

 

---

rbegin()      返回Vector尾部的逆迭代器 (reverse_iterator)
rend()         返回Vector起始的逆迭代器 (reverse_iterator) (譯註:實指向第一個元素的前一個位置) ,rend()-1指向的是第一個元素

 

注:這兩個就相當於指針,可以把他們返回的值賦給一個聲明的 reverse_iterator(逆迭代器),這個迭代器可以 ++  -- 的操作,還可以直接加一個數字,但如果當前指向的是第7維,如果加2就指向的是第5維,如果++就是第6維,如果減2就是第9維

 

例2:

 std::vector<int> a(10);
 std::vector<int>::reverse_iterator it;
 int i = 0;
 for (it = a.rbegin(); it != a.rend(); it++)
 {
  *it = i;
  i++;
 }

 cout<<*(a.rend()-1)<<endl; // 輸出的爲:9

cout<<*(a.rbegin()+4)<<endl; // 輸出的爲:4

 

注:a 中的值從第0爲到第10維分別是: 9,8,7,6,5,4,3,2,1,0;

 

---

front()        返回第一個元素 (相當於 *begin() )

at()            返回指定位置的元素 (參數添幾相當於提取第幾維的元素的值,而不是指針)
back()        返回最末一個元素 (相當於 *(end()-1) )

 

注:這三個函數取得的都是值而不是指針

 

例3:
 std::vector<int> a(10);
 for (int i = 0; i<a.size(); i++)
 {
   a.at(i) = i; // 相當於a[i] = i;
 }
 cout<<a.front()<<endl; // 輸出的爲:0
 cout<<a.back()<<endl; // 輸出的爲:9

 

注:a 中的值從第0爲到第10維分別是: 0,1,2,3,4,5,6,7,8,9;