【c++】模拟实现vector

一.vector的成员变量与迭代器

vector里面可以存各种数据类型，所以必定会用到模板，假设vector的模板参数为T，那么T*这个指针封装后就是vector的迭代器

和string的迭代器很像，只不过string确定存的是字符，所以迭代器直接是char的指针，而vector存的数据类型不确定，就使用T的指针

而vector的3个成员变量_start,_finish,_endofstorage也就是3个迭代器，分别指向vector的开头，vector有效数据的结尾，vector容量的结尾

二.主干结构

namespace cyf
{
    
    template<class T>
    class vector
    {
        typedef T* iterator;
    public:
        //...
    private:
        //迭代器可看作一个指针,但也有区别
        iterator _start;//起始位置
        iterator _finish;//最后一个有效元素的下一位置
        iterator _endofstorage;//最大容量位置下一位
    };
}

三.构造函数和析构函数

1.构造函数

// 1
vector(size_t n, const T& val = T())
// 调用resize()接口需要计算size()和capacity()，所以要进行初始化
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
        resize(n,val);
}
// 用 n 个 val 值进行初始化，可以复用 resize 接口，但要注意调用resize()接口需要计算size()和capacity()，所以要将成员变量进行初始化

// 2
template<class InputIterator>
vector(InputIterator first, InputIterator last)
    : _start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}
//   用一段迭代器区间进行初始化，由于不同类型的容器迭代器类型可能不同，因此设计成函数模板，将区间内的内容尾插入vector即可，但注意调用push_back接口通过 _finish == _endofstorage 判断是否满，需要初始化


// 3
vector(size_t n, const T& val = T())
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    reserve(n);
    for (size_t i = 0;i < n;++i)
    {
        push_back(val);
    }
}


// 4
vector(int n, const T& val = T())
    :_start(nullptr)
    , _finish(nullptr)
    , _endofstorage(nullptr)
{
    reserve(n);
    for (size_t i = 0;i < n;++i)
    {
        push_back(val);
    }
}

构造函数3和4的原因是当 vector<int> v(10,5)去初始化时 这是因为当使用两个参数进行构造时，编译器会优先匹配构造函数 （2），10和5都是int 类型但是1中对应的是size_t和int类型，所以编译器会优先匹配构造函数 2 ，此时对*first解引用会报错。所以需要再实现两个不同参数类型的构造函数重载：

2.析构函数

        ~vector()
        {
            if (_start)
            {
                delete[] _start;//释放空间
            }
            _start = _finish = _end_of_storage = nullptr;//置空
        }

四.reserve和resize

   void reserve(size_t n)
{
    if (n > capacity())
    {
        T* tmp = new T[n]; // 新开辟一块空间
        // 容器不为空
        if (_start)
        {
            size_t sizecp = size(); // 计算原来容器size个数
            for (size_t i = 0; i < size(); i++) // 拷贝数据
            {
                tmp[i] = _start[i];
            }
            delete[]_start; // 释放旧空间

            _start = tmp; // 更新_start
            _finish = _start + sizecp; // 更新_finish
            _endofstorage = _start + n; // 更新_endofstorage
        }
        // 容器为空，更新_start，_finish，_endofstorage的位置
        else
        {
            _start = _finish = tmp;
            _endofstorage = _start + n;
        }
    }
}

在reserve模拟实现时最容易犯的错误就是用memcpy进行拷贝数据 ，因为对于需要深拷贝的自定义类型，使用memcpy函数以后，新开辟空间里的元素和原空间里的元素所指向的内存空间是一样的，但是对于自定义类型来说扩容就需要深拷贝，memcpy拷贝完成后释放旧空间，当旧空间被释放时，会调用自定义类型的析构函数，从而使得新开辟空间里的元素指向的内存空间也被释放掉了，此时新空间中_start指向的就是被释放的空间，vector使用完后会自动调用析构函数，将_start指向的空间置为nullptr，将不属于自己维护的空间置为空释放就会报错。

void resize(size_t n, const T& val = T())//泛型编程用匿名对象给缺省值
    {
        if (n <= size())
        {
            _finish = _start + n;
        }
        else
        {
            if (n > capacity())
            {
                reserve(n);
            }
            while (_finish < _start + n)
            {
                *_finish = val;
                _finish++;
            }
        }
    }

当n<size时直接将_finish移动到_start+n的位置但是容量是不变的

当n>size并且大于capacity时先扩容然后填充数据

五.拷贝构造与operator=

        vector(const vector<T>& v)
            :_start(nullptr)
            , _finish(nullptr)
            , _endofstorage(nullptr)
        {
            reserve(v.capacity()); //直接push_back的话capacity可能不一样大
            for (auto e : v)
            {
                push_back(e);
            }
            
        }

• 进行拷贝构造时我们也容易使用memcpy进行拷贝，也会造成和reserve一样的问题

• 所以我们可以用另一种巧妙的方式避免浅拷贝，那就是先扩容然后遍历要拷贝的vector，将其中每一个数据push_back进新的vector中

        void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endofstorage, v._endofstorage);
        }
        vector<T>& operator=(vector<T> v)
        {
            swap(v);
            return *this;
        }

六.插入和删除

    void push_back(const T& x)
    {
        if (_finish == _endofstorage)
        {
            size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
            reserve(newcapacity);
        }
        *_finish = x;
        _finish++;
    }

尾插首先检查容量，如果没有容量就扩容，在有效元素的下一个位置插入数据，并且挪动_finish的位置

void pop_back()
        {
            assert(!empty());
            _finish--;
        }

尾删要保证有元素才能进行删除，只需要挪动_finish 的位置即可

void insert(iterator pos, const T& x)
        {
            assert(pos < _finish);
            if (_finish == _endofstorage)
            {
                size_t len = pos - _start;
                size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapacity);
                pos = _start + len;
            }
            iterator end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                end--;
            }
            *pos = x;
            _finish++;
            
        }

在pos位置插入数据x 首先检查pos位置的合理性，然后检查容量,从后往前挪动数据在pos 位置插入数据然后++_finish

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

覆盖性删除元素注意边界的问题

七.其他接口

iterator begin()
{
    return _start;
}
iterator end()
{
    return _finish;
}
const_iterator begin()
{
    return _start;
}
const_iterator end()
{
    return _finish;
}


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


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

八.迭代器失效问题

1. • 扩容导致迭代器失效

#include <iostream>
#include <vector>
using namespace std;

void Test()
{
    vector<int> v{ 1,2,3,4,5,6 };
    auto it = v.begin();

    // 将有效元素个数增加到100个，多出的位置使用1填充，操作期间底层会扩容
    // v.resize(100, 1);
    
    // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
    // v.reserve(100);
    
    // 插入元素期间，可能会引起扩容，而导致原空间被释放
    // v.insert(v.begin(), 0); // v.push_back(8);
    
    // 给vector重新赋值，可能会引起底层容量改变
    v.assign(100, 8);

    while (it != v.end()) 
    {
        cout << *it << " ";
         ++it;
    }
    cout << endl;
}

int main()
{
    Test();
    return 0;
}

出错原因： 以上操作，都有可能会导致vector扩容，也就是说vector底层原来旧空间被释放掉， 而在打印时，it还使用的是释放之前的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间而引起代码运行时崩溃。

解决方式： 在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可

2.erase导致迭代器失效

#include <iostream>
#include <vector>
using namespace std;

void Test()
{
    int a[] = { 1, 2, 3, 4 };
    vector<int> v(a, a + sizeof(a) / sizeof(int));
    // 使用find查找3所在位置的iterator
    auto pos = find(v.begin(), v.end(), 3);
    // 删除pos位置的数据，导致pos迭代器失效。
    v.erase(pos);
    cout << *pos << endl; // 此处会导致非法访问
}

int main()
{
    Test();
    return 0;
}

erase删除pos位置元素后，pos位置之后的元素会往前移，没有导致底层空间的改变，理论上讲迭代器应该不会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是 没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

总之，使用迭代器应注意迭代器失效问题，解决办法是：在使用前，对迭代器重新赋值即可