【C++初阶8-vector实现】没想的那么简单！

最新推荐文章于 2023-11-07 20:31:05 发布
最新推荐文章于 2023-11-07 20:31:05 发布
阅读量601 收藏 8
点赞数 14
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BaconZzz/article/details/128527571
版权

前言

本期带来vector实现，和以前的顺序表差别不大。

博主水平有限，不足之处望请斧正！

预备知识

实现参考SGI的stl30

我们看这种源码，要抓框架看：首先找类，看它的属性，再看方法

template <class T, class Alloc = alloc>
class vector {
public:
  typedef T value_type;
  typedef value_type* iterator;
  typedef const value_type* const_iterator;
  
  //...
  
protected:
  iterator start;
  iterator finish;
  iterator end_of_storage;
  
  //...
}

public:
  iterator begin() { return start; }
  const_iterator begin() const { return start; }
  iterator end() { return finish; }
  const_iterator end() const { return finish; }
	
	//...

}

可以看到，vector是使用三个迭代器 start、 finish、 end_of_storage维护的，这是怎么个思路？

如图所示：

在这里插入图片描述

  • _start 指向起始位置
  • _finish 指向最后一个有效数据的下一个位置
  • _endofstorage 指向容量的下一个位置

有了这些储备，就能开始实现我们自己的vector了。

实现

分离

我们用一个 main.cpp 和一个 vector.h

#include <iostream>
using namespace std;

#include "vector.h"

int main()
{
		bacon::...; //调用测试函数
    return 0;
}

这里需要注意命名空间展开和包含头文件的顺序：为了编译速度，编译器找定义都是向上找。当 "vector.h" 展开，只会向上找——如果先包含 "vector.h" 后展开命名空间，"vector.h" 中使用 cout 之类向上就找不到。

跑起来
namespace bacon
{

template <class T>
class vector
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;

    
    iterator& begin() { return _start; }
    iterator& end() { return _finish; }
    const_iterator& begin() const { return _start; }
    const_iterator& end() const { return _finish; } 
    
    vector()
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    {}
    
    size_t capacity() { return _endofstorage - _start; }
    
    size_t size() { return _finish - _start; }
    
    void reserve(size_t n)
    {
        if(n > capacity())
        {
            size_t oldsize = size();
            T* tmp = new T[n];
            if(_start)
            {
                memcpy(tmp, _start, sizeof(T) * size());
            }
            delete[] _start;

            _start = tmp;
            _finish = _start + size(); 
            _endofstorage = _start + size();
        }
    }
    
    void push_back(const T& val)
    {
        if(_finish == _endofstorage)
            reserve(capacity() == 0 ? 4 : capacity() * 2);
        
        *_finish = val;
        ++_finish;
    }
    
    T& operator[](size_t index)
    {
        assert(index < size());
        return _start[index];
    }
    
    
private:
    iterator _start;
    iterator _finish;
    iterator _endofstorage;
};

void test1()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}

}

//main.cpp
#include <iostream>
using namespace std;

#include "vector.h"

int main()
{
    bacon::test1();
    return 0;
}

测一下发现报错了

在这里插入图片描述

注意：reserve这里非常容易出bug

    void reserve(size_t n)
    {
        if(n > capacity())
        {
            T* tmp = new T[n];
            if(_start)
            {
                memcpy(tmp, _start, sizeof(T) * size());
            }
            delete[] _start;
            _start = tmp;
          	//size():return _finish - _start
          	//_finish = _start + _finish - _start; 
            _finish = _start + size(); 
            _endofstorage = _start + size();
        }
    }

size()本来应该用老的_start来和_finish作差，但是_start变了，导致size()返回的不是0，而是_finish - _start，原语句则变成_finish = _start + _finish - _start; 最终_finish还是nullptr。

解决方案1：先更新_finish，仍然能用老的_start计算大小。

_finish = tmp + size();
_start = tmp;
_endofstorage = _start + size();

解决方案2：提前保存size，用临时保存的size迭代_finish和_endofstorage。

size_t oldsize = size();     
_start = tmp;
_finish = _start + oldsize;
_endofstorage = _start + oldsize;

所以reserve应该是这样：

		void reserve(size_t n)
    {
        if(n > capacity())
        {
            size_t oldsize = size();
            T* tmp = new T[n];
            if(_start)
            {
                memcpy(tmp, _start, sizeof(T) * size());
            }
            delete[] _start;

            //err:_start的改变影响size()
            //_finish = _start + size() = _start + _finish - _start = nullptr
            //1.调换顺序
            _finish = tmp + size();
            _start = tmp;
            _endofstorage = _start + size();
            
            //2.提前保存
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + n;
        }
    }

跑起来：

//vector.h
void test1()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}

//main.cpp
#include <iostream>
using namespace std;

#include "vector.h"

int main()
{
    bacon::test1();
    return 0;
}

1 2 3 4 1 2 3 4
补充成员函数
resize 、empty
    void resize(size_t n, T val = T())
    {
        if(n > capacity()) reserve(n); //需要扩就扩了
        
        if(n > size())
        {
            while(_finish < _start + n)
            {
                *_finish = val;
                ++_finish;
            }
        }
        else
        {
            _finish = _start + n;
        }
    }
    
    bool empty() { return _start == _finish; }

resize

  1. 需要扩容则扩容

  2. n > size:填数据

  3. n <= size:删除数据

    (n == size)包含在哪种情况都一样

跑一下：

void test2()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
    
    
    v.resize(100);
    cout << v.size() << endl;
    cout << v.capacity() << endl;
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}

//main.c
#include <iostream>
using namespace std;

#include "vector.h"

int main()
{
    bacon::test2();
    return 0;
}

1 2 3 4 1 2 3 4 
100
8
1 2 3 4 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
pop_back
    void pop_back()
    {
        assert(!empty());
        --_finish;
    }
insert
		void insert(iterator pos, const T& val)
    {
        if(_finish == _endofstorage)
            reserve(capacity() == 0 ? 4 : capacity() * 2);
        
        iterator end = _finish - 1; //最后一个有效数据
        while(end >= pos)
        {
            *(end + 1) = *end;
            --end;
        }
        
        *pos = val;
        ++_finish;
    }

测一下，发现报错。

因为属性换成 _start 这些，挪动数据的时候不会有类型提升影响。那是什么问题？

其实是迭代器是小问题

#在insert内部，迭代器失效

为什么？

在这里插入图片描述

未扩容前：

在这里插入图片描述

pos仍正常，属于_start 到 _finish 的范围内

在这里插入图片描述

扩容后：

在这里插入图片描述

画图分析一下：

在这里插入图片描述

扩容导致_start 和 _finish 变化，所以pos已经不属于 _start 到 _finish 的范围内了。此时，用 end 和 pos 比较显然不是我们的意思了。

所以如果扩容了，需要更新一下 pos（按理也要检查一下pos）。

所以insert内部迭代器失效的原因是：扩容，未更新迭代器。

怎么解决？

更新迭代器

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

        
        iterator end = _finish - 1; //最后一个有效数据
        while(end >= pos)
        {
            *(end + 1) = *end;
            --end;
        }
        
        *pos = val;
        ++_finish;
    }

在这里插入图片描述
:
在这里插入图片描述

更新成功。

void test4()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
    
    v.insert(v.begin(), 9);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}

1 2 3 4 
9 1 2 3 4

insert内部迭代器失效

原因：扩容，迭代器未更新，导致迭代器野指针。

解决：更新迭代器。


#在insert外部，迭代器失效
void test4()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
    
    vector<int>::iterator pos = find(v.begin(), v.end(), 2);
    v.insert(pos, 9);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    
    *(pos)++; //可以吗？
    
    cout << endl;
}

main 内 insert以后，pos能否继续使用？

不能，有可能是失效的。insert 内的迭代器是传值传参得到的，不影响main内的 pos ，而我们仅在 insert 内 更新了迭代器，若 insert时发生扩容，main 的 pos 不会被更新。

那有什么方式可以解决？

传值不行，传引用？还是不行。引用形参只能接收左值（能修改的），当我们传了右值，如 v.begin()，调用返回涉及到临时变量，就会出错。

Error:非常量引用的初始值必须为左值

看看文档，发现还有个返回值

		iterator insert (iterator position, const value_type& val);

文档中这样描述返回值：

An iterator pointing to the new location of the element that followed the last element erased by the function call. This is the container end if the operation erased the last element in the sequence.

一个迭代器，指向被函数调用删除的最后一个元素之后的元素的新位置。如果操作擦除了序列中的最后一个元素，则这是容器结束。

比如，某迭代器原来指向 v[3]，删除后指向新的 v[3]，如果 v[3] 是最后一个元素，迭代器就是_finish。

哦！当我们 insert 后还是需要用 pos ，通过返回值更新一下就好了！

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

        
        iterator end = _finish - 1; //最后一个有效数据
        while(end >= pos)
        {
            *(end + 1) = *end;
            --end;
        }
        
        *pos = val;
        ++_finish;
        
        return pos;
    }

insert外部迭代器失效

原因：insert的迭代器参数是传值传参，内部更新不影响外部。main的迭代器仍然失效。

解决：外部按需通过返回值更新迭代器。

erase

经历前面的迭代器失效后，我们也想：这个会不会也导致迭代器失效呢？

好像不会哦？因为不缩容，空间不会变的。用库里的测一下，看库怎么说：

		void test5()
    {
        std::vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);

        std::vector<int>::iterator pos = find(v.begin(), v.end(), 3);
        v.erase(pos);
        for (size_t i = 0; i < v.size(); ++i)
        {
            cout << v[i] << ' ';
        }
        cout << endl;

        //读
        cout << *pos << endl;
        //写
        ++(*pos);  
     }

vs2022：

在这里插入图片描述

Xcode：

1 2 4 
4
#在erase外部，迭代器失效

为什么？

  1. 意义来说，迭代器如果不更新，是失效的（原来指向的数据都删了，现在指向谁说不准）
  2. 而且我们的代码得在所有平台能跑。

所以我们还是认为 erase 后，迭代器失效。

怎么解决？

同样的，通过返回值来选择性更新（需要再用就更新）。

		iterator erase(iterator pos)
    {
        assert(!empty());
        assert(pos >= _start && pos < _finish);
        
        iterator begin = pos + 1;
        while(begin < _finish)
        {
            *(begin - 1) = *begin;
            ++begin;
        }
        --_finish; 
        
        return pos;
    }

erase外部迭代器失效

原因：意义改变

解决：按需通过返回值更新迭代器

find

可以直接用算法库的find了

template<class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val)
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}

算法库的find是函数模版，只需要我们的vector支持 != 、 *、 ==、 ++就行。

void test4()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
    
    vector<int>::iterator pos = find(v.begin(), v.end(), 2);
  	if(pos != v.end())
    	v.insert(pos, 9);
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << v[i] << ' ';
    }
    cout << endl;
}

1 2 3 4 
1 9 2 3 4
swap
		void swap(vector<T>& v)
    {
        std::swap(this->_start, v._start);
        std::swap(this->_finish, v._finish);
        std::swap(this->_endofstorage, v._endofstorage);
    }
clear
    void clear() { _finish = _start; }
~vector
    ~vector()
    {
        delete[] _start;
        _start = _finish = _endofstorage = nullptr;
    }
vector(const vector<T>& v)

传统写法：开空间，拷贝数据（复用）

    vector(const vector<T>& v)
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
    {
        reserve(v.capacity());
        for(auto& e : v) 	//不加引用每次拿v内对象赋值给e，效率低
        {
            push_back(e);
        }
    }

现代写法：抓壮丁（迭代器区间构造）

vector(InputIterator first, InputIterator last)
    template <class InputIterator>
    vector(InputIterator first, InputIterator last)
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
    {
        while(first != last)
        {
            push_back(*first);
            ++first;
        }
    }

    vector(const vector<T>& v)
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
    {
        vector<T> man(v.begin(), v.end());
        swap(man);
    }
vector<T>& operator= (vector<T>& v)

现代写法：抓壮丁（传值传参调用拷贝构造产生的临时对象）

    vector<T>& operator= (vector<T> v)
    {
        swap(v);
        return *this;
    }

只要拷贝构造写好了，都能用这个现代写法~

但是，上面的写法有一个缺陷：v1 = v1，自己给自己赋值，白拷贝了。但可以容忍，因为这种场景非常少，而且程序能正常运行。

想实现全一点的话还可以实现一个这个。

explicit vector (size_type n, const value_type& val = value_type()

explicit：由于这是个单参构造，涉及赋值运算符的时候，若类型合适，可能将 n 转换为 vector。

class t1
{
public:
	t1(int n) :_n(n) {}
private:
	int _n;
};

class t2
{
public:
	explicit t2(int n) :_n(n) {}
private:
	int _n;
};

int main()
{
	int num = 0;

	t1 t1 = num;
	
	t2 t2 = num;

	return 0;
}

如上，单参构造类型合适（int的形参和要初始化的属性合适），int n 转换成了t1 n。

如此能防止单参构造的 n 转换为 vector。

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

但是，这有个坑。

#n个val构造的匹配问题
void test9()
{
  	//vector<char> v(10, 'A'); //正常运行
    vector<int> v(10, 1);
    
    for(auto e : v)
        cout << e << ' ';
    cout << endl;
}

在这里插入图片描述

vector<int> v(10, 1);

vector(size_t n, const T& val = T())

template <class InputIterator>
    vector(InputIterator first, InputIterator last)

为什么vector<char> v(10, 'A');能匹配到vector(size_t n, const T& val = T())?

10这个字面量的类型是int，'A'这个字面量的类型是char，模版参数T上绑定了char类型。虽然int到size_t有一点不匹配，但是可以类型转换，也没有其他更加匹配的函数。

而对于vector<int> v(10, 1);，两个字面量类型都是int，调用vector(size_t n, const T& val = T())需要将int转换为size_t，函数模版显然能产生更好的匹配，int被当做迭代器解引用，当然不行。

那如何解决呢？

想不到办法可以参考源码的实现

  vector() : start(0), finish(0), end_of_storage(0) {}
  vector(size_type n, const T& value) { fill_init ialize(n, value); }
  vector(int n, const T& value) { fill_initialize(n, value); }
  vector(long n, const T& value) { fill_initialize(n, value); }
  explicit vector(size_type n) { fill_initialize(n, T()); }

直接一样来一个。

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

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

原因：迭代器区间模版更匹配
解决：一样来一个，让它匹配

到这就差不多了……吗？

我们开空间的操作还有问题！拷数据简单地用memcpy就能解决吗？不能！当要拷贝的元素涉及深拷贝就完了！

#元素浅拷贝问题
void test11()
{
    vector<int> v(10, 1);
    vector<vector<int>> vv;
    
    vv.push_back(v);
    for(size_t i = 0; i < vv.size(); ++i)
    {
        for(size_t j = 0; j < vv[i].size(); ++j)
        {
            cout << vv[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl;
}

在这里插入图片描述

void reserve(size_t n)
    {
        if(n > capacity())
        {
            size_t oldsize = size();
            T* tmp = new T[n];
            if(_start)
            {
//                浅拷贝不够用，有些要深拷贝的
                memcpy(tmp, _start, sizeof(T) * size());
            }
            delete[] _start;
            
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + n;
        }
    }

对于reserve画图分析一下：

在这里插入图片描述

这是浅拷贝后未释放空间的情况，vv的属性直接拷贝给tmp ，vv 和 tmp 指向同一块空间。这时再 delete[] _start; ，对每个自定义类型vector<int> v都调用析构，在这之前，每个vector<int> v 又会对自己的空间调用析构。
在这里插入图片描述

扩容后，vv指向新空间，但新空间的前4个元素的空间已经被析构，此时如果vv[0][0]，解引用野指针，必然出错。

调试验证：

1.浅拷贝，新空间指向原空间

在这里插入图片描述

2.原空间释放，新空间受影响，[_start, _start+4) 变成野指针
在这里插入图片描述

3.解引用野指针（对野指针的访问，打印出随机值）

在这里插入图片描述

为什么说C++不适合用C语言的内存函数，这里若用realloc，其内部memcpy拷贝数据，完球。（要使用必须确定不会影响）

对于哪哪都是自定义类型的C++，我们尽量选择为其量身定制的new 和 delete，会自动调用构造和析构。

如何解决？自然是每个元素都深拷贝：

void reserve(size_t n)
    {
        if(n > capacity())
        {
            size_t oldsize = size();
            T* tmp = new T[n];
            if(_start)
            {
//                浅拷贝不够用，有些要深拷贝的
//                memcpy(tmp, _start, sizeof(T) * size());
                for(size_t i = 0; i < oldsize; ++i)
                {
                    tmp[i] = _start[i];
                }
            }
            delete[] _start;
            
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + n;
        }
    }

在这里插入图片描述

解决是解决了，效率是不是有点低？确实，现阶段没有好的解决办法，后期学了C++11就有了。

此处的问题不仅出现在刚刚的场景，只要是涉及 reserve 拷贝数据的地方，都会出现问题，如 拷贝构造 ，其中调用了 push_back，会调用到 reserve。

vector的实现到这就差不多了，附上整体代码（如有错误不足之处，希望指出）

namespace bacon
{

template <class T>
class vector
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    
    
    iterator begin() { return _start; }
    iterator end() { return _finish; }
    const_iterator begin() const { return _start; }
    const_iterator end() const { return _finish; }
    
    vector()
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    {}
    
    //explicit:对于单参的构造，类型合适的时候会触发隐式类型转换
    //这里是怕n隐式类型转换成vector，传size_t就不会转换成vector
    explicit vector(int n, const T& val = T())
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    {
        reserve(n);
        for(int i = 0; i < n; ++i)
        {
            push_back(val);
        }
    }
    
    //按n的类型再给一个（long也能再给一个）方法，解决参数不匹配的问题
    explicit vector(size_t n, const T& val = T())
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    {
        reserve(n);
        for(int i = 0; i < n; ++i)
        {
            push_back(val);
        }
    }
    
    template <class InputIterator>
    vector(InputIterator first, InputIterator last)
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    //这里的实现体现了迭代器的意义，不同的迭代器，同样的控制，一套代码走所有容器
    {
        while(first != last)
        {
            push_back(*first);
            ++first;
        }
    }
    
    //现代写法
    vector(const vector<T>& v)
    :_start(nullptr)
    ,_finish(nullptr)
    ,_endofstorage(nullptr)
    {
        vector<T> man(v.begin(), v.end());
        swap(man);
    }
    
    //复用写法
    //    vector(const vector<T>& v)
    //        :_start(nullptr)
    //        ,_finish(nullptr)
    //        ,_endofstorage(nullptr)
    //    {
    //        reserve(v.capacity());
    //        for(auto& e : v) //不加引用每次拿v内对象赋值给e，效率低
    //        {
    //            push_back(e);
    //        }
    //    }
    

    ~vector()
    {
        delete[] _start;
        _start = _finish = _endofstorage = nullptr;
    }
    
    //v1 = v1
    vector<T>& operator= (vector<T> v)
    {
        swap(v);
        return *this;
    }
    
    bool empty() const { return _start == _finish; }
    
    size_t capacity() const { return _endofstorage - _start; }
    
    size_t size() const { return _finish - _start; }
    
    void reserve(size_t n)
    {
        if(n > capacity())
        {
            size_t oldsize = size();
            T* tmp = new T[n];
            if(_start)
            {
//                浅拷贝不够用，有些要深拷贝的
//                memcpy(tmp, _start, sizeof(T) * size());
                for(size_t i = 0; i < oldsize; ++i)
                {
                    tmp[i] = _start[i];
                }
            }
            delete[] _start;
            
            //err:_start的改变影响size()
            //_finish = _start + size() = _start + _finish - _start = nullptr
            //1.调换顺序
            //            _finish = tmp + size();
            //            _start = tmp;
            //            _endofstorage = _start + size();
            
            //2.提前保存
            _start = tmp;
            _finish = _start + oldsize;
            _endofstorage = _start + n;
        }
    }
    
    void resize(size_t n, T val = T())
    {
        //        1. 需要扩容则扩容
        //        2. n > size:填数据
        //        3. n <= size:删除数据
        //        (n == size)包含在哪种情况都一样
        if(n > capacity()) reserve(n); //需要扩就扩了
        
        if(n > size())
        {
            while(_finish < _start + n)
            {
                *_finish = val;
                ++_finish;
            }
        }
        else
        {
            _finish = _start + n;
        }
    }
    
    void push_back(const T& val)
    {
        if(_finish == _endofstorage)
            reserve(capacity() == 0 ? 4 : capacity() * 2);
        
        *_finish = val;
        ++_finish;
    }
    
    void pop_back()
    {
        assert(!empty());
        --_finish;
    }
    
    iterator insert(iterator pos, const T& val)
    {
        assert(pos >= _start && pos < _finish);
        
        if(_finish == _endofstorage)
        {
            size_t len = pos - _start;
            reserve(capacity() == 0 ? 4 : capacity() * 2);
            pos = _start + len;
        }
        
        
        iterator end = _finish - 1; //最后一个有效数据
        while(end >= pos)
        {
            *(end + 1) = *end;
            --end;
        }
        
        *pos = val;
        ++_finish;
        
        return pos;
    }
    
    iterator erase(iterator pos)
    {
        assert(!empty());
        assert(pos >= _start && pos < _finish);
        
        iterator begin = pos + 1;
        while(begin < _finish)
        {
            *(begin - 1) = *begin;
            ++begin;
        }
        --_finish;
        
        return pos;
    }
    
    void swap(vector<T>& v)
    {
        std::swap(this->_start, v._start);
        std::swap(this->_finish, v._finish);
        std::swap(this->_endofstorage, v._endofstorage);
    }
    
    void clear() { _finish = _start; }
    
    
    T& operator[](size_t index)
    {
        assert(index < size());
        return _start[index];
    }
    
    const T& operator[](size_t index) const
    {
        assert(index < size());
        return _start[index];
    }
    
    
private:
    iterator _start;
    iterator _finish;
    iterator _endofstorage;
};


}

重点回顾

insert内部的迭代器失效

  • 原因：扩容，迭代器未更新，野指针
  • 解决：需要扩容则更新迭代器

insert外部的迭代器失效

  • 原因：insert迭代器传值传参，内部更新不影响外部
  • 解决：按需用返回值更新迭代器

erase外部的迭代器失效

  • 原因：迭代器指向的数据已经删除，迭代器意义改变
  • 解决：按需用返回值更新迭代器

n个val构造类型不匹配

  • 原因：有些场景类型不够匹配，会走到迭代器区间构造（模版）
  • 解决：按n可能传的类型，多写几个这样的构造

元素浅拷贝问题

  • 原因：对自定义类型的元素浅拷贝，指向错误，导致新空间被影响
  • 解决：对每个元素的拷贝都调用它们自己的赋值重载或者拷贝构造等。

今天的分享就告一段落了。

这里是培根的blog，期待与你共同进步！

下期见~

周杰偷奶茶
关注
  • 14
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
【C++】vector容器的模拟实现
ly_6699的博客
03-10 1033
vector容器实际是一个动态数组，它与array的操作非常相似。最大的区别就在于vector的“动态”，动态的理解就是数组的扩容由vector内部机制实现动态开辟空间，无需用户手动操作（申请新空间-复制元素-释放原空间）。 下面我将通过对vector的理解，自己模拟实现vector的基本操作方法，供大家更好的理解这个容器。 下面是vector函数实现的思想，最下面附有笔者完整代码和测试类，有需要的自取~
vector的实现（c++）
m0_68641696的博客
05-25 1626
vector的部分接口实现的代码
vector的实现及总结
qq_41078889的博客
08-17 3704
vector: vector的数据安排以及操作方式与array非常类似。两者唯一的差别就是在于空间的运用灵活性，array是静态空间，一旦分配了就是固定的，无法改变其大小。需要用户重新申请更大的空间，移动数据，释放原来的空间。而vector是动态空间，有其内部的空间分配机制来及时调整空间大小，其实就是vector把申请空间，移动数据，释放原来的空间等操作封装在内部，不需要用户去处理。 接下来我们自己实现一下vector，并给其加上空间配置器。 // 简单的vector容器实现，主要查看其嵌套类ite
【C++】自己编写函数实现Vector部分功能
Quentin的博客
09-09 845
写在前面 该题目源于哈工大竞技机器人队视觉组暑期培训，感觉很有意思，决定放在博客上留存。 题目 动手实现Vector，要求如下： 自己动手实现一个泛型的动态数组，并实现Vector中的部分操作：push_back、pop_back、.at、[]、clear和复制构造函数。要求构造和析构正确。（注意是动态数组，所以要求不能直接使用普通的定长数组或者链表实现）要求main中有该类对象的调用。 对上述的程序添加预编译命令，使得其在DEBUG阶段加入一些调试信息...
用c++写vector
最新发布
nnnnn_36D的博客
11-07 47
vector.h文件。main.cpp文件。
C++ vector----臭飯飯_C++_vector_
10-03
在C++编程语言中，`std::vector`是标准模板库(STL)中的一种容器，它提供了动态数组的功能。`vector`是一个可以容纳任意类型的对象的容器，它能够自动管理内存，允许我们在运行时改变其大小。这个容器的灵活性使得它...
[C++]STL-vector容器
01-06
当插入新元素时，如果空间不足，那么vector会重新申请更大的一块内存空间，将原来空间拷贝到新空间上，释放旧空间的数据，再把新元素插入新申请的空间。 默认会申请两倍的新空间，但当空间达到一定大小时，会动态...
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C/C++实现HMAC-SHA1和base64编码
12-16
C语言版的实现HMAC-SHA1和base64编码，已经对C++做了兼容处理,在VS下运行main.c代码，可以得到经过HMAC-SHA1处理后的结果，并且可以运行里面的base64编码函数得到想要的结果，可以用于连接阿里云MQTT
C++实现 vector 的四则运算
09-02
在C++编程中，`vector`是一个常用的容器，它提供了动态数组的功能，允许存储同一类型的元素集合。在本文中，我们将探讨如何实现高效地对`vector`进行四则运算，即加法、减法、乘法和除法。通常，当我们需要对两个`...
自己实现的vector
06-18
自己实现的vector，优化的动态内存管理
自己实现vector不使用泛型
09-06
这是自己用在不使用泛型的基础上，用c++实现的一个vector功能，经过10万测试考验，没问题可用，如果大家有更好的建议和意见，还请指出，有不对的地方也请指出，大家一起进步，学习，加油。
STL中vector类的自我简单实现
qq_55143256的博客
04-18 476
前面写了STL中关于string类的自我实现,感兴趣的小伙伴可以移步至这里((45条消息) STL中string类的自己实现_芜湖开冲～的博客-CSDN博客https://blog.csdn.net/qq_55143256/article/details/124212845),接着上面,今天我们来实现vector类的简单实现(友情提示:很全,比我网上找到的大部分都全),所谓的vector类,其实就是顺序表,只不过这个顺序表不仅能存放int,还能存放各种各样的类型,vector类的实现其实也不是很难,别看底下
vector的实现
weixin_66232462的博客
03-17 256
最主要的是迭代器失效的问题以及如何解决
自己实现vector(C++)
mwt_442396446的博客
07-13 211
#ifndef MVECTOR_H #define MVECTOR_H #include<iostream> #include"vector_iterator.h" using namespace std; template<typename T> class Mvector { public: typedef Vector_Iterator<Mvector<T>> iterator; Mvector(T* arr, int len) { _len
[C++] std::vector
weixin_55664293的博客
05-30 5020
std::vector template < class T, class Alloc = allocator<T> > class vector; // generic template vector是表示可以改变大小的数组的序列容器。 就像数组一样，向量对其元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针上的偏移量来访问它们的元素，并且与在数组中一样有效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。 在内部，向量使用动态分配的数组来
【C++】STL —— vector基本使用
M的博客
06-08 2540
vector常用接口一张思维导图帮你总结
(C++) 简单实现vector
cuber-lotus的博客
06-25 381
对于自己尝试写的一些模仿标准库等操作。永远不要觉得自己实现的有多nb，在各大编译器的标准库面前就是个弟弟。因此别再觉得自己数据结构课上写的那些基础线性表操作有多熟料，只能说人外有人，山外有山。对于实现一个vector的基本考虑数据类型的声明构造 constructor析构 destructor拷贝 移动 copy move迭代器 iterators存取器 accessor容量 capacity修改器 modifier尾部追加删除 do_back运算符重载等等等等。
SHA-1算法C++实现
03-10
本文档是用C++语言实现SHA-1算法的过程，提供了清晰的逻辑结构和详细的注释，方便理解和学习。 首先，SHA-1算法的核心步骤包括初始化五个32位（8字节）的哈希寄存器A、B、C、D和E，它们的初始值分别为A0、B0、C0、D...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

周杰偷奶茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值