C++中的vector结构解读、迭代器失效问题以及模拟实现

1、vector的介绍

vector是一个容器，底层使用数组实现，那就意味着，可以使用下标对vector进行访问，和数组一样高效，但是又不像数组一样，他的大小是可以动态改变的，底层实现了扩容的逻辑，有的编译器也对缩容进行了实现。

本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

 vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

下面就介绍一个vector常用的一些操作函数

2、vector的定义

构造函数和赋值运算符的重载

(constructor)构造函数的声明	接口说明
vector()	无参构造
vector(size_type n,const value_type& val = value_type())	构造并初始化n和val
vector(const vector& x)	拷贝构造
vector(InputIterator first, InutInterator last)	使用迭代器进行初始化
vector& operator=(vector v)	赋值运算符的重载

构造函数和赋值操作和之前的string一样都涉及到了深度拷贝，如果自己对其进行实现的话，注意不能使用 memcpy() 和 memncpy() 对其进行拷贝，因为这样只是实现了一层深拷贝，如果构造的容器是一个多层容器嵌套，那么就会导致拷贝或者赋值前后的多个容器空间的底层指向同一块内存空间，那么在容器的声明周期结束的时候，析构函数就会对同一块空间进行过次析构，这样就会导致野指针访问，

#include 
using namespace std;
void test() {
    vector> vvi1(10);
    while(auto v : vvi1) {
        v.resize(10,0);
    }
    vector> vvi2(v1);
}

vector的迭代器相关

在C++的STL中，底层用顺序存储结构实现的，那么他的迭代器底层就是一个原始指针，其他的容器的迭代器我会在之后的文章中去进行解释，所以不能说迭代器就是原始指针，要对应实际的应用场景使用的容器。先来看看vector的迭代器：

iterator的使用	接口说明
begin()	获取第一个数据的位置iterator/const_iterator
end()	获取最后一个数据的下一个位置iterator/const_interator
rbegin()	获取最后一个数据的位置reverse_iterator
rend()	获取第一个数据的前一个位置reverse_interator

vector空间相关

容量空间	接口说明
size	有效数据个数
capacity	容量空间大小
empty	是否为空
resize	改变vector的size
reserve	改变vector的capacity

vector增删改查相关

增删改查	接口说明
push_back	尾插
pop_back	尾删
find	查找，(这个是算法模块实现的要包含头文件,不是成员接口)
insert	position之前插入value
erase	删除position位置的值
swap	交换两个vector的数据空间
operator[]	像数组一样访问

3、vector的迭代器失效问题

迭代器说白了就是给出一个概念，让使用者可以不用关心底层数据结构的实现。他的底层实际上就是一个封装过的指针。

如果说对一个满了的vector中添加数据，那就涉及到扩容的问题，C++中没有提供扩容的接口，所底层对于vector的扩容就是new一块大一点的空间，将原数据拷贝到新空间中，释放原空间，

那么在扩容后，我们拿到的迭代器还能用吗，

int main()
{
	vector v;
    v.resize(4);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    vector::iterator it = v.begin();
	while(it != v.end())
	{
        if(*it == 3) {
            v.insert(it,10);
        }
		cout << *it << " ";
	}
    cout << endl;
	return 0;
}

这个程序会崩溃，因为在插入之后，底层进行了扩容，迭代器it没有进行更新，就会造成野指针,正确的做法是对迭代器进行更新。

int main()
{
	vector v;
    v.resize(4);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    vector::iterator it = v.begin();
	while(it != v.end())
	{
        if(*it == 3) {
            it = v.insert(it,10);
        }
		cout << *it << " ";
	}
    cout << endl;
	return 0;
}

在删除的时候也会造成错误的运行结果：

int main()
{
	int ar[] ={1,2,3,4,0,5,6,7,8,9};
	int n = sizeof(ar) / sizeof(int);
	vector v(ar, ar+n);
	vector::iterator it = v.begin();
	while(it != v.end())
	{
		if(*it != 0)
			cout<<*it;
		else
			v.erase(it);
		it++;
	}
	return 0;
    输出：1,2,3,4,6,7,8,9
}

也应该对迭代器进行更新，有的比较新的编译器检查的比较严格，会对执行过erase的迭代器进行保护，不能在对其进行访问。

对vector进行模拟实现

namespace ltx
{
    template
    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(new T[n]), _finish(_start), _endOfStorage(_finish + n) {
            for (; n > 0; n--) {
                push_back(value);
            }
        }
        template
        vector(InputIterator first, InputIterator last) 
            : _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
        {
            while (first != last) {
                push_back(*first);
                first++;
            }
        }
        vector(const vector& v) 
            :_start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
        {
            reserve(v.capacity());
            iterator it = begin();
            const_iterator vit = v.cbegin();
            while (vit != v.cend()) {
                *it++ = *vit++;
            }
            _finish = it;
        }
        vector& operator= (vector 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()) {
                int size = this->size();
                T* temp = new T[n];
                int i = 0;
                if (_start) {
                    while (i < size) {
                        temp[i] = _start[i];
                        i++;
                    }
                    delete[] _start;
                }
                _start = temp;
                _finish = _start + size;
                _endOfStorage = _start + n;
            }
        }
        void resize(size_t n, const T& value = T()) {
            reserve(n);
            if (n < size()) {
                if (n > 0)
                    _finish -= n;
                else
                    _finish = _start;
            }
            else {
                for (int i = size(); i <= n; i++) {
                    push_back(value);
                }
            }
        }

        ///access///

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

        ///modify/

        void push_back(const T& x) {
            insert(end(),x);
        }
        void pop_back() {
            if (_finish != _start) {
                _finish--;
            }
        }
        void swap(vector& 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);
            // 空间不够先进行增容
            if (_finish == _endOfStorage)
            {
                //size_t size = size();
                size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
                reserve(newCapacity);
                // 如果发生了增容，需要重置pos
                pos = _start + size();
            }
            iterator end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                --end;
            }
            *pos = x;
            ++_finish;
            return pos;
        }
        iterator erase(iterator pos) {
            iterator temp = pos;
            while (temp != _finish) {
                *temp = *(temp + 1);
                temp++;
            }
            return pos;
        }
    private:
        iterator _start; // 指向数据块的开始
        iterator _finish; // 指向有效数据的尾
        iterator _endOfStorage; // 指向存储容量的尾
    };
}