vector的介绍使用及模拟实现

目录

一、vector的介绍

二、vector的使用

1.vector的定义

2.vector iterator 的使用

3.vector 空间增长问题

4.vector 增删查改

5.vector模拟实现

一、vector的介绍

二、vector的使用

1.vector的定义

2.vector iterator 的使用

3.vector 空间增长问题

4.vector 增删查改

5.vector模拟实现

#include <iostream>
//#include <vld.h>
using namespace std;
namespace bite
{ 
    template<class T>
    class vector
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
        vector() :_start(nullptr), _end(nullptr), _finish(nullptr)
        {
        }
 
        vector(int n,const T &v = T()) :_start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(n);
            while (n--)
                push_back(v);
        }
 
        template<class inputiterator>
        vector(inputiterator first, inputiterator last):_start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(last - first);
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }
 
        vector(const vector<T>& v):_start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(v.capacity());
            iterator dest = _start, src = v._start;
            for (int i = 0; i < v.size(); i++)
                *dest++ = *src++;
        }
 
 
        ~vector()
        {
            delete _start;
            _start = _finish = _end = nullptr;
        }
 
        void push_back(const T &v)
        {
            insert(end(), v);
        }
 
        void pop_back()
        {
            erase(end()-1);  
        }
 
        size_t size()const
        {
            return _finish - _start;
        }
 
        size_t capacity()const
        {
            return _end - _start;
        }
 
        //扩充容量
        void reserve(size_t n)
        {
            if (n > capacity())
            {
                T* newstart = new T[n];
                int oldsize = size();
                memcpy(newstart, _start, sizeof(T) * oldsize);
                delete _start;
                _start = newstart;
                _finish = _start + oldsize;
                _end = _start + n;
            }
        }
 
        void resize(size_t n,const T &x = T())
        {
            if (n <= size())
            {
                _finish = _start + n;
                return;
            }
            if (n > capacity())
            {
                reserve(n);
                iterator p=_finish;
                _finish = _start + n;
                while (p != _finish)
                {
                    *p++ = x;
                }
            }
        }
        
        T& operator[](size_t pos)
        {
            return _start[pos];
        }
 
        const T& operator[](size_t pos)const
        {
            return _start[pos];
        }
 
        iterator begin()
        {
            return _start;
        }
 
        const_iterator begin()const
        {
            return _start;
        }
 
        iterator end()
        {
            return _finish;
        }
 
        const_iterator end()const
        {
            return _finish;
        }
 
        iterator insert(iterator it, const T& x = T())
        {
            if (_end == _finish)
            {
                //扩容
                size_t offset = it - _start;  //偏移量
                size_t newcapacity = capacity() == 0 ? 1 : capacity() * 2;
                reserve(newcapacity);
 
                //扩容成功后，it会失效，需要重新赋值
                it = _start + offset;
            }
 
            iterator pos = _finish;
            while (pos != it)
            {
                *pos = *(pos - 1);
                pos--;
                *it = x;
                _finish++;
            }
            return it;
        }
 
        iterator erase(iterator it)
        {
            _finish--;
            iterator p = it;
            while (p != _finish)
            {
                *p = *(p + 1);
                p++;
            }
            return it;
        }
 
    private:
        iterator _start;
        iterator _end;
        iterator _finish;
    };
};
int main()
{
    bite::vector<int> v;
    cout << "size=" << v.size() << endl;
    cout << "capacity=" << v.capacity() << endl;
 
    v.reserve(10);
    cout << "size=" << v.size() << endl;
    cout << "capacity=" << v.capacity() << endl;
 
    v.insert(v.begin(), 3);
    cout << "size=" << v.size() << endl;
    cout << "capacity=" << v.capacity() << endl;
    for (i = 0; i <= 5; i++)
        v.push_back(i);
}