vector实现

#include <iostream>
#include <memory>

using std::endl;
using std::cout;

template<typename T>
class Vector
{
public:
    using iterator = T *;//C++的写法
    //typedef T* iterator ;//C的写法
    Vector(int n);
    Vector()
    :_start (nullptr)
    ,_finish (nullptr)
    ,_end_of_storage (nullptr)
    {
    }
    ~Vector();

    void push_back(const T &value);
    void pop_back();
    void print();

    iterator begin()
    {
        return _start;
    }
    iterator end()
    {
        return _finish;
    }

    int size();
    int capacity();
private:
    void reallocate();//重新分配内存,动态扩容要用的
private:
    static std::allocator<T> _alloc;

    T *_start;                 //指向数组中的第一个元素
    T *_finish;                //指向最后一个元素之后的下一个位置
    T *_end_of_storage;        //指向分配的内存之后的位置
};

template<typename T>
std::allocator<T> Vector<T>::_alloc;


template<typename T>
Vector<T>::Vector(int n)
:_start (_alloc.allocate(n))
,_finish (_start)
,_end_of_storage (_start + n)
{
}

template<typename T>
Vector<T>::~Vector()
{
    //先销毁对象
    for(T *p = _start; p!=_finish; p++)
    {
        _alloc.destroy(p);
    }
    //再回收内存
    if(size())
    {
        _alloc.deallocate(_start,capacity());
        _start = nullptr;
        _finish =nullptr;
        _end_of_storage =nullptr;
    }
}

template<typename T>
void Vector<T>::push_back(const T &value)
{
    if(size() == capacity())//内存达到上限
    {
        reallocate();//重新分配内存
    }
    if(capacity()>0)
    {
        _alloc.construct(_finish, value);//构建对象
        ++_finish;
    }
}

template<typename T>
void Vector<T>::pop_back()
{
    if(size() == 0)
    {
        cout << "error" <<endl;
    }
    else
    {
        _alloc.destroy(--_finish);//销毁对象
    }
}

template<typename T>
int Vector<T>::size()
{
    return _finish - _start;
}

template<typename T>
int Vector<T>::capacity()
{
    return _end_of_storage - _start;
}

template<typename T>
void Vector<T>::reallocate()
{
    //初始未分配内存时，需要分配1内存
    int newCapacity = size() > 0 ? 2 * capacity() : 1;//以两倍空间扩容
    T *_pNewStart = _alloc.allocate(newCapacity);
    T *_pNewFinsh = _pNewStart;

    if(size() > 0)
    {
        //复制旧空间的元素到新空间
        //不用copy()的原因：如果对自定义类型的对象进行复制时，copy底层会访问_pNewStart中的对象
        //但此时_pNewStart上并没有构建对象
        //所以必须使用不需要在新空间上构建对象的uninitialized_copy()进行复制
        std::uninitialized_copy(_start, _finish, _pNewStart);
        /*for(T *p = _start; p != _finish; ++p, ++_pNewFinsh)
        {
            _alloc.construct(_pNewFinsh, *p);//构造对象
             _alloc.destroy(p);//销毁旧空间对象
        }*/

        _alloc.deallocate(_start,capacity());//回收内存
    }
    int t=size();
    _start = _pNewStart;
    _finish =_start + t;
    _end_of_storage =_start + newCapacity;
}

template <typename T>
void Vector<T>::print()
{
    for(T *p = _start; p != _finish; p++)
    {
        cout << *p <<" ";
    }
    cout << endl;
}

int main()
{
    Vector <int> vec;
    vec.push_back(2);
    cout << "size()=" << vec.size() << endl;
    cout << "capacity()=" << vec.capacity() << endl;
    vec.push_back(3);
    vec.print();
    vec.push_back(4);
    cout << "size()=" << vec.size() << endl;
    cout << "capacity()=" << vec.capacity() << endl;
    for(auto &elem : vec)
    {
        cout << elem << " ";
    }
    cout << "HELLO" <<endl;
    vec.pop_back();
    cout << "size()=" << vec.size() << endl;
    vec.print();
}