C++学习__08—Vector

羽t

已于 2024-05-29 12:29:18 修改

阅读量727

点赞数 21

分类专栏： C++学习文章标签： c++ 学习开发语言

于 2024-05-20 20:03:29 首次发布

本文链接：https://blog.csdn.net/dfggc/article/details/138868912

版权

C++学习专栏收录该内容

14 篇文章 0 订阅

订阅专栏

【本节目标】
1.vector 的介绍及使用
2.vector 深度剖析及模拟实现

（建议通过计算机设备进行观看，以获得更佳的视觉效果。若选择在移动设备上观看，可能会因屏幕限制导致部分内容的排版效果不理想，且信息展示过于密集，从而影响观看体验。)

（本内容有大量借鉴比特课件，故特此说明！）

（有不足之处，望周知）

1.vector 的介绍及使用

1.1 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 统一的迭代器和引用更好。
学习方法：使用 STL 的三个境界：能用，明理，能扩展，那么下面学习 vector ，我们也是按照这个方法去学习.

1.2 vector 的使用

vector 学习时一定要学会查看文档：vector 的文档介绍，vector 在实际中非常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口是要重点掌握的。

1.2.1 vector 的定义

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

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

int main()
{
	vector<int> v1;							// 无参构造
	vector<int> v2(4,1);					// 构造并初始化4个1
	vector<int> v3(v2.begin(),v2.end());	// 使用迭代器进行初始化构造
	vector<int> v4(v3);						// 拷贝构造

	for (auto e : v2)
	{
		cout << e;
	}
	cout << endl;

	// 下面涉及迭代器初始化的部分，我们学习完迭代器再来看这部分
	int myints[] = { 1,2,3,4 };
	vector<int> v5(myints, myints + sizeof(myints) / sizeof(int));
	vector<int>::iterator it = v5.begin();
	while (it != v5.end())
	{
		cout << ' ' << *it;
		++it;
	}
	cout << endl;
	return 0;
}

代码运行结果：

1.2.2 vector 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;
	}

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

	PrintVector(v);
	return 0;
}

代码运行结果：

1.2.3 vector 空间增长问题

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

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

// vector::capacity
#include<iostream>
#include<vector>
using namespace std;
int main()
{
	size_t sz;
	vector<int> foo;
	sz = foo.capacity();
	cout << "making foo grow:\n";
	for (int i = 0; i < 100; i++)
	{
		foo.push_back(i);
		if (sz != foo.capacity())
		{
			sz = foo.capacity();
			cout << "capacity changed:" << sz << '\n';
		}
	}
	return 0;
}

代码运行结果：

// vector::reserve
#include<iostream>
#include<vector>
using namespace std;
int main()
{
	size_t sz;
	vector<int> foo;
	sz = foo.capacity();
	cout << "making foo grow:\n";
	for (int i = 0; i < 100; i++)
	{
		foo.push_back(i);
		if (sz != foo.capacity())
		{
			sz = foo.capacity();
			cout << "capacity changed:" << sz << '\n';
		}
	}
	vector<int> bar;
	sz = bar.capacity();
	bar.reserve(100);	// this is the only difference with foo above			
	cout << "making bar grow:\n";
	for (int i = 0; i < 100; i++)
	{
		bar.push_back(i);
		if (sz != bar.capacity())
		{
			sz = bar.capacity();
			cout << "capacity changed:" << sz << '\n';
		}
	}
	return 0;
}

代码运行结果：

// vector::resize
#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<int> myvector;

	// set some initial content:
	for (int i = 1; i < 10; i++)
	{
		myvector.push_back(i);
	}

	myvector.resize(5);
	myvector.resize(8,100);
	myvector.resize(12);

	cout << "myvector contains:";
	for (int i = 0; i < myvector.size(); i++)
	{
		cout << ' ' << myvector[i];
	}
	cout << '\n';
	return 0;
}

代码运行结果：

1.2.4 vector 增删查改

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

// push_back / pop_back
#include<iostream>
#include<vector>
using namespace std;
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<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;
	}
	cout << endl;
	return 0;
}

代码运行结果：

// operator[]+index 和 C++11中vector的新式for+auto的遍历
// vector使用这两种遍历方式是比较便捷的
#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> swap_s;
	swap_s.swap(v);

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

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

	// C++11支持的新式范围for遍历
	for (auto e : swap_s)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

代码运行结果：

1.2.5 vector 迭代器失效问题 (重点)

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：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 };

	auto it = v.begin();

	// 将有效元素个数增加到10个，多出的位置使用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;
}

代码运行结果：

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);
		}
		// else 
		++it;
	}
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

#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)
		{
			it = v.erase(it);
		}
		else 
			++it;
	}
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

第一个代码运行结果：

第二个代码运行结果：

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

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

2.1 std::vector 的核心框架接门的模拟实现 yut :: vector

可以自己先尝试实现一下一些函数接口

#include<iostream>
using namespace std;
#include<assert.h>
namespace yut
{
	template<class T>
	class vector
	{
	public:
		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)
			,_end_of_storage(nullptr)
		{ }
		vector(const vector<T>& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	_finish = _start;
		//	_end_of_storage = _start + v.capacity();
		//	for (size_t i = 0; i < v.size(); i++)
		//	{
		//		*_finish = v[i];
		//		_finish++;
		//	}
		//}
		vector(size_t n,const T& value=T())
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(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()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}
	    iterator operator++();
	    iterator operator++(int);
	    iterator operator--();
	    iterator operator--(int);
		size_t size()const;
		size_t capacity()const;
		bool empty()const;
		void reserve(size_t n);
		void resize(size_t n, const T& value = T());
		void push_back(const T& x);
		void pop_back();
		T& operator[](size_t pos);
		const T& operator[](size_t pos)const;
		vector<T>& operator=(vector<T> v);
		void swap(vector<T>& v);
		iterator insert(iterator pos,const T& x);
		iterator erase(iterator pos);
        iterator find(iterator begin,iterator end,const T& value);// 这个可有可无

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

具体代码如下：

#include<iostream>
using namespace std;
#include<assert.h>
namespace yut
{
	template<class T>
	class vector
	{
	public:
		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;
		}
		iterator operator++()
		{
			_start += 1;
			return _start;
		}
		iterator operator++(int)
		{
			auto tmp = _start;
			_start += 1;
			return tmp;
		}
		iterator operator--()
		{
			_start -= 1;
			return _start;
		}
		iterator operator--(int)
		{
			auto tmp = _start;
			_start -= 1;
			return tmp;
		}
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{ }
		vector(const vector<T>& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	_finish = _start;
		//	_end_of_storage = _start + v.capacity();
		//	for (size_t i = 0; i < v.size(); i++)
		//	{
		//		*_finish = v[i];
		//		_finish++;
		//	}
		//}
		vector(size_t n,const T& value=T())
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(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()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}
		size_t size()const
		{
			return _finish - _start;
		}
		size_t capacity()const
		{
			return _end_of_storage - _start;
		}
		bool empty()const
		{
			return _start == _finish ? 1 : 0;
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t size_s = size();
				T* tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < size_s; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + size_s;
				_end_of_storage = _start + n;
			}
		}
		void resize(size_t n, const T& value = T())
		{
			if (n > size())
			{
				if (n > capacity())
				{
					reserve(n);
				}
				while (_finish < _start + n)
				{
					*_finish = value;
					_finish++;
				}
				//for (size_t i = 0; i < n-size(); i++)
				//{
				//		(*_finish) = value;
				//		_finish++;
				//}
			}
			else
			{
				_finish = _start + n;
				//_finish -= n;
			}
		}
		void push_back(const T& x)
		{
			if (size() == capacity())
			{
				size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		void pop_back()
		{
			assert(size() > 0);
			_finish--;
		}
		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
			//return *(_start + pos);
		}
		const T& operator[](size_t pos)const
		{
			assert(pos < size());
			return _start[pos];
			//return *(_start + pos);
		}
		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		delete[] _start;
		//		_start = new T[v.capacity()]; 
		//		_finish = _start;
		//		_end_of_storage = _start + v.capacity();
		//		for (size_t i = 0; i < v.size(); i++)
		//		{
		//			*_finish = v[i];
		//			_finish++;
		//		}
		//	}
		//	return *this;
		//}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		void swap(vector<T>& v)
		{
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_end_of_storage, v._end_of_storage);
		}
		iterator insert(iterator pos,const T& x)
		{
			assert(pos <= _finish);
			if (size() == capacity())
			{
				size_t n = pos - _start;
				size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
				reserve(newcapacity);
				pos = _start + n;
			}
			iterator end = _finish;
			while (end > pos)
			{
				*end = *(end - 1);
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		iterator erase(iterator pos)
		{
			assert(pos < _finish);
			iterator it = pos;
			while (it < _finish)
			{
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}
	private:
		iterator _start;			// 指向数据块的开始
		iterator _finish;			// 指向有效数据的尾
		iterator _end_of_storage;	// 指向存储容量的尾
	};
}

2.2 使用 memcpy 拷贝问题

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

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

问题分析:
1. memcpy 是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
2.如果拷贝的是自定义类型的元素，memcpy 即高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为 memcpy 的拷贝实际是浅拷贝。

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

2.3 对 yut : : vector 核心接口的测试

#include"vector.h"


void print_vector(yut::vector<int>& v)
{
	yut::vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void print_vector(yut::vector<string>& v)
{
	yut::vector<string>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

// constructing vectors
void test_vector1()
{
	yut::vector<int> v0;
	yut::vector<int> v1(4, 1);
	yut::vector<int> v2(v1);
	v0 = v1;
	print_vector(v0);
	print_vector(v1);
	print_vector(v2);
}

void test_vector1_1()
{
	// 报错了，暂时找不到原因
	yut::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	//yut::vector<int> v2(v1.begin(),v1.end());
	//print_vector(v2);

}

void test_vector2()
{
	// 使用push_back插入4个数据
	yut::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	print_vector(v1);

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

	// C++支持iterator及接口，就支持范围for
	for (auto e : v1)
	{
		cout << e << " ";
	}
}

// find / insert / erase
void test_vector3()
{
	yut::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	print_vector(v1);

	// find为头文件库自带的函数,当然,也可以自己写,实现很容易
	// 使用find查找3所在位置的iterator
	auto pos = find(v1.begin(), v1.end(), 3);

	// 在pos位置之前插入30
	v1.insert(pos, 30);
	print_vector(v1);

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

}

// iterator 失效问题
void test_vector4()
{
	yut::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	// 删除pos位置的数据，导致pos迭代器失效
	auto pos = find(v1.begin(), v1.end(), 3);
	v1.erase(pos);
	cout << *pos << endl;  // 此处会导致非法访问


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



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

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

}

void test_vector5()
{
	// 测试T是string时，拷贝问题
	yut::vector<string> strv;
	strv.push_back("1111");
	strv.push_back("2222");
	strv.push_back("3333");
	strv.push_back("4444");
	print_vector(strv);

	strv.resize(8, "55555");
	print_vector(strv);

}

2.4 动态二维数组理解

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	// 以杨慧三角的前n行为例: 假设n为5
	// 使用vector定义二维数组vv，vv中的每个元素都是vector<int>
	vector<vector<int>> vv(3);

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

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

	return 0;
}

构造一个 w 动态二维数组，w中总共有 n 个元素，每个元素都是 vector 类型的，每行没有包含任何元素，如果 n 为 5 时如下所示 :

羽t

关注

21
点赞
踩
12

收藏

觉得还不错? 一键收藏
1
评论
C++学习__08—Vector

erase 删除 pos 位置元素后，pos 位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是: 如果 pos 刚好是最后一个元素，删完之后 pos 刚好是 end 的位置，而 end 位置是没有元素的，那么 pos 就失效了。其做法是，分配一个新的数组，然后将全部元素移到这个数组。2.如果拷贝的是自定义类型的元素，memcpy 即高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为 memcpy 的拷贝实际是浅拷贝。
复制链接

扫一扫

专栏目录