深入浅出C++ ——vector深度剖析

---

一、vector类简介

标准库中的vector类:

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

  以上内容来自：www.cplusplus.com vector类文档的介绍，在STL的学习中，推荐大家看这个文档，对每个类都有详细的介绍。

---

有vector<char> ，为什么不能把 string 类取消掉

   string类的数据结尾有 ‘\0’ ，而且 string类有find成员函数，支持比较大小，还支持输入>>、输出<< 运算符重载等，因为string类有着vector无法替代的特性，所以vector<char>无法替代string。

---

二、vector类常用接口

1. vector类的默认成员函数

函数名称	功能说明
vector（size_type n, const value_type& val = value_type() ）	构造并初始化n个val
vector ()	构造空的vector类对象，即无参构造
vector (InputIterator first, InputIterator last)	使用迭代器进行初始化构造
vector (const vector& x)	拷贝构造
operator = (const vector& x)	赋值运算符重载

---

使用vector类默认成员函数案例

vector的默认成员函数//
vector<int> v1;                          // 无参构造
vector<int> v2(5, 100);                  // 构造并初始化5个大小为100的整型
vector<int> v3(v2.begin(), v2.end());    // 使用迭代器进行初始化构造
vector<int> v4(v3);                      // 拷贝构造
v1 = v4;                                 //赋值重载函数

vector<int> v{ 1, 2, 3, 4 };             //使用列表方式初始化，C++11新语法

---

2. vector类的迭代器及访问遍历操作

函数名称	功能说明
begin+ end	获取第一个数据位置的 iterator/const_iterator， 获取最后一个数据的下一个位置的 iterator/const_iterator
rbegin + rend	获取最后一个数据位置的 reverse_iterator，获取第一个数据前一个位置的 reverse_iterator
operator[ ]	返回vector容器中位置 n 处元素的引用
范围for	C++11支持更简洁的范围for的新遍历方式
back	返回顺序表中最后一个元素的引用
front	返回顺序表中第一个元素的引用

---

vector类的三种遍历方式：

//vector类的迭代器及访问遍历操作
vector<int> v{1, 2, 3, 4};
// 通过[]读写第0个位置。
v[0] = 10;
cout << v[0] << endl;

// 1. 使用for+[]小标方式遍历
for (size_t i = 0; i < v.size(); ++i)
{
	cout << v[i] << " ";
}
cout << endl;

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

// 3. 使用范围for遍历
for (auto x : v)
	cout << x << " ";
cout << endl;

1.下标+[ ]遍历

   下标+[ ]遍历和at( )的用法相同，但是 [ ]越界断言报错，at 抛异常报错。

2. 迭代器遍历

• [begin(), end()) ; end()返回的不是最后一个数据位置的迭代器，返回是最后一个位置下一个位置。
• 也要注意的是，C++中凡是给迭代器一般都是给的[ ) 左闭右开的区间,迭代器是类似指针一样东西。
• 当对象是const类型时，要使用 vector::const_iterator迭代器 保证权限不被放大。
• 迭代器意义：像string、vector这种底层是连续存放的容器支持[ ]遍历，但是list、map等链式结构的容器不支持[ ]。我们就要用迭代器遍历，所以迭代器是一种统一使用的方式。
• 迭代器的比较，都是用 == 或 != 不用< 和 >，因为底层是连续内存的容器可以用< 和 >比较，但是面对list和map等链式结构就不行了。

3.C++11 提供范围for遍历
  范围for遍历写起来简洁，依次取容器中的数据，自动赋值给e，自动判断结束。

---

3. vector类的容量操作

函数名称	功能说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize	改变vector的size
reserve	改变vector的capacity

1. capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的，因为vs是PJ版本STL，g++是SGI版本STL。
2. reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
3. resize在开空间的同时还会进行初始化，影响size。

vector类的容量操作/
	vector<int> v{ 1, 2, 3, 4 ,5, 6, 7};

	cout << v.size() << endl;		//7
	cout << v.capacity() << endl;	//7
	cout << v.empty() << endl;		//0

	v.resize(5);
	cout << v.size() << endl;		//5
	v.resize(12);
	cout << v.size() << endl;		//12
	//如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够 就可以避免边插入边扩容导致效率低下的问题了
	v.reserve(50);					
	cout << v.capacity() << endl;//50 提前将容量设置好，可以避免一遍插入一遍扩容

---

4. vector类的修改操作

函数名称	功能说明
push_back	尾插
pop_back	尾删
find	查找（注意这个是算法模块实现，不是vector的成员接口）
insert	在position之前插入val
erase	删除position位置的数据
swap	交换两个vector的数据空间

• 一般少用insert和erase，因为他们两如果是头部或者中间插入删除，效率是O(N),因为他们要挪动数据。
• vector没有提供find函数接口，而是放到STL的algorithm算法库中，不是vector的成员接口函数
• 一般不用STL的algorithm算法库中的swap，因为如果自定义类型，用算法库中的swap函数会涉及到深拷贝和赋值重载，效率低。

---

修改vector类操作案例

//vector类的修改操作
	vector<int> v{1, 2};
	
	v.push_back(3);				//尾插
	v.push_back(4);

	auto it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";		//1 2 3 4
		++it;
	}
	cout << endl;

	v.pop_back();				//尾删

	it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";		//1 2 3
		++it;
	}
	cout << endl;

	// 在指定位置前插入值为val的元素，比如：2之前插入30,如果没有则不插入
	// 1. 先使用find查找3所在位置
	// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
	auto pos = find(v.begin(), v.end(), 2);
	if (pos != v.end())
	{
		// 2. 在pos位置之前插入30
		v.insert(pos, 30);
	}
	auto i = v.begin();
	while (i != v.end())
	{
		cout << *i << " "; // 1 30 2 3
		++i;
	}
	cout << endl;

---

三、vector迭代器失效问题

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

---

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

vector<int>v{1,2,3,4,5};

auto pos = find(v.begin(), v.end(), 3);

if (pos != v.end())
{
	v.insert(pos, 30); //在3前面插入30
}

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

   v.insert(pos, 30)报错的主要原因是再插入数据，容量就满了要增容，把数据拷贝到新的空间，释放旧的空间。

   解决方式是在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给pos重新赋值即可。

---

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

vector<int> v{1,2,3,4};	
auto pos = find(v.begin(), v.end(), 3);
v.erase(pos);// 删除pos位置的数据，导致pos迭代器失效。
cout << *pos << endl; // 此处会导致非法访问。

  因为删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

---

常见错误

//删除vector中所有的偶数
vector<int> v{1, 2, 30, 3, 4 ,5 ,6};
auto it = v.begin();
while (it != v.end())
{
	if (*it % 2 == 0)
		v.erase(it);
	++it;
}

• 因为erase(it）会返回删除位置it的下一个位置，迭代器的意义变了。
• 在vs下 erase(it）后it失效，不能++。
• 2为偶数，会earse(2)的位置，并且earse会导致数据前移覆盖，然后it++后就到了3的位置，跳过了30，导致30没有被检查到。

• 当执行到最后一个偶数的时候，程序删除6同时it移动6的下一位，此时vector的end在it前面，会导致越界，直接报错。

正确写法：

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

---

迭代器失效总结

  迭代器失效有两种情况，一、在增容/缩容的过程中迭代器失效，it变成野指针，二、迭代器意义变了。 所以迭代器失效解决办法就是在使用前，对迭代器重新赋值即可。

---

四、STL中vector模拟实现

vector结构

  在侯捷老师的《STL源码剖析》中，对vector类的描述如下图所示。

---

代码实现

namespace MyVector
{
	template<class T>
	class vector
	{
	public:

		/默认成员函数/
		//构造函数
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _end_Of_Storage(nullptr)
		{}

		// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器，迭代器区间[first,last)可以是任意容器的迭代器
		// 类模板的成员函数，还可以再是函数模板
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			: _start(nullptr)
			, _finish(nullptr)
			, _end_Of_Storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		
		vector(size_t n, const T& value = T())//T类的匿名对象作为缺省值，T会调用自己的默认构造初始化
			: _start(nullptr)
			, _finish(nullptr)
			, _end_Of_Storage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}

		//拷贝构造函数----注意要实现深拷贝
		vector(const vector<T>& v)
			: _start(nullptr)
			, _finish(nullptr)
			, _end_Of_Storage(nullptr)
		{
			reserve(v.capacity());//不初始化，reserve会崩溃
			for (const auto& e : v)
			{
				push_back(e);//拷贝数值
			}		
		}
		// 现代写法，实现拷贝构造函数
		vector(const vector<T>& v)
			: _start(nullptr)
			, _finish(nullptr)
			, _end_Of_Storage(nullptr)
		{
			vector<T>tmp(v.begin(),v.end());
			swap(tmp);
		}
		

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

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

		//析构函数
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_Of_Storage = nullptr;
			}
		}

		//迭代器及访问遍历操作
		// Vector的迭代器是一个原生指针
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		//const对象调用const迭代器，只读
		const_iterator begin() const 
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

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

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

		//vector类的容量操作

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

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

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

		void resize(size_t n, const T& value = T()) //T类的匿名对象作为缺省值，T会调用自己的默认构造初始化
		{
			// 1.如果n小于当前的size，则数据个数缩小到n
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}
			else
			{
				// 2.空间不够则增容
				if (n > capacity())
					reserve(n);

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				// 1. 开辟新空间
				T* tmp = new T[n];
				// 2. 拷贝元素
				//	memcpy(tmp, _start, sizeof(T)*size);
				//不可以用memcpy,如果T是内置类型或浅拷贝类型，他们增容或者拷贝构造中，我们用memcpy是没有问题的(浅拷贝)
				//但是T是深拷贝的自定义类型，比如string类，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，可能会引起内存泄漏甚至程序崩溃
				//在vs中，string的结构跟g++不同，在T(自定义类型)对象加了一个buf[16]的数组存储数据，如果数据小于16可能不会报错，实际还是有问题。
				if (_start)
				{
					for (size_t i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i]; //这个调用T(自定义类型)::operator=,赋值重载函数本来就是深拷贝
					}
					// 3. 释放旧空间
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + oldSize;
				_end_Of_Storage = _start + n;
			}
		}

		///vector类的修改操作//
		void push_back(const T& x)
		{
			if (_finish == _end_Of_Storage)
			{
				size_t newCapacity = 0 == capacity()) ? 1 : capacity() * 2;
				reserve(newCapacity);
			}
			*_finish = x;
			++_finish;
			//insert(end(), x);
		}

		void pop_back()
		{
			assert(!empty());
			--_finish;
			//erase(end() - 1);
		}

		//返回值指向新插入这个元素的位置 
		//有返回值的函数，不一定要定义变量来接收
		iterator insert(iterator pos, const T& x) 
		{
			assert(pos <= _finish);
			// 空间不够先进行增容
			if (_finish == _endOfStorage)
			{
				size_t len = pos - _start; //计算pos相对_start是第几个位置
				size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
				reserve(newCapacity);
				// 如果发生了增容，更新pos，解决增容后pos失效的问题
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
			return pos;
		}

		// 方便解决:一边遍历一边删除的迭代器失效问题
		iterator erase(iterator pos)
		{
			// 挪动数据进行删除
			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;
			return pos;//返回删除数据的下一个位置
		}
		
		T& front()
		{
			return *_start;
		}

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

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

		const T& back()const
		{
			return *(_finish - 1);
		}
	
	private:
		iterator _start;			// 指向数据块的开始
		iterator _finish;			// 指向有效数据的尾
		iterator _end_Of_Storage;	// 指向存储容量的尾
	};
}