【STL】之Vector的模拟实现

一：迭代器失效？

前面我们了解迭代器其实就是智能指针，可以通过运算符的操作来实现接口函数，但有时有会存在安全隐患。这就是我们常说的迭代器失效。所谓的迭代器失效其实是找某个位置的元素，删除，然后再通过operator++，operator--访问下一个元素，会出现野指针造成崩溃的问题；

如下：

#include<iostream>
#include<list>
using namespace std;
void TestList()
{
    list<int> l;
    l.push_back(1);
    l.push_back(2);
    l.push_back(3);

    list<int>::iterator it = l.begin();

    while (it!=l.end())
    {
        if (*it % 2 == 0)
        {
            l.erase (it);
        }
        ++it;
    }
    cout << endl;
}

我们分析程序为什么会挂掉，我们知道it是一个指针，当执行erase函数时，会将当前的指针释放掉，而it又要和下一个指针链上，这样就会出现一个非法的指针指向一个合法的指针，也就是常说的野指针的问题，从而导致内存崩溃，那么怎么才能防止野指针呢？

void TestList()
{
    list<int> l;
    l.push_back(1);
    l.push_back(2);
    l.push_back(3);
    l.push_back(4);

    list<int>::iterator it = l.begin();

    while (it!=l.end())
    {
        if (*it % 2 == 0)
        {
            it = l.erase (it);
        }
        else
        {
            ++it;
        }
    }
    cout << endl;
}

我们的方法时先把当前位置的元素删除，然后返回下一个迭代器，再通过operator++,或者operator--访问下一个元素。结果显示如下：

二：resize（）函数和reseve（）函数的区别：

我们先看resize函数：

void TestVector()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    vector<int> ::iterator it = v.begin();
    while (it!=v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    v.resize(2);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    v.resize(4);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    v.resize(6);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
}

为什么会出现这种结果?我们看看STL中是如何解释的。

在STL中resize（）函数的作用是改变vector元素的个数：

主要有三层含义：

1：如果n比vector容器的size小，结果size减小到n，然后删除n之后的数据。

2：如果n比vector容器的size大，扩展空间，然后在size后面插入元素并且初始化，否则初始化为缺省值。

3：如果n比vector容器的capacity还要大，自动进行内存分配。

reseve（）函数：

void TestVector()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    vector<int> ::iterator it = v.begin();
    while (it!=v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    v.reserve(2);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    v.reserve(4);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
    v.reserve(6);
    cout << "size:" << v.size() << endl;
    cout << "capacity:" << v.capacity() << endl;
}

在STL中reserve（）的作用是改变容量：

1：如果n的大小比vector的容量大，开空间增容到n

2:其他的情况，没有开空间，vetor的容量不受影响。而且size的值没有变化。

当然使用reserve的优点是减少开销。

总结resize（）函数时改变数组的个数并对其初始化，而reserve（）函数只是改变容量。

三.STL中Vector的模拟实现

.h文件
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
template <class T>
class Vector
{
public:
    typedef T* Iterator;
    typedef T* ConstIterator;
    Vector()
        :_start(NULL)
        ,_finsh(NULL)
        ,_EndOfStorage(NULL)
    {}
     //v1(v2)
    Vector(const Vector &v)
        :_start(NULL)
        , _finsh(NULL)
        , _EndOfStorage(NULL)
    {
        size_t size = Size();
        size_t capacity = Capacity();
        T*tmp = new T[capacity];//开辟空间
        for (size_t i = 0; i < size; ++i)//拷贝数据
        {
            //memcpy在string会出现浅拷贝
            tmp[i] = v._start[i];
        }
        delete[]_start;
        _start = tmp;
        _finsh = v._finsh;
        _EndOfStorage = v._EndOfStorage;
    }
    //v1 = v3
    Vector<T>&operator = (Vector<T>&v)
    {
        swap(_start, v._start);
        swap(_finsh, v._finsh);
        swap(_EndOfStorage, v._EndOfStorage);
        return *this;
    }
    ~Vector()
    {
        _Destroy();
    }

void PushBack(const T& val)
{
        _Expand(Capacity()*2 + 3);
        *_finsh = val;
        ++_finsh;
}
void PopBack()
{
    Erase(End());
}

//改变容量
void Reserve(size_t n)
{
        assert(n > 0);

        if (_finsh == _EndOfStorage)
        {
            _Expand(n);
        }
}
//改变数组的个数
void Resize(size_t n, T val = T())
{
    if (n > Capacity())
    {
        _Expand(n);
    }
    if (n < Size())
    {
        //--_Size();
        _finsh = _start + n;
    }
    else
    {
        for (size_t i = Size(); i < Capacity(); ++i)
        {
            _start[i] = val;
        }
    }
}
//随机位置的插入
void Insert(Iterator pos,size_t n, const T&x)
{
    size_t sub = pos - strat;//当前位置与_start的相对位置
    _Expand(n);//检查容量
    size_t pos = _start + pos;//更新pos防止迭代器失效
    Iterator it = _finsh;
    while (pos < it)
    {
        *it = *(it - 1);
        --it;
    }
    *pos = x;
    ++_finsh;
}
//随机位置的删除
void Erase(Iterator pos)
{
    if (Empty())
    {
        assert(false);
        return;
    }
    Iterator Cur = pos;
    Iterator end = End();
    while (Cur < end)
    {
        *Cur = *(Cur + 1);
        ++Cur;
    }
    --_finsh;
}
void _Destroy()
{
    if (_start != NULL)
    {
        delete[]_start;
    }
    _start = _finsh = _EndOfStorage = NULL;
}
size_t Size()
{
    return _finsh - _start;
}
size_t Capacity()
{
    return _EndOfStorage - _start;
}
//迭代器的操作
public:
    Iterator  Begin()
    {
        return _start;
    }
    Iterator End()
    {
        return _finsh;
    }
    bool Empty() const
    {
        return Begin() == End();
    }
    ConstIterator  Begin() const
    {
        return _start;
    }
    ConstIterator End() const
    {
        return _finsh;
    }
    T& operator[](size_t indes)
    {
        assert(indes < Size());
        return  _start[indes];
    }
    const T& operator[](size_t indes) const
    {
        assert(indes < Size());
        return  _start[indes];
    }
//增容
protected:
void _Expand(size_t n)
{
    assert(n > 0);
    assert(n > Capacity());
    T*tmp = new T[n];
    if (_start)
    {
        //memcpy()（string）存在浅拷贝
       for (size_t i = 0; i < Size(); ++i)
      {
            tmp[i] = _start[i];
       }
      delete[] _start;
    }
    size_t size = Size();
    _start = tmp;
    _finsh = _start + size;
    _EndOfStorage = _start + n;
}
protected:
        Iterator _start;
        Iterator _finsh;
        Iterator _EndOfStorage;
};

测试函数

cpp文件
#include"Vector.h"
void PrintVector(const Vector<int> &v)
{
    Vector<int> ::ConstIterator it = v.Begin();
    while (it != v.End())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}
void TestVector()
{
    Vector<int> v;
    v.PushBack(1);
    v.PushBack(2);
    v.PushBack(3);
    v.PushBack(4);
    PrintVector(v);


    v.PopBack();
    v.PopBack();
    v.PopBack();
    v.PopBack();
    PrintVector(v);
}
int main()
{
    TestVector();
    system("pause");
    return 0;
}

在这里面尤其注意的是在随机位置的插入Insert() 函数和随机位置的删除Erase() 函数：

1：此时的pos是个迭代器；挪动数据通过指针实现；

2：在进行插入时要进行容量检查，删除时要进行判空。