STL容器_vector类

前言

vector类是STL中的另一大容器，经过封装，vector是一个可变长度并且拥有各种功能的顺序表，在其内部可以利用数组实现。vector和string在物理与逻辑结构上十分相似，不过vector是一个模板类，我们可以在其中存放任意类型的数据。

vector的优点：

1.可以通过下标进行随机访问
2.在尾部插入或者删除元素时更加高效
3.底层空间连续，内存利用率高

vector的缺点：

1.在内部进行插入删除操作的效率低（需要挪动数据）
2.当动态添加的数据超过默认内存大小时，要进行扩容，整体的重新分配、拷贝、释放

应用场景：

应用于支持随机访问，不关心插入和删除效率的场景。

一：标准库中的vector类

vector是一个可变大小数组的序列容器，采用连续存储空间来存储元素。

1.1 vector类的常用接口

vector类对象的常见构造：

函数名称	功能说明
vector（）	无参构造
vector（size_type n, const value_type& val = value_type()）	构造并初始化n个val
vector (const vector& x)	拷贝构造
vector (InputIterator first, InputIterator last)	使用迭代器进行初始化构造

举个栗子：

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

int main(){
	// 无参构造
	vector<int> array1;

	// 构造并初始化n个val
	vector<int> array2(4, 100);

	// 拷贝构造
	vector<int> array3(array2);

	// 使用迭代器进行初始化构造
	vector<int> array4(array2.begin(), array2.end());

	// 迭代器初始化
	int array[] = { 1, 2, 3, 4, 5, 6 };
	vector<int> array5(array, array + sizeof(array) / sizeof(array[0]));
	for (vector<int>::iterator it = array5.begin(); it != array5.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

输出结果： 1 2 3 4 5 6

vector 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>& array){
	// const对象使用const迭代器进行遍历打印
	vector<int>::const_iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

int main(){
	vector<int> array;

	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	// 使用正向迭代器进行遍历(可修改)
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		*it *= 2;
		cout << *it << " ";
		++it;
	}
	cout << endl;

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

	// const迭代器
	PrintVector(array);
}

输出结果：2 4 6 8 10
       ：5 4 3 2 1 
       ：1 2 3 4 5

vector类对象的容量操作：

函数名称	功能说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize	改变vector的实际存储数据的个数（可初始化）
reverse	为vector预留空间

vs是PJ版本的STL，g++是SGI版本的STL，vs下capacity是按1.5倍增长的，g++是按2倍增长的

reserve只负责开辟空间，如果确定需要用多少空间，reserve可以缓解vector增容的代价缺陷问题

举个栗子：

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

int main(){
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	// 获取vector的size和capacity
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;


	// 改变vector的size为3
	array.resize(3);
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 改变vector的size为10，多余空间用10填充
	array.resize(10, 10);
	cout << array.size() << endl;
	cout << array.capacity() << endl;
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 为vector预留空间
	array.reserve(100);
	cout << array.capacity() << endl;
}

运行结果：
5
6
1 2 3 4 5
3
6
1 2 3
10
10
1 2 3 10 10 10 10 10 10 10
100

vector类对象的增删查改：

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

举个栗子：

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

int main(){
	vector<int> array;
	// 尾插
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// 尾删
	array.pop_back();
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// insert
	// 注意pos位置是迭代器
	array.insert(array.begin(), 0);
	array.insert(array.begin()+3, 3);
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// erase
	// 注意pos位置是迭代器
	array.erase(array.begin());
	it = array.begin();
	while (it != array.end()){
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// operator[]进行读写
	array[0] = 0;
	for (int cur = 0; cur < array.size(); cur++){
		cout << array[cur] << " ";
	}
	cout << endl;

	// swap
	// 交换后array变为空
	vector<int> v;
	v.swap(array);
	for (const auto& e : v){
		cout << e << " ";
	}
	cout << endl;

	// find
	// 删掉vector中键值为3的元素
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	if (pos != v.end()){
		v.erase(pos);
	}
	for (const auto& e : v){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：
1 2 3
1 2
0 1 2 3
1 2 3
0 2 3
0 2 3
0 2

1.2 vector迭代器失效问题

在容器的使用中我们经常要操作迭代器，迭代器的主要作用就是让算法能够不用关心底层的数据结构，迭代器底层实际就是一个类似指针，或者是对指针进行了封装。

迭代器失效就是：我们使用接口进行增加或删除的时候，迭代器指向的内容会发生改变甚至是指向非法内存，原因是原来的内存已经被释放，迭代器失效会导致指向内容改变，从而引起bug甚至是内存越界访问导致程序崩溃。

引起vector底层空间改变的操作，都有可能是迭代器失效（push_back,insert,resize,reserve）
erase删除元素的操作，也有可能引起迭代器失效（非法访问）

解决迭代器失效的问题：如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可

举个栗子：

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

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

	vector<int>::iterator it = array.begin();

	array.push_back(6);
	// 1.增容可能导致迭代器失效（push_back,insert,resize,reserve）
	// array.push_back(7); 
	// 插入7则产生迭代器失效问题
	// vector空间不够则增容，开辟新的空间，将数据拷贝到新空间再释放旧空间
	// 这时it是指向旧空间已经被释放，从而导致it失效
	// 不要在迭代器定义之后进行可能增容的操作

	while (it != array.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void Test_iterator2(){
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);
	array.push_back(6);

	// 2.it的意义改变导致迭代器失效
	// 要求删除容器中的所有偶数
	// 删除2：将3、4、5、6向前挪一位，此时it指向3，++it后3没有被判断，导致迭代器失效
	// vs下进行检查会报错  gcc下不会检查导致结果出问题
	/*vector<int>::iterator it = array.begin();
	while (it != array.end()){
		if (*it % 2 == 0){
			array.erase(it);
		}
		
		++it;
	}*/

	// 解决
	// erase返回删除it的下一个位置的迭代器
	vector<int>::iterator it = array.begin();
	while (it != array.end()){
		if (*it % 2 == 0){
			it = array.erase(it);
		}
		else{
			++it;
		}
	}

	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

int main(){
	Test_iterator1();
	Test_iterator2();
}

运行结果：
1 2 3 4 5 6
1 3 5

二：vector类的深度剖析及模拟实现

vector类的深度剖析：

底层其实是三个指针：_ start指向数据块的开始、_ finish指向有效数据的尾、_ endofstorage指向存储容量的尾。

vector类的模拟实现：

#include<memory.h>
#include<assert.h>

namespace WJL{
	template<class T>
	class Vector{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

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

		// 深拷贝
		/*Vector(const Vector<T>& v){
			_start = new T[v.capacity()];
			_finish = _start;
			_endofstorage = _start + v.capacity();

			for (size_t i = 0; i < v.size(); i++){
				*_finish = v[i];
				_finish++;
			}
		}*/

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

		/*Vector<T>& operator=(const Vector<T>& v){
			if(this != &v){
				delete[] _start;
				_start = new T[v.capacity()];
				memcpy(_start, v._start, sizeof(T)*v.size());
			}
			return *this;
		}*/

		// v1 = v3  现代写法
		Vector<T>& operator=(Vector<T> v){
			swap(v);
			return *this;
		}

		// 自定义类型涉及深拷贝建议自己实现swap（仅指针交换代价小）
		void swap(Vector<T>& v){
			::swap(_start, v._start);
			::swap(_finish, v._finish);
			::swap(_endofstorage, v._endofstorage);
		}

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

		void reserve(size_t n){
			if (n > capacity()){
				// 开辟新空间
				size_t sz = size();
				T* temp = new T[n];
				if (_start){
					memcpy(temp, _start, sizeof(T)*sz);
					delete[] _start;
				}
				_start = temp;
				_finish = temp + sz;
				_endofstorage = temp + n;
			}
		}

		void resize(size_t n, const T& val = T()){
			if (n < size()){
				_finish = _start + n;
			}
			else{
				if (n>capacity()){
					reserve(n);
				}
				while (_finish < _start + n){
					*_finish = val;
					++_finish;
				}
			}
		}

		void push_back(const T& val){
			if (_finish == _endofstorage){
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			++_finish;
		}

		void pop_back(){
			assert(_start < _finish);
			--_finish;
		}

		void insert(iterator pos, const T& val){
			assert(pos >= _start&&pos <= _finish);
			if (_finish == _endofstorage){
				size_t n = pos - _start;
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
				// 增容原来的pos会失效
				pos = _start + n;
			}
			// 定义开始挪动的位置
			iterator end = _finish - 1;
			while (pos <= end){
				*(end + 1) = *end;
				--end;
			}

			*pos = val;
			++_finish;
		}

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

			// 返回当前位置的下一个位置
			return pos;
		}

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

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

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

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

		iterator begin(){
			return _start;
		}

		iterator end(){
			return _finish;
		}

		const_iterator begin()const{
			return _start;
		}

		const_iterator end()const{
			return _finish;
		}

	private:
		iterator _start; // 开始位置
		iterator _finish; // 最后一个位置的下一个位置
		iterator _endofstorage; // 相当于capacity
	};

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

		v.pop_back();

		v.insert(v.begin(), 0);

		v.erase(v.begin());

		v.resize(10);

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

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

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

	void test_vector2(){
		Vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		Vector<int> v2(v1);

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

		Vector<int> v3;
		v3.push_back(10);
		v3.push_back(20);
		v3.push_back(30);
		v3.push_back(40);
		v3.push_back(50);

		v1 = v3;
		for (size_t cur = 0; cur < v1.size(); cur++){
			cout << v1[cur] << " ";
		}
		cout << endl;
	}
}

使用memcpy的拷贝问题：

memcpy是内存的二进制格式拷贝（按字节），将一段内存空间中内容原封不动的拷贝到另外一段内存空间中

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

举个栗子：

容量不够调用reserve增容，拷贝数据使用memcpy。

void reserve(size_t n){
	if (n > capacity()){
		// 开辟新空间
		size_t sz = size();
		T* temp = new T[n];
		if (_start){
			memcpy(temp, _start, sizeof(T)*sz);
			delete[] _start;
		}
		_start = temp;
		_finish = temp + sz;
		_endofstorage = temp + n;
	}
}

注意：如果T是自定义类型，使用memcpy拷贝数据后，新空间中被拷贝过来指针会指向被释放的旧空间，这时_str也就被称为野指针。

解决办法：

采用赋值，将对象进行赋值操作，进行深拷贝。

这就变为了两个对象之间的赋值操作，不会指向同一空间。

void reserve(size_t n){
	if (n > capacity()){
		// 开辟新空间
		size_t sz = size();
		T* temp = new T[n];
		if (_start){
			//memcpy(temp, _start, sizeof(T)*sz);
			for (size_t i = 0; i < sz; ++i){
				temp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = temp;
		_finish = temp + sz;
		_endofstorage = temp + n;
	}
}

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

STL容器_vector类

前言

一：标准库中的vector类

1.1 vector类的常用接口

1.2 vector迭代器失效问题

二：vector类的深度剖析及模拟实现

DAPPER 事务 TRANSACTION

Java中线程的创建方式

一键自动化博客发布工具,chrome和firfox详细配置

面向對象程序設計的三大特性（三）：C++中的多態

IPC：進程間的通信方式

Linux網絡套接字編程（socket詳解）

面向對象程序設計的三大特性（二）：C++中的繼承

STL容器_string類以及string類的模擬實現

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結