C++：模拟实现vector以及vector的迭代器失效和拷贝问题

实现的功能

模拟实现

由于前面实现了string，因此这里实现过程不为重点，重点为关于迭代器失效和拷贝问题

template <class T>
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;

	// constructor
	vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endofstorge(nullptr)
	{}

	template <class InputIterator>
	vector(InputIterator first, InputIterator last)
		: _start(nullptr)
		, _finish(nullptr)
		, _endofstorge(nullptr)
	{

		while (first != last)
		{
			push_back(*first);
			first++;
		}
	}

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

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

	vector(vector<T>& v)
	{
		reserve(v.capacity());
		for (auto& e : v)
		{
			push_back(e);
		}
	}

	// destructor
	~vector()
	{
		delete[] _start;
		_start = _finish = _endofstorge = nullptr;
	}

	// operator=
	vector<T>& operator=(vector<T>& v)
	{
		//_start = new T[v.capacity()];
		//_finish = _start + v.size();
		//_endofstorge = _start + v.capacity();
		swap(v);
		return *this;
	}

	// capacity
	size_t size()
	{
		return _finish - _start;
	}
	void resize(size_t num, const T& val = T())
	{
		if (num < size())
		{
			_finish = _start + num;
		}
		else
		{
			while (_finish != _start + num)
			{
				push_back(val);
				_finish++;
			}
		}
	}
	size_t capacity()
	{
		return _endofstorge - _start;
	}
	void reserve(size_t num)
	{
		if (num > capacity())
		{
			T* tmp = new T[num];
			size_t sz = size();
			if (_start)
			{
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;
			}

			_start = tmp;
			_finish = _start + sz;
			_endofstorge = _start + num;
		}
	}
	bool empty()
	{
		if (_start == _finish)
			return true;
		return false;
	}

	// element access
	T& operator[](size_t pos)
	{
		return *(_start + pos);
	}

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

	// modifier
	void push_back(T data)
	{
		if (_finish == _endofstorge)
		{
			size_t sz = size();
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			T* tmp = new T[newcapacity];

			if (_start)
			{
				//memcpy(tmp, _start, sizeof(T) * size());
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}

			_finish = tmp + sz;
			_endofstorge = tmp + newcapacity;
			_start = tmp;
		}

		assert(_finish);
		*(_finish) = data;
		++_finish;
	}

	void pop_back()
	{
		--_finish;
	}

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

		if (_finish == _endofstorge)
		{
			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;
	}

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

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

		--_finish;

		return pos;
	}


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

private:
	iterator _start;
	iterator _finish;
	iterator _endofstorge;
};

迭代器失效

首先要清楚，什么是迭代器失效，迭代器失效的应用场景是哪里？

这里举一个例子，迭代器可能会在进行insert的过程中失效，具体失效原因：

迭代器本身可以理解成就是一个指针而这个指针指向的空间又是固定的，因此这里当使用指针时，如果原来的空间由于扩容，导致原来空间被销毁，那么这个迭代器所指向的内容其实也就没有任何意义了，这也就是迭代器失效的原因

用下面这个例子来理解会更方便一些：

void test_vector1()
{
	vector<int> v(5,5);

	auto it = v.begin();

	v.insert(it, 10);
	v.insert(it, 10);
	v.insert(it, 10);
	v.insert(it, 10);
	v.insert(it, 10);

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

这里定义了一个vector，里面有5个数字5，此时_start所指向的空间是一个区域，因此这里使用迭代器就可以找到容器的头部，实现插入是很方便的

但当插入数据后，_start所指向的空间发生改变了，而这里的迭代器却依旧指向原来的位置，在这种情况下就是经典的迭代器失效的问题，因此在一些编译器下，标准库下的迭代器如果被insert/erase所使用，迭代器是要被强制检查，不可以被使用的

在有些编译器下，不会进行检查，因此就会产生迭代器失效的情况，基于这样的情况，在使用迭代器时，要注意是否有失效的可能

隐含浅拷贝问题

先来看下面代码

	void push_back(T data)
	{
		if (_finish == _endofstorge)
		{
			size_t sz = size();
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			T* tmp = new T[newcapacity];

			if (_start)
			{
				//memcpy(tmp, _start, sizeof(T) * size());
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}

			_finish = tmp + sz;
			_endofstorge = tmp + newcapacity;
			_start = tmp;
		}

		assert(_finish);
		*(_finish) = data;
		++_finish;
	}

如果你对memcpy是否可以使用存在疑惑，可以看下面的测试函数

void test_vector1()
{
	vector<string> v;
	v.push_back("111111111111111111111");
	v.push_back("111111111111111111111");
	v.push_back("111111111111111111111");
	v.push_back("111111111111111111111");
	v.push_back("111111111111111111111");

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

如果使用memcpy的结果是这样的

出现这样结果的原因也很简单，这是因为memcpy本质上其实是一种浅拷贝，它的工作原理是把每一个字节的内容都进行拷贝，因此这样其实是一种浅拷贝，用下面的机制来解释可以看成：
因此我们采用了改良版的拷贝机制，让这些数据也进行一定程度的拷贝

这样就可以实现拷贝的效果