[C++](11)vector的使用与模拟实现：迭代器失效，深浅拷贝详细剖析

世真

已于 2022-07-10 23:17:32 修改

阅读量1k

点赞数 10

分类专栏： C++学习文章标签： c++ 开发语言算法后端 c语言

于 2022-07-10 23:15:01 首次发布

本文链接：https://blog.csdn.net/CegghnnoR/article/details/125712783

版权

C++学习专栏收录该内容

35 篇文章 5 订阅

订阅专栏

文章目录

vector 的使用
模拟实现
完整代码

vector 是表示可变大小数组的序列容器，就和我们之前写的顺序表差不多，使用起来和 string 差不多。

vector 的使用

vector 是类模板，使用时要指定类型。并且要包头文件 <vector>

构造

下面介绍 vector 实际使用的常见接口。

构造函数	说明
①`vector()`	默认构造
②`vector(const vector& x)`	拷贝构造
③`vector(size_type n, const value_type& val = value_type())`	用n个元素构造一个容器。每个元素都是val的副本。
④`vector(InputIterator first, InputIterator last)`	迭代器区间初始化

①默认构造：

void test1()
{
	vector<int> v1; //存储int类型
	v1.push_back(1);
	v1.push_back(2);

	vector<double> v2; //存储double类型
	v2.push_back(1.1);
	v2.push_back(2.2);

	vector<string> v3; //存储string类型
	v3.push_back("张三"); //单参数的构造函数支持隐式类型转换
	v3.push_back("李四");
}

③④

void test2()
{
	vector<int> v4(10, 5);

	vector<int> v5(v4.begin(), v4.end());
}

遍历

void test3()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	//下标+[]
	for (size_t i = 0; i < v.size(); ++i)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	//迭代器
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	//范围for
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

会 string 就会用 vector 使用方面没什么好讲的了。

容量

void test4()
{
	size_t sz;
	vector<int> foo;
	sz = foo.capacity();
	for (int i = 0; i < 100; ++i)
	{
		foo.push_back(i);
		if (sz != foo.capacity())
		{
			sz = foo.capacity();
			cout << "capacity changed：" << sz << endl;
		}
	}
}
//结果：
//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

由上看出vs下，是1.5倍扩容。

同样的代码放到Linux的g++下

[CegghnnoR@VM-4-13-centos 2022_7_3]$ ./a.out
capacity changed：1
capacity changed：2
capacity changed：4
capacity changed：8
capacity changed：16
capacity changed：32
capacity changed：64
capacity changed：128

Linux g++ 下是2倍扩容。

可以看出这两种版本各有权衡：

单次增容越多，同样是插入n个值，增容次数就越少，效率就越高，但是可能浪费的空间就越多。

如果你提前知道要开多少空间，当然也可以用 reserve 扩容

插入删除

vector 和 string 的区别就在于，vector 的 insert 和 erase 只支持迭代器。

iterator insert(iterator position, const value_type& val); //single element (1)
    void insert(iterator position, size_type n, const value_type& val); //fill (2)
    void insert(iterator position, InputIterator first, InputIterator last); //range (3)

iterator erase (iterator position);
iterator erase (iterator first, iterator last);

例子：

void test5()
{
	vector<int> v1(10, 5);
	v1.insert(v1.begin() + 3, 2); //在下标为3的位置插入一个2
	v1.insert(v1.begin(), 2, 3); //在头部插入两个3
	vector<int> v2(10, 4);
	v1.insert(v1.begin(), ++v2.begin(), --v2.end()); //在头部插入v2去掉头和尾的部分
	v1.erase(v1.begin()); //头删
	v1.erase(v1.begin(), v1.end()); //全删，相当于clear
}

查找

vector 内部没有提供查找的成员函数，要查找需要 <algorithm> 里的 find

此函数模板的行为等效于：

template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}

使用时只要传入要查找的范围的迭代器和要查找的值即可：

vector<int> v(10, 5);
vector<int>::iterator pos = find(v.begin(), v.end(), 5);
if (pos != v.end())
{
    cout << "找到了" << endl;
}
else
{
    cout << "没有找到" << endl;
}

模拟实现

框架

vector 是个类模板，有一个模板参数。成员变量 _start 指向第一个元素，_finish 指向最后一个元素的下一个位置，_endofstoage 指向空间的最后一个位置的下一个位置。

template<class T>
class Vector
{
public:
    typedef T* iterator;
	typedef const T* const_iterator;
private:
	iterator _start;
	iterator _finish;
	iterator _endofstorage;
};

默认构造和析构

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

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

迭代器

iterator begin()
{
    return _start;
}
iterator end()
{
    return _finish;
}
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];
}

容量

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

void reserve(size_t n)
{
	size_t sz = size();
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)
		{
			for (size_t i = 0; i < size(); ++i) //此处涉及深浅拷贝
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
	}
	_finish = _start + sz;
	_endofstorage = _start + n;
}

👆：for (size_t i = 0; i < size(); ++i){tmp[i] = _start[i];} 是将 vector 里的元素拷贝到新的空间里，注意不能写成memcpy(tmp, _start, size() * sizeof(T));。

👆：错因分析：因为memcpy本身是浅拷贝，如果 vector 里的元素是 string，vector<int> 等涉及深拷贝的类型，那么使用 memcpy 只是拷贝了指针，新空间里的指针和旧空间里的指针指向同一块空间，接着 delete[] _start 释放旧空间的同时也把里面的元素所指向的空间一起释放了，新空间里的指针成了野指针。

👆：解决方法：使用赋值的方式进行深拷贝，赋值重载的实现在下面。

resize 还是分三种情况考虑：

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

👆：参数中 val 表示要初始化的值，默认为 T()。这是一个特性，如果T是内置类型，则相当于是值初始化，自定义类型则 T() 相当于匿名对象，会自动调用构造函数。

修改

push_back、pop_back

为了方便介绍迭代器失效问题，这里先把 push_back 和 pop_back 实现出来，后续可以复用 insert 和 erase

void push_back(const T& x)
{
    if (_finish == _endofstorage)
    {
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newCapacity);
    }

    *_finish = x;
    ++_finish;
}

void pop_back()
{
	if (_finish > _start) --_finish;
}

insert、迭代器失效(重点)

iterator insert(iterator pos, const T& x)
{
    assert(pos >= _start && pos <= _finish); //检查
    if (_finish == _endofstorage) //扩容
    {
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newCapacity);
    }
    for (iterator end = _finish; end > pos; --end) //挪数据
    {
        *end = *(end - 1);
    }
    *pos = x; //插入
    ++_finish;
    return pos;
}

insert 这样写会出现迭代器失效

测试：

void test2()
{
	Vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.insert(v.begin(), 0);
	for (auto& e : v)
	{
		cout << e << ' ';
	}
}
//结果：
//1 2 3 4 -842150451

👆：问题在于，插入第五个数据的时候会发生扩容，扩容后整个数组的存储位置全部转移，但是 pos 还指向着原来的空间，成为了野指针。也就是说：扩容以后，pos 就失效了

解决方法：在扩容前计算好相对位置，扩容后更新 pos：

iterator insert(iterator pos, const T& x)
{
    assert(pos >= _start && pos <= _finish);
    if (_finish == _endofstorage)
    {
        size_t n = pos - _start; //防止迭代器失效
        size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newCapacity);
        pos = _start + n; //防止迭代器失效
    }
    for (iterator end = _finish; end > pos; --end)
    {
        *end = *(end - 1);
    }
    *pos = x;
    ++_finish;
    return pos;
}

但是问题还没有结束，我们在使用的时候依然有可能出现迭代器失效，

如下，我们想在每个偶数元素的前面插入一个20：

void test3()
{
	Vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
    //每个偶数元素前面插入一个20
	for (Vector<int>::iterator it = v.begin(); it != v.end(); ++it) //遍历
	{
		if (*it % 2 == 0) //判断偶数元素
		{
			v.insert(it, 20); //插入
            ++it; //此处要再++一次，保证指向的是原来的元素，而不是刚插入的元素。
		}
	}

	for (auto& e : v)
	{
		cout << e << ' ';
	}
}

👆：通过调试可以看出，第一个20成功插入，但是第二个20插入时被 assert 检查出来。因为第一次插入时发生了扩容，it 成为野指针，而后 for 循环遍历着一个不存在的数组。也就是说，扩容以后，it 失效了。

正确的方式：

可以提前 reverse 开好空间防止扩容，但是更推荐接收 insert 的返回值来更新 it。

void test3()
{
	Vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	for (Vector<int>::iterator it = v.begin(); it != v.end(); ++it)
	{
		if (*it % 2 == 0)
		{
			it = v.insert(it, 20); //it 接收返回值
			++it;
		}
	}

	for (auto& e : v)
	{
		cout << e << ' ';
	}
}
//结果：1 20 2 3 20 4

erase、clear

iterator erase(iterator pos)
{
    assert(pos >= _start && pos < _finish);
    for (iterator it = pos + 1; it != _finish; ++it)
    {
        *(it - 1) = *it;
    }
    --_finish;
    return pos;
}

void clear()
{
	_finish = _start;
}

拷贝构造、赋值重载

关于深浅拷贝的问题在[C++](10)C++的string类如何实现？中有详细讲解。vector 涉及资源管理，需要深拷贝。

为了方便，这里就直接使用现代写法，在这之前，还需要写一个有参的构造函数和一个类内的 swap 函数

因为传入的迭代器可能是各种类型，所以可以单独写一个函数模板。

template<class InputIterator>
Vector(InputIterator first, InputIterator last)
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	while (first != last)
	{
		push_back(*first++);
	}
}

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

拷贝构造：

Vector(const Vector<T>& v)
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	Vector<T> tmp(v.begin(), v.end());
	swap(tmp);
}

赋值重载：

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

👆：Vector<T>& operator=(Vector<T> v) 也可以写成 Vector& operator=(Vector v) 。但是这样有点怪，不推荐。

填充构造

Vector(int n, const T& val = T())
	: _start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n);
	for (size_t i = 0; i < n; ++i)
	{
		push_back(val);
	}
}

注意：参数 int n，不要写成 size_t n 。

对于函数重载，编译器在调用函数时，会选择参数类型最匹配的进行调用。

如同一组实参，有多个重载的函数可以调用，则调用优先级为：类型完全匹配的函数 > 函数模板实例化 > 需要类型转换才能调用的函数

如 Vector<int> v(10, 5); 10是int 类型，要变成 size_t 类型需要类型转换。相比之下，迭代器范围构造是个函数模板，模板参数只有一个，函数参数两个，显然更加匹配，编译器则会去调用那个模板实例化的函数，从而导致错误。

完整代码

#pragma once
#include <iostream>
#include <cassert>
#include <cstring>
using namespace std;

template<class T>
class Vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{}

	template<class InputIterator>
	Vector(InputIterator first, InputIterator last)
		: _start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		while (first != last)
		{
			push_back(*first++);
		}
	}

	Vector(int n, const T& val = T())
		: _start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		reserve(n);
		for (size_t i = 0; i < n; ++i)
		{
			push_back(val);
		}
	}

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

	Vector(const Vector<T>& v)
		: _start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		Vector<T> tmp(v.begin(), v.end());
		swap(tmp);
	}

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

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

	iterator begin()
	{
		return _start;
	}
	iterator end()
	{
		return _finish;
	}
	const_iterator begin() const
	{
		return _start;
	}
	const_iterator end() const
	{
		return _finish;
	}

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

	void reserve(size_t n)
	{
		size_t sz = size();
		if (n > capacity())
		{
			T* tmp = new T[n];
			if (_start)
			{
				for (size_t i = 0; i < size(); ++i)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}
			_start = tmp;
		}
		_finish = _start + sz;
		_endofstorage = _start + n;
	}

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

	void push_back(const T& x)
	{
		//if (_finish == _endofstorage)
		//{
		//	size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		//	reserve(newCapacity);
		//}

		//*_finish = x;
		//++_finish;
		insert(end(), x);
	}

	void pop_back()
	{
		//if (_finish > _start) --_finish;
		erase(end() - 1);
	}

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

	iterator insert(iterator pos, const T& x)
	{
		assert(pos >= _start && pos <= _finish);
		if (_finish == _endofstorage)
		{
			size_t n = pos - _start;
			size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newCapacity);
			pos = _start + n;
		}
		for (iterator end = _finish; end > pos; --end)
		{
			*end = *(end - 1);
		}
		*pos = x;
		++_finish;
		return pos;
	}

	iterator erase(iterator pos)
	{
		assert(pos >= _start && pos < _finish);
		for (iterator it = pos + 1; it != _finish; ++it)
		{
			*(it - 1) = *it;
		}
		--_finish;
		return pos;
	}

	void clear()
	{
		_finish = _start;
	}
private:
	iterator _start;
	iterator _finish;
	iterator _endofstorage;
};