模板实现Vector

模板
模板是泛型编程的基础。所谓泛型编程就是编写与类型无关的逻辑代码，是一种复用的方式。模板分为模板函数和模板类。

模板实现Vector优点
通过使用模板实现Vector可以提高代码的复用度，原先在实现Vector只能定义一种具体类型，如果要再定义另外一种类型，必须将代码重新修改一遍，通过模板实现Vector解决了代码复用度低的问题。

---

头文件部分：

#include 
using namespace std;
#include
#include

Vector定义：
注意：
1.模板实现Vector类时，类的类型是Vector< T >
2.在传参数时，注意考虑当T的类型为string是，该如何设置参数

template
class Vector
{
public:
    Vector()
        :_data(NULL)
        , _size(0)
        , _capacity(0)
    {}
    Vector(const Vector& v)
    {
        _data = new T[v._capacity];
        if (v._size != 0)
        {
            for (size_t i = 0; i < v._size; ++i)
            {
                _data[i] = v._data[i];
            }
            _size = v._size;
            _capacity = v._capacity;
        }
    }
    Vector& operator=(const Vector& v)
    {
        if (this != &v)
        {
            Vector tmp(v);
            swap(_data, tmp._data);
            _size = tmp._size;
            _capacity = tmp._capacity;
        }
        return *this;
    }
    ~Vector()
    {
        if (_data != NULL)
        {
            delete[] _data;
            _size = _capacity = 0;
            _data = NULL;
        }
    }

public:
    void PushBack(const T& data)
    {
        CheckCapacity();
        _data[_size++] = data;
    }
    void PopBack()
    {
        if (_size != 0)
        {
            if (--_size == 0)
                delete[] _data;
        }
    }
    void Erease(size_t pos)
    {
        assert(pos >= 0 && pos<_size && _size>0);
        size_t i = pos;
        while (i < _size-1)
        {
            _data[i] = _data[i+1];
            i++;
        }
        _size--;
    }
    T& Front()
    {
        return *_data;
    }
    void Insert(size_t pos, const T& data)
    {
        assert(pos >= 0 && pos <= _size);
        CheckCapacity();
        size_t i = _size;
        while(i > pos)
        {
            _data[i] = _data[i-1];
            --i;
        }
        _data[pos] = data;
        ++_size;
    }
    bool Empty()
    {
        if (_size == 0)
            return true;
        else
            return false;
    }
    void Display()
    {
        for (size_t i = 0; i < _size; ++i)
        {
            cout << _data[i] << " ";
        }
        cout << endl;
    }
protected:
    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            size_t NewCapacity = 2 * _capacity + 3;
            T* tmp = new T[NewCapacity];
            if (_data != NULL)
            {
                //memcpy(tmp, _data, sizeof(int)*_size);错误分析见下
                for (size_t i = 0; i < _size; ++i)
                {
                    tmp[i] = _data[i];
                }
                delete[] _data;
            }
            _data = tmp;
            _capacity = NewCapacity;
        }
    }
protected:
    T* _data;
    size_t _size;
    size_t _capacity;
};

关于在CheckCapacity（）中由于//memcpy(tmp, _data, sizeof(int)*_size);语句在测试函数Test2（）出现崩溃原因分析：
在此处涉及浅拷贝的现象，memcpy（）为值拷贝，即发生浅拷贝。

当字符串长度不超过Buf[15]数组存储长度，字符串是存储在Buf[15]数组中的，memcpy可以实现拷贝；当字符串的长度超过Buf[15]数组可以存储的范围后，Buf[15]就弃之不用，通过_ptr来存储指向字符串的指针，此时就得注意浅拷贝的问题，故使用for循环来拷贝字符串的内容。

测试部分：

void Test1()
{
    Vector v1;
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);

    v1.Display();

    v1.PopBack();
    v1.PopBack();
    v1.PopBack();
    v1.PopBack();
    v1.PopBack();
    v1.Display();
}

void Test2()
{
    Vector v1;
    v1.PushBack("123111111111111111111111111");
    v1.PushBack("456");
    v1.PushBack("789");
    v1.PushBack("111");

    v1.Display();
}

void Test3()
{
    Vector v1;
    v1.PushBack("123");
    v1.PushBack("456");
    v1.PushBack("789");
    v1.PushBack("111");

    v1.Display();

    Vector v2(v1);
    v2.Display();
    getchar();
}

void Test4()
{
    Vector v1;
    v1.PushBack("123");
    v1.PushBack("456");
    v1.PushBack("789");
    v1.PushBack("111");
    v1.Display();

    v1.Erease(1);
    v1.Display();
    v1.Erease(1);
    v1.Display();
    v1.Erease(1);
    v1.Display();
    v1.Erease(1);
    v1.Display();
    getchar();
}

void Test5()
{
    Vector v1;
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);

    v1.Display();

    Vector v2(v1);
    v2.Display();

    Vector v3;
    v3.Insert(0, 5);
    v3.Display();
    v3 = v2;
    v3.Display();

    v3.Insert(1, 6);
    v3.Display();

    cout<.Front()<;


    getchar();
}