C++vector类

一、vector的介绍及使用

1.1 vector的介绍

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

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(InputIterator first, InputIterator last)	使用迭代器进行初始化构造

1.2.2 vector iterator的使用

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

1.2.3 vector空间增长问题

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

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

1.2.4 vector增删查改

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

(vector的部分接口测试：VectorTest)

二、vector深度剖析及模拟实现

vector容器的存储机制如下：
由于vector这个容器是采用连续的存储空间来存储元素的，所以我们采用三个指针_start，_finish，_endofstorage来模拟实现vector。(注意：定义的vector是一个类模版)

2.1vector迭代器的实现

注意：迭代器区间是左闭右开的。

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

这里的迭代器begin、end本质返回的是一个指针，通过指针来访问vector容器里的元素。下面还会讲到迭代器失效的问题。

2.2 vector构造函数的模拟实现

//无参的构造函数(成员变量给了缺省值)
vector()
{ }
//带模版的构造函数(迭代器区间)
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}
//用n个val去构造一个vector对象
vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}
//当传的参数n是int类型时,会优先匹配下面的构造函数
vector(int n, const T& val = T())
{
	reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

//例如v2(v1):用v1去拷贝构造v2(this是v2,v是v1)
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(v.capacity());
	for (auto& e : v)
	{
		push_back(e);
	}
}

注意：上面的无参构造函数虽然什么都没写，但是不能省略。因为我们已经定义了其他的带参构造函数，那系统就不会再生成默认的构造函数，而且成员变量也给了缺省值，所以需要显式定义。

1.可以用迭代器区间去构造一个vector对象，迭代器按性质和功能划分有多种类型。
2.拷贝构造函数是一种特殊的构造函数，先为要赋值的对象开辟一个跟v一样的容量空间，然后再将v里的数据尾插到要赋值的对象中。这里的push_back尾插数据是一种深拷贝。下面会讲到。

2.3 模拟实现vector的size、capacity、reserve、resize、=重载

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

void reserve(size_t n)
{
	//如果n大于现在的容量,则进行扩容;若n小于等于现在的容量则不做处理
	if (n > capacity())
	{
		//提前储存现在的有效数据个数size
		size_t sz = size();
		T* tmp = new T[n];
		if (_start != nullptr)
		{
			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, const T& val = T())
{
	if (n <= size())
	{
		_finish = _start + n;
	}
	else
	{
		reserve(n);
		while (_finish < _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
}

注意：切记用memcpy去拷贝数据，这样可能会造成深层次的浅拷贝问题。例如：向实例化的v对象里尾插几个字符串：

int main()
{
	Vec::vector<string> v;
	v.push_back("1111");
	v.push_back("2222");
	v.push_back("3333");
	v.push_back("4444");

    v.push_back("5555");
	return 0;
}

一开始v并没有开空间，而是在插入数据时才会进行扩容。如果在插入第一个字符串"1111"时，开劈的空间容量为4，那在插入第五个字符串"5555"时会进行一次扩容。那就会涉及到reserve扩容，而我们这里的扩容都是采用异地扩容，并且指针指向的空间是在堆上申请的，所以如果采用memcpy拷贝数据的话，就会造成浅拷贝的问题。也就是直接将指针的值拷贝过来了，那就会出现有多个指针指向同一块空间，则使用delete释放原来的旧空间_start时，就会先调用析构函数释放堆上空间，那现在申请的新空间tmp指向的堆上的空间也就被释放掉了：
比如：我们插入每次插入的字符串长度比较长的话，那string类底层的存储会在堆上申请空间进行字符串的存储。扩容时memcpy会造成的浅拷贝问题，打印结果如下：(内存中的随机值查对应的编码表就是下面的值(vs2013))
所以reserve中可以采用赋值来实现深拷贝：
赋值是对两个已经存在的对象进行的操作：

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}
//v2 = v1:将v1的值赋值给v2(this是v2,tmp是v1的拷贝构造)
vector<T>& operator=(vector<T> tmp)
{
	swap(tmp);
	return *this;
}

这里在进行赋值操作之前，会先传参，传参会调用拷贝构造函数去构造临时对象tmp。这里的拷贝构造就是一种深拷贝，push_back下面我们会着重讲。将tmp的值与被赋值的对象进行交换，交换就是将指针的值进行交换，交换完毕后，由于tmp是一个临时变量，函数调用结束后会调用析构函数释放掉，正好就将原来被赋值对象的资源给释放掉。

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

2.4 模拟实现vector的push_back、insert、erase

void push_back(const T& x)
{
	if (_finish == _endofstorage)
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}
	*_finish = x;
	++_finish;
}
iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);

	if (_finish == _endofstorage)
	{
		size_t len = pos - _start; //提前保存pos与_start的偏移量
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len; //让pos指向新空间的_start加上偏移量
	}

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

	return pos;
}
iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	auto it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;

	return pos;
}

vector的push_back是尾插一个元素，尾插之前先检查空间是否已满，如果空间已满就要先进行扩容，然后再插入数据。

2.4.1 insert的迭代器失效问题

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

对于vector可能会导致其迭代器失效的操作有:
1.会引起其底层空间改变的操作，都有可能使迭代器失效，比如: resize、reserve、insert、assign、push_back等。
比如我们将insert设计成如下面的代码：那会遇到什么问题吗？

//下面这段代码存在迭代器失效问题
void insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);

	if (_finish == _endofstorage)
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;
}
//假设现在的空间容量为8
void test_vector()
{
	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);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.insert(v.begin() + 2, 30); //在元素为3的位置插入一个30
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.insert(v.begin() + 3, 30); //在begin()+3位置插入一个30时pos迭代器失效
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

如果上面push_back7个数据，现空间容量为8，则再插入一个元素是没有问题的；当再插入一个元素时，insert的pos迭代器就会失效。因为这里出现了异地扩容，在释放了原空间以后pos迭代器还指向原来那块空间。但_start已经指向了一块新空间了，所以pos迭代器就失效了。
异地扩容以后：
而且还需要注意，insert的pos参数是值传递，所以pos是begin()+2的一份临时拷贝，pos的修改不会影响原来的迭代器。所以对于insert的pos迭代器在异地扩容时需要注意更新，以防失效：
insert的返回值即指向第一个新插入元素的迭代器。如果有涉及异地扩容，那pos也会随着更新。如果后续想继续使用insert后的pos迭代器，就返回它即可。

2.4.2 erase的迭代器失效问题

erase也存在迭代器失效的问题。如果我们将erase设计成下面的代码：

//下面这段代码存在迭代器失效问题
void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	auto it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;
}

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 (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int>::iterator it = v.begin();
	//删除v中所有的偶数
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}	
		++it;
	}
	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);

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

	vector<int>::iterator it = v.begin();
	//删除v中所有的偶数
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
			
		}	
		++it;
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

void test_vector3()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

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

	vector<int>::iterator it = v.begin();
	//删除v中所有的偶数
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
			
		}	
		++it;
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

可以看到上面的两段代码，test_vector2()中在尾插一个6后直接报错，test_vector3()中虽然没有报错，但是没有把偶数删干净。我们来分析一下上面的偶数删除过程：
可以看到test_vector1()中能把偶数删除完的原因是it++后正好能走到下一个偶数处，所以it正好能和end()相遇，即这里能把偶数删除掉是一个巧合。再来分析test_vector2中的问题：
这里是因为erase一个元素后_finish会-1，而it++超过了end()，所以对其解引用会报错(erase里断言了pos<_finish)。再来分析test_vector3:
所以上面的erase函数设计得有问题，我们希望it是要删除元素的下一个位置的元素迭代器。所以迭代器失效解决办法: 在使用前，对迭代器重新赋值即可。所以erase函数要带有返回值，并且返回值是指向被函数调用擦除的元素的后面一个元素的新位置的迭代器。如果操作擦除序列中的最后一个元素，则这是容器的末端。

//erase的正确写法:
iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	auto it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;

	return pos;
}

2.5 []重载

[]运算符的重载，可以让我们更好的对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];
}

(vector模拟实现的代码库：SimulateVector)