自己实现简单的类vector容器

爱被打了一巴掌 2022-05-15 10:54 225阅读 0赞

只是一个简单的类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