c++还原简单的vector_[&amp；](const vector&lt；uint8_t&gt； &amp；_data) -&gt； bool

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

迭代器

这里的迭代器iterator可看作为指针

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)
		{}

析构函数

~vector()//析构函数
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

size()

指针相减 得指针之间成员个数

size_t size() const//size---有效成员个数
		{
		return 	_finish - _start;
		}

capacity()

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

operator[]重载

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

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

扩容

void reserve(size_t n)
{
  if (n > capacity())
  {
  size_t oldsize = size();//记录成员个数
  T\* tmp = new T[n];//开辟新空间
  if (_start)//如果\_start指向的空间不为空就要拷贝数据
  {
         //把\_start的数据拷贝到tmp上面
		//memcpy(tmp, \_start, sizeof(T) \* oldsize);//这里实现了浅拷贝
                    //后面会谈到memcpy的弊端
      for(size_t i=0;i<oldsize;i++)
           {
                   tmp[i]=_start[i];//这里实现深拷贝
           }
		//删除旧空间-空间不为空才需要释放
          delete[]_start;
	}
		_start = tmp;//指向新空间
//原来的size=\_finish-\_start,而此时的\_start是新空间的\_start, //\_finish是旧空间的\_finish，相减得出不是之间成员个数了；所以我们要用oldsize()来记录先前的成员个数，用新的\_start+oldsize()得出新的\_finish
				_finish = _start + oldsize;
				_endofstorage = _start + n;
 }
}

resize()

void resize(size_t n, T val = T())//value\_type val 给匿名对象
//n<size():缩容；
//size()<n<capacity():用val初始化有效成员以外的成员变量；
//n>capacity():扩容且用val初始化有效成员以外的成员变量； 
{
    
			if (n > capacity())//n大于容量
			{
				reserve(n);//扩容
			}
			if (n > size())
			{
				while (_finish < _start + n)
				{//用val初始化有效成员以外的成员变量；
					\*_finish = val;
					++_finish;
				}
			
			}
			else
			{
				_finish = _start + n;//缩size（）
			}
		}

尾插

void push\_back(const T& x)//尾插
		{
			if (_finish == _endofstorage)//扩容
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() \* 2;
				reserve(newcapacity);
			}
			\*_finish = x;
			++_finish;
		}

验证是否为空

bool empty()const
		{
			return _start == _finish;
		}

尾删

void pop\_back()
		{
			assert(!empty());
			--_finish;
		}

clear 清除

void clear()//清理---不影响容量
		{
			_finish = _start;
		}

swap交换

void swap(vector<T>& v)//交换
{//这里要指明是std库里的swap，因为头文件展开后从上往下找swap函数不一定先找到的是std库里的swap，还可能是vector的swap
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage,v._endofstorage);
		}

insert插入

这里我们实现第一个接口

//迭代器失效：当插入时要扩容，pos指针指向原来的空间，而\_start指向新空间，在挪动数据时会出问题
		iterator insert(iterator pos, const T& val)
		{//pos要在\_start和\_finish之间
			assert(pos >= _start);
			assert(pos < _finish);

			//\_start为空时插入要扩容或者容量满了都要扩容
			if (  _finish==_endofstorage)
			{
				size_t len = pos - _start;//记录pos的相对位置
				size_t newcapacity = capacity() == 0 ? 4 : capacity() \* 2;
				reserve(newcapacity);
				pos = _start + len;//针对迭代器失效要对pos更新
			}
			iterator end = _finish - 1;
			while (end >= pos)//挪动数据
			{
				\*(end + 1) = \*(end);
				--end;
			}
			\*(pos) = val;
			++_finish;	
            return pos;
		}

erase删除

这里我们实现第一个接口

	iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator begin=pos+1;
			while (begin<_finish)
			{
				\*(begin-1) = \*(begin );
				++begin;
			}
			--_finish;
			return pos;//返回迭代器
		}

在这里我们创建一个vector往里面尾插1234；之后我们删除4；并且打印删除后的迭代器位置

这里我们运行了看起来没有问题，实际上问题很大！删除4后容器的数据只有123，而我们访问到了4—野指针越界访问！ 这里我们实现的模拟跟Linux系统下相似，所以在Linux系统下也不会报错；但我们如果删除的是2或者是3呢？会越界吗？换句话说：迭代器会失效吗？答：在Linux系统下迭代器可能会失效也可能不会！但在vs下必然失效！

这里我们换库里面的vector的erase试一下

果然在vs下对迭代器做了更严格的检查，读都不给读，更何况是写；—迭代器失效了吗？？？好像失效了，这里有人会说你这个删除4肯定是越界了，那我删除别的对象不就不越界了嘛？

好现在我们删除2

照样报错！所以我们使用完迭代器之后最好就不要再用迭代器了

如果硬要用就更新迭代器！

删除4—会被断言出越界

删除2—更新了迭代器不会报错

现在在vs还是Linux下都不会发生迭代器失效了，若越界直接断言！

迭代器区间初始化构造函数

		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
            //构造函数：用迭代器区间去初始化
			: \_start(nullptr)
			, \_finish(nullptr)
			, \_endofstorage(nullptr)
		{
			while (first != last)
			{
				push\_back(\*first);
				++first;
			}
		}

拷贝构造

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

		{
			push\_back(\*first);
			++first;
		}
	}

#### 拷贝构造




[外链图片转存中...(img-9YCPE90m-1715737407912)]
[外链图片转存中...(img-9L7gQhhG-1715737407912)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**