C++ vector底层代码实现

原文链接

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

	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _last;
	}

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _last;
	}

	vector() 
		:_start(nullptr)
		,_last(nullptr)
		,_endofstorage(nullptr)
		{}

	template <class InputIterator>
	vector(InputIterator first, InputIterator last)//此构造函数，可以让别的拥有头尾迭代器的容器能够存入vector容器中
		: _start(nullptr)
		, _last(nullptr)
		, _endofstorage(nullptr)
	{
		while (first != last)
		{
			push_back(*first);
			++first;
		}
	}

	// v2(v1)，传统写法
	vector(const vector<T>& v)
		:_start(nullptr)
		, _last(nullptr)
		, _endofstorage(nullptr)
	{
		reserve(v.capacity());
		for (const auto& e : v)//可以直接通过范围for来逐个插入到v2中，不用像现代写法重新开辟tmp的vector对象
		{
			push_back(e);
		}
	}

	~vector()
	{
		delete[] _start;
		_last = nullptr;
		_start = nullptr;
		_endofstorage = nullptr;
	}

	void swap(vector<T>& v)
	{
		std::swap(_start, v._start);
		std::swap(_last, v._last);
		std::swap(_endofstorage, v._endofstorage);
	}
	//现代写法v1=v2
	vector<T>& operator=(vector<T> v)//这里没用使用引用，即在创建v时会开辟一个新的空间
	{
		swap(v);//此时直接调用swao函数即可，且v为形参，swap后获得this原本的数据，函数结束时v同原本this数据一同释放
		return *this;
	}

	size_t size()
	{
		return _last - _start;
	}

	size_t capacity()
	{
		return _endofstorage - _start;
	}

	bool empty()
	{
		return _start == _last;
	}

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t sz = capacity();
			T* tmp = new T[n];
			memcpy(tmp, _start, sizeof(T) * sz);
			_start = tmp;
			_last = _start + sz;
			_endofstorage = _start + n;
		}
	}

	void resize(size_t n,const T& val=T())
	{
		if (n <= size())
		{
			_last = _start + n;//是减小大小，而不是扩大
		}
		else
		{
			if (n > capacity())
			{
				reserve(n);
			}
			while(_last<_start+n)//不用等于，因为_last是指向有效字符的后一位
			{
				*_last= val;
				_last++;//这里改变了size的大小
			}
		}
	}

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

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

	void Push_back(const T& x)
	{
		/*if (_last==_endofstorage) 
		{
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);
		}
		*_last = x;
		++_last;*/
		insert(end(), x);
	}

	void Pop_back()
	{
		assert(!empty());
		--_last;
	}

	iterator insert(iterator pos, const T& x)
	{
		assert(pos >= _start && pos <= _last);
		if (_last == _endofstorage)
		{
			size_t len = pos - _start;
			size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
			reserve(newcapacity);
			pos = _start + len;
		}//此语句是为了提高复用性，可以直接对Push_back进行复用
		//size_t len = pos - _start;
		//iterator end = _last + 1;
		//if (_last == _endofstorage) 
		//{
		//	reserve(capacity() + 1);
		//}
		//pos = _start + len;//注意：重新开空间后pos也变成野指针；所以要重新找回来
		//end = _last;//注意：end必须在if语句后面在写一次，因为resrve函数会重新开空间，不然end会变成野指针
		iterator end = _last;
		while (end >= pos)
		{
			*end = *(end - 1);//注，这里不能用--end，因为前面的end也会被改变
			--end;
		}
		*pos = x;
		++_last;
		return pos;//为了给用户能够重新使用原本指向的数，避免野指针的情况
	}

	iterator erase(iterator pos)
	{
		assert(pos >= _start && pos <= _last);
		iterator end = pos + 1;
		while (end < _last)
		{
			*(end - 1) = *end;//注，这里不能用--end，因为前面的end也会被改变
			++end;
		}
		--_last;
		return pos;//同样为了避免野指针问题，给用户一个返回值，是被删元素的后面一个值
	}

private:
	iterator _start;
	iterator _last;
	iterator _endofstorage;
};