template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
    typedef ReverseIterator<Iterator, Ref, Ptr> Self;

    Iterator cur;

    ReverseIterator(Iterator it)
        :cur(it)
    {}

    Self& operator++()//前置++
    {
        --cur;
        return *this;
    }

    Self operator++(int)//后置++
    {
        Iterator tmp = cur;
        --cur;
        return tmp;
    }

    Self& operator--()//前置--
    {
        ++cur;
        return *this;
    }

    Self operator--(int)//后置--
    {
        Iterator tmp = cur;
        ++cur;
        return tmp;
    }

    Ref operator*()//解引用
    {
        Iterator tmp = cur;
        --tmp;
        return *tmp;
    }

    Ptr operator->()
    {
        return &(operator*());
    }

    bool operator!=(const Self& s)
    {
        return cur != s.cur;
    }

    bool operator==(const Self& s)
    {
        return cur == s.cur;
    }

};

template<class T>
class vector
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
    typedef ReverseIterator<const_iterator, T&, T*> const_reverse_iterator;

    reverse_iterator rbegin()
    {
        return reverse_iterator(end());
    }
    reverse_iterator rend()
    {
        return reverse_iterator(begin());
    }
    const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(end());
    }
    const_reverse_iterator rend() const
    {
        return const_reverse_iterator(begin());
    }

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

    vector(){}
    vector(const vector<T>& v);
    template <class InputIterator>
    vector(InputIterator first, InputIterator last);
    vector(size_t n, const T& val = T());
    vector(int n, const T& val = T());
    vector<T>& operator= (vector<T> v);
    ~vector();
    size_t size() const;
    size_t capacity() const;
    void reserve(size_t n);
    void resize(size_t n, const T& val = T());
    T& operator[](size_t pos);
    const T& operator[](size_t pos)const;
    void push_back(const T& x);
    void pop_back();
    void swap(vector<T>& v);
    iterator insert(iterator pos, const T& x);
    iterator erase(iterator pos);
private:
    iterator _start = nullptr; // 指向數(shù)據(jù)塊的開始
    iterator _finish = nullptr; // 指向有效數(shù)據(jù)的尾
    iterator _endOfStorage = nullptr; // 指向存儲(chǔ)容量的尾
};