[逆向]容器的实现（c++）

#include 
#include 
using namespace std;
#define SUCCESS 1 //成功
#define ERROR -1 //失败
#define MALLOC_ERROR -2//申请内存失败
#define INDEX_ERROR -3//错误的索引号


template 
class Vector
{
public:
	Vector();
	~Vector();
	Vector(DWORD dwSize);

public:
	DWORD   push_back(T Element); //将元素存储到容器的最后一个元素
	VOID	pop_back();//抹除最后一个元素
	DWORD	insert(DWORD dwIndex, T Element);//将元素插入到指定索引值
	DWORD	capacity();//返回容器的剩余容量
	VOID	clear();//清除
	T		at(DWORD dwIndex);//返回对应索引的值
	BOOL	empty();//判断Vector是否为空 返回true时为空			
	DWORD	erase(DWORD dwIndex);//删除指定元素			
	DWORD	size();	//返回Vector元素数量的大小	
	VOID	print();//打印容器内的所有内容

private:
	BOOL expand();

private:
	DWORD m_dwIndex;//下一个可用索引
	DWORD m_dwIncrement;//每次增容的大小
	DWORD m_dwLen; //当前容器的长度
	DWORD m_dwInitSize;//默认初始化大小
	T* m_pVector;//容器指针
	
};

template 
Vector::Vector():m_dwInitSize(10),m_dwIncrement(5)
{
	//1.创建长度为m_dwInitSize个T对象
	m_pVector = new T[m_dwInitSize];
	
	//2.将新创建的空间初始化
	memset(m_pVector, 0, sizeof(T) * m_dwInitSize);

	//设置其他值
	m_dwIndex = 0;
	m_dwLen = m_dwInitSize;
}


template 
Vector::~Vector()
{
	delete[] m_pVector;
	m_pVector = nullptr;
}


template 
Vector::Vector(DWORD dwSize):m_dwIncrement(5)
{
	//创建dwSize个T对象的数组
	m_pVector = new T[dwSize];

	//将创建的空间初始化
	memset(m_pVector, 0, sizeof(T) * dwSize);
	
	//设置其他值
	m_dwIndex = 0;
	m_dwLen = dwSize;
}

template 
BOOL Vector::expand()
{
	DWORD dwTempLen = m_dwLen+m_dwIncrement;//增加后的长度
	T* pTemp = new T[dwTempLen];//创建一个新的空间
	
	memcpy_s(pTemp, dwTempLen, m_pVector, m_dwLen);//将数据复制到新的空间

	delete[] m_pVector;//释放掉原来的空间
	pTemp = nullptr;

	//为各种属性赋值
	m_dwLen = dwTempLen;
	return SUCCESS;
}

template 
DWORD  Vector::push_back(T Element)
{
	//1.判断是否需要增容，如果需要就需要调用增容的函数
	if (m_dwIndex >= m_dwLen)
	{
		expand();
	}

	//将新的元素放入容器(放在最后一个位置)
	memcpy_s(&m_pVector[m_dwIndex], sizeof(T), &Element, sizeof(T));
	
	//修改属性
	m_dwIndex++;
	return SUCCESS;
}

template 
VOID Vector::pop_back()
{
	memset(&m_pVector[--m_dwIndex], 0, sizeof(T));
}


template 
DWORD Vector::insert(DWORD dwIndex, T Element)
{
	//判断索引是否正确
	if (dwIndex < 0 || dwIndex > m_dwIndex)
	{
		return INDEX_ERROR;
	}
	//如果移动后超出空间，则需要增容
	if (dwIndex >= m_dwLen)
	{
		expand();
	}
	//将dwIndex后的元素后移动一位
	memcpy_s(&m_pVector[dwIndex+1], sizeof(T)*(m_dwIndex - dwIndex+1) , &m_pVector[dwIndex], sizeof(T) * (m_dwIndex - dwIndex+1));
	//将该元素插入索引dwIndex
	memcpy_s(&m_pVector[dwIndex], sizeof(T), &Element, sizeof(T));
	//修改元素
	m_dwIndex++;
}

template 
DWORD Vector::capacity()
{
	DWORD left = m_dwLen - m_dwIndex;
	return left;
}


template 
VOID Vector::clear()
{
	memset(m_pVector, 0, sizeof(T) * m_dwLen);
	delete[] m_pVector;
	m_pVector = nullptr;
}

template 
T Vector::at(DWORD dwIndex)
{
	if (dwIndex < 0 || dwIndex >= m_dwIndex)
	{
		return INDEX_ERROR;
	}
	return m_pVector[dwIndex];
}

template 
BOOL Vector::empty()
{
	if (m_dwIndex == 0)
	{
		return true;
	}
}

template 
DWORD Vector::erase(DWORD dwIndex)
{
	if (dwIndex < 0 || dwIndex >= m_dwIndex)
	{
		return INDEX_ERROR;
	}
	
	memcpy_s(&m_pVector[dwIndex], sizeof(T) * (m_dwIndex - dwIndex-1), &m_pVector[dwIndex + 1], sizeof(T) * (m_dwIndex - dwIndex-1));
	m_pVector[m_dwIndex - 1] = 0;
	m_dwIndex--;
	return SUCCESS;
}

template 
DWORD Vector::size()
{
	return m_dwIndex;
}

template 
VOID Vector::print()
{
	if (m_pVector == nullptr)
	{
		return;
	}
	for (int i = 0; i < m_dwIndex; i++)
	{
		cout << m_pVector[i] << " ";
	}
	cout << endl;
}

int main()
{
	Vector v;
	v.push_back(1);
	v.push_back(2);
	v.insert(0, 2);
	v.erase(0);
	v.erase(0);
	v.erase(0);
	v.print();
	return 0;
}