vector的介紹

vector是表示可變大小數組的序列容器。
就像數組一樣，vector也採用連續存儲空間來存儲元素。也就是意味着可以採用下標對vector的元素進行訪問，和數組一樣高效。但是又不像數組，它的大小是可以動態改變的，而且它的大小會被容器自動處理。
本質講，vector使用動態分配數組來存儲它的元素。當新元素插入時候，這個數組需要被重新分配大小爲了增加存儲空間。其做法是，分配一個新的數組，然後將全部元素移到這個數組。就時間而言，這是一個相對代價高的任務。每當一個新的元素加入到容器的時候，vector並不會每次都重新分配大小。
vector分配空間策略：vector會分配一些額外的空間以適應可能的增長，因爲存儲空間比實際需要的存儲空間更大。不同的庫採用不同的策略權衡空間的使用和重新分配。但是無論如何，重新分配都應該是對數增長的間隔大小，以至於在末尾插入一個元素的時候是在常數時間的複雜度完成的。
因此，vector佔用了更多的存儲空間，爲了獲得管理存儲空間的能力，並且以一種有效的方式動態增長。
與其它動態序列容器相比（deque, list）， vector在訪問元素的時候更加高效，在末尾添加和刪除元素相對高效。對於其它不在末尾的刪除和插入操作，效率更低。
使用vector時必須加上頭文件#include<vector>和using namespace std;

vector的基本使用

vector的定義

構造函數聲明	接口說明
vector()	無參構造
vector(size_t n, const value_type& val = value_type())	構造並初始化n個val
vector(const vector& x)	拷貝構造
vector(InputIterator first, InputIterator last)	使用迭代器進行初始化構造

    vector<int> v1;                       // empty vector of ints
    vector<int> v2(4, 100);               // four ints with value 100
    vector<int> v3(v2.begin(), v2.end()); // iterating through v2
    vector<int> v4(v3);                   // a copy of v3

    int arr[] = { 16,2,77,29 };           // iterating through arr
    vector<int> v5(arr, arr + sizeof(arr) / sizeof(arr[0]));

vector迭代器的使用

iterator的使用	接口說明
begin + end	begin獲取第一個數據位置的iterator/const_iterator, end獲取最後一個數據的下一個位置的iterator/const_iterator
rbegin + rend	rbegin獲取最後一個數據位置的reverse_iterator, rend獲取第一個數據前一個位置的reverse_iterator

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

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

int main()
{
    // 使用push_back插入4個數據
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);

    // 使用迭代器進行遍歷打印
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    // 使用迭代器進行修改
    it = v.begin();
    while (it != v.end())
    {
        *it *= 2;
        cout << *it << " ";
        ++it;
    }
    cout << endl;

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

    // 使用const迭代器進行遍歷再打印
    PrintVector(v);

    return 0;
}

vector空間增長問題

容量空間	接口說明
size	獲取數據個數
capacity	獲取容量大小
empty	判斷是否爲空
resize	改變vector的size
reserve	改變vector的capacity

capacity的代碼在vs和g++下分別運行會發現，vs下capacity是按1.5倍增長的，g++是按2倍增長的。不要固化的認爲，順序表增容都是2倍，具體增長多少是根據具體的需求定義的。vs是PJ版本STL，g++是SGI版本STL。
reserve只負責開闢空間，如果確定知道需要用多少空間，reserve可以緩解vector增容的代價缺陷問題。
resize在開空間的同時還會進行初始化，影響size。

    // vector 的增容   VS中1.5倍增長   Linux中2倍增長
    vector<int> v;
    size_t sz = v.capacity();
    cout << sz << endl;
    cout << "making v grow:" << endl;
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << endl;
        }
    }

vector增刪查改

vector增刪查改	接口說明
push_back	尾插
pop_back	尾刪
find	查找（注意這個是算法模塊實現，不是vector的成員接口）
insert	在pos之前插入val
erase	刪除pos位置的數據
swap	交換兩個vector的數據空間
operator[]	像數組一樣訪問

//push_back、pop_back
void Test1()
{
    int arr[] = { 1, 2, 3, 4 };
    vector<int> v(arr, arr + sizeof(arr) / sizeof(arr[0]));
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

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

//find、erase、insert
void Test2()
{
    int arr[] = { 1, 2, 3, 4 };
    vector<int> v(arr, arr + sizeof(arr) / sizeof(int));

    // 使用find查找3所在位置的iterator
    vector<int>::iterator pos = std::find(v.begin(), v.end(), 3);

    // 在pos位置之前插入30
    v.insert(pos, 30);
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    pos = find(v.begin(), v.end(), 3);
    // 刪除pos位置的數據
    v.erase(pos);
    it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

//operator[]、範圍for
void Test3()
{
    int arr[] = { 1, 2, 3, 4 };
    vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));

    // 通過[]讀寫第0個位置。
    v1[0] = 10;
    cout << v1[0] << endl;

    // 通過[i]的方式遍歷vector
    for (size_t i = 0; i < v1.size(); ++i)
    {
        cout << v1[i] << " ";
    }     
    cout << endl;

    vector<int> v2;
    v2.swap(v1);

    cout << "v data:";
    for (size_t i = 0; i < v1.size(); ++i)
    {
        cout << v1[i] << " ";
    }      
    cout << endl;

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

    // C++11支持的新式範圍for遍歷
    for (auto e : v2)
    {
        cout << e << " ";
    }    
    cout << endl;
}

vector 迭代器失效問題
迭代器的主要作用就是讓算法能夠不用關心底層數據結構，其底層實際就是一個指針，或者是對指針進行了封裝，比如：vector的迭代器就是原生態指針 T*。因此迭代器失效，實際就是迭代器底層對應指針所指向的空間被銷燬了，而使用一塊已經被釋放的空間，造成的後果是程序崩潰(即如果繼續使用已經失效的迭代器，程序可能會崩潰)。

對於vector可能會導致其迭代器失效的操作有：

會引起其底層空間改變的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
指定位置元素的刪除操作：erase刪除pos位置元素後，pos位置之後的元素會往前搬移，沒有導致底層空間的改變，理論上講迭代器不應該會失效，但是：如果pos剛好是最後一個元素，刪完之後pos剛好是end的位置，而end位置是沒有元素的，那麼pos就失效了。因此刪除vector中任意位置上元素時，vs就認爲該位置迭代器失效了。

迭代器失效解決辦法：在使用前，對迭代器重新賦值即可。

vector的模擬實現（造輪子）

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

namespace MakeVector
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	public:
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

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

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

		//拷貝構造傳統寫法
		//vector(const vector<T>& v)
		//	: _start(nullptr)
		//	, _finish(nullptr)
		//	, _endofstorage(nullptr)
		//{
		//	_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 (auto e : v)
			{
				push_back(e);
			}
		}

		//賦值運算符傳統寫法
		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		delete[] _start;
		//		_start = new T[v.capacity()];
		//		_finish = _start;
		//		_endofstorage = _start + v.capacity();
		//		for (size_t i = 0; i < v.size(); ++i)
		//		{
		//			*_finish = v[i];
		//			++_finish;
		//		}
		//	}
		//	return *this;
		//}

		//賦值運算符現代寫法
		vector<T>& operator=(vector<T> v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
			return *this;
		}

		void reserve(size_t new_capacity)
		{
			if (new_capacity > capacity())
			{
				size_t sz = size();
				T* tmp = new T[new_capacity];
				if (_start)
				{
					//memcpy對於內置類型和自定義類型都是淺拷貝
					//memcpy(tmp, _start, sizeof(T) * sz);

					for (size_t i = 0; i < sz; ++i)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + new_capacity;
			}
		}

		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 new_capacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(new_capacity);
			}

			*_finish = val;
			++_finish;
		}

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

		iterator insert(iterator pos, const T& val)
		{
			assert(pos <= _finish);
			//擴容
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t new_capacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(new_capacity);
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = val;
			++_finish;
			return pos;
		}

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

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

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

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

		const size_t capacity() const
		{
			return _endofstorage - _start;
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}

STL容器：vector的簡介與使用

vector的介紹

vector的基本使用

vector的模擬實現（造輪子）

AI 畫圖真刺激，手把手教你如何用 ComfyUI 來畫出刺激的圖

公司剛入職了一名 Java 中級開發，短短 4 行代碼居然湊齊了 3 個 bug！我哭了~~

公衆號5月C#/.NET熱文一覽

git 下載大陸鏡像地址

美妙的STL

STL容器：list的簡介與使用

STL容器適配器：stack的簡介與使用

STL容器：deque的簡介與使用

STL容器：vector的簡介與使用

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

linux以太網驅動總結