vector的模拟实现

---

实现部分

#pragma once
#include <assert.h>

namespace zx
{
    template<class T>
    class vector
    {
    public:
        // Vector的迭代器是一个原生指针
        typedef T* iterator;
        typedef const T* const_iterator;
        iterator begin()
        {
            return _start;
        }
        iterator end()
        {
            return _finish;
        }
        const_iterator cbegin() const
        {
            return _start;
        }
        const_iterator cend() const
        {
            return _finish;
        }
        // construct and destroy
        vector()
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {}
        vector(int n, const T& value = T())
            : _start(nullptr)
                , _finish(nullptr)
                , _endOfStorage(nullptr)
            {
                reserve(n);
                while (n--)
                {
                    push_back(value);
                }
            }
        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }
        vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto& i : v)
                push_back(i);
        }
        vector<T>& operator= (vector<T> v)
        {
            swap(v);
            return *this;
        }
        ~vector()
        {
            delete[]_start;
            _start = nullptr;
            _finish = nullptr;
            _endOfStorage = nullptr;
        }
        // capacity
        size_t size() const
        {
            return _finish - _start;
        }
        size_t capacity() const
        {
            return _endOfStorage - _start;
        }
        void reserve(size_t n)
        {
            if (n > capacity())
            {
                iterator tmp = new T[n];
                size_t sz = size();
                if (_start)
                {
                    for (size_t i = 0; i < sz; i++)
                        tmp[i] = _start[i];
                    delete[]_start;
                }
                _start = tmp;
                _finish = _start + sz;
                _endOfStorage = _start + n;
            }
        }
        void resize(size_t n, const T& value = T())
        {
            if (n <= size())
                _finish = _start + n;
            else {
                reserve(n);
                while (_finish < _start + n)
                {
                    *_finish = value;
                    ++_finish;
                }
            }
        }
        ///access///
        T& operator[](size_t pos)
        {
            assert(pos < size());
            return _start[pos];
        }
        const T& operator[](size_t pos)const
        {
            assert(pos < size());
            return _start[pos];
        }
        ///modify/
        void push_back(const T& x)
        {
            insert(end(), x);
        }
        void pop_back()
        {
            erase(end());
        }
        void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endOfStorage, v._endOfStorage);
        }
        iterator insert(iterator pos, const T& x)
        {
            assert(pos >= _start);
            assert(pos <= _finish);
            if (_finish == _endOfStorage)
            {
                //更新pos，防止扩容导致的迭代器失效影响结果
                size_t len = pos - _start;
                reserve(capacity() == 0 ? 4 : 2 * capacity());
                pos = _start + len;
            }
            iterator _end = _finish - 1;
            while (_end >= pos)
            {
                *(_end + 1) = *(_end);
                --_end;
            }
            *pos = x;
            _finish++;
            return pos;
        }
        iterator erase(iterator pos)
        {
            assert(pos >= _start);
            assert(pos <= _finish);
            iterator _begin = pos + 1;
            while (_begin < _finish)
            {
                *(_finish - 1) = *_finish;
                _begin++;
            }
            --_finish;
        }
    private:
        iterator _start; // 指向数据块的开始
        iterator _finish; // 指向有效数据的尾
        iterator _endOfStorage; // 指向存储容量的尾
    };
}

---

test.cpp部分

#include <iostream>
#include <vector>
using namespace std;
#include "vector.h"

void test1()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.pop_back();
	cout << "push_back and pop_back :";
	for (auto i : v)
		cout << i << " ";
	cout << endl;
	v.insert(v.begin() + 2, 30);
	cout << "insert:";
	for (auto x : v)
		cout << x << " ";
	cout << endl;
	v.erase(v.end() - 1);
	cout << "erase:";
	for (auto x : v)
		cout << x << " ";
	cout << endl;
	v.reserve(20);
	cout << "reserve(20): size:" << v.size() << " capacity:" << v.capacity() << endl;
	v.resize(100);
	cout << "resize(100): size:" << v.size() << " capacity:" << v.capacity() << endl;
}

int main()
{
	test1();
	return 0;
}

部分测试结果