【C++ vector】

最新推荐文章于 2024-09-02 23:09:18 发布

_三分糖

最新推荐文章于 2024-09-02 23:09:18 发布

阅读量251

点赞数 4

文章标签： c++ 数据结构算法

本文链接：https://blog.csdn.net/m0_60900383/article/details/126253356

版权

2.1std::vector的核心框架接口的模拟实现rzy::vector

2.2使用memcpy拷贝的问题

2.3动态二维数组理解

1.vector的介绍及使用

1.1vector的介绍

1.vector是表示可变大小数组的序列容器

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

3.本质讲，vector使用动态分配数组来存储它的元素。当新元素插入的时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

4.vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际存储的空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

5.因此vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

6.与其他动态序列容器相比(deques,lists and forward_lists),vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其他不在末尾的删除和插入操作、效率更低。比起lists和forward_lists统一的迭代器和引用更好。

学习方法：使用STL的三个境界：能用，明理，能扩展;

1.2vector的使用

vector学习时候一般学会查看文档，vector在实际中非常的重要，在实际中我们数字常见的接口就可以，下面列出的是要重点掌握的。

1.2.1vector的定义

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

int main()
{
	//constructor used in the same order as described above:
	std::vector<int>first;//empty vector of ints
	std::vector<int>second(4,100);//4 ints with value 100
	std::vector<int>third(second.begin(), second.end());//iterating through second
	std::vector<int>fourth(third);//a copy of third

	//下面涉及迭代器初始化的部分，学完迭代器再来看
	//the iterator constructor can also be used to construct from arrays
	int myints[] = { 1, 3, 5, 8 };
	std::vector<int>fifth(myints, myints + sizeof(myints) / sizeof(int));

	std::cout << "the contents of fifth are:";
	for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end();++it)
	{
		std::cout << " " << *it;
	}
	std::cout << endl;
	return 0;
}

1.2.2vector iterator的使用

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

#include<iostream>
#include<vector>
using namespace std;

void PrintVector(const vector<int>& v)
{
	//const对象使用const迭代器进行遍历打印
	vector<int>::const_iterator it = v.begin();
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

int main()
{
	//使用push_back插入4个数据
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	//使用迭代器进行遍历打印
	vector<int>::iterator it = v.begin();
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//使用迭代器进行修改
	it = v.begin();
	while (it!=v.end())
	{
		*it *= 2;
		++it;
	}
	cout << endl;


	//使用反向迭代器进行遍历再打印
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit!=v.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	PrintVector(v);
	return 0;
}

1.2.3vector空间增长问题

容量空间	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize(重点)	改变vector的size
reserve(重点)	改变vector放入capacity

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常经常会考察，不要固化的认为顺序表增容都是按2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL,g++是SGI版本STL;
reserve只是负责开辟空间的同时还会进行初始化，reserve可以缓解vector增容的代价缺陷问题。
resize在开空间的同时还会进行初始化，影响size

1.2.4vector的增删查改

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

//push_back/pop_back
#include<iostream>
#include<vector>

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int>v(a, a + sizeof(a) / sizeof(int));

	vector<int>::iterator it = v.begin();
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;


	v.pop_back();
	v.pop_back();

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

//find/insert/erase
#include<algorithm>
#include<iostream>
#include<vector>
using namespace std;

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int>v(a, a+sizeof(a) / sizeof(int));

	//使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);

	//在pos位置前插入30
	v.insert(pos, 30);

	vector<int>::iterator it = v.begin();
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	pos = find(v.begin(), v.end(), 3);
	//删除pos位置的数据
	v.erase(pos);

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

#include<iostream>
#include<vector>
using namespace std;

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int>v(a, a + sizeof(a) / sizeof(int));

	//通过[]读写第0个位置
	v[0] = 10;
	cout << v[0] << endl;
	//通过[i]的方式遍历vector
	for (size_t i = 0; i < v.size();++i)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	vector<int>swapv;
	swapv.swap(v);//v有数据，swapv没数据
	//现在交换了之后swapv有数据，v没有
	cout << "v data:";
	for (size_t i = 0; i < v.size();++i)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	cout << "swapv data:";
	for (size_t i = 0; i < swapv.size();++i)
	{
		cout << swapv[i] << " ";
	}
	cout << endl;
	//c++11支持的新式范围for
	v.swap(swapv);
	for (auto x:v)
	{
		cout << x << " ";
	}
	cout << endl;
	return 0;
}

1.2.5vector迭代器时效问题（重点）

迭代器的主要作用就是让算法能够不关心底层数据结构，其底层实际就是个指针，或者对指针进行了封装，比如：vector的迭代器就是原生态指针T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃（即如果继续使用已经失效的迭代器，程序可能会崩溃）。

对于vector可能会导致其迭代器失效的操作有：

1.会引起其底层空间改变的操作，都有可能使迭代器失效，比如：resize,reserve,insert,assign,push_back等。

#include<iostream>
#include<vector>
using namespace std;

int main()
{
	vector<int>v{ 1, 2, 3, 4, 5, 6 };
	auto it = v.begin();
	
	//将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
	//v.resize(100,8);

	//reserve的作用是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
	//v.reserve(100);

	//插入元素期间，可能会引起扩容，而导致原空间被释放
	//v.insert(v.begin(), 0);

	//v.push_back(8);

	//给vector重新赋值，可能会引起底层容量改变
	v.assign(100, 8);


	/*下面代码会出错；出错原因：以上操作都有可能会导致vector扩容，也就是说
	vector底层原理就空间被释放调，而在打印时，it还是用的是释放之前的旧空间，在对
	it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃
	解决方式：
	在以上操作完成后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可*/
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;

	return 0;
}

2.指定位置元素的删除操作

//2.指定位置元素的删除操作---erase
#include<iostream>
#include<vector>
using namespace std;

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int>v(a, a + sizeof(a) / sizeof(int));

	//使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);

	//删除pos位置的数据，导致pos迭代器失效
	v.erase(pos);
	cout << *pos << endl;//此处导致非法访问

	return 0;
}

erase删除pos位置元素后，pos位置之后的元素会往前移，没有导致底层空间的改变，理论上讲迭代器不应该会消失，但是：如果pos刚好是最后一个元素，删除完pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

以下代码的功能是删除vector中所有的偶数，请问哪个代码是正确的？为什么？

#include<iostream>
#include<vector>
using namespace std;

/*int main()
{
	vector<int>v{ 1, 2, 3, 4 };
	auto it = v.begin();
	while (it!=v.end())
	{
		if (*it%2==0)
		{
			v.erase(it);
		}
		++it;//it位置已经删掉了,失效了再++会报错
	}
	return 0;
}*/


int main()
{
	vector<int>v{ 1, 2, 3, 4 };
	auto it = v.begin();
	while (it!=v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.erase(it);
		}
		else
			++it;
	}
	return 0;
}

迭代器失效解决办法：在使用前，对迭代器重新赋值即可；

2.vector的深度剖析及模拟实现

2.1std::vector的核心框架接口的模拟实现rzy::vector

//std::vector的核心框架接口的模拟实现rzy::vector
namespace rzy
{
	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 cbegin()const
		{
			return _start;
		}
		const_iterator cend()const
		{
			return _finish;
		}

		//construct and destroy
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{}


		vector(int n, int const T& value = T())//vector(3,8)fill
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}


		//若使用iterator做迭代器，会导致初始化的迭代器区间(first,last)只能是vector的迭代器，
		//重新声明迭代器,迭代器区间(first,last)可以是任意容器的迭代器
		template<class InputIterator>
		vector(InputIterator first,InputIterator last)
		{
			reserve(last - first);
			while (first!=last)
			{
				push_back(*first);
				++first;
			}
		}


		vector(const vector<T>&v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(v.capacity());
			iterator it = begin();
			const_iterator vit = v.cbegin();
			while (vit!=v.cend())
			{
				*it++ = *vit++;
			}
		}


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

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


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

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

		void reverse(size_t n)
		{
			if (n>capacity())
			{
				size_t oldSize = size();
				T*tmp = new T[n];

				//这里直接使用memcpy?
				//if(_start)
				//memcpy(tmp,_start,sizeof(T)*size)

				if (_start)
				{
					for (size_t i = 0; i < oldSize;++i)
					{
						tmp[i] = _start[i];
					}
				}
				_start = tmp;
				_finish = _start + oldSize;
				_endOfStorage = _start + n;
			}
		}


		void resize(size_t n, const T&value = T())
		{
			//1.如果n小于当前的size,则数据个数缩小到n
			if (n<=size())
			{
				_finish = _start + n;
				return;
			}

			//2.空间不够则增容
			if (n>capacity)
			{
				reserve(n);
			}

			//3.将size扩大到n
			iterator it = _finish;
			_finish = _start + n;
			while (it!=_finish)
			{
				*it = value;
				++it;
			}
		}


		//acess
		T&operator[] = (size_t pos)
		{ 
			return _start[pos];
		}
		const T&operator[](size_t pos)const
		{
			return _start[pos];
		}

		//modify
		void push_back(const T&x)
		{
			insert(end(), x);
		}
		void pop_back()
		{
			erase(--end());
		}

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

		iterator insert(iterator pos, const T&x)
		{
			assert(pos <= _finish);
			//空间不够先进行增容
			if (_finish==_endOfStroage)
			{
				//size_t size=size();
				size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
				reserve(newCapacity);

				//如果发生了增容,需要重置pos
				pos = _start + size();
			}

			iterator end = _finish - 1;
			while (end>=pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
			return pos;
		}

		//返回删除数据的下一个数据
		//方便解决：一边遍历一边删除的迭代器时效问题
		iterator erase(iterator pos)
		{
			//挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _finish)
			{
				*(begin - 1) = *begin;
				++begin;
			}
			--finish;
			return pos;
		}

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

2.2使用memcpy拷贝的问题

假设模拟实现的vector中的reserve接口中，使用memcpy进行的拷贝，以下代码会发生什么问题？

int main()
{
 rzy::vector<rzy::string> v;
 v.push_back("1111");
 v.push_back("2222");
 v.push_back("3333");
 return 0;
}

问题分析：

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

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

结论：

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

2.2对rzy::vector核心接口的测试

//对rzy::vector核心接口的测试
//constructing vectors
void TestVector1()
{
	//constructors used in the same order as described zbove:

	rzy::vector<int>first;   //empty vector of ints
	rzy::vector<int>second(4, 100);    //four ints with value 100

	rzy::vector<int>third(second.begin(), second.end());//iterating through second
	rzy::vector<int>fourth(third);        //a copy of third

	//the iterator constructor can also be used to construct from arrays:
	int myints[] = { 2, 5, 6, 9 };
	rzy::vector<int>fifth(myints, myints + sizeof(myints) / sizeof(int));

	std::cout << "the contents of fifth are:";
	for (rzy::vector<int>::iterator it = fifth.begin(); it != fifth.end();++it)
	{
		std::cout << *it << " ";
	}
	std::cout << endl;


	//测试T是string时，拷贝问题
	rzy::vector<string>strV;
	strV.PushBack("111");
	strV.PushBack("222");
	strV.PushBack("333");
	strV.PushBack("444");

	for (size_t i = 0; i < strV.size();++i)
	{
		cout << strV[i] << " ";
	}
	cout << endl;
}

//vector iterator的使用
void PrintVector(const rzy::vector<int>&v)
{
	//使用const迭代器进行遍历打印
	rzy::vector<int>::const_iterator it = v.begin();
	while (it!=v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void TestVector2()
{
	//使用push_back插入4个数据
	rzy::vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(1);

	PrintVector(v);

	//使用迭代器进行修改
	auto it = v.begin();
	while (it!=v.end())
	{
		*it *= 2;
		++it;
	}
	PrintVector(v);

	//这里可以看出C++11支持iterator及接口，旧支持范围for
	for (auto e:v)
	{
		cout << e << " ";
	}
}

//find / insert /erase
void TestVector3()
{
	int a[] = { 1, 2, 3, 4 };
	rzy::vector<int>v{ a, a + sizeof(a) / sizeof(int) };

	//使用find查找3所在位置的iterator
	auto pos = find(v.begin(), v.end(), 3);

	//在pos为之前插入30
	v.insert(pos, 30);
	PrintVector(v);

	//删除pos位置的数据，导致pos迭代器失效
	auto pos = find(v.begin(), v.end(), 3);
	v.erase(pos);
	cout << *pos << endl;

	//在pos位置插入数据，导致pos迭代器失效
	//insert会导致迭代器失效，是因为insert可能会导致增容，增容后pos还能
	//只想原来的空间，而原来的空间已经释放了
	pos = find(v.begin(), v.end(), 3);
	v.insert(pos, 30);
	cout << *pos << endl;//此处会导致非法访问

	//实现删除v中的所有偶数
	//下面的程序会崩溃，如果是偶数erase会导致it失效
	//对失效的迭代器进行++it，会导致程序崩溃
	auto it = v.begin();
	while (it!=v.end())
	{
		if (*it%2==0)
		{
			v.erase(it);
		}
		++it;
	}

	//以上程序要改成这样,erase会返回删除位置的下一个位置
	it = v.begin();
	while (it!=v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.erase(it);
		}
		else
			++it;
	}
}

2.3动态二维数组理解

void test5(size_t n)
{
	//使用vector定义二维数组vv,vv中每个元素都是vector<int>
	rzy::vector<rzy::vector<int>>vv(n);

	//将二维数组每一行中的vector<int>中的元素全部设置为1
	for (size_t i = 0; i < n;++i)
	{
		vv[i].resize(i + 1, 1);
	}

	//给杨辉三角出第一列和对角线的所有元素赋值
	for (int i = 2; i < n;++i)
	{
		for (int j = 1; j < i;++j)
		{
			vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
		}
	}
}

rzy::vector<rzy::vector<int>>vv(n);构造一个vv动态二维数组，vv中总共有n个元素，每个元素都是vector类型的，每行没有包含任何元素；

_三分糖

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
4
评论
【C++ vector】

1.vector是表示可变大小数组的序列容器2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着卡伊采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。3.本质讲，vector使用动态分配数组来存储它的元素。当新元素插入的时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。......
复制链接

扫一扫