【C++、stl】vector模拟实现（附带源码和注释）

已于 2023-11-15 23:14:32 修改
阅读量101 收藏
点赞数 1
分类专栏： c++ 文章标签： c++ stl 学习 经验分享 visualstudio c语言 容器
于 2023-11-12 15:15:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/White_popalr/article/details/134340470
版权

文章目录

前言

本文章对我们stl标准库中的vector容器进行实现

一、模拟前准备

模拟模拟，我们先要知晓其模样是怎样的才能模拟，所以我们首先打开stl库的源码来大概了解一下vector的基本实现模式。

1.源码使用方式

我们使用源码时一行行的看可不行，不信去自己去试一试，大量的typedef会让你晕头转向，而且现阶段理解也不重要。所以我们要按照规律来对源码庖丁解牛，同时对不懂的成员变量和函数也要大胆猜测：

①先找到我们vector的成员变量看看：

在这里插入图片描述

protected:
  iterator start;
  iterator finish;
  iterator end_of_storage;

首先它是一个迭代器类型的，我们可以右键速览定义浅浅看看iterator是什么，虽然我们看不懂，但是注释很清楚的告诉我们迭代器就是一个类！具体我们了解迭代器类请点击转到另一篇文章：链接: 【C++、stl】迭代器是什么？迭代器理解！，看完此篇后便了解了vector可以用我们容器原生指针做迭代器。
在这里插入图片描述
于是在我们眼中，这三个变量不过是三个指向vector容器空间的指针罢了。
但是这三个指针成员变量和我们熟知的数据结构中的顺序表成员有很大差别啊，那么我们怎么知道它们分别是干甚么的呢？
答案是：先看我们的构造函数，再看一些可以改变我们成员变量的插入等函数。

②再找到我们的构造函数和插入接口以了解成员变量

构造函数：

看我们的构造函数再配合c++文档，我们可以很容易知道这些重载的构造函数的作用，对于第二个用n个value值为函数初始化的构造函数 vector(size type n, const T& value) ，我们再次右键看不懂的函数fill_initialize对其速览：
在这里插入图片描述
此时就不要再对allocate_and_fill函数速览了，因为这里涉及空间配置器（内存池）知识，我们当前无需深究，我们只要知道它是开辟空间的函数就可以了，开启我们连蒙带猜模式，allocate_and_fill这几个单词不就是分配和填满吗？结合我们c++文档中了解到的这个构造函数的作用是用n个T类的变量为vector初始化，所以我们很自然想到allocate_and_fill是一个开辟空间n个T的值并返回该空间的函数，所以我们指针start便很自然的指向我们开辟的空间的头位置，finish便是空间的尾位置的指针，结合名字猜测end_of_storage便是我们空间实际容量位置的指针了。
在这里插入图片描述

我们再看看我们插入接口验证我们的答案：
在这里插入图片描述

if-else这里我们有了初阶数据结构的经验很容易知晓这是我们的判断vector是否满的逻辑。这里如果还是不能验证我们上面的猜测，我们可以把开辟空间的reserve函数和插入insert函数拉出来：

③再找到我们的reserve函数和插入insert函数验证猜测

reserve函数：
在这里插入图片描述
insert函数：
在这里插入图片描述

二、开始模拟

1.模版参数定义

我们使用模版实现的vector，以至于可以用多种类型实例化vector。

template<class T>

T为我们vector的模版参数。

2.typedef部分

因为我vector的存储空间连续，所以我们模拟时就直接用vector的空间的指针做它的迭代器，用const类的指针做const类的迭代器。

 // Vector的迭代器是一个原生指针
        typedef T* iterator;
        typedef const T* const_iterator;

3.成员变量部分

我们模仿库中的实现，为我们的vector类添加3个成员变量，分别指向vector空间中实际数据的头、尾和实际储存容量的尾。

private:
        iterator _start= nullptr; // 指向数据块的开始
        iterator _finish= nullptr; // 指向有效数据的尾
        iterator _endOfStorage= nullptr; // 指向存储容量的尾

4.构造函数

①默认构造函数

 vector()
            //这里我们甚至不用为成员变量初始化，因为自从c++11之后有了成员变量的缺省值可用，我们可以直接在成员变量位置加nullptr
            //:_start(nullptr)
            //,_finish(nullptr) // 指向有效数据的尾
            //,_endOfStorage(nullptr)
        {}

我们这里可以将注释取消，用初始化列表为我们认成员变量初始化，但cpp11后有了成员变量的缺省值，所以我们在声明成员变量时就就为其加上了一个缺省值，在这里就无需再为变量初始化了。

②用n个T类变量初始化的构造函数

 //以下两个构造是文档中第二第三个构造
        vector(size_t n, const T& value = T())
        {
            resize(n, value);
        }

这里对resize函数进行了复用。

②用一个迭代器区间初始化的构造函数

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

这里是什么？它有什么含义？
这很明显是一个模版，我们虽然是在用模版写vector，但是我们在实现vector的函数时也可以用模版写，他的模版参数取名为InputIterator也是因为这里的模版参数之后是要接收迭代器类型的，这样我们就得到了一个迭代器类的区间[first,last)，而我们对迭代器区间访问，然后逐个解引用并传给push_back函数，便为vector插入了这个迭代器对象内部成员变量的数据。
注意：
A: 这里就算T类是一个自定义类也是可以插入的，因为我们push_back函数中的（*_finish = x）也调用了自定义类的赋值重载。
B: 这里的模版参数可以是别的容器的迭代器也可以使vector自己的迭代器，甚至可以单纯用一个数组的指针区间做模版参数。

5.拷贝构造函数

普通写法

 vector(const vector<T>& v)
        {
            /*iterator tmp=new T[v.capacity()];
            _start = tmp;*/
            //不用多此一举，可以改为=》
            _start= new T[v.capacity()];
            /*memcpy(_start,v._start,sizeof(T)* v.size());*/
            //这里要是用memcpy会出现问题，因为memcpy是简单的浅拷贝，扩容逻辑这里也是用的memcpy也需要改一下
            //简单浅拷贝的话在用自定义类实现的vector调用该拷贝函数时会出现vector中的自定义类被重复析构的情况。
            //所以我们需要用深拷贝实现我们的拷贝函数=》
            for (size_t i = 0; i < v.size(); i++)
            {
                //这里的[]是返回的是类型T的引用，而=又访问的是T类型自己的赋值重载，如在用string实例化的vector中：_start[i]逐步访问了
                //每个vector中的string，并调用了string的赋值重载=，实现了对string自定义类型的深拷贝。
                _start[i] = v._start[i];
            }
            _finish = _start + v.size();
            _endOfStorage = _start + v.capacity();
        }

这里也要注意不要单纯的memcpy内部空间，因为memcpy只是单纯的浅拷贝，这样会出现两个vector变量同时指向一片空间的问题，这是一个很严重的问题，会导致一片空间被析构函数析构两次，编译器毫无疑问无法通过。

现代写法

 //或者有另一种现代的拷贝函数的写法：
       /* vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto e : v)
            {
                push_back(e);
            }
        }*/
       //这种拷贝函数调用的是vector的push_back,而push_back函数中的（*_finish = x）也调用了自定义类的赋值重载;
       //这里值得注意的是：我们用来实例化的自定义类型一定要有赋值重载，不然就是自己坑自己。

这里的现代写法其实和普通的本质上没什么区别：
A：普通用new开辟空间，而现代的复用了reserve函数，本质也是new的空间。
B：普通的用_start[i] = v._start[i]，访问到元素并调用了元素的“=”赋值重载，以实现深拷贝。而现代的调用了push_back函数，它内部也是调用了元素的“=”赋值重载实现了深拷贝。
C（不同点/优化点）：现代的push_back函数会自动改变成员变量的值，普通的需要自己改动。

6.赋值重载函数

普通写法

		vector<T>& operator= (const vector<T>& v)
        {
        	if(this!=&v)//不能为自己赋值
        	{
            	iterator* tmp=new iterator[v.capacity()];//开辟空间
            	memcpy(tmp,v._start,v.size());//复制空间数据
				delete[] _start;//销毁原先数据
				_start=tmp;//替换空间tmp是一个临时变量，出作用域自动销毁

				_finish=_start+v.size();//改变其他成员
				_endOfStorage=_start+v.capacity();
            }
        }

我们正常开辟一块空间，用v的空间为它初始，然后销毁我们this的成员指向的空间（不用担心销毁空指针的情况，因为delete会自己做判断，当指定销毁的指针是空时不做任何操作。），替换我们的空间，并为改动其他成员的位置。

升级写法

		void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endOfStorage, v._endOfStorage);

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

复用拷贝构造创建一个临时的vector对象，因为这是一个用v为参数调用拷贝函数创造的临时变量tmp，所以tmp的里面数据和v中的一模一样，调用上面的swap函数，将上面的tmp中的数据和我this中的数据做交换，这样我的this中就有了和v中一样的数据。而函数结束时我们的临时变量tmp会自动调用析构函数，将我们原先*this之中的数据销毁（好一个反客为主的阴暗写法，实在妙极）

现代写法

		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;
        }

既然我们升级写法中需要创建临时变量，那我们不如直接传值给函数，这样该函数就自动掉用拷贝函数创建了一个临时变量，并且出函数也自动销毁，我们函数内部便省去了自己创建临时变量的工作了，这便是现代写法的又一升级之处。

7.析构函数

~vector()
        {
            if (_start)
            {
                delete[]  _start;
                _start = _finish = _endOfStorage = nullptr;
            }
        }

8.迭代器部分

typedef T* iterator;
        typedef const T* const_iterator;
        iterator begin()
        {
            return _start;
        }
        iterator end()
        {
            return _finish;
        }
        //这里我们写迭代器最好不要改它的名字，因为编译器有自动识别的
        //如果改了，你自己用自己写的迭代器访问容器还好，但是范围for就用不了了。
        //编译器会对范围for做简单的替换，将其替换成用迭代器访问
        const_iterator begin() const
        {
            return _start;
        }
        const_iterator end() const
        {
            return _finish;
        }

9.有关空间容量等函数

①计算实际数据和容量大小的函数

 		size_t size() const
        {
            return _finish-_start;//用地址相减算当前数据的大小
        }

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

②开辟空间的函数

        void reserve(size_t n)
        {
            if (n > capacity())
            {
                size_t sz = size();
                T* tmp = new T[n];
                //这里如果不将size（）大小存住的话，在我们vector的首次插入时，_start为空，不会走if
                if (_start)
                {
                    //将_start指向的原生数据拷贝给tmp的位置，然后删除原先_start位置的数据
                    /*memcpy(tmp, _start, sizeof(T) *sz );*/
                    //这里用memcpy的话会在扩容的时候出问题，因为我们扩容逻辑用的是reserve函数，
                    //memcpy是简单是浅拷贝，如果是用自定义类实例化的vector，在下面析构原先空间的时候
                    //因为析构会先调用自定义类的析构函数，然后再释放空间，但我们简单浅拷贝复制到新空
                    //间中的自定义类中的成员指针指向的就是已经被析构后的地址了。
                    //所以我们应该用深拷贝的方式=》
                    for (size_t i = 0; i < sz; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                //用tmp替换_start
                _start = tmp;
                //于是这里就会出现问题，因为改了_start位置，但是_finish的位置还是空指针，所以这里在调用size（）的话就会出现空指针对_start位置的减
                //会出现错误，并且报错不明显，很难改。
                _finish = _start + sz;
                _endOfStorage = _start + n;
            }
        }


        /*void resize(size_t n, const T& value = T())
        {
            if (n > _endOfStorage)
            {
                reserve(n);
            }
            while (_finish != _start + n)
            {
                *_finish = val;
                ++_finish;
            }
        }*/
        //这里的代码有些错误，因为没有真正理解resize的所有功能
        //将代码改为以下=》
        void resize(size_t n, const T& value = T())
        {
            //resize的大小并不是总是大于当前vector的capacity的，有时甚至小于当前存储的数据大小，当n小于当前数据大小
            //我们为了控制大小为n，便要舍弃一些数据
            if (n < size())
            {
                _finish = _start + n;
            }
            //这里的reserve又有人说：可能n小于capacity啊，但是别忘了我们的reserve中自有判断，只有当n大于capacity时才会扩容
            else
            {
                reserve(n);
                //这里就是将每个数据逐一初始化为参数value的过程，这里就算是内置类型也可以，因为面向对象将内置类做了升级，
                // 可以理解为内置类也有构造函数
                while (_finish != _start + n)
                {
                    *_finish = value;
                    ++_finish;
                }
            }
        }

有关空间的函数有一些细节容易出现问题且极难调试，特别是一些深浅拷贝问题，请仔细阅读注释。

10.[]运算符重载函数

 //这个pos位置并不是一个迭代器位置，它是供用户使用的函数，它需要用下标访问；
        //T& operator[](size_t pos)
        T& operator[](size_t pos)
        {
            assert(pos < size());
            //我们对vector使用[]重载时就是相当于对它内部的指针使用了[]
            return _start[pos];
        }

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

我们为vector类重载[]函数重载，为方便用户直接通过该函数访问我们vector空间（_start指针指向的空间）中的元素的引用。需要注意我们的const类的vector需要返回const类元素的引用，因为const类vector对象内部是不能让用户修改数据的。

11.数据元素改动类接口

		void push_back(const T& x)
        {
            //我们正常的push_back函数当然可以这样写
            //但是我们要是已经先实现了insert，可以用insert复用
            /*if (_finish == _endOfStorage)
            {
                size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapacity);
            }
            *_finish = x;
            _finish++;*/
            //改为=》
            insert(end(), x);
        }

        void pop_back()
        {
            --_finish;
        }


        iterator insert(iterator pos, const T& x)
        {
            assert(pos >= _start && pos <= _finish);
            //这里insert扩容的时候会有迭代器失效的问题，因为传的pos位置是原来位置，但是一旦扩容，vector存储位置改变了，但是
            //pos还是原来的位置，就会出现类似对野指针访问的错误情况。
            //这里的解决方法是扩容之前先将pos到_start的距离存起来，然后扩容后再将_start+该长度。
            if (_finish == _endOfStorage)
            {
                
                size_t len = pos - _start;
                size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapcacity);
                pos = _start + len;
            }

            iterator end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                --end;
            }
            //这里不用显示的指定调用来使用迭代器，因为这是在类中。
            //也不用多此一举的用end（）函数来访问_finish位置了，因为这是在类中，可以直接使用成员变量
            /*bit::vector<int>::iterator it = end()-1;
            while (it>=pos)
            {
                *(it+1) = *it;
                --it;
            }*/
            *pos = x;
            _finish++;
            return pos;
        }

        iterator erase(iterator pos)
        {
            assert(pos < _finish && pos >= _start);
            /*iterator cur = pos;
            while (cur != _finish)
            {
                *cur = *(cur + 1);
                cur++;
            }*/
            //以上的移动代码也可以，虽然它移动了一个_finish位置的未知的值
            //但是它后面会_finish--，这个位置数并不会被读到，所以也可以，但是我们最好不要让这种事发生，显得我们很
            //很不专业
            //改为以下代码=》
            iterator cur = pos + 1;
            while (cur != _finish)
            {
                *(cur - 1) = *cur;
                ++cur;
            }
            _finish--;
            return pos;
        }

代码内部注释同样有很多易错点和原理解释，还有许多优化改进部分，请认真阅读注释和源码。

完整源码

#pragma once

#include<iostream>
#include<assert.h>
#include<string>

using  std::cout;
using  std::endl;

namespace bit
{
    template<class T>
    class vector
    {
    public:

        // Vector的迭代器是一个原生指针

        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;
        }



        // construct and destroy
        //构造函数
        vector()
            //这里我们甚至不用为成员变量初始化，因为自从c++11之后有了成员变量的缺省值可用，我们可以直接在成员变量位置加nullptr
            //:_start(nullptr)
            //,_finish(nullptr) // 指向有效数据的尾
            //,_endOfStorage(nullptr)
        {}
        
        //这个是为了使vector<int> (10,1)不冲突
        vector(int n, const T& value = T())
        {
            resize(n, value);
        }

        //以下两个构造是文档中第二第三个构造
        vector(size_t n, const T& value = T())
        {
            resize(n, value);
        }

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

        vector(const vector<T>& v)
        {
            /*iterator tmp=new T[v.capacity()];
            _start = tmp;*/
            //不用多此一举，可以改为=》
            _start= new T[v.capacity()];
            /*memcpy(_start,v._start,sizeof(T)* v.size());*/
            //这里要是用memcpy会出现问题，因为memcpy是简单的浅拷贝，扩容逻辑这里也是用的memcpy也需要改一下
            //简单浅拷贝的话在用自定义类实现的vector调用该拷贝函数时会出现vector中的自定义类被重复析构的情况。
            //所以我们需要用深拷贝实现我们的拷贝函数=》
            for (size_t i = 0; i < v.size(); i++)
            {
                //这里的[]是返回的是类型T的引用，而=又访问的是T类型自己的赋值重载，如在用string实例化的vector中：_start[i]逐步访问了
                //每个vector中的string，并调用了string的赋值重载=，实现了对string自定义类型的深拷贝。
                _start[i] = v._start[i];
            }
            _finish = _start + v.size();
            _endOfStorage = _start + v.capacity();
        }

        //或者有另一种现代的拷贝函数的写法：
       /* vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto e : v)
            {
                push_back(e);
            }
        }*/
       //这种拷贝函数调用的是vector的push_back,而push_back函数中的（*_finish = x）也调用了自定义类的赋值重载;
       //这里值得注意的是：我们用来实例化的自定义类型一定要有赋值重载，不然就是自己坑自己。
      
        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;
        }
        

        ~vector()
        {
            if (_start)
            {
                delete[]  _start;
                _start = _finish = _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())
            {
                size_t sz = size();
                T* tmp = new T[n];
                //这里如果不将size（）大小存住的话，在我们vector的首次插入时，_start为空，不会走if
                if (_start)
                {
                    //将_start指向的原生数据拷贝给tmp的位置，然后删除原先_start位置的数据
                    /*memcpy(tmp, _start, sizeof(T) *sz );*/
                    //这里用memcpy的话会在扩容的时候出问题，因为我们扩容逻辑用的是reserve函数，
                    //memcpy是简单是浅拷贝，如果是用自定义类实例化的vector，在下面析构原先空间的时候
                    //因为析构会先调用自定义类的析构函数，然后再释放空间，但我们简单浅拷贝复制到新空
                    //间中的自定义类中的成员指针指向的就是已经被析构后的地址了。
                    //所以我们应该用深拷贝的方式=》
                    for (size_t i = 0; i < sz; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                //用tmp替换_start
                _start = tmp;
                //于是这里就会出现问题，因为改了_start位置，但是_finish的位置还是空指针，所以这里在调用size（）的话就会出现空指针对_start位置的减
                //会出现错误，并且报错不明显，很难改。
                _finish = _start + sz;
                _endOfStorage = _start + n;
            }
        }


        /*void resize(size_t n, const T& value = T())
        {
            if (n > _endOfStorage)
            {
                reserve(n);
            }
            while (_finish != _start + n)
            {
                *_finish = val;
                ++_finish;
            }
        }*/
        //这里的代码有些错误，因为没有真正理解resize的所有功能
        //将代码改为以下=》
        void resize(size_t n, const T& value = T())
        {
            //resize的大小并不是总是大于当前vector的capacity的，有时甚至小于当前存储的数据大小，当n小于当前数据大小
            //我们为了控制大小为n，便要舍弃一些数据
            if (n < size())
            {
                _finish = _start + n;
            }
            //这里的reserve又有人说：可能n小于capacity啊，但是别忘了我们的reserve中自有判断，只有当n大于capacity时才会扩容
            else
            {
                reserve(n);
                //这里就是将每个数据逐一初始化为参数value的过程，这里就算是内置类型也可以，因为面向对象将内置类做了升级，
                // 可以理解为内置类也有构造函数
                while (_finish != _start + n)
                {
                    *_finish = value;
                    ++_finish;
                }
            }
        }



        ///access///
        //这个pos位置并不是一个迭代器位置，它是供用户使用的函数，它需要用下标访问；
        //T& operator[](size_t pos)
        T& operator[](size_t pos)
        {
            assert(pos < size());
            //我们对vector使用[]重载时就是相当于对它内部的指针使用了[]
            return _start[pos];
        }

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



        ///modify/
        
        void push_back(const T& x)
        {
            //我们正常的push_back函数当然可以这样写
            //但是我们要是已经先实现了insert，可以用insert复用
            /*if (_finish == _endOfStorage)
            {
                size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapacity);
            }
            *_finish = x;
            _finish++;*/
            //改为=》
            insert(end(), x);
        }

        void pop_back()
        {
            --_finish;
        }


        iterator insert(iterator pos, const T& x)
        {
            assert(pos >= _start && pos <= _finish);
            //这里insert扩容的时候会有迭代器失效的问题，因为传的pos位置是原来位置，但是一旦扩容，vector存储位置改变了，但是
            //pos还是原来的位置，就会出现类似对野指针访问的错误情况。
            //这里的解决方法是扩容之前先将pos到_start的距离存起来，然后扩容后再将_start+该长度。
            if (_finish == _endOfStorage)
            {
                
                size_t len = pos - _start;
                size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newcapcacity);
                pos = _start + len;
            }

            iterator end = _finish - 1;
            while (end >= pos)
            {
                *(end + 1) = *end;
                --end;
            }
            //这里不用显示的指定调用来使用迭代器，因为这是在类中。
            //也不用多此一举的用end（）函数来访问_finish位置了，因为这是在类中，可以直接使用成员变量
            /*bit::vector<int>::iterator it = end()-1;
            while (it>=pos)
            {
                *(it+1) = *it;
                --it;
            }*/
            *pos = x;
            _finish++;
            return pos;
        }

        iterator erase(iterator pos)
        {
            assert(pos < _finish && pos >= _start);
            /*iterator cur = pos;
            while (cur != _finish)
            {
                *cur = *(cur + 1);
                cur++;
            }*/
            //以上的移动代码也可以，虽然它移动了一个_finish位置的未知的值
            //但是它后面会_finish--，这个位置数并不会被读到，所以也可以，但是我们最好不要让这种事发生，显得我们很
            //很不专业
            //改为以下代码=》
            iterator cur = pos + 1;
            while (cur != _finish)
            {
                *(cur - 1) = *cur;
                ++cur;
            }
            _finish--;
            return pos;
        }

        private:

        iterator _start= nullptr; // 指向数据块的开始

        iterator _finish= nullptr; // 指向有效数据的尾

        iterator _endOfStorage= nullptr; // 指向存储容量的尾

    };
    void print(const vector<int>& v)
    {
        for (auto e : v)
        {
            cout << e << " ";
        }
        cout << endl;
    }

}

总结

本文对c++stl库中的vector容器实现了简单的模拟实现，还简单分析了我们应该如何使用源码做我们模拟实现前的准备。

本文章为作者的笔记和心得记录，顺便进行知识分享，有任何错误请评论指点：）。

_poplar_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【c++、stl】list的模拟实现（附带源码和注释）
poplar的博客
11-15 191
本文对stl标准库中的list容器进行模拟实现，实现需要我们对初阶数据结构有所了解。如对不熟悉我们的基本模拟流程，可以先从我们的vector模拟实现开始：链接:vector的模拟实现（附带源码和注释）一、模拟前准备还是和vector实现时一样，我们先看stl库中的源码，了解基本实现模式。1.查看源码list是一个链表，先看它的节点结构体。本文对c++stl库中的双向带头循环链表list进行了模拟实现。本文章为作者的笔记和心得记录，顺便进行知识分享，有任何错误请评论指点：）。一、模拟前准备。
【C++】STL——vector 深度剖析 及 模拟实现
m0_70980326的博客
04-21 937
深度剖析vector的底层结构及其模拟实现、详解vector的深拷贝问题、迭代器失效问题等。
STL容器 -- vector的模拟实现（配详细注释）
weixin_70056514的博客
07-15 336
在C++的STL（Standard Template Library）中，vector是一种动态数组容器。它提供了一种存储和访问元素的方式，类似于固定大小的数组，但具有动态调整大小的能力。 vector容器可以在运行时根据需要自动调整大小，可以在末尾快速添加或移除元素。它提供了一组成员函数和迭代器，用于访问和操作容器中的元素，例如插入、删除、查找元素等。
c++stl vector源码简析
weixin_40081916的博客
12-11 1538
vector是我们经常用的容易之一，我们现在来简单看一下vector的部分源码理解vector的行为以便我们在使用过程中更得心应手 首先看一下vector的alloc基类： template class _Tp, class _Allocator, bool _IsStatic> class _Vector_alloc_base { public: typedef typename _
C++ vector STL实现详解
cyber的博客
11-19 2956
前言 stl库位置 vector代码分析 vector变量gdb输出总结0.前言  早前使用gdb调试特别不习惯，1）没有具备图形界面IDE（比如Visual Studio）的强大功能：边打断点边代码跟进，退出断点保存，可以随时查看当前变量数据，对stl变量显示友好。2）gdb打印输出的内容有时难以理解，比如gdb只会打印出stl相关容器、复杂的类对象，智能指针的成员数据，而不会做格式化内容输出。比
C++ STL Queue,Stack底层实现分析
qq_51845557的博客
10-17 2037
C++容器适配器(Adapter) stack与queue是非常常用的STL容器.队列与栈也是比较基础的数据结构类型.今天我们来实现一个stack与一个queue. 基本结构 stack也就是栈,遵循的是先进后出原则.queue也就是队列,遵循的是先进先出的原则. 作为基本数据结构的队列与栈没有什么难点. 此外,stack与queue不能遍历,不能随机访问,不能查询中间结点,不能插入中间结点,只能做与其性质对应的两端结点的操作. STL...
C++入门之stl六大组件--Vector库函数的介绍，以及模拟实现一些常用接口
jolly0514的博客
07-26 934
本节主要阅读了vector的源码，以及vector的使用vector是表示可变大小数组的序列容器。就像数组，vector也采用连续空间来存储元素，即可以使用下标对vector元素访问，但是它的大小是可以动态改变的，并且它的大小会被容器自动处理本质上，vector使用动态分配数组来存储它的元素，当新元素插入，就需要重新分配大小增加存储空间。它的做法是，动态开辟一个新的数组，然后将元素移动进来。时间代价较高。事实上，每当一个新的元素加入到容器，并不会每次都重新分配空间。
超详细STL之基于源码剖析vector实现原理及注意事项
cpp加油站的专栏
06-02 403
本篇文章基于源码来剖析标准模板库中vector容器的实现原理及一些特殊注意事项。 说明一下，我用的是gcc7.1.0编译器，标准库源代码也是这个版本的。 多年以前面试的时候第一次被问到stl中vector的底层实现，那个时候的我真的很low，根本回答不上来，后来面试回来，在网络上搜索了一些vector底层实现，知道了它的底层是动态数组，但光知道动态数组是不够的，进一步的，动态数组写满了怎么办，它的实现用了c++的什么技术，一些特殊场景下怎么使用vector更有效率等等，这些极少有人讲清楚，今天我基于gc
【C++ STL学习笔记】C++ STL基础
qq_41854911的博客
08-04 2270
文章目录C++ STL是什么，有什么用？学STL能干什么？C++ STL的发展历程是怎样的？C++ STL版本有哪些？HP STLSGI STLSTLportPJ STLRouge Wave STL熟练使用STL标准库是每个C++程序员的必备技能！泛型是什么，C++泛型编程又是什么？C++ STL基本组成（6大组件+13个头文件）如何衡量一个算法的执行效率？GNU开源精神及其发展历程 C++ STL是什么，有什么用？ 在已有 C++ 尤其是 C++ 模板的基础上，从本节开始，我们开始系统地学习 STL 标准
C++ STL VECTOR的实现
06-25
c++的STL的vector的一个实现。使用了c++11的大部分特性，包含vector的几乎所有功能。仅作学习之用。
C++标准库STL源码
03-24
SGI STL的源码是开源的,其设计和实现体现了诸多优秀的编程思想和技巧。下面是对SGI STL源码的一些关键特点和描述:泛型编程、算法与容器的分离、迭代器、函数对象等。 SGI STL的源码是学习和理解STL实现原理的宝贵...
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C++实现STL容器之Vector
04-08
C++实现STL容器之Vector
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 110
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C++ shared_ptr
qq_40135848的博客
06-15 1534
C++ shared_ptr
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1174
Deque（双端队列）是C++ STL中的一种序列容器
C的I/O操作
最新发布
weidl001的博客
06-17 728
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值