STL容器_vector類

前言

vector類是STL中的另一大容器，經過封裝，vector是一個可變長度並且擁有各種功能的順序表，在其內部可以利用數組實現。vector和string在物理與邏輯結構上十分相似，不過vector是一個模板類，我們可以在其中存放任意類型的數據。

vector的優點：

1.可以通過下標進行隨機訪問
2.在尾部插入或者刪除元素時更加高效
3.底層空間連續，內存利用率高

vector的缺點：

1.在內部進行插入刪除操作的效率低（需要挪動數據）
2.當動態添加的數據超過默認內存大小時，要進行擴容，整體的重新分配、拷貝、釋放

應用場景：

應用於支持隨機訪問，不關心插入和刪除效率的場景。

一：標準庫中的vector類

vector是一個可變大小數組的序列容器，採用連續存儲空間來存儲元素。

1.1 vector類的常用接口

vector類對象的常見構造：

函數名稱	功能說明
vector（）	無參構造
vector（size_type n, const value_type& val = value_type()）	構造並初始化n個val
vector (const vector& x)	拷貝構造
vector (InputIterator first, InputIterator last)	使用迭代器進行初始化構造

舉個栗子：

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

int main(){
	// 無參構造
	vector<int> array1;

	// 構造並初始化n個val
	vector<int> array2(4, 100);

	// 拷貝構造
	vector<int> array3(array2);

	// 使用迭代器進行初始化構造
	vector<int> array4(array2.begin(), array2.end());

	// 迭代器初始化
	int array[] = { 1, 2, 3, 4, 5, 6 };
	vector<int> array5(array, array + sizeof(array) / sizeof(array[0]));
	for (vector<int>::iterator it = array5.begin(); it != array5.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

輸出結果： 1 2 3 4 5 6

vector iterator 的使用：

函數名稱	功能說明
begin + end	獲取第一個數據位置的iterator/const_iterator，獲取最後一個數據的下一個位置的iterator/const_iterator
rbegin + rend	獲取最後一個數據位置的reverse_iterator，獲取第一個數據前一個位置的reverse_iterator

舉個栗子：

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

void PrintVector(const vector<int>& array){
	// const對象使用const迭代器進行遍歷打印
	vector<int>::const_iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

int main(){
	vector<int> array;

	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	// 使用正向迭代器進行遍歷(可修改)
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		*it *= 2;
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 使用反向迭代器進行遍歷
	vector<int>::reverse_iterator rit = array.rbegin();
	while (rit != array.rend()){
		*rit /= 2;
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	// const迭代器
	PrintVector(array);
}

輸出結果：2 4 6 8 10
       ：5 4 3 2 1 
       ：1 2 3 4 5

vector類對象的容量操作：

函數名稱	功能說明
size	獲取數據個數
capacity	獲取容量大小
empty	判斷是否爲空
resize	改變vector的實際存儲數據的個數（可初始化）
reverse	爲vector預留空間

vs是PJ版本的STL，g++是SGI版本的STL，vs下capacity是按1.5倍增長的，g++是按2倍增長的

reserve只負責開闢空間，如果確定需要用多少空間，reserve可以緩解vector增容的代價缺陷問題

舉個栗子：

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

int main(){
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	// 獲取vector的size和capacity
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;


	// 改變vector的size爲3
	array.resize(3);
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 改變vector的size爲10，多餘空間用10填充
	array.resize(10, 10);
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 爲vector預留空間
	array.reserve(100);
	cout << array.capacity() << endl;
}

運行結果：
5
6
1 2 3 4 5
3
6
1 2 3
10
10
1 2 3 10 10 10 10 10 10 10
100

vector類對象的增刪查改：

函數名稱	功能說明
push_back	尾插
pop_back	尾刪
insert	在pos位置之前插入val
erase	刪除pos位置的數據
operator[ ]	根據下標訪問
swap	交換兩個vector的數據空間
find	查找（注意：不是vector的成員接口，find在算法模塊實現）

舉個栗子：

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

int main(){
	vector<int> array;
	// 尾插
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// 尾刪
	array.pop_back();
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// insert
	// 注意pos位置是迭代器
	array.insert(array.begin(), 0);
	array.insert(array.begin()+3, 3);
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// erase
	// 注意pos位置是迭代器
	array.erase(array.begin());
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// operator[]進行讀寫
	array[0] = 0;
	for (int cur = 0; cur < array.size(); cur++){
		cout << array[cur] << " ";
	}
	cout << endl;

	// swap
	// 交換後array變爲空
	vector<int> v;
	v.swap(array);
	for (const auto& e : v){
		cout << e << " ";
	}
	cout << endl;

	// find
	// 刪掉vector中鍵值爲3的元素
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	if (pos != v.end()){
		v.erase(pos);
	}
	for (const auto& e : v){
		cout << e << " ";
	}
	cout << endl;
}

運行結果：
1 2 3
1 2
0 1 2 3
1 2 3
0 2 3
0 2 3
0 2

1.2 vector迭代器失效問題

在容器的使用中我們經常要操作迭代器，迭代器的主要作用就是讓算法能夠不用關心底層的數據結構，迭代器底層實際就是一個類似指針，或者是對指針進行了封裝。

迭代器失效就是：我們使用接口進行增加或刪除的時候，迭代器指向的內容會發生改變甚至是指向非法內存，原因是原來的內存已經被釋放，迭代器失效會導致指向內容改變，從而引起bug甚至是內存越界訪問導致程序崩潰。

引起vector底層空間改變的操作，都有可能是迭代器失效（push_back,insert,resize,reserve）
erase刪除元素的操作，也有可能引起迭代器失效（非法訪問）

解決迭代器失效的問題：如果想要繼續通過迭代器操作vector中的元素，只需給it重新賦值即可

舉個栗子：

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

void Test_iterator1(){
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	vector<int>::iterator it = array.begin();

	array.push_back(6);
	// 1.增容可能導致迭代器失效（push_back,insert,resize,reserve）
	// array.push_back(7); 
	// 插入7則產生迭代器失效問題
	// vector空間不夠則增容，開闢新的空間，將數據拷貝到新空間再釋放舊空間
	// 這時it是指向舊空間已經被釋放，從而導致it失效
	// 不要在迭代器定義之後進行可能增容的操作

	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void Test_iterator2(){
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);
	array.push_back(6);

	// 2.it的意義改變導致迭代器失效
	// 要求刪除容器中的所有偶數
	// 刪除2：將3、4、5、6向前挪一位，此時it指向3，++it後3沒有被判斷，導致迭代器失效
	// vs下進行檢查會報錯  gcc下不會檢查導致結果出問題
	/*vector<int>::iterator it = array.begin();
	while (it != array.end()){
		if (*it % 2 == 0){
			array.erase(it);
		}
		
		++it;
	}*/

	// 解決
	// erase返回刪除it的下一個位置的迭代器
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		if (*it % 2 == 0){
			it = array.erase(it);
		}
		else{
			++it;
		}
	}

	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

int main(){
	Test_iterator1();
	Test_iterator2();
}

運行結果：
1 2 3 4 5 6
1 3 5

二：vector類的深度剖析及模擬實現

vector類的深度剖析：

底層其實是三個指針：_ start指向數據塊的開始、_ finish指向有效數據的尾、_ endofstorage指向存儲容量的尾。

vector類的模擬實現：

#include<memory.h>
#include<assert.h>

namespace WJL{
	template<class T>
	class Vector{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		Vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}

		// 深拷貝
		/*Vector(const Vector<T>& v){
			_start = new T[v.capacity()];
			_finish = _start;
			_endofstorage = _start + v.capacity();

			for (size_t i = 0; i < v.size(); i++){
				*_finish = v[i];
				_finish++;
			}
		}*/

		Vector(const Vector<T>& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v){
				push_back(e);
			}
		}

		/*Vector<T>& operator=(const Vector<T>& v){
			if(this != &v){
				delete[] _start;
				_start = new T[v.capacity()];
				memcpy(_start, v._start, sizeof(T)*v.size());
			}
			return *this;
		}*/

		// v1 = v3  現代寫法
		Vector<T>& operator=(Vector<T> v){
			swap(v);
			return *this;
		}

		// 自定義類型涉及深拷貝建議自己實現swap（僅指針交換代價小）
		void swap(Vector<T>& v){
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_endofstorage, v._endofstorage);
		}

		~Vector(){
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		void reserve(size_t n){
			if (n > capacity()){
				// 開闢新空間
				size_t sz = size();
				T* temp = new T[n];
				if (_start){
					memcpy(temp, _start, sizeof(T)*sz);
					delete[] _start;
				}
				_start = temp;
				_finish = temp + sz;
				_endofstorage = temp + n;
			}
		}

		void resize(size_t n, const T& val = T()){
			if (n < size()){
				_finish = _start + n;
			}
			else{
				if (n>capacity()){
					reserve(n);
				}
				while (_finish < _start + n){
					*_finish = val;
					++_finish;
				}
			}
		}

		void push_back(const T& val){
			if (_finish == _endofstorage){
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			++_finish;
		}

		void pop_back(){
			assert(_start < _finish);
			--_finish;
		}

		void insert(iterator pos, const T& val){
			assert(pos >= _start&&pos <= _finish);
			if (_finish == _endofstorage){
				size_t n = pos - _start;
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
				// 增容原來的pos會失效
				pos = _start + n;
			}
			// 定義開始挪動的位置
			iterator end = _finish - 1;
			while (pos <= end){
				*(end + 1) = *end;
				--end;
			}

			*pos = val;
			++_finish;
		}

		iterator erase(iterator pos){
			assert(pos < _finish);
			iterator it = pos;
			while (it < _finish){
				*it = *(it + 1);
				++it;
			}
			--_finish;

			// 返回當前位置的下一個位置
			return pos;
		}

		T& operator[](size_t i){
			assert(i < size());
			return _start[i];
		}

		const T& operator[](size_t i)const{
			assert(i < size());
			return _start[i];
		}

		size_t size() const{
			return _finish - _start;
		}

		size_t capacity() const{
			return _endofstorage - _start;
		}

		iterator begin(){
			return _start;
		}

		iterator end(){
			return _finish;
		}

		const_iterator begin()const{
			return _start;
		}

		const_iterator end()const{
			return _finish;
		}

	private:
		iterator _start; // 開始位置
		iterator _finish; // 最後一個位置的下一個位置
		iterator _endofstorage; // 相當於capacity
	};

	void test_vector1(){
		Vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		v.pop_back();

		v.insert(v.begin(), 0);

		v.erase(v.begin());

		v.resize(10);

		Vector<int>::iterator it = v.begin();
		while (it != v.end()){
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (const auto& e : v){
			cout << e << " ";
		}
		cout << endl;

		for (size_t cur = 0; cur < v.size(); cur++){
			cout << v[cur] << " ";
		}
		cout << endl;
	}

	void test_vector2(){
		Vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		Vector<int> v2(v1);

		for (size_t cur = 0; cur < v2.size(); cur++){
			cout << v2[cur] << " ";
		}
		cout << endl;

		Vector<int> v3;
		v3.push_back(10);
		v3.push_back(20);
		v3.push_back(30);
		v3.push_back(40);
		v3.push_back(50);

		v1 = v3;
		for (size_t cur = 0; cur < v1.size(); cur++){
			cout << v1[cur] << " ";
		}
		cout << endl;
	}
}

使用memcpy的拷貝問題：

memcpy是內存的二進制格式拷貝（按字節），將一段內存空間中內容原封不動的拷貝到另外一段內存空間中

如果拷貝的是內置類型的元素，memcpy即高效又不會出錯，但如果拷貝的是自定義類型元素，並且自定義類型元素中涉及到資源管理時，就會出錯，因爲memcpy的拷貝實際是淺拷貝。

舉個栗子：

容量不夠調用reserve增容，拷貝數據使用memcpy。

void reserve(size_t n){
	if (n > capacity()){
		// 開闢新空間
		size_t sz = size();
		T* temp = new T[n];
		if (_start){
			memcpy(temp, _start, sizeof(T)*sz);
			delete[] _start;
		}
		_start = temp;
		_finish = temp + sz;
		_endofstorage = temp + n;
	}
}

注意：如果T是自定義類型，使用memcpy拷貝數據後，新空間中被拷貝過來指針會指向被釋放的舊空間，這時_str也就被稱爲野指針。

解決辦法：

採用賦值，將對象進行賦值操作，進行深拷貝。

這就變爲了兩個對象之間的賦值操作，不會指向同一空間。

void reserve(size_t n){
	if (n > capacity()){
		// 開闢新空間
		size_t sz = size();
		T* temp = new T[n];
		if (_start){
			//memcpy(temp, _start, sizeof(T)*sz);
			for (size_t i = 0; i < sz; ++i){
				temp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = temp;
		_finish = temp + sz;
		_endofstorage = temp + n;
	}
}

結論：如果對象中涉及到資源管理時，千萬不能使用memcpy進行對象之間的拷貝，因爲memcpy是淺拷貝，否則可能會引起內存泄漏甚至程序崩潰。

STL容器_vector類

前言

一：標準庫中的vector類

1.1 vector類的常用接口

1.2 vector迭代器失效問題

二：vector類的深度剖析及模擬實現

面向對象程序設計的三大特性（三）：C++中的多態

IPC：進程間的通信方式

Linux網絡套接字編程（socket詳解）

面向對象程序設計的三大特性（二）：C++中的繼承

STL容器_string類以及string類的模擬實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結