04.向量容器+迭代器+空間配置器

容器：順序容器/關聯容器

順序容器：

向量容器vector、雙端隊列 deque、雙向鏈表 list。

元素在容器中的位置同元素的值無關，即容器不是排序的。

vector 是可變長的動態數組。#include <vector>。查找速度快，但插入、刪除不盡人意。可以嵌套形成二維動態數組vector<vector<int> > v(3); //v有3個元素，每個元素都是vector<int> 容器。

list是雙向鏈表容器。#include <list>。查找速度慢，但插入刪除快。不支持隨機訪問，所以STL中算法sort無法對list排序。但list容器引入了sort成員函數來完成排序。

deque雙端隊列容器。#include <deque>。vector頭插較慢，尾插較快。deque頭尾都挺快。首先動態開闢二維數組，並且還有一個小塊的一維數組(最開始開闢能存放兩個指針的空間)用指針來管理這個二維數組。當擴容的時候首先擴容這個一維的，再2倍擴容存放數據的空間，並且是再原有的基礎上前面放一塊，後面放一塊。從而保證始終都可以頭查和尾插。但因爲是動態開闢的空間，所以並不連續。

關聯容器：

關聯容器：set、multiset、map、multimap。

關聯容器內的元素是排序的。插入元素時，容器會按一定的排序規則將元素放到適當的位置上，因此插入元素時不能指定位置。（默認情況下，從小到大排序）

容器適配器：

棧 stack、隊列 queue、優先級隊列 priority_queue。容器適配器沒有迭代器。容器適配器，就是對容器的一個封裝。

eg：棧stack和隊列queue底下使用的就是deque實現。

爲啥用deque不用vector ：初期開闢的空間多，效率高(vector最開始只開闢1字節，後進行2倍擴容)。 並且再擴容的時候，deque只需要複製地址，而vector需要拷貝數據。

優先隊列priority_queue選的是vector，vector可以計算下標，deque不連續，無法計算。

容器都是類模板。它們實例化後就成爲容器類。用容器類定義的對象稱爲容器對象。

 

迭代器：正向/反向迭代器

要訪問容器中的元素，需要通過“迭代器（iterator）”進行。迭代器相當於容器和操縱容器的算法之間的中介。迭代器可以指向容器中某個元素，通過*可以訪問容器元素，所以與指針類似。

迭代器的設計：每個數據類型都有自己的迭代器，並不是共用一個迭代器。

迭代器的目的：是用戶脫離容器。不需要關心底層實現。

迭代器的定義：迭代器類型設計成了容器類型的嵌套類型。

正向迭代器：容器類名::iterator  迭代器名;

反向迭代器：容器類名::reverse_iterator  迭代器名;

正反迭代器的區別：

• 正向迭代器進行++操作時，迭代器會指向容器中的後一個元素；調用begin函數返回第一個元素的迭代器，從前向後遍歷。
• 反向迭代器進行++操作時，迭代器會指向容器中的前一個元素；調用rbegin函數返回最後一個元素的迭代器，從後向前遍歷。

按迭代器的功能分類：正向迭代器，反向迭代器(可以使用--運算符)，隨機訪問迭代器(可以使用+=，<等。還支持隨機訪問p[i])。

vector	隨機訪問
deque	隨機訪問
list	雙向
set / multiset	雙向
map / multimap	雙向

迭代器的輔助函數

#include <algorithm>  //使用STL算法需要包含此頭文件

STL 中有用於操作迭代器的三個函數模板，它們是：

• advance(p, n)：使迭代器 p 向前或向後移動 n 個元素。
• distance(p, q)：計算兩個迭代器之間的距離，即迭代器 p 經過多少次 + + 操作後和迭代器 q 相等。如果調用時 p 已經指向 q 的後面，則這個函數會陷入死循環。
• iter_swap(p, q)：用於交換兩個迭代器 p、q 指向的值。

空間配置器 ：Allocator

由於new關鍵字在申請對象內存的時候不僅會申請內存還會構造很多對象，但很多時候，這些對象我們其實並不需要使用。我們只需要在使用這個空間的時候在構造對象。
所以我們需要將開闢內存(allocate)和構造對象(construst)分開使用。就有了Allocator空間配置器。（delete同理）

實現簡單的向量容器+迭代器+空間配置器

template<typename T>
struct Allocator
{
	// allocate開闢內存
	T* allocate(size_t size)
	{
		return (T*)malloc(size);  malloc只申請空間，並不構造對象
	}

	// deallocate釋放內存
	void deallocate(void *ptr)
	{
		free(ptr);  只釋放空間
	}

	// construct構造對象
	void construct(void *ptr, const T &val)
	{
		// new   定位new 
		new (ptr) T(val);  表示在ptr指向的內存，構造一個值爲val的對象
	}

	//destroy析構對象   
	void destroy(T *ptr)
	{
		ptr->~T();  只析構對象，並不釋放內存。構造函數不能自己單獨調用，析構函數可以
	}
};

template<typename T>
class Vector
{
public:
	Vector(int size=10):mSize(size),mCur(0)
	{
		//mpVec = new T [size];
		mpVec = allocator.allocate(size * sizeof(T));

	}
	~Vector()
	{
		//delete[] mpVec;
		for(int i = 0 ; i < mCur ; ++i)
		{
			allocator.destroy(mpVec + i);
		}
		allocator.deallocate(mpVec);
		mpVec = NULL;
	}
	Vector(const Vector &src)
	{
		mSize = src.mSize;
		mCur = src.mCur;
		//mpVec = new T [src.mSize];
		mpVec = allocator.allocate(mCur * sizeof(T));
		for(int i = 0;i < src.mCur;++i)  由於使用類模板，所以不能使用memcpy，防止淺拷貝的發生。
		{
			//mpVec[i] = src.mpVec[i];
			allocator.constructa(mpVec + i, src.mpVec[i]);
		}
	}
	Vector<T>& operator=(const Vector<T> &src)  只要返回的東西還活着就返回引用。
                                 返回引用就可以當作左值(不是立即數，立即數是通過寄存器返回的)。
	{
		if(mpVec == src.mpVec)
		{
			return *this;
		}
		//delete[] mpVec;
		for(int i = 0 ; i < mCur ; ++i)
		{
			allocator.destroy(mpVec + i);
		}
		//mpVec = new T [src.mSize];
		mpVec = allocator.allocate(src.mSize * sizeof(T));
		for(int i = 0;i < src.mCur;++i)
		{
			//mpVec[i] = src.mpVec[i];
			allocator.constructa(mpVec + i, src.mpVec[i]);
		}
		mSize = src.mSize;
		mCur = src.mCur;
		return *this;
	}

	int operator [] (int i)
	{
		return mpVec[i];
	}

	void push_back(const T &val)  // 從末尾給向量容器添加元素
	{
		if(mCur == mSize)
		{
			reSize();
		}
		//mpVec[mCur++] = val;
		allocator.construct(mpVec + mCur,val);
		mCur++;
	}

	void pop_back() // 從末尾刪除向量容器的元素
	{
		if(mCur == 0)
		{
			return ;
		}
		mCur--;
		allocator.destroy(mpVec + mCur);
	}

	給向量容器Vector實現迭代器
	class iterator
	{
	public:
		iterator(T *pos):mp(pos)
		{}
		bool operator != (const iterator &src)
		{
			return mp != src.mp;
		}
		void operator ++ ()
		{
			mp++;
		}
		T operator * ()
		{
			return *mp;
		}
	private:
		T *mp;
	};
	iterator begin()// 返回首元素迭代器
	{
		return iterator(mpVec);
	}
	iterator end() // 返回末尾後繼位置的迭代器
	{
		return iterator(mpVec + mCur);
	}
private:
	T *mpVec;
	int mSize;  // 擴容的總大小
	int mCur;   // 當前元素的個數
	Allocator<T> allocator;//空間配置器

	friend ostream& operator<<(ostream &out, const Vector<T> &src);
	void reSize() // 向量容器擴容函數，默認2倍擴容
	{
		T *tmp = new T [mSize * 2];
		mSize *= 2;
		for(int i = 0;i < mCur;++i)
		{
			tmp[i] = mpVec[i];
		}
		delete[] mpVec;
		mpVec = tmp;
	}
};

template<ypename T>
ostream& operator<<(ostream &out, const Vector<T> &src)
{
	out << src.mpVec;
	return out;
}