VECTOR容器模拟

#pragma once
#include<assert.h>
template <class T>
class CMyvector {
	T* pBuff;
	size_t len;
	size_t maxSize;
public:
	struct MyIterator {
		T* pIt;
		MyIterator& operator =(MyIterator const& srcIt) {
			pIt = srcIt.pIt;
			return *this;
		}
		bool operator != (MyIterator const& srcIt) {
			return pIt != srcIt.pIt;
		}
		MyIterator& operator++() {
			pIt++;
			return *this;
		}
		MyIterator operator++(int) {
			MyIterator tempIt = *this;
			pIt++;
			return tempIt;
		}
		T& operator*() {
			return *pIt;
		}
		MyIterator operator+(int n) {
			MyIterator tempIt = *this;
			tempIt.pIt += n;
			return tempIt;
		}
		int operator-(MyIterator const& srcIt) {
			return pIt - srcIt.pIt;
		}
	};
	public:
		MyIterator begin() {
			MyIterator tempIt;
			tempIt.pIt = pBuff;
			return tempIt;
		}
		MyIterator end() {
			MyIterator tempIt;
			tempIt.pIt = pBuff + len;
			return tempIt;
		}
	public:
		MyIterator insert(MyIterator const& pos, MyIterator const& first, MyIterator const& second) {
			MyIterator tempit = pos;
			int n = second - first;
			for (int i = 0; i < n; i++) {
				tempit = insert(tempit, *(first + i));
			}
			return tempit;
		}
		MyIterator insert(MyIterator const& pos, T const& elem) {
			int index = pos.pIt - pBuff;
			if (len >= maxSize) {
				maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
				T* tempBuff = new T[maxSize];
				for (size_t i = 0; i < len; ++i) {
					tempBuff[i] = pBuff[i];
				}
				if (pBuff)
					delete[] pBuff;
				pBuff = tempBuff;
			}
			for (int i = (int)len; i > index; --i) {
				pBuff[i] = pBuff[i - 1];
			}
			pBuff[index] = elem;
			len++;
			MyIterator tempIt;
			tempIt.pIt = pBuff + index;
			return tempIt;
		}
	public:
		MyIterator erase(MyIterator const& pos) {
			int index = pos.pIt - pBuff;
			for (size_t i = index; i < len; i++) {
				pBuff[i] = pBuff[i + 1];
				len--;
				MyIterator tempIt;
				tempIt.pIt = pBuff + index;
				return tempIt;
			}
		}
		MyIterator erase(MyIterator const& first, MyIterator const& second) {
			int n = second - first;
			MyIterator tempIt = first;
			for (int i = 0; i < n; i++) {
				tempIt = erase(tempIt);
			}
			return tempIt;
		}
	public:
		CMyvector();
		CMyvector(int n);
		CMyvector(int n, T const& elsem);
		CMyvector(CMyvector const& other);
		~CMyvector();
		void pop_back();
		void push_back(T const& elem);
		void clear();
	public:
		size_t size() const;
		size_t capacity() const;
		bool empty() const;
	public:
		bool operator == (CMyvector const& srcvector) const;
		bool operator != (CMyvector const& srcvector) const;
		bool operator > (CMyvector const& srcvector) const;
	public:
		void swap(CMyvector& vector1);
		void assign(int n, T const& elem);
	public:
		T at(int index);
		T operator[] (int index);
		T front();
		T back();
	public:
		void resize(int num);
		void resize(int num, T const& elem);
		void reserve(int n);

};
	template <class T>
	void CMyvector<T>::reserve(int n) {
		if (n > maxSize) {
			maxSize = n;
			T* tempBuff = new T[maxSize];
			for (size_t i = 0; i < len; i++) {
				tempBuff[i] = pBuff[i];
			}
			if (pBuff) {
				delete[] pBuff;
			}
			pBuff = tempBuff;
		}
	}
	template <class T>
	void CMyvector<T>::resize(int num, T const& elem) {
		if (num < 0) {
			assert(NULL);
		}
		if (num > maxSize) {
			maxSize = num;
			T* tempBuff = new T[maxSize];
			for (size_t i = 0; i < len; i++) {
				tempBuff[i] = pBuff[i];
			}
			if (pBuff) {
				delete[] pBuff;
			}
			pBuff = tempBuff;
		}
		if (num > len) {
			for (int i = len; i < num; i++) {
				pBuff[i] = elem;
			}
	}
		len = num;
	}
	template<class T>
	void CMyvector<T>::resize(int num) {
		if (num < 0)
			assert(NULL);
		if (num > maxSize) {
			maxSize = num;
			T* tempBuff = new T[maxSize];
			for (size_t i = 0; i < len; ++i) {
				tempBuff[i] = pBuff[i];
			}
			if (pBuff) {
				delete[] pBuff;
			}
			pBuff = tempBuff;
		}
		len = num;
	}
	template<class T>
	void CMyvector<T>::pop_back() {
		len--;
	}
	template<class T>
	void CMyvector<T>::push_back(T const& elem) {
		if (len >= maxSize) {
			maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
			T* tempBuff = new T[maxSize];
			for (size_t i = 0; i < len; i++) {
				tempBuff[i] = pBuff[i];
			}
			if (pBuff) {
				delete[] pBuff;
			}
			pBuff = tempBuff;

		}
		pBuff[len++] = elem;
	}
	template<class T>
	T CMyvector<T>::back() {
		return pBuff[len - 1];
	}
	template <class T>
	T CMyvector<T>::front() {
		return pBuff[0];
	}
	template <class T>
	T CMyvector<T>::operator[](int index) {
		return pBuff[index];
	}
	template<class T>
	T CMyvector<T>::at(int index){
		if (index < 0 || index >= len) {
			throw "out_of_range";
			return pBuff[index];
	}
	}
		template<class T>
	void CMyvector<T>::assign(int n, T const& elem) {
		clear();
		len = maxSize = n;
		if (maxSize > 0) {
			pBuff = new T[maxSize];
			for (size_t i = 0; i < len; i++) {
				pBuff[i] = elem;
			}
		}
	}
	template<class T >
	void CMyvector<T>::swap(CMyvector& vector1) {
		T* tempBuff = pBuff;
		size_t templen = len;
		size_t tempMaxsize = maxSize;

		pBuff = vector1.pBuff;
		len = vector1.len;
		maxSize = vector1.maxsize;

		vector1.pBuff = tempBuff;
		vector1.len = templen;
		vector1.maxsize = tempMaxsize;
	}
	template<class T>
	bool CMyvector<T>::operator>(CMyvector const& srcvector)const {
		size_t minlen = len < srcvector.len ? len : srcvector.len;
		for (size_t i = 0; i < minlen; ++i) {
			if (pBuff[i] > srcvector.pBuff[i]) {
				return true;
			}
			if (pBuff[i] < srcvector.pBuff[i]) {
				return false;
			}
		}
		if (len == minlen) {
			return false;
		}
		return true;
	}

	template <class T>
	bool CMyvector<T>::operator != (CMyvector const& srcvector)const
	{
		return !(*this == srcvector);
	}
	template<class T>
	bool CMyvector<T>::operator==(CMyvector const& srcvector)const
	{
		if (this == &srcvector)
			return true;
		if (len != srcvector.len)
			return false;
		for (int i = 0; i < len; i++) {
			if (pBuff[i] != srcvector.pBuff[i])
				return false;
		}
		return true;
	}
	template <class T>
	bool CMyvector<T>::empty()const {
		return len == 0;
	}
	template<class T>
	size_t CMyvector<T>::capacity() const {
		return maxSize;
	}
	template<class T>
	size_t CMyvector<T>::size() const {
		return len;
	}
	template <class T>
	CMyvector<T>::CMyvector(int n, T const& elem) {
		if (n < 0) {
			pBuff = nullptr;
			len = maxSize = 0;
		}
		else {
			len = maxSize = n;
			pBuff = new T[maxSize];
			for (int i = 0; i < len; i++) {
				pBuff[i] = elem;
			}
		}
	}
	template <class T>
	CMyvector<T>::CMyvector(CMyvector const& other) {
		len = other.len;
		maxSize = other.maxSize;
		pBuff = nullptr;
		if (maxSize > 0) {
			pBuff = new T[maxSize];
			for (int i = 0; i < len; i++) {
				pBuff[i] = other.pBuff[i];
			}
		}
	}
	template<class T>
	CMyvector<T>::CMyvector(int n) {
		if (n < 0) {
			pBuff = nullptr;
			len = maxSize = n;

		}
		else {
			len = maxSize = 0;
			pBuff = new T[maxSize];


		}
	}
template<class T >
void CMyvector<T>::clear() {
	if (pBuff)
		delete[] pBuff;
	pBuff = nullptr;
	len = 0;
	maxSize = 0;
}
template<class T>
CMyvector<T>::~CMyvector() {
	pBuff = nullptr;
	len = 0;
	maxSize = 0;
}