C++初阶：vector类的模拟实现（含模板）

 

目录

1.Vector.h

2.Test.cpp

---

1.Vector.h

#include <iostream>
#include <cassert>
#include <algorithm>
using namespace std;
template <class T>
class Vector
{
public:
    typedef T *iterator;

    typedef const T *const_iterator;

    iterator begin() const
    {
        return _start;
    }

    iterator end() const
    {
        return _finish;
    }

    size_t size() const
    {
        return _finish - _start;
    }

    size_t capacity() const
    {
        return _endofstorage - _start;
    }

    T &operator[](size_t i)
    {
        assert(i < size());
        return _start[i];
    }

    const T &operator[](size_t pos) const
    {
        assert(pos < size());
        return _start[pos];
    }

    Vector<T> &operator=(Vector<T> v)
    {
        swap(v);
        return *this;
    }

    Vector() {}

    Vector(const Vector<T> &v)
    {
        reserve(v.capacity());
        for (auto &e : v)
        {
            push_back(e);
        }
    }

    Vector(initializer_list<T> il)
    {
        reserve(il.size());
        for (auto &e : il)
        {
            push_back(e);
        }
    }

    template <class InputIterator>
    Vector(InputIterator first, InputIterator last)
    {
        while (first != last)
        {
            push_back(*first);
            ++first;
        }
    }

    // 防止push整型时失效
    Vector(int n, const T &val = T())
    {
        reserve(n);
        for (int i = 0; i < n; i++)
        {
            push_back(val);
        }
    }

    Vector(size_t n, const T &val = T())
    {
        reserve(n);
        for (size_t i = 0; i < n; i++)
        {
            push_back(val);
        }
    }

    ~Vector()
    {
        if (_start)
        {
            delete[] _start;
            _start = _finish = _endofstorage = nullptr;
        }
    }

    void reserve(size_t n)
    {
        if (n > capacity())