文章目錄
vector
vector的介紹
vector的文檔介紹
- vector是表示可變大小數組的序列容器。
- 就像數組一樣，vector也採用的連續存儲空間來存儲元素。也就是意味着可以採用下標對vector的元素 進行訪問，和數組一樣高效。但是又不像數組，它的大小是可以動態改變的，而且它的大小會被容器自 動處理。
- 本質講，vector使用動態分配數組來存儲它的元素。當新元素插入時候，這個數組需要被重新分配大小 爲了增加存儲空間。其做法是，分配一個新的數組，然後將全部元素移到這個數組。就時間而言，這是
一個相對代價高的任務，因爲每當一個新的元素加入到容器的時候，vector並不會每次都重新分配大 小。- vector分配空間策略：vector會分配一些額外的空間以適應可能的增長，因爲存儲空間比實際需要的存 儲空間更大。不同的庫採用不同的策略權衡空間的使用和重新分配。但是無論如何，重新分配都應該是
對數增長的間隔大小，以至於在末尾插入一個元素的時候是在常數時間的複雜度完成的。- 因此，vector佔用了更多的存儲空間，爲了獲得管理存儲空間的能力，並且以一種有效的方式動態增 長。
- 與其它動態序列容器相比（deques, lists and forward_lists）， vector在訪問元素的時候更加高效，在 末尾添加和刪除元素相對高效。對於其它不在末尾的刪除和插入操作，效率更低。比起lists和 forward_lists統一的迭代器和引用更好。
其實vector就是數據結構中的順序表， 關於順序表的實現思路我之前有寫過
https://blog.csdn.net/qq_35423154/article/details/104017476
但是他又有些不同，我們傳統的順序表使用了capacity，size和data，而stl中的vector分別使用三個迭代器來實現，start指向數據起始位置，finish指向數據結束位置，endOfStorage指向這塊存儲空間的結束位置。
我簡單的畫了一個圖
這就是vector的內存佈局。
從start到finish這一段就是目前已經存儲的數據域
從start到endOfStorage這一段就是可存儲的空間大小
vector的優缺點
優點：
支持下標的隨機訪問，可以很好的支持很多算法，如二分、排序等
缺點：
1.插入刪除的效率較低，因爲需要挪動數據，效率爲O（n ）
2.因爲是順序結構，所以空間不夠時需要增容，而增容需要申請新空間，將數據拷貝到新空間，釋放舊空間，造成了效率的低下。
vector的優缺點其實也就是順序表的優缺點，所以STL還加入了與順序表互補的鏈表，也就是list，list的模擬實現我也會抽空寫一篇博客
實現時需要注意的細節問題
具體的思路和細節我都寫在了註釋裏，這部分是我覺得需要單獨拿出來說一下的
1. Capacity增長問題
在Windows的vs環境下，capacity的增長接近於1.5倍，而在Linux的g++環境下，capacity的增長是2倍。
兩者之間的分歧主要體現在，是優先考慮時間還是空間的問題。
1.對於g++2倍增容：
優點：每次申請的空間足夠多時，就能減少申請的次數，每次擴容都代表着要申請新空間，拷貝數據，銷燬原空間幾個步驟。所以這樣能夠大大的提升效率，
缺點：有可能因爲申請的空間過多造成資源的浪費
所以這是典型的以空間換時間的做法。
2.對於vs的1.5倍增容：
優點：每次申請1.5倍的空間，這樣就可以更好的利用空間，比起2倍更不容易造成資源浪費。
缺點：如果需求的空間過大，就需要多次擴容，因爲擴容的次數過多，導致效率低
所以這是典型的以時間換空間的做法。
這裏我選用的是g++的2倍增容
2. memset等函數來帶的按字節拷貝問題
我在實現resize中對多出空間初始化時複用了之前string的代碼，使用了memset拷貝數據，然後出現了錯誤，所有數據都和我給的不同。
錯誤的原因是因爲memset等string.h中的函數都是按照一個一個字節拷貝的，這種按字節拷貝的方法對於char類型並沒有什麼問題，但是對於其他大小不爲1字節的類型，就有問題了。
例如我是用memset給整型的數組初始化爲1
int arr[10];
memset(arr, 1, sizeof(int) * 10);
可以看到初始化後的結果是這個
原因就是它是將1這個數據，拷貝到每一個字節中，所以實際上初始化的值是
00000001000000010000000100000001
也就是16843009
3. 深淺拷貝問題
這個問題也與上面有點關聯，對於reserve，我也複用了上次的代碼，其中使用memcpy來拷貝原數據到新的空間中，使用這種方法對於內置類型來說的確是深拷貝，但是對於自定義類型和一些容器如：string來說就是淺拷貝了。
當拷貝string時，拷貝size和capacity都沒有問題，但是拷貝str時他就直接把str的地址拷貝過去了，這時當釋放原空間時，str也被釋放掉，而新數據中的str指向一個被釋放的空間，當調用析構函數，或者對這段空間進行訪問的時候，都會出現錯誤。
解決方法：使用賦值運算符進行深拷貝，因爲會自動調用對應類型的重載後的賦值運算符，這樣就可以避免自定義類型中部分成員淺拷貝的問題
void reserve(size_t n)
{
//容量沒增大則不操作
if (n <= capacity())
return;
//後面會修改到_finish和_start，所以後面無法調用size（）
size_t length = size();
T* temp = new T[n];
//判斷_start是否爲空，防止釋放空指針
if (_start)
{
//深拷貝，這裏不能像string一樣使用strcpy或者memcpy，因爲這兩個都是按照字節拷貝
//還有一個原因，就是對於某些容器如string，memcpy拷貝時會直接淺拷貝_str,就會出現問題，而如果使用賦值則會自動調用對應類型的重載賦值運算符
for (size_t i = 0; i < length; i++)
{
temp[i] = _start[i];
}
delete[] _start;
}
_start = temp;
_finish = _start + length;
_endOfStorage = _start + n;
}
4. 迭代器失效問題
這也是最常見的問題，這樣的問題也分幾種情況
1.數據挪動造成的迭代器失效
比如刪除數據中的偶數
it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
erase(it);
else
++it;
}
}
這樣的代碼就容易出現問題，因爲erase和insert都會因爲插入刪除數據，造成數據的挪動，這時因爲數據地址的變動，導致了使用舊的迭代器訪問不到原本想要訪問的數據。
這個問題在vs下會直接報錯,g++檢查不夠嚴格，不會報錯。
這裏只需要把erase那一行改成這樣，就可以解決，因爲erase會返回新的迭代器，使用新的迭代器即可
it = erase(it);
2.增容帶來的迭代器失效問題
當使用push_back，reserve，insert等會造成增容的函數時，就會出現這種情況，因爲擴容會先申請一個新的空間，然後將原數據拷貝到新空間，再釋放舊空間，此時原來的迭代器就會全部失效，這個問題也需要注意。
實現的接口
默認成員函數部分
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; // 指向數據的開始
iterator _finish; // 指向數據的結束
iterator _endOfStorage; // 指向存儲容量的尾
代碼實現
#pragma once
#include<cassert>
namespace lee
{
//類模板
template<class T>
class vector
{
public:
//迭代器
typedef T* iterator;
typedef const T* const_iterator;
/*
------------------------------------------------------------
默認成員函數部分
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)
{
/*
直接構建一個然後交換
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)
{
//直接和形參交換，交換過去的數據也會在棧幀銷燬時清除。
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，所以後面無法調用size（）
size_t length = size();
T* temp = new T[n];
//判斷_start是否爲空，防止釋放空指針
if (_start)
{
//深拷貝，這裏不能像string一樣使用strcpy或者memcpy，因爲這兩個都是按照字節拷貝
//還有一個原因，就是對於某些容器如string，memcpy拷貝時會直接淺拷貝_str,就會出現問題，而如果使用賦值則會自動調用對應類型的重載賦值運算符
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())
{
//如果原來的大則初始化後面的數據
if (size() < n)
{
//如果容量不夠則擴容
if (capacity() < n)
{
reserve(n);
}
//將多出來的部分初始化爲value
while (_finish < _start + n)
{
*_finish++ = value;
}
}
//如果容量比原來的小，則直接從對應位置截斷數據
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);
}
//數據後移
for (auto i = _finish; i >= pos; i--)
{
*i = *(i - 1);
}
//插入數據，並且結束位置後移
*pos = x;
_finish++;
return pos;
}
iterator erase(iterator pos)
{
assert(pos <= _finish);
//數據前移
for (auto i = pos; i <= _finish; i++)
{
*i = *(i + 1);
}
_finish--;
return pos;
}
void clear()
{
_finish = _start;
}
private:
iterator _start; // 指向數據的開始
iterator _finish; // 指向數據的結束
iterator _endOfStorage; // 指向存儲容量的尾
};
}