C++初阶学习————STL （vector使用及简单的模拟实现）

已于 2023-02-19 18:53:57 修改
阅读量619 收藏 1
点赞数
文章标签： c++ 学习 数据结构
于 2022-10-25 22:32:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxMGE/article/details/127367319
版权

vector模拟实现


vector介绍

vector介绍

  1. vector是表示可变大小数组的序列容器。
  2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
  3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
  4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
  5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
  6. 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

vector常用功能介绍

因为STL中的容器基本功能都差不多，前面已经学习过string了这里就简单介绍一下vector的用法
vector本质上是一个动态数组

1.构造函数

构造函数

声明接口说明
vector()无参构造
vector（size_type n, const value_type& val = value_type()）构造并初始化n个val
vector (const vector& x)拷贝构造
:vector (InputIterator first, InputIterator last);:使用迭代器进行初始化构造

2.迭代器的使用

iterator的使用接口说明
begin + end获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

end是数组最后一个有效数据位置的下一个位置
rend是数组第一个位置的前一个位置

3. vector容量相关的使用

声明接口说明
size获取数据个数
capacity获取容量大小
empty判断是否为空
resize改变vector的size
reserve改变vector的capacity

vs下capacity是按1.5倍增长的，g++是按2倍增长的,不要固化的认为，顺序表增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
resize在开空间的同时还会进行初始化，影响size。

vector 增删查改

vector增删查改接口说明
push_back尾插
pop_back尾删
find查找。（注意这个是算法模块实现，不是vector的成员接口）
insert在position之前插入val
erase删除position位置的数据
swap交换两个vector的数据空间
operator[]像数组一样访问\

vector简单模拟实现

#ifndef MY_VECTOR_H
#define MY_VECTOR_H
#include <iostream>
using namespace std;
namespace dd
{
	template<class T> 
	class My_vector
	{

	public:
			typedef T* iterator;
			typedef const T* const_iterator;
	private:
		iterator _start;			起始位置地址
		iterator _finish;			有效数据的下一个位置地址
		iterator _endofstorage;		容量所在位置的地址
	};
}
#endif MY_VECTOR_H

构造函数(无参)

My_vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
	{}

析构函数

~My_vector()
{
	delete[] _start;
	_start = nullptr;
	_finish = nullptr;
	_endofstorage = nullptr;
}

size

size_t size()
{
	return _finish - _start;	//(arr+size) - (arr+0)
}

capacity

size_t capacity()
{
	return _endofstorage - _start;
}

迭代器

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

operator[ ]

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

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

reserve（有缺陷，改进后的在最下方）

void reserve(size_t n)
{
	if(_finish == _endofstorage)
	{
		T* temp = new T[n];
		size_t sz = size();
		if(_start)
		{
			memcpy(temp,_start, sizeof(T) * sz);
			delete[] _start;
		}
		_start = temp;
		_finish = _start + sz;//原来的位置 
		_endofstorage = _start + n;
	}
}
new在申请空间时会调用构造函数，调用的个数是n的数值

resize

// 内置类型也支持构造，int i = 10 ;int(i);  int j = int(); int k = int(10); 匿名对象生命周期只存在这一行
// T也有可能是内置类型、自定义类型等等，所以缺省值设置一个匿名对象，可以是内置类型也可以是自定义类型
//且const的引用会延长匿名对象的声明周期，在调用结束时才会销毁
void resize(size_t n,const T val = T())		匿名对象
{
	/*if(n <= size())
	{
		_finish = _start + n;
	}
	else
	{*/
	if(n > size())
	{
		if(n > capacity())
		{
			reserve(n)
		}
		//My_vector::iterator it = end();
		size_t len = size();
		while(len < n)
		{
			_start[len] = val;
			len++;
		}
	}
	_finish = _start + n;
	}
}

val = T()		匿名对象的生命周期只存在这一行，但是可以用const延长他的声明周期，调用结束时才会销毁

push_back

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

构造函数（迭代器）

类模板的成员函数，也可以做为函数模板

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

在这里插入图片描述

拷贝构造


传统写法
My_vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	_start = new T[v.capacity()];
	memcpy(_start,v._start,sizeof(T)*v.size());
	_finish = _start + v.size();
	_endofstorage = _start + v.capacity();
}

现代写法
void swap(vector<T>& v)
{
	std::swap(_start,v._start);
	std::swap(_finish,v._finish);
	std::swap(_endofstorage,v._endofstorage);
}
My_vector(const vector<T>& v)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	My_vector<T> temp(v.begin(),v.end());
	swap(temp);					//this->swap(temp)
}

operator =

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

pop_back

void pop_back()
{
	assert(size());
	_finish--;
}

insert

void insert(iterator pos,const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if(_finish == _endofstorage)
	{
		reserve(capacity() == 0?4:capacity()*sizeof(T));
	}
	My_vector::iterator it = end()-1;	//与string不同的是。这里不需要拷贝\0，finish位置是空的	
	while(it >= pos)
	{
		*(it+1) = *it;
		it--;
	}
	/*for(size_t i = size()-1;i >= pos-_start;i--)
	{
		_start[i+1] = _start[i];
	}*/
	*pos = val;
	_finish++;
}

迭代器失效问题1

但是上述代码中存在着一个隐患

My_vector<int> v1
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::iterator pos = find(v1.begin(),v2.end(),2);
if(pos != v1.end())
{
	v1.insert(pos,20);
}

当插入的位置地址是最后一个时，会先扩容，扩容就会把原空间释放并重新开辟空间，那么pos就变成一个野指针了
改进：在扩容之前算出距离长度，扩容之后更新pos

	if(_finish == _endofstorage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0?4:capacity()*sizeof(T)*2);
		pos = _start + len;
	}

但是外面的it仍然是野指针，这种情况就叫迭代器失效

erase

void erase(iterator pos)
{
	assert(pos < _finish);
	assert(pos >= _start);

	My_vector::iterator it = pos;
	while(it+1 < _finish)
	{
		*it = *(it+1);
		it++;
	}
	_finish--;
}

迭代器失效问题2

假如利用erase删除所有偶数

My_vector<int> v1
情况一：
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);

情况二：
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);

情况三：
v1.push_back(1);
v1.push_back(2);
v1.push_back(4);
v1.push_back(5);

My_vector::iterator it = v1.begin();
while(*it != v1.end())
{
	if(*it %2 == 0)
	{
		erase(it);
	}
	it++;
}

情况1：可以正常执行完
在这里插入图片描述

情况2：会崩溃
原因：当删除完最后一个，finish–，此时v1.end()位置就往前挪了一位，而删完后it++导致他往后挪了 一位，这时it和end就错过了，在访问时就是非法越界了
在这里插入图片描述

情况3：没删完
原因：当删完2时，it++，而finish–,导致错过4，it此时指向5的位置
在这里插入图片描述
改进：

while(*it != v1.end())
{
	if(*it %2 == 0)
	{
		erase(it);
	}
	else
	{
		it++;
	}
}

本篇这里模拟实现只是把_finish改变，实际应用中可能会有缩容的情况，缩容就要先释放再申请，原it就成为野指针，所以最好要返回新it位置（缩容并不常见，但是不能不考虑）

while(*it != v1.end())
{
	if(*it %2 == 0)
	{
		it = erase(it);
	}
	else
	{
		it++;
	}
}

改进后的 insert、erase

iterator erase(iterator pos)
{
	assert(pos < _finish);
	assert(pos >= _start);

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

insert也会有扩容后想要获取原it位置的地址情况，虽然用的不多，但也得考虑在内

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

结论：只要用到迭代器访问容器就可能会失效

练习（杨辉三角形vector < vector< int >> 的使用）

在这里插入图片描述
代码如下：

class Solution 
{
public:
	My_vector<My_vector<int>> generate(int numRows) 
	{
		My_vector<My_vector<int>> vv;
		vv.resize(numRows);//申请行
		for(size_t i = 0;i < vv.size();i++)
		{
			vv[i].resize(i+1,1);        //每行申请列并初始化
		   for(size_t j = 0;j < vv[i].size();j++)
			{
				if(j == 0 || j == i)
				{
					vv[i][j] = 1;
				}
				else     
				{
					vv[i][j] = vv[i-1][j-1] + vv[i-1][j];    //[2][1] = [1][0]+[1][1]
				}   
			}
              
		}
		return vv;
	} 
};

vector<vector>和二维数组类似
在这里插入图片描述
T等价于 vector, 此时_start就是vector的指针，对vv扩容，相当于申请了5个vector型的内存
在这里插入图片描述
在这里插入图片描述在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

在这里插入图片描述
申请多少个就调用多少次
在这里插入图片描述
调用的是无参的，所以vector里的成员函数都是空指针
在这里插入图片描述
当对vector中的vector申请内存时，需要先解引用vv[0]，代表第一个vector的实例化对象，（类似于数组指针或二维数组中，对列解引用得到的是一维数组名）
之后再调用vv[0].vectorresize();就是对第一个vector申请内存了
在这里插入图片描述

vector和vector<vector>的理解型式差不多
在这里插入图片描述

reserve中，memcpy深拷贝问题

void reserve(size_t n)
{
	if(_finish == _endofstorage)
	{
		T* temp = new T[n];
		size_t sz = size();
		if(_start)
		{
			memcpy(temp,_start, sizeof(T) * sz);
			delete[] _start;
		}
		_start = temp;
		_finish = _start + sz;//原来的位置 
		_endofstorage = _start + n;
	}
}

上述代码还有一个漏洞，那就是memcpy
例如，vector<vector<int.>> 或者vector <.string>

vector<string> v1;
v1.push_back("1111");
v1.push_back("1111");
v1.push_back("1111");
v1.push_back("1111");
v1.push_back("1111");
当发生扩容时，最后程序会崩溃

如图所示：
在这里插入图片描述
memcpy是按字节序拷贝的，是浅拷贝，str中是char*，是动态的
temp拷贝_start只是拷贝了相同的首地址标号，但拷贝完释放_start时，temp拷贝的数据就不存在了，并且在最后调用扩容函数结束时temp会销毁，随即调用析构，等于对一块空间析构两次
在这里插入图片描述

改进reserve

改进办法如下：

void reserve (size_t n)
{
	if(n > capacity())
	{
		size_t sz = size();
		T* temp = new T[n];
		if(_start)
		{
			//memcpy(temp,_start,sizeof(T)*size());		//error
			for(size_t i = 0; i < sz;i++)
			{
				temp[i] = _start[i];
			}

			delete[] _start;
		}
		_start = temp;
		_finish = _start + sz;
		_endofstorage = _start + n;
	}
}

根据上面的图示做修改，利用string赋值重载就可以避免这个问题了；
只要涉及到深拷贝就不可以用memcpy，因为他是按字节序拷贝的，是浅拷贝

hxMGE
关注
(第一步) STL: stl_vector容器简略版实现
xfy_von的博客
07-31 238
stl_vector容器 本文参考了这位大佬的github，直接先使用了它的基本头文件，在此基础上创建实现自己容器，反向理解底层代码 Alloc.h 分配内存,使用二级配置器 TypeTraits.h 类型萃取 Construct.h 容器的构造和析构 Allocator.h alloc.h和construct.h的直接上级，封装函数 Itearator.h 迭代器 Functional.h 实现小于和等于 Utility.h 算法中使用，
实现一个简单的STL allocator
hongwang0506的博客
09-01 255
1. 概述 本文实现了一个简陋的allocator，并简单解释了new/delete的内部实现过程。 2. 一个简单的STL allocator STL allocator是容器中的空间配置器，标准库默认的是std :: allocator。它的主要作用是内存分配与释放，对象构造和析构。它隐藏在容器内部，一般我们不需要关注，但了解其实现还是很有必要的。 实现的简陋allocator如下（详见参考文献1）： #ifndef MYALLOCATOR_H_ #define MYALLOCATOR_H_
【C++】vector用法&&简单模拟实现
记录学习点滴
01-05 1875
vector的文档介绍（包含函数接口使用）(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造it!it ++) {//无参构造 for(int i = 0;i < 10;i ++) {//使用迭代器进行初始化构造 printVector(v2);//构造并初始化10个100 printVector(v3);//拷贝构造 printVector(v4);return 0。
vector巧用
ACM_Cmy的博客
02-01 282
这个题的思路其实是不重要的，就是一个暴力的模拟题，我写博客的原因是这个题卡内存，就是说你如果无脑的开一万一万的二阶数组的话，直接内存炸了，我们可以看到啊，这是一个天梯赛陈老师出的题，天梯赛的题思路大都简单，但是要求你熟练掌握STL的用法，这个很重要。 你看我写的这个AC代码，他的思路和用到的数据结构都是在躲避空间过剩的问题，我们正常的思路是：开一个二阶数组数组，全赋值为true，然后...
【C++】STL——vector模拟实现
M的博客
06-20 1452
vector的模拟实现
C++初阶学习——探索STL奥秘——vector的模拟实现
Joker10085的博客
09-15 967
vector模拟实现详解
C++初阶学习————STL （list使用及简单的模拟实现）
hxMGE的博客
10-25 454
C++初阶学习
C++初阶学习————STL（priority_queue使用及模拟实现）
hxMGE的博客
11-02 191
C++初阶学习
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1534
C++初阶：STL之vector类模板
C++初阶--vector模拟实现
Iiverson2000的博客
07-29 394
今天我们不直接上代码了，我们先来分析一下vector这个容器。 我们来看看这个东西 vector<vector> 这我们可以大概猜到是一个二维数组。 但并不完全是，二维数组是一个n*n 的矩形结构，而这里的vector套vector可不是这样， 我们来剖析一下它 当我们执行 vv [ i] [ j ] 这行代码时 首先执行 vv. operator [ i ],也就是vv [ i ] 这时候我们在一个大vector中找到了，很多很多的vector。每一个vector 是用i 控制的，一
进阶C++__STL__set/ multiset和map/ multimap使用方法
qq_61386381的博客
08-21 973
一、关联式容器 二、键值对 三、树形结构的关联式容器 set/ multiset 容器 set基本概念 set构造和赋值 set大小和交换 set插入和删除 set查找和统计 set和multiset区别 set / multiset总结 pair对组创建 set容器排序 内置类型指定排序规则 自定义数据类型指定排序规则 map/ multimap容器 map基本概念 map构造和赋值 map大小和交换 map插入和删除 map查找和统计 map容器排序 map
C++map和set的介绍及使用
m0_54853420的博客
06-08 137
关联式容器容器结构底层实现set、map、multiset、multimap树型结构平衡搜索树（红黑树）unordered_set、unordered_map、unordered_multiset、unordered_multimap哈希结构哈希表，哈希桶SGI-STL中关于键值对的定义：template struct pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second;...
vector的常见接口介绍
qq_61434711的博客
07-18 705
vector是C++中stl的一个类,我们用它进行储存各种数据包括但不限于(int,double,string……)甚至可以用vector储存vector的其他容器.我们的vector是通过模板实现的如果大家对模板不熟悉建议先学习模板模板初阶＜C++初阶＞(跑路人笔记)_就一个挺垃圾的跑路人的博客-CSDN博客本次我们还是使用cplusplus网站来讲解vector的接口以及使用.因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。...
C++--vector的使用和模拟实现
拾至名瑰的博客
08-10 1078
今天我们来讲一讲关于vector容器，他是一个顺序表，类似于C语言中的数组，但是容器里面的数据类型可以是内置类型或者自定义类型，其中也包含了很多的函数接口，实现增删查改等等！接下来开始我们的学习!OJ题的答案在文章的末尾！正文开始vector的文档介绍vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的是连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自。......
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 199
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 877
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2232
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
最新发布
二进制君
11-02 42
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1157
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++编程：类模板实现Animal及Vector模拟STL向量
"C++程序设计，涉及到类模板和自定义容器...通过这两个知识点的学习，我们可以理解如何在C++中使用类模板来实现泛型编程，以及如何自定义容器类以实现类似STL的功能。这些技能对于编写高效、可复用的C++代码至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值