vector模拟实现C++

1.vector介绍

2.迭代器接口

3.容量接口

4.默认成员函数

5.修改插入删除接口

1.vector介绍

       vector是表示可变大小数组的序列容器，就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

        成员如下：_start，_finish，_endOStorage

private:

    iterator _start; // 指向数据块的开始

    iterator _finish; // 指向有效数据的尾

    iterator _endOfStorage; // 指向存储容量的尾

2.迭代器接口

a. begin+end：获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置 的iterator/const_iterator。

b. cbegin+cend：获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 reverse_iterator。

    typedef T* iterator;

    typedef const T* const_iterator;

    iterator begin()
    {
        return  _start;
    }

    iterator end()
    {
        return _finish;
    }

        
    const_iterator cbegin()
    {
        return _finish;
    }

    const_iterator cend() const
    {
         return  _start;
    }

3.容量接口

a.size：获取数据个数。

b.capacity：获取容量大小。

c.resize：改变vector的size。

d.resrve:改变vector的capacity。

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

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

        void reserve(size_t n)
        {
            if (n > capacity())
            {
                T* tmp = new T[n];
                size_t x = size();
                if (_start)
                {
                    for (int i = 0; i < x; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                _start = tmp;
                _finish = _start + x;
                _endOfStorage = _start + n;
            }
        }

        void resize(size_t n, const T& value = T())
        {
            if (n > size())
            {
                reserve(n);
                while (_finish<_start+n)
                {
                    *_finish = value;
                    _finish++;
                }
            }
            else
            {
                _finish = _start + n;
            }
        }

4.默认成员函数

        vector()
        {}
        //在初始化时将n个类型T的数写入vector
        vector(int n, const T& value = T())
        {
            reserve(n);
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }
        
        template<class InputIterator>
        //这里是通过迭代器将部分自定义类型写入vector
        //例如：string s("hello world")    vector<char> v(s.begin,s.end);
        vector(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }
        //这里是拷贝构造
        vector(const vector<T>& v)
        {
            reverve(v.capacity());
            for (auto it : v)
            {
                push_back(*it);
                it++;
            }
        }
        //这里是赋值重载
        vector<T>& operator= (vector<T> v)
        {
            reserve(v.capacity());
            for (auto it : v)
            {
                push_back(*it);
                it++;
            }
            return *this;
        }

        ~vector();

5.修改插入删除接口

a.push_back:尾插。

b.pop_back:尾删。

c.insert:在position之前插入val。

d.erase:删除position位置的数据。

e.swap:交换两个vector的数据空间。

d.operator[]:像数组一样访问。

        void push_back(const T& x)
        {
            insert(end(), x);
        }

        void pop_back()
        {
            _finish--;
        }

        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 <= _finish);
            assert(pos >= _start);
            if (_finish == _endOfStorage)
            {
                size_t len = pos - _start;
                reserve(capacity == 0 ? 4 : capacity() * 2);//这里会重置迭代器
                pos = _start + len;
            }
            auto it = end()-1;
            while (it >= pos)
            {
                *(it + 1) = *it;
                --it;
            }
            return pos;
        }

        iterator erase(iterator pos)
        {
            assert(pos <= _finish);
            assert(pos >= _start);
            auto it = pos + 1;
            while (it <= end())
            {
                *(it - 1) = *it;
                it++;
            }
            --_finish;
            return pos;
        }