模拟实现C++中的Vector函数

源代码实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
template<class T>
class Vector
{
public:
    Vector()
        : _start(NULL)
        , _finish(NULL)
        , _endOfStorage(NULL)
    {}

    Vector(T* array, int size)
        :_start(new T[size])
    {
        for (int i = 0; i < size; i++)
            PushBack(array[i]);
        _finish = &_start[size];
        _endOfStorage = &_start[size];
    }
    Vector(const Vector& v)
    {
        int oldSize = (int)v.Size();
        _start = new T[oldSize];
        for (int i = 0; i < oldSize; i++)
            PushBack(v._start[i]);
        _finish = &_start[oldSize];
        _endOfStorage = &_start[oldSize];
    }
    Vector& operator=(const Vector& v)
    {
        int oldSize = (int)v.Size();
        _start = new T[oldSize];
        for (int i = 0; i < oldSize; i++)
            PushBack(v._start[i]);
        _finish = &_start[oldSize];
        _endOfStorage = &_start[oldSize];
    }
    ~Vector()
    {
        Clear();
        if (_start)
            delete[] _start;
    }

    /////////////// Modify ///////////////////////////////////// 
    void PushBack(const T& data)
    {
        _CheckCapacity();
        *_finish = data;
        _finish++;
    }
    void PushFront(const T& data)//头部插入元素
    {
        int i = 0;
        _CheckCapacity();
        if (Empty())
            PushBack(data);
        else
        {
            for (i = Size(); i > 0; i--)
                _start[i] = _start[i - 1];
            _start[i] = data;
            _finish++;
        }
    }
    void PopFront()//头部删除元素
    {
        if (!Empty())
        {
            for (int i = 0; i < Size(); i++)
                _start[i] = _start[i + 1];
            _finish--;
        }
    }
    void PopBack()
    {
        _finish--;
    }
    void Insert(size_t pos, const T& data)
    {
        if (pos > *_finish)
            return;
        _CheckCapacity();
        for (i = _finish - _start; i > pos; i--)
            _start[i] = _start[i - 1];
        _start[pos] = data;
        _finish++;
    }
    void Erase(size_t pos)
    {
        if (pos >= _finish - _start)
            return;
        for (int i = pos; i < _finish - _start; i++)
            _start[i] = _start[i + 1];
        _finish--;
    }
    void Clear()
    {
        // 存在问题？ 
        _finish = _start;
    }

    ///////////////////// Capacity ////////////////////////////////////////// 
    size_t Size()const
    {
        return _finish - _start;
    }
    bool Empty()const
    {
        return _finish == _start;
    }
    size_t Capacity()const
    {
        return  _endOfStorage - _start;
    }
    void ReSize(size_t newSize, const T& data = T())
    {
        if (newSize < _finish)
            _finish = &_start[newSize];
        else
        {
            for (int i = _finish - _start; i < newSize; i++)
            {
                _CheckCapacity();
                _start[i] = data;
            }
            _finish = &_start[newSize];
        }
    }

    ///////////////////Element Acess////////////////////////////////// 
    T& operator[](size_t index)
    {
        return _start[index];
    }
    const T& operator[](size_t index)const
    {
        return _start[index];
    }
    T& Front()
    {
        return _start[0];
    }
    const T& Front()const
    {
        return _start[0];
    }
    T& Back()
    {
        return *(_fininsh - 1);
    }
    const T& Back()const
    {
        return *(_fininsh - 1);
    }

private:
    void _CheckCapacity()
    {
        if (_finish == _endOfStorage)
        {
            int oldSize = Size();
            T* temp = new T[oldSize * 2 + 3];
            for (int i = 0; i < oldSize; i++)
                temp[i] = _start[i];
            if (_start != NULL)
                delete _start;
            _start = temp;
            temp = NULL;
            _finish = &_start[oldSize];
            _endOfStorage = &_start[oldSize * 2 + 3];
        }
    }
private:
    T* _start;
    T* _finish;
    T* _endOfStorage;
};

int main()
{
    Vector<int> v;
    v.PushBack(1);
    v.PushBack(2);
    v.PushBack(3);
    v.PushBack(4);
    v.PushBack(5);
    v.PushBack(6);
    v.PushBack(7);
    cout << v.Size() << endl;
    v.PopBack();
    v.PopFront();
    cout << v.Size() << endl;
}

运行结果：