C++ string and vector(二)

      標準庫類型vector表示對象的集合，其中全部的對象的類型都相同。集合中的每一個對象的每一個對象都有一個與之對應的索引，索引用於訪問對象。由於vector「容納」其餘對象，因此也常稱做容器（container）

    C++語言既有類模板（class template），也有函數模板，其中vector是一個類模板

以vector爲例，提供的額外的信息是vector內所存放對象的類型：

記得加上頭文件：

#include <vector>

vector<int> ivec;                //ivec保存int類型的對象

vector<string> file;            //file保存string類型的對象

       vector<vector<string>> file;  //該向量的元素是vector對象

使用vector有兩種不一樣的形式，即所謂的數組習慣和 STL習慣。

1、數組習慣用法

1. 定義一個已知長度的 vector ：

vector< int > ivec( 10 );  //相似數組定義int ia[ 10 ];

能夠經過ivec[索引號] 來訪問元素

使用 if ( ivec.empty() ) 判斷是不是空，ivec.size()判斷元素個數。

 

2. vector的元素被初始化爲與其類型相關的缺省值：算術和指針類型的缺省值是 0，對於class 類型，缺省值可經過調用這類的缺省構造函數得到，咱們還能夠爲每一個元素提供一個顯式的初始值來完成初始化，例如  
vector< int > ivec( 10, -1 ); 
定義了 ivec 它包含十個int型的元素 每一個元素都被初始化爲-1 

對於內置數組 咱們能夠顯式地把數組的元素初始化爲一組常量值，例如 ： 
int ia[ 6 ] = { -2, -1, 0, 1, 2, 1024 };

咱們不能用一樣的方法顯式地初始化 vector ，可是能夠將 vector 初始化爲一個已有數組的所有或一部分，只需指定但願被用來初始化 vector 的數組的開始地址以及數組最末元的下一位置來實現，例如：   
// 把 ia 的 6 個元素拷貝到 ivec 中  
vector< int > ivec( ia, ia+6 );  

被傳遞給ivec 的兩個指針標記了用來初始化對象的值的範圍，第二個指針老是指向要拷貝的末元素的下一位置，標記出來的元素範圍也能夠是數組的一個子集，例如 :

// 拷貝 3 個元素 ia[2], ia[3], ia[4] 
vector< int > ivec( &ia[ 2 ], &ia[ 5 ] );

3. 與內置數組不一樣 vector 能夠被另外一個 vector 初始化 或被賦給另外一個 vector 例如  
vector< string > svec; 
void init_and_assign() 
{ 
    // 用另外一個 vector 初始化一個 vector 
    vector< string > user_names( svec ); 
    // ... 
 
    // 把一個 vector 拷貝給另外一個 vector 
    svec = user_names; 
}

2、STL習慣用法

在 STL9中對vector 的習慣用法徹底不一樣。咱們不是定義一個已知大小的 vector，而是定義一個空 vector  
vector< string > text;

1. 咱們向 vector 中插入元素，而再也不是索引元素，以及向元素賦值，例如 push_back()操做，就是在 vector 的後面插入一個元素下面的 while 循環從標準輸入讀入一個字符串序列並每次將一個字符串插入到 vector 中  
string word; 
while ( cin >> word ) { 
text.push_back( word ); 
// ... 
}

雖然咱們仍能夠用下標操做符來迭代訪問元素  
cout << "words read are: \n"; 
 
for ( int ix = 0; ix < text.size(); ++ix ) 
      cout << text[ ix ] << ' '; 
 
cout << endl; 
可是 更典型的作法是使用 vector 操做集中的begin()和 end()所返回的迭代器 iterator  
對 ：
cout << "words read are: \n"; 
 
for ( vector<string>::iterator it = text.begin(); 
    it != text.end(); ++it ) 
           cout << *it << ' '; 
 
cout << endl 
iterator 是標準庫中的類，它具備指針的功能 

*it; 
對迭代器解引用，並訪問其指向的實際對象  
++it;

向前移動迭代器 it 使其指向下一個元素  

2. 注意 不要混用這兩種習慣用法， 例如，下面的定義  
vector< int > ivec; 
定義了一個空vector 再寫這樣的語句  
ivec[ 0 ] = 1024; 
就是錯誤的 ，由於 ivec 尚未第一個元素，咱們只能索引 vector 中已經存在的元素 size()操做返回 vector 包含的元素的個數 。

3. 相似地 當咱們用一個給定的大小定義一個 vector 時，例如  ：
vector<int> ia( 10 ); 
任何一個插入操做都將增長vector 的大小，而不是覆蓋掉某個現有的元素，這看起來好像是很顯然的，可是 下面的錯誤在初學者中並很多見 ：
const int size = 7; 
int ia[ size ] = { 0, 1, 1, 2, 3, 5, 8 }; 
vector< int > ivec( size ); 
 
for ( int ix = 0; ix < size; ++ix ) 
    ivec.push_back( ia[ ix ]); 
程序結束時ivec 包含 14 個元素, ia 的元素從第八個元素開始插入。

在c++中，vector是一個十分有用的容器，下面對這個容器作一下總結。

1 基本操做

(1)頭文件#include<vector>.

(2)建立vector對象，vector<int> vec;

(3)尾部插入數字：vec.push_back(a);

(4)使用下標訪問元素，cout<<vec[0]<<endl;記住下標是從0開始的。

(5)使用迭代器訪問元素.

vector<int>::iterator it;for(it=vec.begin();it!=vec.end();it++)
    cout<<*it<<endl;

(6)插入元素：    vec.insert(vec.begin()+i,a);在第i+1個元素前面插入a;

(7)刪除元素：    vec.erase(vec.begin()+2);刪除第3個元素

vec.erase(vec.begin()+i,vec.end()+j);刪除區間[i,j-1];區間從0開始

(8)向量大小:vec.size();

(9)清空:vec.clear();

2

vector的元素不只僅可使int,double,string,還能夠是結構體，可是要注意：結構體要定義爲全局的，不然會出錯。下面是一段簡短的程序代碼：

#include<stdio.h>#include<algorithm>#include<vector>#include<iostream>using namespace std; typedef struct rect {    int id;    int length;    int width;

　　//對於向量元素是結構體的，可在結構體內部定義比較函數，下面按照id,length,width升序排序。
　　bool operator< (const rect &a)  const
    {
        if(id!=a.id)
            return id<a.id;
        else
        {
            if(length!=a.length)
                return length<a.length;
            else
                return width<a.width;
        }
    } }Rect;int main() {    vector<Rect> vec;    Rect rect;    rect.id=1;    rect.length=2;    rect.width=3;    vec.push_back(rect);    vector<Rect>::iterator it=vec.begin();    cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;    return 0; }

 3  算法

(1) 使用reverse將元素翻轉：須要頭文件#include<algorithm>

reverse(vec.begin(),vec.end());將元素翻轉(在vector中，若是一個函數中須要兩個迭代器，

通常後一個都不包含.)

(2)使用sort排序：須要頭文件#include<algorithm>，

sort(vec.begin(),vec.end());(默認是按升序排列,即從小到大).

能夠經過重寫排序比較函數按照降序比較，以下：

定義排序比較函數：

bool Comp(const int &a,const int &b)
{
    return a>b;
}
調用時:sort(vec.begin(),vec.end(),Comp)，這樣就降序排序。

#include <vector>
#include <iostream>
#include <string>
using namespace std;

void main()
{
#ifdef LIST_INIT
	// list initialization, articles has 3 elements
	vector<string> articles = { "a", "an", "the" };
#else
	string temp[] = { "a", "an", "the" };
	vector<string> articles(begin(temp), end(temp));
#endif

	vector<string> svec; // default initialization; svec has no elements
	vector<int> ivec;             // ivec holds objects of type int

	vector<vector<string>> file;  // vector whose elements are vectors
	vector<vector<int>> vecOfvec; // each element is itself a vector

	// all five vectors have size 0
	cout << svec.size() << " " << ivec.size() << " "
		<< " "
		<< file.size() << " " << vecOfvec.size() << endl;

	vector<int> ivec2(10);     // ten elements, each initialized to 0
	vector<int> ivec3(10, -1); // ten int elements, each initialized to -1
	vector<string> svec2(10);  // ten elements, each an empty string
	vector<string> svec3(10, "hi!"); // ten strings; each element is "hi!"
	cout << ivec2.size() << " " << ivec3.size() << " "
		<< svec2.size() << " " << svec3.size() << endl;

	// 10 is not a string, so cannot be list initialization
	vector<string> v1(10); // construct v1 with ten value-initialized elements
#ifdef LIST_INIT
	vector<string> v2{ 10 }; // ten elements value-initialized elements
#else
	vector<string> v2(10);
#endif
	vector<string> v3(10, "hi");  // ten elements with value "hi"
#ifdef LIST_INIT
	// again list initialization is not viable, so ordinary construction
	vector<string> v4{ 10, "hi" };  // ten elements with values "hi"
#else
	vector<string> v4(10, "hi");  // ten elements with values "hi"
#endif

	// all four vectors have size ten
	cout << v1.size() << " " << v2.size()
		<< " " << v3.size() << " " << v4.size() << endl;

#ifdef LIST_INIT
	vector<string> vs1{ "hi" }; // list initialization: vs1 has 1 element 
	vector<string> vs2{ 10 };   // ten default-initialized elements
	vector<string> vs3{ 10, "hi" }; // has ten elements with value "hi"
#else
	vector<string> vs1;
	vs1.push_back("hi"); // explicitly add the element; vs1 has 1 element 
	vector<string> vs2(10); // don't use curlies; 
	// vs2 has ten default-initialized elements
	vector<string> vs3(10, "hi"); // don't use curlies; 
	// vs3 has ten elements with value "hi"
#endif
	cout << vs1.size() << " " << vs2.size() << " " << vs3.size() << endl;

	vector<int> v5(10, 1);  // ten elements with value 1
#ifdef LIST_INIT
	vector<int> v6{ 10, 1 };  // two elements with values 10 and 1
#else
	vector<int> v6;
	v6.push_back(10);
	v6.push_back(1);
#endif
	cout << v5.size() << " " << v6.size() << endl;

#ifdef LIST_INIT
	// intention is clearer
	vector<int> alt_v3 = { 10 };    // one element with value 10
	vector<int> alt_v4 = { 10, 1 }; // two elements with values 10 and 1
#else
	vector<int> alt_v3;
	alt_v3.push_back(10);    // one element with value 10

	vector<int> alt_v4;
	alt_v4.push_back(10);
	alt_v4.push_back(1); // two elements with values 10 and 1
#endif
	cout << alt_v3.size() << " " << alt_v4.size() << endl;

	system("pause");
}

0 0  0 0
10 10 10 10
10 10 10 10
1 10 10
10 2
1 2
請按任意鍵繼續. . .