vector(栈)的一些常用方法实现

#ifndef MYVECTOR_H
#define MYVECTOR_H

#define SAFE_DELARR(p) {if(p){delete []p;p=nullptr;}}

template<class T>
class myvector
{
public:
	struct iterator
	{
		iterator()
		{
			pData = nullptr;
		}
		iterator(iterator const &other)
		{
			pData = other.pData;
		}
		iterator& operator=(iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		iterator& operator ++()//前置++
		{
			++pData;
			return *this;
		}
		iterator operator ++(int)//后置++
		{
			iterator ret = *this;
			++pData;
			return ret;
		}
		iterator& operator --()//前置--
		{
			--pData;
			return *this;
		}
		iterator operator --(int)//后置--
		{
			iterator ret = *this;
			--pData;
			return ret;
		}
		T& operator*()
		{
			return *pData;
		}
		bool operator==(iterator const & other)
		{
			return pData == other.pData;
		}
		bool operator!=(iterator const & other)
		{
			return pData != other.pData;
		}
		int operator-(iterator const &other)
		{
			return pData - other.pData;
		}
		iterator operator+(int n)
		{
			iterator ret = *this;
			ret.pData += n;
			return ret;
		}
		iterator operator-(int n)
		{
			iterator ret = *this;
			ret.pData -= n;
			return ret;
		}
		T *pData;
	};
	struct const_iterator
	{
		T const *pData;
		const_iterator()
		{
			pData = nullptr;
		}
		const_iterator(const_iterator const &other)
		{
			pData = other.pData;
		}
		const_iterator(iterator const &other)
		{
			pData = other.pData;
		}
		const_iterator& operator=(const_iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		const_iterator& operator=(iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		const_iterator& operator++()
		{
			++pData;
			return *this;
		}
		const_iterator& operator++(int)
		{
			const_iterator ret = *this;
			++pData;
			return ret;
		}
		const_iterator& operator--()
		{
			--pData;
			return *this;
		}
		const_iterator& operator--(int)
		{
			const_iterator ret = *this;
			--pData;
			return ret;
		}
		T const & operator*() const
		{
			return *pData;
		}
		bool operator==(const_iterator const &other)
		{
			return pData == other.pData;
		}
		bool operator!=(const_iterator const &other)
		{
			return pData != other.pData;
		}
		int operator-(const_iterator const &other)
		{
			return pData - other.pData;
		}
		const_iterator operator+(int n)
		{
			const_iterator ret = *this;
			ret.pData += n;
			return ret;
		}
		const_iterator operator-(int n)
		{
			const_iterator ret = *this;
			ret.pData -= n;
			return ret;
		}
	};
	struct reverse_iterator
	{
		T *pData;
		reverse_iterator()
		{
			pData = nullptr;
		}
		reverse_iterator(reverse_iterator const &other)
		{
			pData = other.pData;
		}
		reverse_iterator& operator=(reverse_iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		reverse_iterator& operator++()
		{
			--pData;
			return *this;
		}
		reverse_iterator& operator++(int)
		{
			reverse_iterator ret = *this;
			--pData;
			return ret;
		}
		reverse_iterator& operator--()
		{
			++pData;
			return *this;
		}
		reverse_iterator& operator--(int)
		{
			reverse_iterator ret = *this;
			++pData;
			return ret;
		}
		T& operator*()
		{
			return *pData;
		}
		bool operator==(reverse_iterator const &other)
		{
			return pData == other.pData;
		}
		bool operator!=(reverse_iterator const &other)
		{
			return pData != other.pData;
		}
		int operator-(reverse_iterator const &other)
		{
			return other.pData - pData;
		}
		reverse_iterator operator+(int n)
		{
			reverse_iterator ret = *this;
			ret.pData -= n;
			return ret;
		}
		reverse_iterator operator-(int n)
		{
			reverse_iterator ret = *this;
			ret.pData += n;
			return ret;
		}
	};
	struct const_reverse_iterator
	{
		T const *pData;
		const_reverse_iterator()
		{
			pData = nullptr;
		}
		const_reverse_iterator(const_reverse_iterator const &other)
		{
			pData = other.pData;
		}
		const_reverse_iterator(reverse_iterator const &other)
		{
			pData = other.pData;
		}
		const_reverse_iterator& operator=(const_reverse_iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		const_reverse_iterator& operator=(reverse_iterator const &other)
		{
			pData = other.pData;
			return *this;
		}
		const_reverse_iterator& operator++()
		{
			--pData;
			return *this;
		}
		const_reverse_iterator& operator++(int)
		{
			const_reverse_iterator ret = *this;
			--pData;
			return ret;
		}
		const_reverse_iterator& operator--()
		{
			++pData;
			return *this;
		}
		const_reverse_iterator& operator--(int)
		{
			const_reverse_iterator ret = *this;
			++pData;
			return ret;
		}
		T const & operator*() const
		{
			return *pData;
		}
		bool operator==(const_reverse_iterator const &other)
		{
			return pData == other.pData;
		}
		bool operator!=(const_reverse_iterator const &other)
		{
			return pData != other.pData;
		}
		int operator-(const_reverse_iterator const &other)
		{
			return other.pData - pData;
		}
		const_reverse_iterator operator+(int n)
		{
			const_reverse_iterator ret = *this;
			ret.pData -= n;
			return ret;
		}
		const_reverse_iterator operator-(int n)
		{
			const_reverse_iterator ret = *this;
			ret.pData += n;
			return ret;
		}
	};
public:
	myvector()
	{
		m_pData = nullptr;
		m_DataNum = 0;
		m_Capacity = 0;
	}
	myvector(size_t count)
	{
		if (count >0)
		{
			m_pData = new T[count];
			memset(m_pData, 0, sizeof(T)*count);
		}
		else
		{
			m_pData = nullptr;
		}
		m_Capacity = count;
		m_DataNum = count;
	}
	myvector(size_t count, T const &data)
	{
		if (count > 0)
		{
			m_pData = new T[count];
			for (int i = 0; i < count;++i)
			{
				m_pData[i] = data;
			}
		}
		else
		{
			m_pData = nullptr;
		}
		m_Capacity = count;
		m_DataNum = count;
	}
	myvector(myvector const &other)
	{
		if (other.m_DataNum)
		{
			m_pData = new T[other.m_DataNum];
			for (int i = 0; i < other.m_DataNum;++i)
			{
				this->m_pData[i] = other.m_pData[i];
			}
		}
		else
		{
			m_pData = nullptr;
		}
		m_DataNum = other.m_DataNum;
		m_Capacity = other.m_Capacity;

	}
	void assign(size_t count, T const &data)
	{
		SAFE_DELARR(m_pData);
		if (count > 0)
		{
			m_pData = new T[count];
			for (int i = 0; i < count; ++i)
			{
				m_pData[i] = data;
			}
		}
		else
		{
			m_pData = nullptr;
		}
		m_Capacity = count;
		m_DataNum = count;

	}
	template <class Tpt>
	void assign(Tpt first, Tpt last)
	{
		int count = last - first;
		if (count > 0)
		{
			if (count > m_Capacity)
			{
				SAFE_DELARR(m_pData);
				m_pData = new T[count];
				m_Capacity = count;
			}
			Tpt tpt;
			int index = 0;
			for (tpt = first; tpt != last;++tpt)
			{
				m_pData[index++] = *tpt;
			}
			m_DataNum = count;
		}
		else
		{
			m_DataNum = 0;
		}
	}
	T& at(int sit)
	{
		if (sit < 0 || sit >= m_DataNum)
		{
			throw "invaild index";
		}
		return m_pData[sit];
	}
	T const & at(int sit) const
	{
		if (sit < 0 || sit >= m_DataNum)
		{
			throw "invaild index";
		}
		return m_pData[sit];
	}
	iterator begin()
	{
		iterator ret;
		ret.pData = m_pData;
		return ret;
	}
	const_iterator begin() const
	{
		const_iterator cret;
		cret.pData = m_pData;
		return cret;
	}
	iterator end() //指向最后一个有效元素的下一个（无用）
	{
		iterator ret;
		ret.pData = m_pData + m_DataNum;
		return ret;
	}
	const_iterator end() const
	{
		const_iterator cret;
		cret.pData = m_pData + m_DataNum;
		return cret;
	}
	reverse_iterator rbegin()
	{
		reverse_iterator ret;
		ret.pData = m_pData + m_DataNum - 1;
		return ret;
	}
	const_reverse_iterator rbegin() const
	{
		const_reverse_iterator cret;
		cret.pData = m_pData + m_DataNum - 1;
		return cret;
	}
	reverse_iterator rend()
	{
		reverse_iterator ret;
		ret.pData = m_pData - 1;
		return ret;
	}
	const_reverse_iterator rend() const
	{
		const_reverse_iterator cret;
		cret.pData = m_pData - 1;
		return cret;
	}
	iterator erase(iterator where)
	{
		iterator pt;
		for (pt = where; pt != end() - 1;++pt)
		{
			*pt = *(pt + 1);
		}
		--m_DataNum;
		return where;
	}
	iterator erase(iterator first, iterator last)
	{
		int count = last - first;
		if (count > 0)
		{
			for (iterator fpt = first, iterator lpt = last;lpt!=end(); ++fpt, ++lpt)
			{
				*fpt=*lpt;
			}
		}
		else
		{
			if (count < 0)
			{
				throw "invaild index";
			}
		}
	}
	iterator insert(iterator where, T const &data)
	{
		if (m_DataNum >= m_Capacity)
		{
			int sit = where - begin();
			int newsize = m_Capacity + ((m_Capacity / 2) ? (m_Capacity / 2) : 1);
			T *pNewData = new T[newsize];
			if (m_pData)
			{
				for (int i = 0; i < m_DataNum; ++i)
				{
					pNewData[i] = m_pData[i];
				}
				SAFE_DELETE(m_pData);
			}
			m_pData = pNewData;
			pNewData = nullptr;
			m_Capacity = newsize;
			where = begin() + sit;
		}

		for (iterator pt = end(); pt != where; --pt)
		{
			*pt=*(pt - 1);
		}
		*where = data;
		++m_DataNum;
		return where;

	}

	T& back()
	{
		if (m_DataNum <=0)
		{
			throw "invaild index";
		}
		return m_pData[m_DataNum - 1];
	}
	T const & back() const
	{
		if (m_DataNum <= 0)
		{
			throw "invaild index";
		}
		return m_pData[m_DataNum - 1];
	}
	size_t capacity()
	{
		return m_Capacity;
	}
	void Clear()
	{
		m_DataNum = 0;
	}
	bool empty() const
	{
		return m_DataNum <= 0;
	}
	T& front()
	{
		if (m_DataNum <= 0)
		{
			throw "invaild index";
		}
		return m_pData[0];
	}
	T const & front() const
	{
		if (m_DataNum <= 0)
		{
			throw "invaild index";
		}
		return m_pData[0];
	}
	size_t max_size() const
	{
		return 0xffffffff / sizeof(T);
	}
	void pop_back()
	{

		if (m_DataNum <= 0)
		{
			throw "invaild index";
		}
		--m_DataNum;
	}
	void push_back(T const &data)
	{
		if (m_DataNum >=m_Capacity)
		{
			int _newsize = m_Capacity + ((m_Capacity / 2) ? (m_Capacity / 2): 1);
			T * _pNewData = new T[_newsize];
			if (m_pData)
			{
				for (int i = 0; i < m_DataNum; ++i)
				{
					_pNewData[i] = m_pData[i];
				}
				SAFE_DELARR(m_pData);
			}
			m_pData = _pNewData;
			m_Capacity = _newsize;
		}
		m_pData[m_DataNum++]=data;
	}
	void resize(size_t count)
	{
		if (count <= m_DataNum)
		{
			m_DataNum = count;
		}
		else
		{
			if (count > m_DataNum)
			{
				T *pNewData = new T[count];
				if (m_pData)
				{
					for (int i = 0; i < m_DataNum; ++i)
					{
						pNewData[i] = m_pData[i];
					}
					SAFE_DELETE(m_pData);
				}
				m_pData = pNewData;
				pNewData = nullptr;
				m_Capacity = count;
			}
			memset(m_pData + m_DataNum, 0, sizeof(T)*(count - m_DataNum));
			m_DataNum = count;
		}
	}
	void resize(size_t count, T const &data)
	{
		if (count <= m_DataNum)
		{
			m_DataNum = count;
		}
		else
		{
			if (count > m_DataNum)
			{
				T *pNewData = new T[count];
				if (m_pData)
				{
					for (int i = 0; i < m_DataNum; ++i)
					{
						pNewData[i] = m_pData[i];
					}
					SAFE_DELETE(m_pData);
				}
				m_pData = pNewData;
				pNewData = nullptr;
				m_Capacity = count;
			}
			for (int i = m_DataNum; i < count;++i)
			{
				m_pData[i] = data;
			}
			m_DataNum = count;
		}
	}
	void reserve(size_t count)//扩容
	{
		if (count > m_Capacity)
		{
			T *pNewData = new T[count];
			if (m_pData)
			{
				for (int i = 0; i < m_DataNum; ++i)
				{
					pNewData[i] = m_pData[i];
				}
				SAFE_DELETE(m_pData);
			}
			m_pData = pNewData;
			pNewData = nullptr;
			m_Capacity = count;
		}
	}
	size_t size() const
	{
		return m_DataNum;
	}
	void swap(myvector &other)
	{
		int intswap = 0;
		T *pSwap = nullptr;

		pSwap = this->m_pData;
		this->m_pData = other.m_pData;
		other.m_pData = pSwap;

		intswap = this->m_DataNum;
		this->m_DataNum = other.m_DataNum;
		other.m_DataNum = intswap;

		intswap = this->m_Capacity;
		this->m_Capacity = other.m_Capacity;
		other.m_Capacity = intswap;

	}
	T& operator[](int sit)
	{
		if (sit < 0 || sit >=m_DataNum)
		{
			throw "invaild index";
		}
		return m_pData[sit];
	}
	T const & operator[](int sit) const
	{
		if (sit < 0 || sit >= m_DataNum)
		{
			throw "invaild index";
		}
		return m_pData[sit];
	}
	~myvector()
	{
		SAFE_DELARR(m_pData);
		m_DataNum = 0;
		m_Capacity = 0;
	}
protected:
	T *m_pData;
	int m_DataNum;
	int m_Capacity;
};
#endif