【C++】STL常用容器:vector(详解及模拟实现)

前言:
本篇内容主要介绍vector的使用,以及vector的深度剖析及模拟实现。
上篇博客:【C++】STL常用容器:string类(详解及模拟实现)

文章目录

      • 1. vector的介绍及使用
        • 1.1 vector的介绍
        • 1.2 vector的使用
          • 1.2.1 vector的定义(构造函数)
          • 1.2.2 vector iterator的使用
          • 1.2.3 vector空间增长增长问题
          • 1.2.4 vector的增删查改
          • 1.2.5 vector迭代器失效问题(重点)
      • 2. vector深度剖析及模拟实现
        • 2.1 std::vector的核心框架接口的模拟实现
        • 2.2 使用memcpy导致的浅拷贝问题


1. vector的介绍及使用

1.1 vector的介绍

学习工具:C++官方文档 -> 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统一的迭代器和引用更好

学习vector,实际上还是按照SLT学习的三个境界:能用,明理,能扩展

1.2 vector的使用

学习vector必须要学会查看文档:vector的文档介绍,这里面有许多它的接口,在往后的学习过程中,要时常查阅该文档,增加对常用接口的理解与记忆。下面主要介绍常用的接口:

1.2.1 vector的定义(构造函数)
(constructor)构造函数声明 接口说明
vector()(重点) 无参构造
vector (size_type n, const value_type& val = value_type() ) 构造并初始化n个val
vector(const vector& v)(重点) 拷贝构造
template < class InputIterator>; (模板参数) vector (InputIterator first, InputIterator last) 使用迭代器进行初始化,可接收其他容器的迭代器区间

下面是一段演示代码:(vs2019底下)

//	vector的构造
int TestVector1()
{
	// constructors used in the same order as described above:
	vector<int> v1;                                // empty vector of ints
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v2(4, 100);                       // four ints with value 100
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v3(v2.begin(), v2.end());  // iterating through v2
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v4(v3);                       // a copy of v3
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;

	// 下面是迭代器初始化的部分
	// the iterator constructor can also be used to construct from arrays:
	int ints[] = { 16,2,77,29 };
	vector<int> v5(ints, ints + sizeof(ints) / sizeof(int));
	//迭代器区间可以是其他容器,比如string、list等都可以传递进行构造

	cout << "The contents of v5 are:";
	for (vector<int>::iterator it = v5.begin(); it != v5.end(); ++it)
		cout << *it << " ";
	cout << endl;

	return 0;
}

运行结果:
【C++】STL常用容器:vector(详解及模拟实现)_第1张图片

1.2.2 vector iterator的使用
iterator 接口说明
begin() 、end()(重点) 获取第一个数据的iterator/const_iterator,获取最后一个数据的下一个位置的iterator/const_iterator
rbegin()、rend() 获取最后一个数据位置的reverse_iterator/const_reverse_iterator,获取第一个数据的前一个位置的reverse_ iterator/const_reverse_iterator

【C++】STL常用容器:vector(详解及模拟实现)_第2张图片

下面是一段演示代码:

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

void TestVector2()
{
	// 使用push_back插入4个数据
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

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

	// 使用迭代器进行修改
	it = v.begin();
	while (it != v.end())
	{
		*it *= 2;
		++it;
	}

	// 使用反向迭代器进行遍历再打印
	// vector::reverse_iterator rit = v.rbegin();
	auto rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

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

	PrintVector(v);
}

运行结果:
【C++】STL常用容器:vector(详解及模拟实现)_第3张图片

1.2.3 vector空间增长增长问题
容量空间 接口说明
size() 获取数据个数
capacity() 获取容量大小
empty() 判断是否为空
resize()(重点) 改变vector的size,可以用来初始化!
reserve()(重点) 改变vector的capacity

下面是一段演示代码:

//  vector的resize 和 reserve
// reisze(size_t n, const T& val = T())
// 将有效元素个数设置为n个,如果时增多时,增多的元素使用val进行填充
// 注意:resize在增多元素个数时可能会扩容
void TestVector3()
{
	vector<int> v;

	// set some initial content:
	for (int i = 1; i < 10; i++)
		v.push_back(i);

	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(5);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(8, 100);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(12);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;
}

// 往vecotr中插入元素时,如果大概已经知道要存放多少个元素
// 可以通过reserve方法提前将容量设置好,避免边插入边扩容效率低
void TestVectorExpandOP()
{
	vector<int> v;
	size_t sz = v.capacity();
	v.reserve(100);   // 提前将容量设置好,可以避免插入过程中多次扩容的消耗
	cout << "making bar grow:" << endl;
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

运行结果:
【C++】STL常用容器:vector(详解及模拟实现)_第4张图片

关于vector的扩容机制:

  • capacity()的代码在vs和g++下分别运行会发现,vs下的capacity是按1.5倍增长,g++是按2倍增长。这个问题在面试中会经常出现,此时不要简单的认为vector的增容都是2倍,具体增长多少是根据具体的需求定义的。vs是PJ版本的STL,而g++是SGI版本的STL,他们的capacity实现上有所差异!
  • reserve只是负责开辟空间,如果确定知道要用多少空间,reserve可以缓解vector多次增容的代价缺陷。
  • resize在开辟空间的同时,还会进行初始化,最终可影响size,甚至是影响capacity。

下面是一段测试扩容机制的代码,可于不同编译环境底下运行查看结果:

// 测试vector的默认扩容机制
void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	cout << "making v grow:" << endl;
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

运行结果:

  1. vs运行结果:vs底下使用的STL基本是用1.5倍方式扩容
making v grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141
  1. g++运行结果:linux底下使用的STL基本是用2倍方式扩容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128
1.2.4 vector的增删查改
增删查改 接口说明
push_back(重点) 尾插
pop_back(重点) 尾删
find(注意) 查找,它并不是vector的成员函数,它是定义在算法头文件(algorithm)中的一个函数模板
insert 在pos位置之前插入val
erase 删除pos位置的数据
swap 交换两个vector的数据空间
operator[](重点) []重载,使vector对象的元素可以像数组一样访问

下面是一段演示代码:

// vector的增删改查
// 尾插和尾删:push_back/pop_back
void TestVector4()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

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

	v.pop_back();
	v.pop_back();

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

// 任意位置插入:insert和erase,以及查找find
// 注意find不是vector自身提供的方法,是STL提供的算法,定义在algorithm头文件中
void TestVector5()
{
	// 使用列表方式初始化,C++11新语法
	vector<int> v{ 1, 2, 3, 4 };

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

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

	pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据
	v.erase(pos);

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

// operator[]+index 和 C++11中vector的新式for+auto的遍历
// vector使用这两种遍历方式是比较便捷的。
void TestVector6()
{
	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;

	vector<int> swapv;
	swapv.swap(v);

	cout << "v data:";
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;

	// 2. 使用迭代器遍历
	cout << "swapv data:";
	auto it = swapv.begin();
	while (it != swapv.end())
	{
		cout << *it << " ";
		++it;
	}

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

运行结果:
【C++】STL常用容器:vector(详解及模拟实现)_第5张图片

1.2.5 vector迭代器失效问题(重点)

迭代器的主要作用是让算法能够不关心底层数据结构,实际上迭代器的底层就是一个指针,或者是对指针进行了封装,比如:vector采用连续存储空间来存储元素,所以vector的迭代器就是原生指针T*。因此迭代器失效,实际上就是迭代器底层对应的指针所指向的空间被销毁了,该指针仍继续指向一块已经被释放的空间,若此时继续使用该迭代器,造成的后果就是程序崩溃

对于vector来说,可能会导致其迭代器失效的操作有以下几种:

  1. 会引起其底层空间改变的操作,都有可能是其迭代器失效的原因,比如:resize、reserve、insert、assign、push_back等
#include 
using namespace std;
#include 

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

	while (it != v.end())
	{
		cout << *it << " ";//直接崩溃,此时由于扩容,it指向的旧空间已经被释放,要重新更新it
		++it;
	}
	cout << endl;

	/*
	出错原因:以上操作,都有可能会导致vector扩容,也就是说vector底层原理旧空间被释放掉,
	而在打印时,it还使用的是释放之间的旧空间,在对it迭代器操作时,实际操作的是一块已经被释放的
	空间,而引起代码运行时崩溃。
	解决方式:在以上操作完成之后,如果想要继续通过迭代器操作vector中的元素,只需给it重新
	赋值即可。
	*/

	return 0;
}
  1. 指定位置元素的删除操作 – erase、连续的erase
#include 
using namespace std;
#include 
#include 

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);//此时pos失效,再直接访问会崩溃,可以用pos接收erase的返回值!
	cout << *pos << endl; // 此处会导致非法访问

	return 0;
}

erase删除pos位置元素之后,pos位置之后的元素会往前移动,实际上没有导致底层空间的改变(没有空间释放),理论上迭代器不应该失效,但是:若pos刚好指向最后一个元素,删除之后pos刚好是end的位置,此时end位置是没有元素的,即pos失效了。因此在vs底下,不管pos是指向哪,只要删除vector中pos指向的元素后,vs就会认为pos失效了,若不更新,则不会再给用户使用,否则直接报错;而Linux底下,该代码案例pos不指向最后一个元素,有可能不会报错!

下面是一段连续删除的代码,可以分析哪一个才是正确的:

#include 
using namespace std;
#include 

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;
}
  1. 需注意的是:Linux底下,g++编译器对迭代器失效的检测并不是很严格,处理也没有VS下极端。可以试着在这两个环境底下运行测试代码!
  2. 与vector类似,string在插入、扩容、erase之后,迭代器也会出现失效的情况
#include 
using namespace std;
#include 

int main()
{
	string s("hello");

	auto it = s.begin();

	// 放开下面代码的注释之后代码会崩溃,因为resize到20,string会进行扩容
	//s.resize(20, '!');

	// 扩容之后,it指向之前旧空间已经被释放了,该迭代器就失效了
	// 后序打印时,再访问it指向的空间程序就会崩溃
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;

	it = s.begin();
	while (it != s.end())
	{
		// 按照下面方式写,运行时程序会崩溃,因为erase(it)之后
		// it位置的迭代器就失效了
		// s.erase(it);
		//++it;

		//正确写法
		it = s.erase(it);
	}

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

	return 0;
}

小结:迭代器失效的解决方法就是在每次使用前,都对迭代器进行重新赋值更新即可

2. vector深度剖析及模拟实现

关于vector的内存结构,在《STL源码剖析》中有这样一幅图,清晰地表示了vector成员变量的关系。
【C++】STL常用容器:vector(详解及模拟实现)_第6张图片

2.1 std::vector的核心框架接口的模拟实现

vector.h

#pragma once

#include 
using namespace std;
#include 

// 定义命名空间lww与std中的vector做区分
namespace lww
{
	template<class T>
	class vector
	{
	public:
		// 连续存储空间 -> Vector的迭代器是一个原生指针
		typedef T* iterator;
		typedef const T* const_iterator;

		///
		// 构造和销毁
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		vector(size_t n, const T& value = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}

		/*
		* 理论上将,提供了vector(size_t n, const T& value = T())之后
		* vector(int n, const T& value = T())就不需要提供了,但是对于:
		* vector v(10, 5);
		* 编译器在编译时,认为T已经被实例化为int,而10和5编译器会默认其为int类型
		* 就不会走vector(size_t n, const T& value = T())这个构造方法,
		* 最终选择的是:vector(InputIterator first, InputIterator last)
		* 因为编译器觉得区间构造两个参数类型一致,因此编译器就会将InputIterator实例化为int
		* 但是10和5根本不是一个区间,编译时就报错了
		* 故需要增加该构造方法
		*/
		vector(int n, const T& value = T())
			: _start(new T[n])
			, _finish(_start + n)
			, _end_of_storage(_finish)
		{
			for (int i = 0; i < n; ++i)
			{
				_start[i] = value;
			}
		}

		// 若使用iterator做迭代器,会导致初始化的迭代器区间[first,last)只能是vector的迭代器
		// 重新声明迭代器,此时迭代器区间[first,last)可以是任意容器的迭代器
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			iterator it = begin();
			const_iterator vit = v.cbegin();
			while (vit != v.cend())
			{
				*it++ = *vit++;
			}
			_finish = it;
		}

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

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

		/
		// 迭代器相关
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator cbegin() const
		{
			return _start;
		}

		const_iterator cend() const
		{
			return _finish;
		}

		//
		// 容量相关
		size_t size() const
		{
			return _finish - _start;
		}

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

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				// 1. 开辟新空间
				T* tmp = new T[n];

				// 2. 拷贝元素
				// 这里直接使用memcpy只是进行浅拷贝,对于一个若vector里面的元素是一个vector、string等,就会出现浅拷贝问题!!,此时只能使用逐个赋值去进行深拷贝!!
				//if (_start)
				//	memcpy(tmp, _start, sizeof(T)*size);

				if (_start)
				{
					for (size_t i = 0; i < oldSize; ++i)
						tmp[i] = _start[i];//逐个赋值

					// 3. 释放旧空间
					delete[] _start;
				}

				_start = tmp;
				_finish = _start + oldSize;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T& value = T())
		{
			// 1.如果n小于当前的size,则数据个数缩小到n
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}

			// 2.空间不够则增容
			if (n > capacity())
				reserve(n);

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

		///
		// 元素访问
		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

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

		T& front()
		{
			return *_start;
		}

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

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

		const T& back()const
		{
			return *(_finish - 1);
		}
		/
		// vector的修改操作
		void push_back(const T& x)
		{
			//if (_finish == _end_of_storage)
			//{
			//	reserve(capacity() == 0 ? 4 : capacity() * 2);
			//}

			//*_finish = x;
			//++_finish;

			insert(end(), x);
		}

		void pop_back()
		{
			//assert(_finish > _start);
			//--_finish;

			erase(end() - 1);
		}

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

		iterator insert(iterator pos, const T& x)
		{
			assert(pos <= _finish);

			// 空间不够先进行增容
			if (_finish == _end_of_storage)
			{
				//size_t size = size();
				size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
				reserve(newCapacity);

				// 如果发生了增容,需要重置pos
				pos = _start + size();
			}

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

			*pos = x;
			++_finish;
			return pos;
		}

		// 返回删除数据的下一个数据
		// 可以解决:一边遍历一边删除的迭代器失效问题
		iterator erase(iterator pos)
		{
			// 挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _finish) {
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;
			return pos;
		}

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

test.c

/// 对模拟实现的vector进行严格测试
void TestVector1()
{
	lww::vector<int> v1;
	lww::vector<int> v2(10, 5);

	int array[] = { 1,2,3,4,5 };
	lww::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));

	lww::vector<int> v4(v3);

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

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

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

void TestVector2()
{
	lww::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	cout << v.front() << endl;
	cout << v.back() << endl;
	cout << v[0] << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

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

	v.insert(v.begin(), 0);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.erase(v.begin() + 1);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

2.2 使用memcpy导致的浅拷贝问题

若模拟实现的vector中reserve接口中,使用的是memcpy进行的拷贝,试分析以下代码会出现的问题:

#include "vector.h"

int main()
{
	lww::vector<std::string> v;
	v.push_back("1111");
	v.push_back("2222");
	v.push_back("3333");
	return 0;
}

【C++】STL常用容器:vector(详解及模拟实现)_第7张图片

结论:如果对象中涉及到资源管理时,不能使用memcpy进行对象之间的拷贝,因为memcpy是浅拷贝,否则可能会引起内存泄漏甚至程序崩溃。此时,这种情况只能用赋值!

你可能感兴趣的:(C++,c++,开发语言)