vc++简单的vector动态数组实现

#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(100),
    m_dwIncrement(5),
    m_dwIndex(0)
{
    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(0),
    m_dwIncrement(5)
{
    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 <= 0 || 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-1],sizeof(TELE));
    m_dwIndex--;
    m_dwLen++;
    /*return SUCCESS;*/
}
template<typename TELE>
DWORD    Vector<TELE>::insert(DWORD dwIndex, TELE Element)                    //向指定位置新增一个元素    
{
    //先判断给的索引是否可以插入
    if (dwIndex < 0 || dwIndex > m_dwIndex)
    {
        return INDEX_ERROR;
    }
    if(dwIndex == m_dwIndex)
    {
        CopyMemory(&m_pVector[m_dwIndex],&Element,sizeof(TELE));
        return SUCCESS;
    }
    if(m_dwLen <=0 || 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-1],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 =0;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 < 0)return INDEX_ERROR;    //
    ZeroMemory(&m_pVector[dwIndex],sizeof(TELE));
    for (DWORD i =dwIndex;i<m_dwIndex;i++)    //把指定索引后面的元素向前移动即可
        CopyMemory(&m_pVector[i],&m_pVector[i+1],sizeof(TELE));
    m_dwLen++;
    m_dwIndex--;
    return SUCCESS;
}
template<typename TELE>
DWORD    Vector<TELE>::size()                    //返回Vector元素数量的数量    
{
    return (m_dwIndex-1);
}

#endif