vector模拟实现

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

 

文章目录

• 前言
• 一、vector介绍
• 二、使用步骤
  • 1.vector模拟实现
  • 2.测试main函数
  • 3.测试结果

 

---

前言

vector模拟实现

 

一、vector介绍

1.vector:向量，动态数组。

2.vector采用连续存储空间来存储元素，空间大小可以改变。

3.vector在进行扩容时，会重新开辟一块空间。原来的迭代器可能会失效。

4.vector相较于其他动态序列容器随机访问元素和在尾部进行插入或删除的效率较高。

二、使用步骤

1.vector模拟实现

代码如下：

#include<iostream>
using namespace std;
namespace VECTOR
{
    template <class _ty>
    class vector
    {
    public:
        typedef _ty* iterator;
    public:
        vector() :_start(nullptr), _finish(nullptr), _end(nullptr)
        {}
        vector(int n,const _ty &v=_ty()) :_start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(n);
            iterator pos = _start;
            while (n--)
                push_back(v);

        }
        template<class inIterator>
        vector(inIterator first, inIterator last) : _start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(last - first);
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        vector(const vector<_ty>& v) : _start(nullptr), _finish(nullptr), _end(nullptr)
        {
            reserve(v.capacity());
            iterator pos1 = _start, pos2 = v._start;
            for (int i = 0; i < v.size(); ++i)
                *pos1++ = *pos2++;
            _finish = _start + v.size();
        }
        ~vector()
        {
            delete[]_start;
            _start = _finish = _end = nullptr;
        }
    public:
        void push_back(const _ty& v)
        {
            insert(end(),v);
        }
        void pop_back()
        {
            erase(end()-1);
        }
        size_t size() const
        {
            return _finish - _start;
        }
        size_t capacity() const
        {
            return _end - _start;
        }
        iterator begin()
        {
            return _start;
        }
        const iterator begin()const
        {
            return _start;
        }
        iterator end()
        {
            return _finish;
        }
        const iterator end()const
        {
            return _finish;
        }
        //[]重载
        _ty& operator[](size_t pos)
        {
            //不进行越界检查
            return _start[pos];
        }
        const _ty& operator[](size_t pos)const
        {
            return _start[pos];
        }
        _ty at(size_t pos)
        {
            //要进行越界检查
            if (pos >= 0 && pos <= size())
                return _start[pos];
            else
                cout << "位置不合法" << endl;
        }
        void Cout(const vector<_ty>& v)
        {
            for (iterator i = v.begin(); i < v.end(); i++)
            {
                cout << *i<<" ";
            }
            cout << endl;
        }
        //插入元素
        iterator insert(iterator it, const _ty& x = _ty())
        {
            if (_finish == _end)
            {
                size_t old_it = it - _start;
                size_t new_capacity=capacity() == 0 ? 1 : capacity() * 2;
                reserve(new_capacity);
                //因为vector扩容会重新开辟一块空间，所以it及其以后的迭代器均失效，需要对it重新赋值
                it = _start + old_it;
            }
            iterator pos = _finish;
            while (pos != it)
            {
                *(pos) = *(pos-1);
                pos--;
            }
            *pos = x;
            _finish++;
            return it;
        }
        //删除元素
        iterator erase(iterator it)
        {
            _finish--;
            iterator pos = it;
            while(pos != _finish)
            {
                *pos = *(pos + 1);
                pos++;
            }
            return it;
        }
        //扩容
        void reserve(size_t n)
        {
            if (n > capacity())
            {
                int old_size = size();
                _ty* new_start= new _ty[n];
                //memcpy(new_start, _start, sizeof(_ty)*old_size));//浅拷贝，在对字符串或其他自定义类型用此函数进行拷贝可能出现错误（对一个地址空间释放两次）
                for (int i = 0; i < old_size; i++)
                {
                    new_start[i] = _start[i];//深拷贝，调用对应类型的赋值函数
                }
                delete[]_start;
                _start = new_start;
                _finish = _start + old_size;
                _end = _start + n;
            }
        }
        //按照给定的容量大小改变容量，如果容量小于原先的容量，不进行容量改变，只将超出所给容量的元素进行删除
        void resize(size_t n, const _ty& x = _ty())
        {
            if (n < size())
            {
                _finish = _start + n;
                return;
            }
            if (n > capacity())
            {
                reserve(n);
            }
            iterator old_finish=_finish;
            _finish=_start+n;
            while (old_finish != _finish)
            {
                *old_finish++=x;
            }
        }
    private:
        iterator _start;
        iterator _finish;//指向最后一个元素的下一个位置
        iterator _end;//指向vector容器的最后一个有效空间
    };
}

2.测试main函数

代码如下（示例）：

int main()
{
    VECTOR::vector<int> my_vec(10,5);
    VECTOR::vector<int>::iterator it=my_vec.end();
    my_vec.Cout(my_vec);
    it=my_vec.insert(it, 3);
    my_vec.Cout(my_vec);
    it=my_vec.erase(it);
    my_vec.Cout(my_vec);
    my_vec.push_back(4);
    my_vec.Cout(my_vec);
    my_vec.pop_back();
    my_vec.Cout(my_vec);
    my_vec.resize(15);
    my_vec.Cout(my_vec);
    my_vec.resize(5);
    my_vec.Cout(my_vec);
    return 0;
}

3.测试结果

---