动态数组(Vector)

#pragma once
template <class T_ELE>
class Vector
{
public:
    Vector();
    Vector(DWORD dwSize);
    ~Vector();
public:
    DWORD    at(DWORD dwIndex, OUT T_ELE* pEle);                    //根据给定的索引得到元素                
    DWORD    push_back(T_ELE Element);                        //将元素存储到容器最后一个位置                
    VOID    pop_back();                    //删除最后一个元素                
    DWORD    insert(DWORD dwIndex, T_ELE Element);                    //向指定位置新增一个元素                
    DWORD    capacity();                    //返回在不增容的情况下，还能存储多少元素                
    VOID    clear();                    //清空所有元素                
    BOOL    empty();                    //判断Vector是否为空 返回true时为空                
    VOID    erase(DWORD dwIndex);                    //删除指定元素                
    DWORD    size();                    //返回Vector元素数量的大小                
private:
    BOOL    expand();
private:
    DWORD  m_dwIndex;                        //下一个可用索引                
    DWORD  m_dwIncrement;                        //每次增容的大小                
    DWORD  m_dwLen;                        //当前容器的长度                
    DWORD  m_dwInitSize;                        //默认初始化大小                
    T_ELE* m_pVector;                        //容器指针                
};






// c++学习.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <windows.h>
#include "cPlusPlus.h"
#pragma warning(disable:4996)

#define SUCCESS                        1 // 成功
#define ERROC                    -1 // 失败
#define MALLOC_ERROR             -2 // 申请内存失败
#define INDEX_ERROR              -3 // 错误的索引号

template <class T_ELE>
Vector<T_ELE>::Vector()
    :m_dwInitSize(100), m_dwIncrement(5)
{
    //1.创建长度为m_dwInitSize个T_ELE对象    
    m_pVector = new T_ELE[m_dwInitSize];
    //2.将新创建的空间初始化
    memset(m_pVector,0,sizeof(T_ELE) * m_dwInitSize);
    //3.设置其他值
    m_dwIndex = 0;
    m_dwLen = m_dwInitSize;
}
template <class T_ELE>
Vector<T_ELE>::Vector(DWORD dwSize)
    :m_dwIncrement(5)
{
    //1.创建长度为dwSize个T_ELE对象
    m_pVector = new T_ELE[dwSize];
    //2.将新创建的空间初始化    
    memset(m_pVector, 0, sizeof(T_ELE) * dwSize);
    //3.设置其他值
    m_dwIndex = 0;
    m_dwLen =  dwSize;

}

template <class T_ELE>
Vector<T_ELE>::~Vector()
{
    delete[] m_pVector;
    m_pVector = NULL;
    //释放空间 delete[]                

}

template <class T_ELE>
BOOL Vector<T_ELE>::expand()
{
    // 1. 计算增加后的长度
    DWORD dwtemplen = 0;
    dwtemplen = m_dwLen + m_dwIncrement;
    // 2. 申请空间
    T_ELE* m_ptemp = 0;
    m_ptemp = new T_ELE[dwtemplen];
    memset(m_ptemp, 0, sizeof(T_ELE) * dwtemplen);
    // 3. 将数据复制到新的空间
    memcpy(m_ptemp, m_pVector, sizeof(T_ELE) * m_dwLen);

    // 4. 释放原来空间
    delete[] m_pVector;
    m_pVector = m_ptemp;
    m_ptemp = NULL;
    // 5. 为各种属性赋值
    m_dwLen = dwtemplen;
    return SUCCESS;
}

template <class T_ELE>
DWORD  Vector<T_ELE>::push_back(T_ELE Element)
{
    //1.判断是否需要增容，如果需要就调用增容的函数
    if (m_dwIndex >= m_dwLen)
    {
        expand();
    }
    //2.将新的元素复制到容器的最后一个位置
    memcpy(&m_pVector[m_dwIndex], &Element, sizeof(T_ELE));
    //3.修改属性值
    m_dwIndex++;
    return SUCCESS;
}

template <class T_ELE>
DWORD  Vector<T_ELE>::insert(DWORD dwIndex, T_ELE Element)
{
    //1.判断是否需要增容，如果需要就调用增容的函数        
    while (dwIndex >= m_dwLen)
    {
        expand();
    }

    //2.判断索引是否在合理区间
    if (0 <= dwIndex && dwIndex <= m_dwIndex)
    {
        for (DWORD i = m_dwIndex; i > dwIndex; i--)
        {
            //3.将dwIndex只后的元素后移
            memcpy(&m_pVector[i], &m_pVector[i-1],sizeof(T_ELE));
        }
    }
    else
    {
        printf("不是合理的索引值");
        return INDEX_ERROR;
    }
    //4.将Element元素复制到dwIndex位置                
    memcpy(&m_pVector[dwIndex], &Element, sizeof(T_ELE));

    //5.修改属性值    
    m_dwIndex++;
    return SUCCESS;
}
template <class T_ELE>
DWORD Vector<T_ELE>::at(DWORD dwIndex, T_ELE* pEle)
{
    //判断索引是否在合理区间
    if (0 <= dwIndex && dwIndex < m_dwIndex)
    {
        memcpy(pEle, &m_pVector[dwIndex], sizeof(T_ELE));
        return SUCCESS;
    }
    else
    {
        printf("不是合理的索引值");
        return INDEX_ERROR;
    }
    //将dwIndex的值复制到pEle指定的内存                

}
template <class T_ELE>
VOID Vector<T_ELE>::pop_back()
{
    memset(&m_pVector[m_dwIndex],0,sizeof(T_ELE));
}
template <class T_ELE>
DWORD Vector<T_ELE>::capacity()
{
    return m_dwLen - m_dwIndex;
}
template <class T_ELE>
VOID Vector<T_ELE>::clear()
{
    memset(m_pVector, 0, sizeof(T_ELE) * m_dwIndex);
}
template <class T_ELE>
BOOL Vector<T_ELE>::empty()
{
    for (int i = 0; i < m_dwLen; i++)
    {
        if (m_pVector[i] != 0)
        {
            return FALSE;
        }
    }
    return TRUE;
}
template <class T_ELE>
VOID Vector<T_ELE>::erase(DWORD dwIndex)
{
    for (int k = dwIndex; k < m_dwIndex; k++)
    {
        memcpy(&m_pVector[k+1], &m_pVector[k],sizeof(T_ELE));
    }
}
template <class T_ELE>
DWORD Vector<T_ELE>::size()
{
    return m_dwIndex;
}
void TestVector()
{
    Vector<int>* pVector = new Vector<int>(5);

    pVector->push_back(1);
    pVector->push_back(2);
    pVector->push_back(3);
    pVector->push_back(4);
    pVector->push_back(5);

    int x = 0;

    pVector->at(4,&x);
    printf("%x", x);
}
int main()
{
    TestVector();
    return 0;
}