#ifndef __MYVECTOR__

 #define __MYVECTOR__

 #include <Windows.h>

 #define SUCCESS                        1 // 成功

 #define ERRORS                         -1 // 失败

 #define MALLOC_ERROR             -2 // 申请内存失败

 #define INDEX_ERROR              -3 // 错误的索引号

 template<typename TELE>

 class Vector

 {

 public:

     Vector(void);

     Vector(DWORD dwSize);

     ~Vector();

 public:

     DWORD    at(DWORD dwIndex,OUT TELE* pEle);                    //根据给定的索引得到元素

     DWORD   push_back(TELE Element);                        //将元素存储到容器最后一个位置

     VOID    pop_back();                    //删除最后一个元素

     DWORD    insert(DWORD dwIndex, TELE Element);                    //向指定位置新增一个元素

     DWORD    capacity();                    //返回在不增容的情况下，还能存储多少元素

     VOID    clear();                    //清空所有元素

     BOOL    empty();                    //判断Vector是否为空 返回true时为空

     DWORD    erase(DWORD dwIndex);                    //删除指定元素

     DWORD    size();                    //返回Vector元素数量的大小

 private:

     BOOL    expand();                    //容器满了需要扩充

 private:

     DWORD  m_dwIndex;                        //下一个可用索引

     DWORD  m_dwIncrement;                        //每次增容的大小

     DWORD  m_dwLen;                        //当前容器可用的长度

     DWORD  m_dwInitSize;                        //默认初始化大小

     TELE *m_pVector;                        //容器指针                

 };

 template<typename TELE>

 Vector<TELE>::Vector(void)        //无参构造函数

     :m_dwInitSize(),

     m_dwIncrement(),

     m_dwIndex()

 {

     m_pVector = new TELE[m_dwInitSize];

     ZeroMemory(m_pVector,sizeof(TELE)*m_dwInitSize);

     m_dwLen = m_dwInitSize;

 }

 template<typename TELE>

 Vector<TELE>::Vector(DWORD dwSize)    //有参构造函数

     :m_dwInitSize(dwSize),

     m_dwIndex(),

     m_dwIncrement()

 {

     m_pVector = new TELE[m_dwInitSize];

     ZeroMemory(m_pVector,sizeof(TELE)*m_dwInitSize);

     m_dwLen = m_dwInitSize;

 }

 template<typename TELE>

 Vector<TELE>::~Vector()    //析构函数

 {

     if(m_pVector)delete [] m_pVector;

     m_dwLen=NULL;

     m_dwIncrement = NULL;

     m_dwInitSize = NULL;

     m_pVector = NULL;

     m_dwIndex = NULL;

 }

 template<typename TELE>

 DWORD    Vector<TELE>::at(DWORD dwIndex,OUT TELE* pEle)                //根据给定的索引得到元素

 {

     if(empty()||dwIndex >= m_dwIndex)

         return INDEX_ERROR;

     else

     {

         CopyMemory(pEle,&m_pVector[dwIndex],sizeof(TELE));

     }

     return SUCCESS;

 }

 template<typename TELE>

 BOOL    Vector<TELE>::expand()                    //容器满了需要扩充

 {

     //先申请内存空间用来存储新的数据

     TELE* m_TempPtr = nullptr;

     DWORD dw_NewInitSize = m_dwInitSize + m_dwIncrement;

     m_TempPtr = new TELE[dw_NewInitSize];

     if (!m_TempPtr)return false;

     ZeroMemory(m_TempPtr,sizeof(TELE)*dw_NewInitSize);

     CopyMemory(m_TempPtr,m_pVector,sizeof(TELE)*m_dwInitSize);

     m_dwInitSize = dw_NewInitSize;

     delete [] m_pVector;    //释放原来的指针

     m_pVector = m_TempPtr;    //把新的指针给头指针

     m_dwLen += m_dwIncrement;

     return true;

 }

 template<typename TELE>

 DWORD    Vector<TELE>::push_back(TELE Element)                        //将元素存储到容器最后一个位置

 {

     //先判断容器是否满了

     if(m_dwLen <=  || m_dwIndex >= m_dwInitSize)

     {

         //需要扩充

         if(!expand())

         {

             return ERRORS;

         }

     }

     CopyMemory(&m_pVector[m_dwIndex],&Element,sizeof(TELE));

     m_dwIndex++;

     m_dwLen--;

     return SUCCESS;

 }

 template<typename TELE>

 VOID    Vector<TELE>::pop_back()                    //删除最后一个元素

 {

     //先确定它是不是空的

     if (empty())return;

     ZeroMemory(&m_pVector[m_dwIndex-],sizeof(TELE));

     m_dwIndex--;

     m_dwLen++;

     /*return SUCCESS;*/

 }

 template<typename TELE>

 DWORD    Vector<TELE>::insert(DWORD dwIndex, TELE Element)                    //向指定位置新增一个元素

 {

     //先判断给的索引是否可以插入

     if (dwIndex <  || dwIndex > m_dwIndex)

     {

         return INDEX_ERROR;

     }

     if(dwIndex == m_dwIndex)

     {

         CopyMemory(&m_pVector[m_dwIndex],&Element,sizeof(TELE));

         return SUCCESS;

     }

     if(m_dwLen <= || m_dwIndex >= m_dwInitSize)    //判断是否够插入新元素

     {    //如果不够就要扩充

         if(!expand())return ERRORS;

     }

     //0 1 2 3 4 5 6 7

     //把要插入的索引的位置后面的元素后移

     for(DWORD i = m_dwIndex;i>dwIndex;i--)

         CopyMemory(&m_pVector[i],&m_pVector[i-],sizeof(TELE));

     CopyMemory(&m_pVector[dwIndex],&Element,sizeof(TELE));

     m_dwIndex++;

     m_dwLen--;

     return SUCCESS;

 }

 template<typename TELE>

 DWORD    Vector<TELE>::capacity()                    //返回在不增容的情况下，还能存储多少元素

 {

     return m_dwLen;

 }

 template<typename TELE>

 VOID    Vector<TELE>::clear()                    //清空所有元素

 {

     if(empty())return;

     for (DWORD i =;i<m_dwIndex;i++)

         ZeroMemory(&m_pVector[i],sizeof(TELE));

     m_dwLen = NULL;

     m_dwIndex = NULL;

     m_dwInitSize = NULL;

     m_dwIncrement = NULL;

 }

 template<typename TELE>

 BOOL    Vector<TELE>::empty()                    //判断Vector是否为空 返回true时为空

 {

     if(m_dwIndex)

         return false;

     else

         return true;

 }

 template<typename TELE>

 DWORD    Vector<TELE>::erase(DWORD dwIndex)                    //删除指定元素

 {

     if(empty() || dwIndex < )return INDEX_ERROR;    //

     ZeroMemory(&m_pVector[dwIndex],sizeof(TELE));

     for (DWORD i =dwIndex;i<m_dwIndex;i++)    //把指定索引后面的元素向前移动即可

         CopyMemory(&m_pVector[i],&m_pVector[i+],sizeof(TELE));

     m_dwLen++;

     m_dwIndex--;

     return SUCCESS;

 }

 template<typename TELE>

 DWORD    Vector<TELE>::size()                    //返回Vector元素数量的数量

 {

     return (m_dwIndex-);

 }

 #endif