自己实现简单的类vector容器

只是一个简单的类vector容器，其内存是连续的 ，类似于数组。暂未实现迭代器，等有时间再研究吧。代码比较容易理解，在此基础上可以进行扩展。

//---------------------------------------------------------------------
// vector_sp.h
// @Author		: Shaoguang.
// @Date		: 2018-08-28.
// @Abstract	: 实现简单的类vector容器.
//---------------------------------------------------------------------
#ifndef VECTORSP_H
#define VECTORSP_H

template <typename T>
class vector_sp
{
public:
	vector_sp()
	{
		m_nStepCount = 16;
		m_nEleCount = 0;
		m_nMemCount = 0;
		m_pT = NULL;
	}

	vector_sp(int nStepCount)
	{
		m_nStepCount = nStepCount > 0 ? nStepCount : 1;
		m_nEleCount = 0;
		m_nMemCount = 0;
		m_pT = NULL;
	}

	// 容器包含nCount个值为Value的元素
	vector_sp(int nCount, const T &Value)
	{
		m_nStepCount = 16;
		m_nEleCount = 0;
		m_nMemCount = 0;
		m_pT = NULL;

		while (nCount--)
		{
			Add(Value);
		}
	}

	// 构造一个vec_sp的副本容器
	vector_sp(const vector_sp &vec_sp)
	{
		m_nStepCount = 16;
		m_nEleCount = 0;
		m_nMemCount = 0;
		m_pT = NULL;

		CopyVector(vec_sp);
	}

	~vector_sp()
	{
		if (NULL != m_pT)
		{
			delete[]m_pT;
			m_pT = NULL;
		}
	}

public:
	// 设置扩容步长.
	void SetStep(int nStepCount)
	{
		m_nStepCount = nStepCount > 0 ? nStepCount : 1;
	}

	// 首元素指针
	T *First()
	{
		return m_pT;
	}

	// 末元素指针
	T *Last()
	{
		return m_pT + m_nEleCount - 1;
	}

	// 第n个元素指针
	T *GetAt(int nPosition)
	{
		return m_pT + nPosition;
	}

	// 第n个元素,返回元素的引用
	T &RefAt(int nIndex)
	{
		return m_pT[nIndex];
	}

	// 第n个元素
	T At(int nIndex)
	{
		return m_pT[nIndex];
	}

	// 重新分配内存
	void Resize(int nMemSize)
	{
		RemoveAll();
		m_nEleCount = 0;
		m_nMemCount = nMemSize;
		m_pT = new T[m_nMemCount];
	}

	// 取元素个数
	int Count() const
	{
		return m_nEleCount;
	}

	// 设置/修改某个元素的值
	void SetAt(int nIndex, const T &newElement)
	{
		m_pT[nIndex] = newElement;
	}

	// 移除某个元素
	void RemoveAt(int nIndex)
	{
		for (int i = 0; i < m_nEleCount; ++i)
		{
			m_pT[i] = m_pT[i + 1];
		}
		m_nEleCount--;
	}

	// 移除所有，清空内存
	void RemoveAll()
	{
		if (NULL != m_pT)
		{
			delete[]m_pT;
			m_pT = NULL;
		}
		m_nEleCount = 0;
		m_nMemCount = 0;
	}

	// 判断是否为空
	bool Empty()
	{
		return m_nEleCount < 1;
	}

	// 在末尾添加元素
	void Add(const T &newElement)
	{
		if (m_nEleCount == m_nMemCount)
		{
			T *pTemp = new T[m_nMemCount += m_nStepCount];
			for (int i = 0; i < m_nEleCount; ++i)
			{
				pTemp[i] = m_pT[i];
			}

			delete[]m_pT;
			m_pT = pTemp;
		}

		m_pT[m_nEleCount++] = newElement;
	}

	// 插入元素
	void Insert(int nIndex, const T &newElement)
	{
		Add(newElement);
		for (int i = m_nEleCount - 1; i > nIndex; i--)
		{
			m_pT[i] = m_pT[i - 1];
		}	

		m_pT[nIndex] = newElement;
	}

	// 在末尾添加一组元素
	void AddBlock(const T *pNewElement, int nCount)
	{
		while (nCount--)
		{
			Add(pNewElement[i]);
		}
	}

	// 在特定位置添加一组元素
	void AddBlockAt(int nIndex, const T *pNewElement, int nCount)
	{
		AddBlock(pNewElement, nCount);
		for (int i = m_nEleCount - 1; i > m_nEleCount - nCount - 1; i--)
		{
			m_pT[i] = m_pT[i - nCount];
		}

		for (int i = 0; i < nCount; ++i)
		{
			m_pT[nIndex + i] = pNewElement[i];
		}
	}

	// 操作符重载
	void operator=(const vector_sp &src)
	{
		CopyVector(src);
	}

	T &operator[](int nIndex)
	{
		return m_pT[nIndex];
	}

	bool operator==(const vector_sp &src)
	{
		if (m_nEleCount != src.m_nEleCount)
			return false;

		if (m_nEleCount > 0)
		{
			for (int i = 0; i < m_nEleCount; ++i)
			{
				if (m_pT[i] != src.m_pT[i])
					return false;
			}
		}

		return true;
	}

private:
	void CopyVector(const vector_sp &src)
	{
		if (m_nMemCount < src.m_nMemCount)
		{
			delete[] m_pT;
			m_nMemCount = src.m_nMemCount;
			m_pT = new T[m_nMemCount];
		}

		m_nEleCount = src.m_nEleCount;
		m_nStepCount = src.m_nStepCount;
		if (m_nEleCount < 1)
			return;
		for (int i = 0; i < m_nEleCount; ++i)
		{
			m_pT[i] = src.m_pT[i];
		}
	}

private:
	T		*m_pT;
	int		m_nEleCount;	// 元素个数.
	int		m_nMemCount;	// 总个数.
	int		m_nStepCount;	// 扩容步长.
}; // class vector_sp

#endif // !VECTORSP_H