vector介绍及底层原理

已于 2022-07-17 20:42:18 修改
阅读量2.7k 收藏 13
点赞数 3
分类专栏： C++入门学习 文章标签： c++
于 2022-07-17 20:41:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64397669/article/details/125815286
版权

目录

1.介绍

2.模拟实现

2.1.基本框架

2.2.简单函数实现

2.3.扩容函数实现

2.4插入删除函数实现 

2.5构造函数等 

2.6迭代器失效问题

1.介绍

1. vector 是表示可变大小数组的序列容器。
2. 就像数组一样， vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对                 vecto 的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而          且它的大小会被容器自动处理
函数有：

 

举例：

void test_vector1()
{
	vector<int> v;
	v.push_back(7);
	v.push_back(3);
	v.push_back(5);
	v.push_back(9);
	v.push_back(2);
	for (auto& ch : v)
	{
		ch += 1;
		cout << ch << " ";
	}
	cout << endl;
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		(*it) -= 1;
		cout << *it << " ";
		it++;
	}
	cout << endl;

	sort(v.begin(), v. end());
	for (auto ch : v)
	{
		cout << ch << " ";
	}
	cout << endl;
}

结果：

8 4 6 10 3
7 3 5 9 2
2 3 5 7 9

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);

	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.insert(it, 20);//insert返回的是新插入元素的后一个元素的地址
			it++;
		}
		it++;
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

结果：
1 20 2 3 20 4 5 20 6

用法与string类似，可查看文档：vector - C++ Reference 进行学习。

2.模拟实现

2.1.基本框架

namespace LF
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		vector()//无参构造函数
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{}


		//........其余函数的实现

	private:
		iterator _start;//T类型的指针，指向该内存空间起始位置
		iterator _finish;//指向有效数据的位置
		iterator _endofstoage;//指向该内存结束位置
	};
}

2.2.简单函数实现

        iterator begin()//返回起始空间的地址
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		size_t size() const//返回元素的个数
		{
			return _finish - _start;
		}

		size_t capacity() const//返回容量的大小
		{
			return _endofstoage - _start;
		}
        T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

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

			return _start[pos];
		}

        void clear()
		{
			_finish = _start;
		}

2.3.扩容函数实现

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

                     for (size_t i = 0; i < size(); ++i)
					{
						tmp[i] = _start[i];//若—_start[i]是vector类型，里面有指针，要完成深拷贝
					}
					delete[] _start;
				}
		
				_start = tmp;//_start所指向的空间改变了
			}

			_finish = _start + sz;//扩容后—_start改变了，—_finish应在新的_start后面
			_endofstoage = _start + n;
		}

		void resize(size_t n, T val = T())//T()会去调用它的默认构造函数，在C++中，内置类型也有默认构造函数
		{
			if (n > capacity())
			{
				reserve(n);
			}

			if (n > size())
			{
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

2.4插入删除函数实现 

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

			*_finish = x;
			++_finish;
		}

		void pop_back()
		{
			if (_finish > _start)
			{
				--_finish;
			}
		}

       iterator insert(iterator pos , const T&)//此处pos接受的是值传递
		{
			assert(pos >= _start && pos <= _finish);
			size_t sz = pos - _start;
			if (_finish == _endofstoage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 4;
				reverse(newcapacity);
				pos = _start + sz;//扩容后，pos指向的内存空间也失效了，要重新赋值
			}
			// 2  4  6  7 
			iterator end = _finish - 1;
			while (end>=pos)
			{
			
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			++_finish;

			return pos;//返回的pos指针是指向新元素的
		}

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

2.5构造函数等 

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

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

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

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

	
		vector(const vector<T>& v)
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());//构造一个临时对象，开辟新空间，内容与v相同
			swap(tmp);//将*this与tmp中的三个指针交换。
		}


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

2.6迭代器失效问题

        iterator insert(iterator pos , const T&)//此处pos接受的是值传递
		{
			assert(pos >= _start && pos <= _finish);
			size_t sz = pos - _start;
			if (_finish == _endofstoage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 4;
				reverse(newcapacity);
				pos = _start + sz;//扩容后，pos指向的内存空间也失效了，要重新赋值
			}
			// 2  4  6  7 
			iterator end = _finish - 1;
			while (end>=pos)
			{
			
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			++_finish;

			return pos;//返回的pos是指向新元素的
		}

库里面的实现与上面原理类似，每次插入新元素后，返回的是新元素的地址。

倘若在没有接受该函数的返回值的情况下：

1.若未发生扩容，此时的pos指针指向新插入的数据。

2.若发生扩容，由于该函数中pos是值传递，即使在函数内部改变了pos，在未接受返回值的情况下，该pos所指向的内存空间已经失效了。

在vs2022下演示：

int main()
{
	vector<int> v;
	v.reserve(10);
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(5);
	v.push_back(6);
	auto pos = find(v.begin(), v.end(), 5);
	if (pos!=v.end())
	{
		cout << "capacity:"<<v.capacity() << "size:"<<v.size() << endl;
		v.insert(pos, 100);
		/*pos = 9999;*/
	}
	cout << *pos << endl;
	return 0;
}

在未扩容的情况下，pos所指向的空间不变，但数据改变了，在vs2022平台上不能进行访问（vs2014可以访问）；

 在扩容的情况下，pos所指向的空间已失效。vextor<int>已重新开辟了新的空间。

        iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;
			return pos;//返回的pos指向的数据是被删除元素的下一个元素
		}

因为erase函数删除数据时，不会减小容量，不会存在野指针问题，但pos指向的数据意义变了（与insert中第二种情况一样）。vs2022下不可访问，可认为失效了。

 不同平台下检查机制不一样，可能有不同的结果，

总结：在使用insert，erase函数时，最好要接受它的返回值。

"派派"
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简谈vector的底层实现
PAWNKNIGHT的博客
08-11 2539
一、vector 概述 vector的数据安排方式和操作方式与array十分相似。两者的唯一区别是array是静态空间，空间一旦配置就无法改变，如果一定需要改变，需要用户自己重新开辟一个新的大小空间，然后原有空间上的数据一 一拷贝到新的空间，然后将原有空间释放掉。而vector是一个动态空间，在元素的不断加入的过程中，如果空间满了，它会自行扩充空间。 vector实现的关键技术在于其对大小的控制以及重新配置时的数据移动效率。 二、vector的实现原理 vector定义了三个指针start（表示目前使用空
诊断开发流程介绍-Vector
08-26
它不仅需要理解底层硬件的工作原理，还需要熟悉相关的通信协议，如CAN（Controller Area Network）、LIN（Local Interconnect Network）或FlexRay等。Vector工具集成了这些协议的支持，使得开发者能够方便地与目标...
Java集合（四）Vector底层结构
weixin_45385991的博客
03-02 1145
Java集合（四）Vector底层结构 文章目录Java集合（四）Vector底层结构一、Vector类的基本介绍1.1、Vector类的定义说明1.2、Vector类底层1.3、Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized（在开发中，需要线程同步安全时，考虑使用Vector）二、Vector和ArrayList的比较2.1、Vector和ArrayList的比较三、Vector底层源码 一、Vector类的基本介绍 1.1、Vector类的定义说明 Lis
带你深入理解STL中的vector
m0_61227789的博客
10-08 935
vector底层是一个动态数组，包含三个迭代器，start和finish之间是已经被使用的空间范围，end_of_storage是整块连续空间包括备用空间的尾部。当空间不够装下数据（vec.push_back(val)）时，会自动申请另一片更大的空间（1.5倍或者2倍），然后把原来的数据拷贝到新的内存空间，接着释放原来的那片空间【vector内存增长机制】。当释放或者删除（vec.clear()）里面的数据时，其存储空间不释放，仅仅是清空了里面的数据。
【C++】vector的底层原理讲解及其实现
2201_76005883的博客
05-11 1250
其实上面的代码大体逻辑是没有什么问题的，问题就出在这个memcpy上，要知道memcpy底层实现是按字节一个一个拷贝过去的，虽然我们的vector是深拷贝，但是memcpy是浅拷贝，这样写针对内置类型是🆗的，但是针对自定义类型会存在指向同一块空间的问题，两次析构等问题，话不多说，我们看图解。这里我利用库里的函数来实现swap，只交换vector的三个指针更高效，赋值构造的参数是传值传参，会调用拷贝构造，将v2拷贝一份给v，然后之间调用swap函数，将v和。赋值构造：两个已经存在的对象，一个赋值给另一个。
vector底层实现及应用注意事项
热门推荐
weixin_52259848的博客
09-01 3万+
vector底层实现及应用注意事项
vector的底层原理
weixin_39354845的博客
02-12 1万+
考察vector 一、原理：动态数组vector 底层原理及其相关面试题-帅地玩编程 二、使用： #if 1 int main() { vector<int> iv(3, 9); for (auto e : iv) cout << e << endl; cout << "============================" << endl; iv.push_back(1); iv.push_back(2); iv
C++ vector函数接口及其底层原理
weixin_59112191的博客
04-28 2412
什么是vector vector类我们可以将其底层看作是一个能够动态扩容数组。 在vs下其扩容一般每次是按照前一次容量的1.5倍进行扩容。如：4，6 9…string类支持的功能，在vector下基本都能使用。 vector的构造函数 vector的底层原理 vector类中包含了三个T类型的指针，分别是 -start：指向空间的起始部分 _finish:指向当前已用空间的末尾 _endofstorger:指向申请空间的末尾 push_back vector的push_back和string一样，都是
Vector常用操作的工程文件
最新发布
06-06
在C++编程中，`std::vector`是一个非常重要的容器，它提供了动态数组的功能，允许我们在运行时调整其大小。...记得在实践中多尝试，理解每个方法的底层工作原理，这将有助于你编写更高效、更稳定的代码。
Vector-XCP 源代码
07-06
XCP协议支持多种底层通信链路，如CAN（Controller Area Network）、LIN（Local Interconnect Network）、FlexRay等，以适应不同的汽车网络环境。 在"Vector-XCP 源代码"中，你可以找到关于如何集成XCP协议到你的ECU...
你知道synchronizedList和Vector底层原理实现和区别吗？其实开始我也不知道！（超详细源码分析）
12-22
探究ArrayList为什么查询快、增删慢，实现add方法底层原理详解 ArrayList源码分析（基于JDK8） 因为Vector和ArrayList除了数组扩容有点差别，还有加锁使Vector迈进了线程安全的行列外，底层实现大约是没有太大区别...
C++中vector可以作为map的键值实例代码
08-30
本文将详细介绍如何使用vector作为map的键值实例代码。 首先，让我们回顾一下map容器的基本原理。Map容器使用红黑树作为底层数据结构，红黑树是一种自平衡二叉搜索树，它可以在O(log n)时间内实现插入、删除和查找...
三.vector的实现原理
小呆鸟blog
02-17 4961
文章目录一.vector的实现原理1.vector 基类介绍2.vector从最后面插入元素时发生了什么2.1对空vector插入一个元素2.2vector当前内存用完时插入4.vector删除元素内存会被释放吗4.1从容器最后删除4.2从容器中间删除5.vector如何修改某个位置的元素值6.vector读取与插入元素的时间复杂度7.vector基本算法8.vector底层实现总结二.vector的注意事项3. vector的迭代器会失效的原因4. vector怎么迅速的释放内存4.1 通过swap函数4
【C++入门】STL容器--vector底层数据结构剖析
2202_75605090的博客
01-20 1562
vector在C++中非常重要的容器，在刷题中也经常使用，它是一个动态的数组，提供了快速的随机访问和在尾部的插入和删除操作。vector的底层实现也是非常优秀的数据结构，值得我们去学习鉴赏，使用STL我们需要做到三个境界：能用，明理，能扩展；所以了解它的基本底层原理也是非常有必要的。在本文中，我们深入探讨了STL容器中的vector，以及它的底层数据结构。vector的底层设计也是比较好的，值得每位初学者借鉴学习；
C++入门篇(11)之vector的底层实现
m0_51723227的博客
11-17 6150
文章目录前言定义初始结构声明构造函数容量有关操作获取有效数据大小size()获取数据容量capacity()增加容量reserve()重置大小resize()迭代器数据操作尾插push_back()尾删pop_back()某一位置插入 insert()某一位置删除 erase()拷贝构造[]访问操作=赋值操作特别注意!!!! 前言 上一小节,我们讲解了vector的使用,也大概了解了其创建对象,增删改查数据等操作.那么今天,我们就来大致实现一下吧. 定义初始结构 在标准C++中,vector同样是一个模板
【C++】理解vector的底层原理并模拟实现（手撕vector）
谁在夜里看海.的博客
04-03 1099
但是我们不仅要会用，还要理解它的底层原理，今天我们通过手撕一个自己的vector，来进一步加深对vector容器的理解。
【STL】vector的底层原理及其实现
稻草人敲代码的博客
04-05 855
vector一共有4个构造函数，分别对应不同的构造场景。1.vector().无参构造2..构造并且初始化n个元素的值为value.3..拷贝构造4..迭代器初始化构造int main()// 无参构造// 构造的同时初始化4个元素都为100// 迭代器初始化构造// 拷贝构造//迭代器初始化构造示例it!
C++基础篇——vector介绍及其底层实现
Tlzns的博客
10-17 911
C++基础篇——vector介绍及其底层实现
vector的底层实现！（万字长文详解！）
m0_74376760的博客
11-27 1421
c++之vector的实现！
vector底层原理
07-31
回答: vector容器的底层实现机制是通过使用三个迭代器来表示。这三个迭代器分别是start、finish和end_of。其中，start指向vector容器对象的起始字节位置，finish指向当前最后一个元素的末尾字节，end_of指向整个vector容器所占用内存空间的末尾字节。通过这三个迭代器，vector容器可以实现对元素的访问和操作。[1]在源代码中，还可以看到一些typedef定义，如Iterator和const_Iterator，用于定义迭代器的类型。此外，还可以看到一些成员函数，如cbegin、cend、begin和end，用于返回迭代器的起始位置和结束位置。[2]通过分析vector容器的源代码，可以更深入地了解其底层原理。[1][2]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值