文章目錄

• vector
• • vector的介紹
  • vector的優(yōu)缺點
• 實現(xiàn)時需要注意的細節(jié)問題
• • 1. Capacity增長問題
  • 2. memset等函數(shù)來帶的按字節(jié)拷貝問題
  • 3. 深淺拷貝問題
  • 4. 迭代器失效問題
• 實現(xiàn)的接口
• 代碼實現(xiàn)

---

vector

vector的介紹

vector的文檔介紹

vector是表示可變大小數(shù)組的序列容器。

就像數(shù)組一樣，vector也采用的連續(xù)存儲空間來存儲元素。也就是意味著可以采用下標(biāo)對vector的元素 進行訪問，和數(shù)組一樣高效。但是又不像數(shù)組，它的大小是可以動態(tài)改變的，而且它的大小會被容器自 動處理。

本質(zhì)講，vector使用動態(tài)分配數(shù)組來存儲它的元素。當(dāng)新元素插入時候，這個數(shù)組需要被重新分配大小 為了增加存儲空間。其做法是，分配一個新的數(shù)組，然后將全部元素移到這個數(shù)組。就時間而言，這是
一個相對代價高的任務(wù)，因為每當(dāng)一個新的元素加入到容器的時候，vector并不會每次都重新分配大 小。

vector分配空間策略：vector會分配一些額外的空間以適應(yīng)可能的增長，因為存儲空間比實際需要的存 儲空間更大。不同的庫采用不同的策略權(quán)衡空間的使用和重新分配。但是無論如何，重新分配都應(yīng)該是
對數(shù)增長的間隔大小，以至于在末尾插入一個元素的時候是在常數(shù)時間的復(fù)雜度完成的。

因此，vector占用了更多的存儲空間，為了獲得管理存儲空間的能力，并且以一種有效的方式動態(tài)增 長。

與其它動態(tài)序列容器相比（deques, lists and forward_lists）， vector在訪問元素的時候更加高效，在 末尾添加和刪除元素相對高效。對于其它不在末尾的刪除和插入操作，效率更低。比起lists和 forward_lists統(tǒng)一的迭代器和引用更好。

其實vector就是數(shù)據(jù)結(jié)構(gòu)中的順序表， 關(guān)于順序表的實現(xiàn)思路我之前有寫過
https://blog.csdn.net/qq_35423154/article/details/104017476

但是他又有些不同，我們傳統(tǒng)的順序表使用了capacity，size和data，而stl中的vector分別使用三個迭代器來實現(xiàn)，start指向數(shù)據(jù)起始位置，finish指向數(shù)據(jù)結(jié)束位置，endOfStorage指向這塊存儲空間的結(jié)束位置。

我簡單的畫了一個圖

這就是vector的內(nèi)存布局。
從start到finish這一段就是目前已經(jīng)存儲的數(shù)據(jù)域
從start到endOfStorage這一段就是可存儲的空間大小

vector的優(yōu)缺點

優(yōu)點：
支持下標(biāo)的隨機訪問，可以很好的支持很多算法，如二分、排序等
缺點：
1.插入刪除的效率較低，因為需要挪動數(shù)據(jù)，效率為O（n ）
2.因為是順序結(jié)構(gòu)，所以空間不夠時需要增容，而增容需要申請新空間，將數(shù)據(jù)拷貝到新空間，釋放舊空間，造成了效率的低下。

vector的優(yōu)缺點其實也就是順序表的優(yōu)缺點，所以STL還加入了與順序表互補的鏈表，也就是list，list的模擬實現(xiàn)我也會抽空寫一篇博客

---

實現(xiàn)時需要注意的細節(jié)問題

具體的思路和細節(jié)我都寫在了注釋里，這部分是我覺得需要單獨拿出來說一下的

1. Capacity增長問題

在Windows的vs環(huán)境下，capacity的增長接近于1.5倍，而在Linux的g++環(huán)境下，capacity的增長是2倍。

兩者之間的分歧主要體現(xiàn)在，是優(yōu)先考慮時間還是空間的問題。
1.對于g++2倍增容：
優(yōu)點：每次申請的空間足夠多時，就能減少申請的次數(shù)，每次擴容都代表著要申請新空間，拷貝數(shù)據(jù)，銷毀原空間幾個步驟。所以這樣能夠大大的提升效率，
缺點：有可能因為申請的空間過多造成資源的浪費

所以這是典型的以空間換時間的做法。

2.對于vs的1.5倍增容：
優(yōu)點：每次申請1.5倍的空間，這樣就可以更好的利用空間，比起2倍更不容易造成資源浪費。
缺點：如果需求的空間過大，就需要多次擴容，因為擴容的次數(shù)過多，導(dǎo)致效率低

所以這是典型的以時間換空間的做法。

這里我選用的是g++的2倍增容

---

2. memset等函數(shù)來帶的按字節(jié)拷貝問題

我在實現(xiàn)resize中對多出空間初始化時復(fù)用了之前string的代碼，使用了memset拷貝數(shù)據(jù)，然后出現(xiàn)了錯誤，所有數(shù)據(jù)都和我給的不同。

錯誤的原因是因為memset等string.h中的函數(shù)都是按照一個一個字節(jié)拷貝的，這種按字節(jié)拷貝的方法對于char類型并沒有什么問題，但是對于其他大小不為1字節(jié)的類型，就有問題了。

例如我是用memset給整型的數(shù)組初始化為1

int arr[10];memset(arr, 1, sizeof(int) * 10);

可以看到初始化后的結(jié)果是這個
原因就是它是將1這個數(shù)據(jù)，拷貝到每一個字節(jié)中，所以實際上初始化的值是
00000001000000010000000100000001
也就是16843009

---

3. 深淺拷貝問題

這個問題也與上面有點關(guān)聯(lián)，對于reserve，我也復(fù)用了上次的代碼，其中使用memcpy來拷貝原數(shù)據(jù)到新的空間中，使用這種方法對于內(nèi)置類型來說的確是深拷貝，但是對于自定義類型和一些容器如：string來說就是淺拷貝了。

當(dāng)拷貝string時，拷貝size和capacity都沒有問題，但是拷貝str時他就直接把str的地址拷貝過去了，這時當(dāng)釋放原空間時，str也被釋放掉，而新數(shù)據(jù)中的str指向一個被釋放的空間，當(dāng)調(diào)用析構(gòu)函數(shù)，或者對這段空間進行訪問的時候，都會出現(xiàn)錯誤。

解決方法：使用賦值運算符進行深拷貝，因為會自動調(diào)用對應(yīng)類型的重載后的賦值運算符，這樣就可以避免自定義類型中部分成員淺拷貝的問題

void reserve(size_t n){//容量沒增大則不操作if (n <= capacity())return;//后面會修改到_finish和_start，所以后面無法調(diào)用size（）size_t length = size();T* temp = new T[n];//判斷_start是否為空，防止釋放空指針if (_start){//深拷貝，這里不能像string一樣使用strcpy或者memcpy，因為這兩個都是按照字節(jié)拷貝//還有一個原因，就是對于某些容器如string，memcpy拷貝時會直接淺拷貝_str,就會出現(xiàn)問題，而如果使用賦值則會自動調(diào)用對應(yīng)類型的重載賦值運算符for (size_t i = 0; i < length; i++){temp[i] = _start[i];}delete[] _start;}_start = temp;_finish = _start + length;_endOfStorage = _start + n;}

---

4. 迭代器失效問題

這也是最常見的問題，這樣的問題也分幾種情況

1.數(shù)據(jù)挪動造成的迭代器失效

比如刪除數(shù)據(jù)中的偶數(shù)

it = v.begin();while (it != v.end()){if (*it % 2 == 0)erase(it);else++it;} }

這樣的代碼就容易出現(xiàn)問題，因為erase和insert都會因為插入刪除數(shù)據(jù)，造成數(shù)據(jù)的挪動，這時因為數(shù)據(jù)地址的變動，導(dǎo)致了使用舊的迭代器訪問不到原本想要訪問的數(shù)據(jù)。

這個問題在vs下會直接報錯,g++檢查不夠嚴格，不會報錯。

這里只需要把erase那一行改成這樣，就可以解決，因為erase會返回新的迭代器，使用新的迭代器即可

it = erase(it);

2.增容帶來的迭代器失效問題
當(dāng)使用push_back，reserve，insert等會造成增容的函數(shù)時，就會出現(xiàn)這種情況，因為擴容會先申請一個新的空間，然后將原數(shù)據(jù)拷貝到新空間，再釋放舊空間，此時原來的迭代器就會全部失效，這個問題也需要注意。

---

實現(xiàn)的接口

默認成員函數(shù)部分

vector(); vector(int n, const T& value = T()); vector(const_iterator first, const_iterator last); vector(const vector<T>& v); vector<T>& operator=(vector<T> v); ~vector();

迭代器部分

typedef T* iterator; typedef const T* const_iterator; iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const;

容量部分

size_t capacity() const; size_t size() const; bool empty() const; void reserve(size_t n); void resize(size_t n, const T& value = T());

元素訪問部分

T& operator[](size_t pos); const T& operator[](size_t pos) const;

修改部分

void push_back(const T& x); void pop_back(); void swap(vector<T>& v); iterator insert(iterator pos, const T& x); iterator erase(iterator pos); void clear();

私有成員

iterator _start; // 指向數(shù)據(jù)的開始 iterator _finish; // 指向數(shù)據(jù)的結(jié)束 iterator _endOfStorage; // 指向存儲容量的尾

---

代碼實現(xiàn)

#pragma once #include<cassert>namespace lee {//類模板template<class T>class vector{public://迭代器typedef T* iterator;typedef const T* const_iterator;/*------------------------------------------------------------默認成員函數(shù)部分Member functions------------------------------------------------------------*/vector(): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){}vector(int n, const T& value = T()){assert(n > 0);//直接用resize就可以，功能一樣resize(n, value);}vector(const_iterator first, const_iterator last): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){reserve(last - first);//深拷貝while (first != last){*_finish++ = *first++;}_endOfStorage = _finish;}vector(const vector<T>& v): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){/*直接構(gòu)建一個然后交換vector temp(v.begin(), v.end());swap(temp);*/reserve(v.capacity());for (const auto& i : v){push_back(i);}}vector<T>& operator=(vector<T> v){//直接和形參交換，交換過去的數(shù)據(jù)也會在棧幀銷毀時清除。swap(v);return *this;}~vector(){delete[] _start;_start = _finish = _endOfStorage = nullptr;}/*------------------------------------------------------------迭代器部分Iterators:------------------------------------------------------------*/iterator begin(){return _start;}iterator end(){return _finish;}const_iterator begin() const{return _start;}const_iterator end() const{return _finish;}/*------------------------------------------------------------容量部分Capacity------------------------------------------------------------*/size_t size() const{return _finish - _start;}size_t capacity() const{return _endOfStorage - _start;}void reserve(size_t n){//容量沒增大則不操作if (n <= capacity())return;//后面會修改到_finish和_start，所以后面無法調(diào)用size（）size_t length = size();T* temp = new T[n];//判斷_start是否為空，防止釋放空指針if (_start){//深拷貝，這里不能像string一樣使用strcpy或者memcpy，因為這兩個都是按照字節(jié)拷貝//還有一個原因，就是對于某些容器如string，memcpy拷貝時會直接淺拷貝_str,就會出現(xiàn)問題，而如果使用賦值則會自動調(diào)用對應(yīng)類型的重載賦值運算符for (size_t i = 0; i < length; i++){temp[i] = _start[i];}delete[] _start;}_start = temp;_finish = _start + length;_endOfStorage = _start + n;}//value為該類型的缺省值void resize(size_t n, const T& value = T()){//如果原來的大則初始化后面的數(shù)據(jù)if (size() < n){//如果容量不夠則擴容if (capacity() < n){reserve(n);}//將多出來的部分初始化為valuewhile (_finish < _start + n){*_finish++ = value;}}//如果容量比原來的小，則直接從對應(yīng)位置截斷數(shù)據(jù)else{_finish = _start + n;}}bool empty() const{return _start == _finish;}/*------------------------------------------------------------元素訪問部分Element access:------------------------------------------------------------*/T& operator[](size_t pos){assert(pos < size());return _start[pos];}const T& operator[](size_t pos) const{assert(pos < size());return _start[pos];}/*------------------------------------------------------------修改部分Modifiers:------------------------------------------------------------*/void push_back(const T& x){//容量滿了則擴容if (_finish == _endOfStorage){size_t newCapacity = capacity() == 0 ? 2 : 2 * capacity();reserve(newCapacity);}*_finish++ = x;}void pop_back(){assert(_start < _finish);_finish--;}void swap(vector<T>& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endOfStorage, v._endOfStorage);}iterator insert(iterator pos, const T& x){assert(pos <= _finish);//空間滿了則擴容if (_finish == _endOfStorage){size_t newCapacity = capacity() == 0 ? 2 : 2 * capacity();reserve(newCapacity);}//數(shù)據(jù)后移for (auto i = _finish; i >= pos; i--){*i = *(i - 1);}//插入數(shù)據(jù)，并且結(jié)束位置后移*pos = x;_finish++;return pos;}iterator erase(iterator pos){assert(pos <= _finish);//數(shù)據(jù)前移for (auto i = pos; i <= _finish; i++){*i = *(i + 1);}_finish--;return pos;}void clear(){_finish = _start;}private:iterator _start; // 指向數(shù)據(jù)的開始iterator _finish; // 指向數(shù)據(jù)的結(jié)束iterator _endOfStorage; // 指向存儲容量的尾}; }

總結(jié)

以上是生活随笔為你收集整理的C++ STL : 模拟实现STL中的vector类的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。