C++ vector类

C++ vector类

引言

在C++编程中，vector类是标准模板库（STL）中常用的容器类型之一，它能够动态管理元素的集合，提供高效的存储和访问能力。与数组不同，vector的大小是动态可扩展的，它能够根据需要自动调整容量，以适应不同规模的数据。在这篇博客中，我们将深入探讨C++ vector类的使用方法、功能以及内部实现，帮助你更好地理解如何利用vector高效地处理数据。我们还将讨论一些常见的问题，如空间增长、迭代器失效等，并给出实际的代码示例来加深理解。

vector的文档介绍

---

---

1.vector的使用

1.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 vector iterator 的使用

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

---

1.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.4 vector的增删查改

vector增删查改	接口说明
push back	尾插
pop back	尾删
find	查找（这个是算法模块实现的，并不是vector的成员接口）
insert	在position之前插入val
erase	删除position位置的数据
swap	交换两个vector的数据空间
operator[ ]	和数组一样

---

1.5 vector的迭代器失效问题

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

可能会导致迭代器失效的操作有：

1. 会引起底层空间改变的操作，都有可能使迭代器失效，例如：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;
   }
   

2. 指定位置元素的删除操作——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; // 此处会导致非法访问
    /*
出错原因：erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素
时，vs就认为该位置迭代器失效了。 
    */
	return 0;
}

3. 注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

4. 与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;
   	}
   }
   

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

---

2. vector的深度剖析

2.1 使用memcpy拷贝问题

问题分析：

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中

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

结论：

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

---

2.2 动态二维数组理解

// 以杨慧三角的前n行为例：假设n为5
void test2vector(size_t n)
{
	// 使用vector定义二维数组vv，vv中的每个元素都是vector<int>
	Jason::vector<Jason::vector<int>> vv(n);
	// 将二维数组每一行中的vecotr<int>中的元素全部设置为1
	for (size_t i = 0; i < n; ++i)
	vv[i].resize(i + 1, 1);
	// 给杨慧三角出第一列和对角线的所有元素赋值
	for (int i = 2; i < n; ++i)
	{
    	for (int j = 1; j < i; ++j)
		{
			vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
		}
	}
}

Jason::vector<Jason::vector<int>> vv(n);构造一个W动态数组，W中总共有n个元素，每个元素都是vector类型的，每行没有包含任何元素，如果n为5时如下所示：

W中元素填充完成之后，如下图所示，且和标准库中vector构建动态二维数组时是一致的。

---

3.vector 的模拟实现

Vector.h 文件

#pragma once
#include<list>
#include<string>
#include<assert.h>

//Vector的实现需要用到类模版
//类模版实例化必须采用显示实例化
//模版不建议声明和定义分离到两个文件，否则会导致链接错误
template<typename T>
class Vector //现在类型不再是Vector，而是Vector<T>
{
public:		
	typedef T* iterator;
	typedef const T* const_iterator;
public:
	//construct destory

	//c++11 强制生成默认构造
	Vector() = default;
	
	//拷贝构造
	Vector(const Vector<T>& v)
	{
		//申请一样的空间
		this->reserve(v.size());
		for(auto&e : v)//遍历v中的每个元素e
		{
			push_back(e);//并将e尾插到对象中
		}
	}
	//构造并初始化n个val
	Vector(int n, const T& val = T())//T()为缺省值
	{
		reserve(n);
		for (int i = 0; i < n; i++)
		{
			push_back(val);
		}
	}

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

	//使用迭代器进行区间初始化构造
	template<class InputIterator>
	Vector(InputIterator first, InputIterator last)
	{
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}

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

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

	//迭代器标记点
	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}
	//const修饰成员函数，实际上是修饰该函数的隐含的this指针 
	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}



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

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

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

	void clear()
	{
		_finish = _start;
	}

	//这个缺省值是调用官方的类型初始化
	void resize(size_t n,T val = T())
	{
		if (n < size())
		{
			_finish = _start + n;
		}
		else
		{
			reserve(n);
			while (_finish < _start + n)
			{
				*_finish = val;
				++_finish;
			}
		}
	}

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			//先留住原先的标记
			size_t old_size = size();
			//申请空间并赋给tmp
			T* tmp = new T[n];
			//遍历把老空间的值放到新空间
			for (size_t i = 0; i < old_size; i++)
			{
				tmp[i] = _start[i];
			}
			//释放掉老空间以及重新放置标记
			delete[] _start;
			_start = tmp;
			_finish = tmp + old_size;
			_end_of_storage = tmp + n;
		}
	}

	//acess——重载操作符[]
	T& operator[](size_t i)
	{
		assert(i < size());
		return _start[i];
	}

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


	//modify
	void swap(Vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_end_of_storage, v._end_of_storage);
	}


	void push_back(const T& x)
	{
		//检查容量是否够用，不够就扩容
		if (_finsh == _end_of_storage)
		{
			reserve(capacity() == 0 ? 4 : capacity() * 2);
		}
		*_finish = x;
		++_finish;
	}

	void pop_back()
	{
		assert(!empty);
		--_finish;
	}


	//这个返回值是为了传回对的pos从而阻止迭代器失效
	iterator insert(iterator pos, const T& x)
	{
		assert(pos >= _start);
		assert(pos <= _finish);

		// 扩容
		if (_finish == _end_of_storage)
		{
			size_t len = pos - _start;
			reserve(capacity() == 0 ? 4 : capacity() * 2);
			pos = _start + len;
		}

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

		++_finish;

		return pos;
	}

	void erase(iterator pos)//删除指定位置的元素
	{
		assert(pos > _start);
		assert(pos < _finish);
		iterator it = pos + 1;
		while (it != end())
		{
			//每个元素都向前移动一个位置
			*(it - 1) = *it;
			++it;
		}
		--_finish;
	}

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

template<class T>
void print_Vector(const Vector<T>& v)
{
	//规定：不要在没有实例化的类模版里面取东西，
	//		因为编译器不能区分这里的const_iterator是类型还是静态变量
	//如果执意要取，需要用typename显示说明是类型
	typename Vector<T>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}