VECTOR

• vector 定義
• • 用法:
  • • 1.文件包含:
    • 2.變量聲明:
    • 3.具體的用法以及函數調用:
    • 4.內存管理與效率
    • 5.Vector 內存管理成員函數的行為測試
    • 6.vector的其他成員函數
• vector 其他用法
• • 內部排序
  • 內部元素交換位置
  • 刪除元素
  • erase
  • remove：
  • pop_back()
  • clear()
  • 實戰
  • CString插入元素
• 在用vector的過程中的一些問題,特此列出討論:

vector 定義

vector(向量): C++中的一種數據結構,確切的說是一個類.它相當于一個動態的數組,當程序員無法知道自己需要的數組的規模多大時,用其來解決問題可以達到最大節約空間的目的.

用法:

1.文件包含:

首先在程序開頭處加上#include以包含所需要的類文件vector
加上using namespace std;

2.變量聲明:

2.1 例:聲明一個int向量以替代一維的數組:
vector a;(等于聲明了一個int數組a[],大小沒有指定,可以動態的向里面添加刪除)。

2.2 例:用vector代替二維數組.其實只要聲明一個一維數組向量即可,而一個數組的名字其實代表的是它的首地址,所以只要聲明一個地址的向量即可,即:vector <int > a.同理想用向量代替三維數組也是一樣,vector <int*>a;再往上面依此類推.

3.具體的用法以及函數調用:

3.1 如何得到向量中的元素?其用法和數組一樣:
例如:

vector <int *> aint b = 5;a.push_back(b);//該函數下面有詳解cout<<a[0]; //輸出結果為5

1.push_back 在數組的最后添加一個數據
2.pop_back 去掉數組的最后一個數據
3.at 得到編號位置的數據
4.begin 得到數組頭的指針
5.end 得到數組的最后一個單元+1的指針
6．front 得到數組頭的引用
7.back 得到數組的最后一個單元的引用
8.max_size 得到vector最大可以是多大
9.capacity 當前vector分配的大小
10.size 當前使用數據的大小
11.resize 改變當前使用數據的大小，如果它比當前使用的大，者填充默認值
12.reserve 改變當前vecotr所分配空間的大小
13.erase 刪除指針指向的數據項
14.clear 清空當前的vector
15.rbegin 將vector反轉后的開始指針返回(其實就是原來的end-1)
16.rend 將vector反轉構的結束指針返回(其實就是原來的begin-1)
17.empty 判斷vector是否為空
18.swap 與另一個vector交換數據

3.2 詳細的函數實現功能：
其中vector c.
c.clear() 移除容器中所有數據。
c.empty() 判斷容器是否為空。
c.erase(pos) 刪除pos位置的數據
c.erase(beg,end) 刪除[beg,end)區間的數據
c.front() 傳回第一個數據。
c.insert(pos,elem) 在pos位置插入一個elem拷貝
c.pop_back() 刪除最后一個數據。
c.push_back(elem) 在尾部加入一個數據。
c.resize(num) 重新設置該容器的大小
c.size() 回容器中實際數據的個數。
c.begin() 返回指向容器第一個元素的迭代器
c.end() 返回指向容器最后一個元素的迭代器

4.內存管理與效率

1》使用reserve()函數提前設定容量大小，避免多次容量擴充操作導致效率低下。關于STL容器，最令人稱贊的特性之一就是是只要不超過它們的最大大小，它們就可以自動增長到足以容納你放進去的數據。（要知道這個最大值，只要調用名叫max_size的成員函數。）對于vector和string，如果需要更多空間，就以類似realloc的思想來增長大小。vector容器支持隨機訪問，因此為了提高效率，它內部使用動態數組的方式實現的。在通過 reserve() 來申請特定大小的時候總是按指數邊界來增大其內部緩沖區。當進行insert或push_back等增加元素的操作時，如果此時動態數組的內存不夠用，就要動態的重新分配當前大小的1.5~2倍的新內存區，再把原數組的內容復制過去。所以，在一般情況下，其訪問速度同一般數組，只有在重新分配發生時，其性能才會下降。正如上面的代碼告訴你的那樣。而進行pop_back操作時，capacity并不會因為vector容器里的元素減少而有所下降，還會維持操作之前的大小。對于vector容器來說，如果有大量的數據需要進行push_back，應當使用reserve()函數提前設定其容量大小，否則會出現許多次容量擴充操作，導致效率低下。reserve成員函數允許你最小化必須進行的重新分配的次數，因而可以避免真分配的開銷和迭代器/指針/引用失效。但在我解釋reserve為什么可以那么做之前，讓我簡要介紹有時候令人困惑的四個相關成員函數。在標準容器中，只有vector和string提供了所有這些函數。

(1) size()告訴你容器中有多少元素。它沒有告訴你容器為它容納的元素分配了多少內存。
(2) capacity()告訴你容器在它已經分配的內存中可以容納多少元素。那是容器在那塊內存中總共可以容納多少元素，而不是還可以容納多少元素。如果你想知道一個vector或string中有多少沒有被占用的內存，你必須從capacity()中減去size()。如果size和capacity返回同樣的值，容器中就沒有剩余空間了，而下一次插入（通過insert或push_back等）會引發上面的重新分配步驟。
(3) resize(Container::size_type n)強制把容器改為容納n個元素。調用resize之后，size將會返回n。如果n小于當前大小，容器尾部的元素會被銷毀。如果n大于當前大小，新默認構造的元素會添加到容器尾部。如果n大于當前容量，在元素加入之前會發生重新分配。
(4) reserve(Container::size_type n)強制容器把它的容量改為至少n，提供的n不小于當前大小。這一般強迫進行一次重新分配，因為容量需要增加。（如果n小于當前容量，vector忽略它，這個調用什么都不做，string可能把它的容量減少為size()和n中大的數，但string的大小沒有改變。在我的經驗中，使用reserve來從一個string中修整多余容量一般不如使用“交換技巧”，那是條款17的主題。）

這個簡介表示了只要有元素需要插入而且容器的容量不足時就會發生重新分配（包括它們維護的原始內存分配和回收，對象的拷貝和析構和迭代器、指針和引用的失效）。所以，避免重新分配的關鍵是使用reserve盡快把容器的容量設置為足夠大，最好在容器被構造之后立刻進行。

例如，假定你想建立一個容納1-1000值的vector。沒有使用reserve，你可以像這樣來做：

vector v;
for (int i = 1; i <= 1000; ++i) v.push_back(i);
在大多數STL實現中，這段代碼在循環過程中將會導致2到10次重新分配。（10這個數沒什么奇怪的。記住vector在重新分配發生時一般把容量翻倍，而1000約等于210。）

把代碼改為使用reserve，我們得到這個：

vector v;
v.reserve(1000);
for (int i = 1; i <= 1000; ++i) v.push_back(i);
這在循環中不會發生重新分配。

在大小和容量之間的關系讓我們可以預言什么時候插入將引起vector或string執行重新分配，而且，可以預言什么時候插入會使指向容器中的迭代器、指針和引用失效。例如，給出這段代碼，

string s;
…
if (s.size() < s.capacity()) {
s.push_back(‘x’);
}
push_back的調用不會使指向這個string中的迭代器、指針或引用失效，因為string的容量保證大于它的大小。如果不是執行push_back，代碼在string的任意位置進行一個insert，我們仍然可以保證在插入期間沒有發生重新分配，但是，與伴隨string插入時迭代器失效的一般規則一致，所有從插入位置到string結尾的迭代器/指針/引用將失效。

回到本條款的主旨，通常有兩情況使用reserve來避免不必要的重新分配。第一個可用的情況是當你確切或者大約知道有多少元素將最后出現在容器中。那樣的話，就像上面的vector代碼，你只是提前reserve適當數量的空間。第二種情況是保留你可能需要的最大的空間，然后，一旦你添加完全部數據，修整掉任何多余的容量。

2》使用“交換技巧”來修整vector過剩空間/內存有一種方法來把它從曾經最大的容量減少到它現在需要的容量。這樣減少容量的方法常常被稱為“收縮到合適（shrink to fit）”。該方法只需一條語句：vector<int>(ivec).swap(ivec);

表達式vector(ivec)建立一個臨時vector，它是ivec的一份拷貝：vector的拷貝構造函數做了這個工作。但是，vector的拷貝構造函數只分配拷貝的元素需要的內存，所以這個臨時vector沒有多余的容量。然后我們讓臨時vector和ivec交換數據，這時我們完成了，ivec只有臨時變量的修整過的容量，而這個臨時變量則持有了曾經在ivec中的沒用到的過剩容量。在這里（這個語句結尾），臨時vector被銷毀，因此釋放了以前ivec使用的內存，收縮到合適。

3》用swap方法強行釋放STL Vector所占內存

template < class T> void ClearVector( vector& v )
{
vectorvtTemp;
vtTemp.swap( v );
}
如
vector v ;
nums.push_back(1);
nums.push_back(3);
nums.push_back(2);
nums.push_back(4);
vector().swap(v);

/* 或者v.swap(vector()); */

/或者{ std::vector tmp = v; v.swap(tmp); }; //加大括號{ }是讓tmp退出{ }時自動析構/

5.Vector 內存管理成員函數的行為測試

C++ STL的vector使用非常廣泛，但是對其內存的管理模型一直有多種猜測，下面用實例代碼測試來了解其內存管理方式，測試代碼如下：

#include
#include
using namespace std;

int main()
{
vector iVec;
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //1個元素， 容器容量為1

iVec.push_back(1);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //2個元素， 容器容量為2

iVec.push_back(2);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //3個元素， 容器容量為4

iVec.push_back(3);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //4個元素， 容器容量為4

iVec.push_back(4);
iVec.push_back(5);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //5個元素， 容器容量為8

iVec.push_back(6);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //6個元素， 容器容量為8

iVec.push_back(7);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //7個元素， 容器容量為8

iVec.push_back(8);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //8個元素， 容器容量為8

iVec.push_back(9);
cout << "容器 大小為: " << iVec.size() << endl;
cout << "容器 容量為: " << iVec.capacity() << endl; //9個元素， 容器容量為16
/* vs2005/8 容量增長不是翻倍的，如
9個元素 容量9
10個元素 容量13 */

/* 測試effective stl中的特殊的交換 swap() */
cout << "當前vector 的大小為: " << iVec.size() << endl;
cout << "當前vector 的容量為: " << iVec.capacity() << endl;
vector(iVec).swap(iVec);

cout << "臨時的vector對象 的大小為: " << (vector(iVec)).size() << endl;
cout << "臨時的vector對象 的容量為: " << (vector(iVec)).capacity() << endl;
cout << "交換后，當前vector 的大小為: " << iVec.size() << endl;
cout << "交換后，當前vector 的容量為: " << iVec.capacity() << endl;

return 0;
}

6.vector的其他成員函數

c.assign(beg,end)：將[beg; end)區間中的數據賦值給c。c.assign(n,elem)：將n個elem的拷貝賦值給c。 c.at(idx)：傳回索引idx所指的數據，如果idx越界，拋出out_of_range。 c.back()：傳回最后一個數據，不檢查這個數據是否存在。c.front()：傳回地一個數據。 get_allocator：使用構造函數返回一個拷貝。 c.rbegin()：傳回一個逆向隊列的第一個數據。 c.rend()：傳回一個逆向隊列的最后一個數據的下一個位置。 c.~ vector <Elem>()：銷毀所有數據，釋放內存。

vector 其他用法

內部排序

通過sort函數實現整個vector變量的內部元素排序
eg：

vector<string> classesname_x_second;//正向排序：按照從小到大的順序進行排序 sort(classesname_x_second.begin(), classesname_x_second.end());//逆向排序：按照從大到小的順序進行排序 sort(classesname_x_second.rbegin(), classesname_x_second.rend());

內部元素交換位置

swap(初始位置，新位置)
eg：
result_up[j]與 result_up[j+1]交換位置

swap(result_up[j], result_up[j+1]);

刪除元素

erase()可以刪除由一個iterator指出的元素，也可以刪除一個指定范圍的元素。

還可以采用通用算法remove()來刪除vector容器中的元素，
不同的是，采用remove一般情況下不會改變容器的大小，而pop_back()與erase()等成員函數會改變容器的大小。

erase

iterator erase(iterator position);
iterator erase(iterator first, iterator last);

erase：
erase函數可以用于刪除vector容器中的一個或者一段元素，在刪除一個元素的時候，其參數為指向相應元素的迭代器，而在刪除一段元素的時候，參數為指向一段元素的開頭的迭代器以及指向結尾元素的下一個元素的迭代器。

在進行單個元素刪除后，傳入的迭代器指向不變，仍然指向被刪除元素的位置，而被刪除元素之后的所有元素都向前移動一位，也就是該迭代器實際上是指向了原來被刪除元素的下一個元素。其實vector還維持著一個last指針，開始的時候=end，隨著刪除，last前移，最終vector的size是last-begin，或者我們可以認為end值改變了，但最初傳入的end沒有變。

用例：

vector<int>::iterator itr = v.begin();while (itr!=v.end()){if (*v==1){v.erase(itr);}itr++;//這里刪除后迭代器會更新出錯}

以上代碼是錯誤的，
因為刪除一個元素之后，迭代器已經指向了被刪除元素的下一個元素，再進行itr++會出現野指針。
也就是說veci.erase(iter)后，iter的狀態是不確定的，再進行++，豈有不崩潰的道理？！

正確代碼為

vector<int>::iterator itr = v.begin();while (itr!=v.end()){if (*v==1){itr=v.erase(itr);}elseitr++;}

也就是說如果沒有erase操作，再將迭代器指向下一個元素。

刪除一段元素后，傳入的迭代器指向也是不變的，仍然指向原來傳進去時候的位置，修改的是刪除段后面的元素的位置。刪除段后面的元素都前移了。被刪除段用被刪除段的下一個元素代替了。

remove：

remove() 算法由定義在 algorithm 頭文件中的模板生成，它可以刪除匹配特定值的一段元素

iterator remove(iterator first, iterator last，val);
remove函數會將范圍內所有等于val的值移動位置

STL中remove（）只是將待刪除元素之后的元素移動到vector的前端，而不是刪除。若要真正移除，需要搭配使用erase()。

vector中的remove的作用是將等于value的元素放到vector的尾部，但并不減少vector的size。STL和vector這兩句表達的意思一樣。

執行remove之后返回新的end()迭代器，但是不改變原來數組的end()迭代器的值，將范圍內值等于val的元素用后一個元素替代。也就是原先數組中新的end()至原end()范圍內的值仍為原來數組的值（等于val的值），但是這部分狀態不可靠。begin()到新的end()這部分是不等于val的值。

區別：

也就是說erase和remove的區別在于執行函數之后返回值不同，被執行的vector的大小會不會改變

vector中erase的作用是刪除掉某個位置position或一段區域（begin, end)中的元素，減少其size，返回被刪除元素下一個元素的位置。

vector中remove的作用是將范圍內為val的值都remove到后面，返回新的end()值（非val部分的end）,但傳入的原vector的end并沒有發生改變，因此size也就沒有變化

兩者結合應用：
刪除vector中值為x的元素

vec.erase(remove(vec.begin(),vec.end(),x),vec.end());

具體可參見leetcode26

重復元素只保留一個，對重復的原地移除。

思路：可以將重復的元素用一個特殊值替代，再統一刪除這個特殊值。

class Solution {
public:
int removeDuplicates(vector& nums) {

if(nums.size()==0)return 0;int res=1;int flag=nums[0];for(int i=1;i<nums.size();i++){if(nums[i]==flag)nums[i]=INT_MAX;else{flag=nums[i];}}nums.erase(remove(nums.begin(),nums.end(),INT_MAX),nums.end());return nums.size(); }

};

pop_back()

刪除容器尾部的元素。例如：

std::vector data(100, 99); // Contains 100 elements initialized to 99
data.pop_back(); // Remove the last element

clear()

刪除所有的元素。例如：

std::vector data(100, 99);// Contains 100 elements initialized to 99
data.clear(); // Remove all elements

eg:

#include <algorithm> #include <vector> #include <iostream> #include <iterator> using namespace std;typedef struct rect //定義結構體 {int id;int length;int width;rect(int i,int l ,int w):id(i),length(l),width(w){}; } Rect;int main() {Rect rect(1,2,3); vector<Rect> vec(2,rect);//定義一個含有2個元素rect的vec容器Rect rect2(3,3,4); vec.push_back(rect2);Rect rect3(4,5,7); vec.push_back(rect3);Rect rect4(6,3,4); vec.push_back(rect4);/**********************刪除前遍歷輸出****************************/for(vector<Rect>::iterator it=vec.begin();it!=vec.end();++it){cout<<(*it).id<<','<<(*it).length<<','<<(*it).width<<endl; } /**********************刪除****************************/for(vector<Rect>::iterator it=vec.begin();it!=vec.end();){Rect temp=*it;if(temp.id==4){it=vec.erase(it); //刪除元素，返回值指向已刪除元素的下一個位置 }else++it; }cout<<"/***********split*************/"<<endl;/**********************刪除后遍歷輸出***************************/for(size_t i=0;i!=vec.size();++i){cout<<vec[i].id<<" "<<vec[i].length<<" "<<vec[i].width<<endl;}return 0;}

實戰

題意是acm的排名系統。

#include <bits/stdc++.h>using namespace std;typedef struct node {int date,peer; } ty;bool rule( ty a, ty b ) // sort的簡易自定義函數 {if ( a.date!=b.date ) {return a.date>b.date;}return a.peer<b.peer; }int main() {vector <node> a;int n;ty t;cin >> n;for ( int i=0; i<n; i++ ) {cin >> t.date>>t.peer;a.push_back(t); // vector中的插入}sort(a.begin(),a.end(),rule); // vector的sort排序vector<node>::iterator p; // vector的迭代器for ( p=a.begin(); p!=a.end(); p++ ) {cout << p->date << " " << p->peer << endl; // 迭代器的使用}return 0; }

原文鏈接：https://blog.csdn.net/weixin_43828245/article/details/90243175

vector<bbox_t> result_vec; //篩選準確度大于90%的檢測結果 vector<bbox_t>::iterator itr = result_vec.begin(); for (itr = result_vec.begin(); itr != result_vec.end(); itr++) { bbox_t temp = *itr;if(temp.prob < 0.9)result_vec.erase(itr); //Delete the second element }

刪除指定id元素

int id_prob;for (int k2 = 0; k2 < classesname_xup_second.size(); k2++){if (classesname_xup_second[k2 + 1] - classesname_xup_second[k2] < 8) //同一個字符被判斷兩次{if (result_up_prob[k2] < result_up_prob[k2 + 1]) id_prob = k2;elseid_prob = k2+1;result_up.erase(result_up.begin() + id_prob);}}

CString插入元素

v2.insert(v2.begin()+4, L"3"); //在指定位置，例如在第五個元素前插入一個元素v2.insert(v2.end(), L"3"); //在末尾插入一個元素v2.push_back(L"9"); //在末尾插入一個元素v2.insert(v2.begin(), L"3"); //在開頭插入一個元素

在用vector的過程中的一些問題,特此列出討論:

1)vector <int > a;int b = 5;a.push_back(b);此時若對b另外賦值時不會影響a[0]的值2)vector <int*> a;int *b;b= new int[4];b[0]=0;b[1]=1;b[2]=2;a.push_back(b);delete b; //釋放b的地址空間for(int i=0 ; i <3 ; i++){cout<<a[0][i]<<endl;}此時輸出的值并不是一開始b數組初始化的值,而是一些無法預計的值.分析:根據1) 2)的結果,可以想到,在1)中, 往a向量中壓入的是b的值,即a[0]=b,此時a[0]和b是存儲在兩個不同的地址中的.因此改變b的值不會影響a[0];而在2)中,因為是把一個地址(指針)壓入向量a,即a[0]=b,因此釋放了b的地址也就釋放了a[0]的地址,因此a[0]數組中存放的數值也就不得而知了.

總結

以上是生活随笔為你收集整理的C++ :vector的使用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。