STL篇二：vector

最新推荐文章于 2024-05-20 15:29:54 发布

不如小布.

最新推荐文章于 2024-05-20 15:29:54 发布

阅读量1k

点赞数 29

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

本文链接：https://blog.csdn.net/qq_62321047/article/details/135622755

版权

C++ 专栏收录该内容

13 篇文章 14 订阅

订阅专栏

前言

前面已经学习了第一个STL容器string，接下来将要学习的是第二种容器vector。

1.vector的介绍和使用

1.1 vector的介绍

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

1.2 vector的使用

vector学习时一定要学会查看文档：vector的文档介绍，vector在实际中非常的重要，在实际中我们熟悉常见的接口就可以。

	void test_vector1()
	{
		//尾插数据
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		//循环遍历
		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << " ";
		}
		cout << endl;

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

		//范围for遍历
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_vector2()
	{
		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);
		v.push_back(7);

		//插入
		v.insert(v.begin() + 3,30);
		v.insert(v.begin(), 10);

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

		//删除
		v.erase(v.begin() + 3);
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

1.2.1 迭代器

首先要介绍一下的是什么是迭代器。迭代器实际上是封装的产物，它可以让你在不知道数据内部实际存储方式的情况下，能以相同的方式遍历你所用到的结构。简单来说，我们知道vector实际上跟数组差不多，那么遍历的话只需要从前往后依次遍历就可以了，那么当我们使用哈希或者set时，我们知道该如果去遍历它吗？而迭代器就此应运而生，它可以让我们以相同的方式遍历不同的数据结构而不用去关注它的内在的存储方式。
在这里插入图片描述
迭代器的本质就是封装了两个指针，一个指向第一个元素，另一个指向最后一个元素的下一个位置，迭代器遍历就是通过这两个指针来访问所有数据。

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

这个就是迭代器的使用方式，每个容器的迭代器的使用方式都是一样的。vector::iterator就是说明类型是vector的迭代器，iterator就是迭代器的意思，it是迭代器的一个变量，v.begin()是进行初始化。

1.2.2 迭代器失效的问题

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

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


#include <iostream>
using namespace std;
#include <vector>
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;
}

在这里插入图片描述

指定位置元素的删除操作–erase

#include <iostream>
using namespace std;
#include <vector>
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>
using namespace std;
#include <vector>
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;
	}

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

注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
    vector<int> v{ 1,2,3,4,5 };
    for (size_t i = 0; i < v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
    auto it = v.begin();
    cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
    // 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效 
    v.reserve(100);
    cout << "扩容之后，vector的容量为: " << v.capacity() << endl;

    // 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
    // 虽然可能运行，但是输出的结果是不对的
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}

程序输出：
1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5


// 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
    vector<int> v{ 1,2,3,4,5 };
    vector<int>::iterator it = find(v.begin(), v.end(), 3);
    v.erase(it);
    cout << *it << endl;
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}
程序可以正常运行，并打印：
4
4 5

// 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
// 此时迭代器是无效的，++it导致程序崩溃
int main()
{
    vector<int> v{ 1,2,3,4,5 };
    // vector<int> v{1,2,3,4,5,6};
    auto it = v.begin();
    while (it != v.end())
    {
        if (*it % 2 == 0)
            v.erase(it);
        ++it;
    }
    for (auto e : v)
        cout << e << " ";
    cout << endl;
    return 0;
}

第一组数据可以正常运行：1 3 5
第二组数据会崩溃

从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

#include <string>
void TestString() 
{
    string s("hello");
    auto it = s.begin();
    // 放开之后代码会崩溃，因为resize到20会string会进行扩容
    // 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
    // 后序打印时，再访问it指向的空间程序就会崩溃
    //s.resize(20, '!');
    while (it != s.end())
    {
        cout << *it;
        ++it;
    }
    cout << endl;
    it = s.begin();
    while (it != s.end())
    {
        it = s.erase(it);
        // 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
        // it位置的迭代器就失效了
        // s.erase(it); 
        ++it;
    }
}

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

1. 只出现一次的数字
 2. 杨辉三角
 3. 删除有序数组的重复项

大家可以通过三个题来练习一下vector的使用。

2.vector的模拟实现

2.1 构造函数

构造函数有无参构造、指定开辟一定空间和存储数据的构造、拷贝构造、迭代器区间构造。其中参数中的 T() 是缺省值，它是一个任意类型的构造函数，如果你存储的是整形数据，它就是整形的构造函数，也就是0。

	vector()
		:_start(nullptr)
		,_finish(nullptr)
		,_endofstorage(nullptr) 
	{}
	
	vector(size_t n, const T& val = T())
	{
		reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			push_back(val); 
		}
	}
	
	vector(const vector<T>& v)
		:_start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		reserve(v.capacity());
		for (auto& e : v)
		{
			push_back(e);
		}
	}
	template<class Iterator>
	vector(Iterator first, Iterator last)
	{
		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}

2.2 析构函数

释放空间并将各成员变量置零。

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

2.3 赋值运算符重载

这里运用的方式十分巧妙，按照以往的方式我们需要先重新开辟一块空间，然后再进行拷贝。在这里我们是实现了一个交换函数，作用是将两个vector的各个成员变量的数据进行交换，然后在重载函数这里是使用了传值传参，那么就会发生拷贝构造，也就是tmp就是一块全新的并且已经拷贝完数据的空间，然后再将其进行交换，就完成了一次赋值。

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

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

在这里插入图片描述

2.4 迭代器的begin ( ) 和 end ( )

迭代器还分为const与非const，这是因为在遍历时可以通过迭代器封装的指针修改数据，如果不允许修改则需要使用const迭代器。

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

2.5 扩容

记得需要处理一下一开始为空的情况，如果为空就不需要拷贝数据了，直接将指向的空间进行交换就好了。 _finish指向的时最后一个数据的后一个位置，_endofstorage是指容量的意思。

	void reserve(size_t n)
	{
		if (n > capacity())
		{	
			size_t sz = size();
			T* tmp = new T[n];
			if (_start)
			{
				//错误的，这是浅拷贝
				//memcpy(tmp,_start,sizeof(T) * size());
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}
			_start = tmp;
			_finish = _start + sz;
			_endofstorage = _start + n;
		}
	}

2.6 修改大小

小于原来的大小就直接将_finish指向修改后的位置即可，大于的话就扩容，并将新开辟中多出来的位置填充上该类型的缺省值（一般都为0）。

void resize(size_t n,const T& val = T())
	{
		if (n <= size())
		{
			//删除
			_finish = _start + n;
		}
		else
		{
			reserve(n);

			while (_finish < _start + n)
			{
				*_finish = val;
				_finish++;
			}
		}
	}

2.7 计算大小和容量

		size_t capacity()const
		{
			return _endofstorage - _start;
		}

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

2.8 尾插

需要注意的是需要提前保留数据的个数，如果不保留的话在后面计算_finish时，_finish = _start + size()；在这里size()中的_finish是指向已经被释放的空间，而_start是指向重新开辟的空间，因此在计算时会出错，因此提前保留数据的个数。

void push_back(const T& x)
	{
		if (_finish == _endofstorage)
		{
			size_t sz = size();
			//提前保留数据的个数，因为后面可能会改变_start，会对size()函数中的运算造成影响，在重新对_finish赋值时造成影响

			size_t cp = capacity() == 0 ? 4 : capacity() * 2;
			T* tmp = new T[cp];
			if (_start)
			{
				//错误的，这是浅拷贝
				//memcpy(tmp,_start,sizeof(T) * size());
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}
			_start = tmp;

			//此处的_finish
			_finish = _start + sz;
			_endofstorage = _start + cp;

			//此处可以替换为
			//reserve( capacity() == 0 ? 4 : capacity() * 2 );
		}

		*_finish = x;
		_finish++;
	}

2.9 插入

这里需要注意的问题与尾插时的问题差不多，这里是在扩容时pos指向的位置为发生改变，因此要提前计算pos的位置，在新开辟空间上再将pos进行更新。

void insert(iterator pos, const T& x)
	{
		assert(pos >= _start && pos <= _finish);
		if (_finish == _endofstorage)
		{
			//当发生扩容时，因为是重新开辟空间，因此_start会发生改变，而pos还是指向原来的空间，因此需要计算pos与原_start的相对距离，将pos进行更新
			size_t sz = pos - _start;
			reserve(capacity() == 0 ? 4 : capacity() * 2);
			pos = _start + sz;
		}

		iterator end = _finish - 1;
		while (pos <= end)
		{
			*(end + 1) = *end;
			end--;
		}

		*pos = x;
		_finish++;
	}

2.10 删除

将需要删除元素的后面元素一个一个向前移动即可。

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

		return pos;
	}

2.11 [ ] 的重载

[ ]重载的实现可以让我们像使用数组那样使用vector。

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

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

3.全部代码

3.1 vector.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

namespace WY
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		const_iterator begin()const
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator end()const
		{
			return _finish;
		}

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

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

		vector(int n, const T val = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

		template<class Iterator>
		vector(Iterator first, Iterator last)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

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

		}

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

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{	
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//错误的，这是浅拷贝
					//memcpy(tmp,_start,sizeof(T) * size());
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}

				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + n;
			}
		}

		//void resize(size_t n,T val = T())
		void resize(size_t n,const T& val = T())
		{
			if (n <= size())
			{
				//删除
				_finish = _start + n;
			}
			else
			{
				reserve(n);

				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t sz = size();
				//提前保留数据的个数，因为后面可能会改变_start，会对size()函数中的运算造成影响，会在重新对_finish赋值时造成影响

				size_t cp = capacity() == 0 ? 4 : capacity() * 2;
				T* tmp = new T[cp];
				if (_start)
				{
					//错误的，这是浅拷贝
					//memcpy(tmp,_start,sizeof(T) * size());
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;

				//此处的_finish
				_finish = _start + sz;
				_endofstorage = _start + cp;

				//此处可以替换为
				//reserve( capacity() == 0 ? 4 : capacity() * 2 );
			}

			*_finish = x;
			_finish++;
		}

		void insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			if (_finish == _endofstorage)
			{
				//当发生扩容时，因为是重新开辟空间，因此_start会发生改变，而pos还是指向原来的空间，因此需要计算pos与原_start的相对距离，将pos进行更新
				size_t sz = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + sz;
			}

			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;
		}

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

			return pos;
		}

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

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

		size_t capacity()const
		{
			return _endofstorage - _start;
		}

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

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;

	};

	void test_vector1()
	{
		//尾插数据
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		//循环遍历
		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << " ";
		}
		cout << endl;

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

		//范围for遍历
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_vector2()
	{
		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);
		v.push_back(7);

		//插入
		v.insert(v.begin() + 3,30);
		v.insert(v.begin(), 10);

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

		//删除
		v.erase(v.begin() + 3);
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

3.2 test.cpp

#define _CRT_SECURE_NO_WARNINGS 1  //这一句是用来消除一些vs编译器的一些警告，不必理会
#include"vector.h"

int main()
{
	WY::test_vector1();
	WY::test_vector2();
	return 0;
}

4.总结

vector与string的存储结构大体上是差不多的，只是双方存储的数据不一样，如果string理解的差不多，相信对于vector也能熟练掌握。接下来会继续讲解list，list的存储结构与前两者大大不同，前两者都是线性结构，list将会是我们遇到的第一个链式结构，我个人感觉list会比前两者难度更高，尤其是对于迭代器封装部分，下一篇内容我们将会讲解迭代器的封装，相信大家对迭代器的理解将会更上一层楼。
如果大家发现有什么错误的地方，可以私信或者评论区指出喔。我会继续深入学习C++，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！觉得不错可以点个赞以示鼓励！！

不如小布.

关注

29
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
2
评论
STL篇二：vector

。vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。
复制链接

扫一扫