C++（vector深度解析）

已于 2024-07-03 20:02:50 修改
阅读量845 收藏 6
点赞数 9
分类专栏： c++ 文章标签： c++
于 2024-07-03 20:00:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68553722/article/details/140109258
版权

引言：

vector与string区别：

string：动态类型的顺序表--->只能存储char

vector：动态类型的顺序表--->任意类型的元素都可以存储

 vector的使用

1.vector构造和遍历

#include<iostream>
using namespace std;

#include<vector>

void TestVector1()
{
	vector<int> v1;     //1.构造一个空的
	vector<int> v2(10, 5);   //2.用10个值为5的元素构造vector


	int array[] = { 1, 2, 3, 4, 5 };
	vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));   //3.

	string s("hello");
	vector<char>v4(s.begin(), s.end());   //4.

	vector<int>v5(v3);  //5.拷贝构造


	//在c++11中，vector还增加了列表方式的构造
	vector<int>v6{ 1, 2, 3, 4, 5, 6 };


   
    //vector的遍历
	//方式1：for下表  ---推荐
	for(size_t i = 0; i < v2.size(); i++)
	{
		cout << v2[i] << " ";
	}
	cout << endl;

	//方式二：范围for循环
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;

	//方式三：采用迭代器
	vector<char>::iterator it = v4.begin();   //可以用  auto it =v4.begin(); 替换
	while (it != v4.end())
	{
		cout << *it << " ";

	}
	cout << endl;

	//反向迭代器
	vector<int>::reverse_iterator rit = v5.rbegin();  //auto rit = v5.rbegin();
	while (rit != v4.rend())
	{
		cout << *rit << " ";

	}
	cout << endl;

}

 2.resize

void TestVector2()
{
	vector<int> v{ 1, 2, 3, 4, 5, 6 };
	v.reserve(20);

	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.resize(10, 7);   //元素新增到10个多出用7填充   ---->无需扩容
	v.resize(30, 8);    //元素新增到30个多出用8填充   -----》需要扩容
	v.resize(50);    

	//元素个数缩小
	v.resize(40);
	v.resize(30);
	v.resize(20);
	v.resize(10);
	
}

假设vector中旧的元素个数为oldsize，当前容量为capacity
当元素增多时：
1.多出的元素需要使用val进行填充
2.当newsize>capacity时，resize需要进行扩容
3.当元素缩减时：仅仅只是将有效元素个数缩减了，底层空间大小不会发生改变

 3.reserve

void TestVector3()
{
	vector<int> v{ 1, 2, 3, 4, 5 };
	v.reserve(10);
	v.reserve(20);
	v.reserve(50);
	v.reserve(70);

	v.reserve(45);
	v.reserve(23);
	v.reserve(16);
	v.reserve(10);
	v.reserve(5);

}

当空间reserve增大时空间会随之扩增，但是当减小时底层空间不会因此减小

4.元素访问

void TestVector4()
{
	vector<int> v{ 1, 2, 3, 4, 5 };
	cout << v[0] << endl;
	//cout << v[5] << endl;  //越界了
	//cout << v.at(5) << endl;  //at和[]一样也越界了，会抛出一个out_of_range异常

	cout << v.front() << endl;
	cout << v.back()<< endl;

}

5. 插入

void TestVector5()
{
	vector<int> v;
	size_t cap = v.capacity();
	for (size_t i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (cap != v.capacity())
		{
			cap = v.capacity();
			cout << cap << endl;
		}
	}
}

1.push_back尾插
2.演示：vector的扩容方式：vs中是按照1.5倍方式扩容  linux中按照2倍
3.一般情况下尽量避免：一边插入一边阔扩容  因为效率太低了---->a.申请新空间  b.拷贝元素  c.释放旧空间
推荐：如果能够预估vector中大概要放多少个元素可以提前将底层空间大小设置好

void TestVector6()
{
	vector<int> v;
	v.reserve(10);
	for (size_t i = 0; i < 100; ++i)
	{
		v.push_back(i);
	
	}

	//时间复杂度：o（N）
	v.insert(v.begin(), 100);//  begin及其后续所有元素都需要向后搬移

	//在第一个5的位置插入10个8
	auto pos = find(v.begin(), v.end(), 5);
	if (pos != v.end())
	{
		v.insert(pos, 10, 8);
	}

	//插入一段区间
	int array[] = { 100, 200, 300, 400, 500 };
	//将数组中的元素插入到vector的末尾
	v.insert(v.end(), array, array + sizeof(array) / sizeof(array[0]));
}

 6.删除

void TestVector7()
{
	vector<int>v{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	v.erase(v.begin());

	v.erase(v.begin(), v.begin() + 5);   //删除1-6

	v.clear();    //v.erase(v.begin(),v.end());
}

 vector迭代器失效的问题

迭代器的本质：迭代器实际上就是指针 ||对指针进行了封装

比如：对于vector来说，它的迭代器实际就是typedef T*iterator；

什么是迭代器失效：

由于迭代器本质是指针，所谓的迭代器失效指的就是迭代器对应的指针失效。

指针失效：无非就是指针指向的空间不存在或者指针成为了一个野指针则该指针才会失效。

 vector什么情况下会迭代器失效？

对于vector来说：

1.所有可能会导致扩容的操作都可能会导致迭代器失效 

所有插入的方法：push_back(data)   insert(v.begin(),data)   

resize(newsize,data)

reserve(newcapacity)

assign

示例：

//迭代器失效
void TestVector8()
{
	vector<int> v{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

	auto it = v.begin();

	//v.insert(v.begin(), 10, 5);  //在起始位置插入10个值为5的元素  
	//这个过程需要扩容导致原来的空间被释放了 迭代器指向原来的空间被释放了  导致迭代器失效了

	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}

	cout << endl;
}

迭代器失效后果：

如果迭代器已经失效了，继续对迭代器使用造成的后果就是程序崩溃了

预防：

在所有可能导致迭代器失效的操作之后，给迭代器从新进行赋值就可以了。

2.第二类导致迭代器失效的原因
//2.erase(pos) :删除之后pos继续后续的元素都失效了
void TestVector9()
{
	vector<int> v{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	auto it = find(v.begin(), v.end(), 5);
	if (it != v.end())
	{
		//erase的返回值：返回删除位置下一个位置的元素
		v.erase(it);
	}

	cout << *it << endl;
}

 预防：在所有可能导致迭代器失效的操作之后，给迭代器从新进行赋值就可以了。

 vector构造二维数组



void TestVector()
{
	//需要构造5行6列的二维数组
	vector<vector<int>> vv;

	vv.resize(5);
	for (size_t i = 0; i < vv.size(); ++i)
	{
		vv[i].resize(6, 8); //每行有6个元素每个元素都为8 
	}

	vector<vector<int>> vv2;
	vv2.resize(5, vector<int>(6, 8));

	vector<vector<int>>vv3(5, vector<int>(6, 8));

}

二维vector构造原理：

 每行元素个数不同
比如：杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1 

void TestVector2(int n) 
{
	vector<vector<int>>vv(n);
	for (size_t i = 0; i < vv.size(); ++i)
	{
		vv[i].resize(i + 1, 1);

		//修改每行的元素：非第0列 以及  对角线上的元素
		for (size_t j = 1; j < i; ++j)
			vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
	}
}

vector的模拟实现

vector的示意图：

代码实现： 

#include<iostream>
using namespace std;

#include<vector>
#include<assert.h>

namespace zilong
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

	public:
		//1.
		vector()
			:start(nullptr)
			, finish(nullptr)
			, endofstorage(nullptr)
		{}
		
		
		//2.
		vector(size_t n, const T& val)
		{
			start = new T[n];
			for (int i = 0; i < n; i++)
			{
				start[i] = val;
			}
			finish = start + n;
			endofstorage = finish;

		}

		//用一段区间的元素构造
		template<class Iterator>
		vector(Iterator first, Iterator last)
		{
			auto it = first;

			//统计【first last】区间中元素的个数
			size_t n = 0;
			while (it != last)
			{
				++it;
				++n;
			}

			start = new T[n];
			finish = starat;
			while (first != last)
			{
				*finish = *first;
				++first;
				++finish;
			}

			endifstorage = finish;
		}

		//拷贝构造
		vector(const vector<T>& v)
		{
			size_t n = v.size();
			strat = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				start[i] = v[i];
				
			}

			finish = start + n;
			endofstorage = finish;

		}

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

		~vector()
		{
			if (start)
			{
				delete[] start;
				start = finish = endofstorage = nullptr;
			}
		}

		//
		//迭代器
		iterator begin()
		{
			return starat;
		}

		iterator end()
		{
			return finish;
		}

		/
		//容量
		size_t size()const
		{
			return finish - start;
		}

		size_t capacity()const
		{
			return endofstorage - start;
		}

		bool empty()const
		{
			return start == finish;
		}

		void resize(size_t newsize, const T& val = T())
		{
			size_t oldsize = size();

			//将有效元素个数缩减到newsize
			if (newsize <= oldsize)
			{
				finish = start + newsize;
			}
			else
			{
				//将有效元素个数增加到newsize
				size_t cap = capacity();
				if (newsize > cap)
					reserve(newsize);

				//多出来的元素使用val填充
				for (size_t i = oldsize; i < newsize; ++i)
				{
					start[i] = val;
				}
				finish = start + newsize;
			}
		}


		void reserve(size_t newcapacity)
		{
			size_t oldCap = capacity();
			if (newcapacity > oldCap)
			{
				//开辟新空间
				T* temp = new T[newcapacity];
          if (start)
				{
					//拷贝元素:memcpy是浅拷贝
					//如果vector中放置的元素中涉及到资源管理时候，采用memcpy的浅拷贝是会出问题
					//memcpy(temp, start, sizeof(T)*size());

					for (size_t i = 0; i < size(); ++i)
					{
						temp[i] = start[i];
					}
					//释放旧空间
					//free(start);

					delete[] start;
				}
			
			}
			size_t sz = size();
			start = temp;
			finish = start + sz;
			endofstorage = start + newcapacity;
		}
		///
		//元素访问

		T& front()
		{
			return *start;
		}

		const T& front()const
		{
			return *start;
		}

		T& back()
		{
			return *(finish-1);
		}

		const T& back()const
		{
			return *(finish - 1);
		}

		//下标运算符的重载
		T& operator[](size_t index)
		{
			assert(index < size());
			return start[index];
		}

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

		//at
		T& at(size_t index)
		{
			if (index >= size())
			{
				throw out_of_range("vector at method:out_of_range");
			}
			return start[index];
		}

		const T& at(size_t index)const
		{
			if (index >= size())
			{
				throw out_of_range("vector at method : out_of_range");
			}
			return start[index];
		}

		/
		//修改
		void push_back(const T& val)
		{
			//先检测空间是否足够
			if (finish == endofstorage)
				reserve(capacity()*1.5 + 3);
			*finish = val;
			++finish;
		}

		void pop_back()
		{
			if (empty())
			{
				return;
			}

			--finish;
		}


		//任意位置插入删除
		//时间复杂度：O(N)
		iterator insert(iterator pos, const T& val)
		{
			//检测pos是否合法：pos必须在[begin(),end()]
			if (pos<begin() || pos>end())
				return end();

			if (finish == endofstorage)
				reserve(capacity() * 2);

			auto it = finish - 1; //最后一个元素位置
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}

			*pos = val;
			finish++;
			return pos;   //返回刚刚插入元素所在的位置
		}

		iterator erase(iterator pos)
		{
			if (empty())
				return end();

			if (pos < begin() || pos >= end())
				return end();

			auto it = pos + 1;
			while (it != end())
			{
				*(it - 1) = *it;
				it++;
			}
			finish--;
			return pos;
		}

		//删除一段区间的元素
		iterator erase(iterator first, iterator last)
		{
			auto it = first;
			auto pos = last;

			size_t n = last - first;
			while (pos != end())
			{
				*it = *pos;
				++it;
				++pos;
				

			}
			finish -= n;
			return first;
		}
	private:
		iterator start;
		iterator finish;
		iterator endofstorage;
	};


}

当存在自定义类型时，就会存在的一些问题：

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。

2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且 自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是 浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

小牛在努力
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++之vector深度剖析
aaaaauaan的博客
11-03 2641
C++之vector深度剖析1.vector的介绍及使用1.1 vector的介绍1.2 vector的使用1.2.1 vector的定义1.2.2 vector iterator 的使用1.2.3 vector 空间增长问题1.2.3 vector 增删查改1.2.4 vector 迭代器失效问题2.vector深度剖析及模拟实现 1.vector的介绍及使用 1.1 vector的介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可
C++关于vector的详细讲解
博客记录学习轨迹，方便日后复习
01-20 736
本文介绍了C++中vector的一些重要的使用方法
C++ 向量(vector)
lisayh的博客
02-15 8128
1.向量vector简介 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。      在使用它时, 需要包含头文件 vector, #include&lt;vector&gt;  ...
C/C++ vector详解
最新发布
2301_77087344的博客
05-20 1628
C/C++初始识：向量，顺序表，是一个类模板，顺序容器。
C++——vector
Ll_R_lL的博客
09-29 6763
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是。
C++ vector
qq_34703466的博客
04-12 98
vector&lt;int&gt; v;排序：sort(v.begin(),v.end());查找：vector&lt;int&gt;::iterator result = find( v.begin( ),v.end( ), 2 ); //find-2
C++深度解析.rar
09-07
《C++深度解析》是一份全面且深入的C++学习资料，主要针对已经掌握C++基础知识，希望进一步提升技能的开发者。这份教程包含了DT全套课程的PPT和文档，提供了丰富的理论知识和实践指导，旨在帮助学习者深入理解C++...
Linux C++ 解析bmp
11-22
本教程将介绍如何在CentOS 7.4上使用C++解析BMP文件。 首先，我们需要理解BMP文件的结构。BMP文件以头部信息开始，包括文件头（BITMAPFILEHEADER）和位图信息头（BITMAPINFOHEADER）。文件头包含了文件类型、文件...
深度探索C++对象模型 超清
05-15
《深度探索C++对象模型》是一本专注于解析C++编程语言底层实现机制的书籍，它旨在帮助开发者深入了解C++的对象模型，从而更好地理解和利用这一强大的编程工具。C++作为一门静态类型、编译型的语言，其对象模型是理解...
C++解析.rar
05-06
《C++解析》 C++是一种强大的、通用的编程语言，由Bjarne Stroustrup在1979年设计并开发，作为C语言的扩展。C++在现代软件开发中占据着重要的地位，尤其在系统软件、嵌入式软件、游戏引擎、高性能计算等领域有着...
深度探索c++对象模型(2012版本)
02-07
《深度探索C++对象模型》是一本专注于C++底层机制的专著，主要针对2012年的标准进行深入解析。C++是一种多范式、静态类型、编译型、并发型、通用程序设计语言，它以其强大的功能和灵活性而闻名。这本书的目标是帮助...
C++ vector使用详解
sushhsishdgsusk的博客
05-19 8659
C++是一门广泛应用于计算机程序设计的编程语言，而vector则是C++中非常常用的一个容器。下面将详细介绍C++ vector的特性和使用方法。
C++ Vector详解
lim6ere的博客
03-07 7306
在本篇文章中，我们将会学到关于C++中vector的使用方法其中包括成员函数（构造，析构），迭代器相关的知识，容量（size,resize,capacity,reverse）,以及vector的增删查改单独定义一个vector：上面这个定义其实相当于是一维数组name[size]，只不过其size可以根据需要进行变化，这就是“变长数组”的名字的由来。
【C++】 vector的使用
m0_72563041的博客
03-04 4339
STL初阶 -- vector
第七章：vector类
m0_63027727的博客
03-20 1005
第七章：vector类 1.vector的介绍 vector的文档 ①vector是表示可变大小数组的序列容器。 ②就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。 ③本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相
STL中的vector容器的一点总结
Vast_Sea的专栏
11-06 773
From:  http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/08/2627666.html 1.vector的简单介绍 vector作为STL提供的标准容器之一，是经常要使用的，有很重要的地位，并且使用起来也是灰常方便。vector又被称为向量，vector可以形象的描述为长度可以动态改变的数组，功能和数组较为相似。实
c++ vector详解
热门推荐
m0_62870588的博客
03-24 12万+
vector的创建和初始化、vector的遍历、向vector添加元素、从vector移除元素、vector相等判断与赋值。
python vector_C++ vector使用方法
weixin_39859954的博客
11-25 3859
在 c++ 中，vector 是一个十分有用的容器。它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。C++ 中数组很坑，有没有类似 Python 中 list 的数据类型呢？类似的就是 vector！vector 是同一种类型的对象的集合，每个对象都有一个对应的整数索引值。和 string 对象一样，标准库将负责管理与存储元...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值