『C++』vector容器模拟实现

Vector.h

#pragma once

#include <iostream>
#include <string.h>
#include <assert.h>

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

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

	Vector(const Vector<T>& v)
		: _start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		Reserve(v.Size());

		for (size_t i = 0; i < v.Size(); ++i){
			PushBack(v[i]);
		}
	}

	Vector<T>& operator=(Vector<T> v){
		swap(v);

		return *this;
	}

	~Vector(){
		if (_start){
			delete[] _start;

			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}
	}

public:
	iterator begin(){
		return _start;
	}

	iterator end(){
		return _finish;
	}

	const_iterator begin() const{
		return _start;
	}

	const_iterator end() const{
		return _finish;
	}

public:
	void Reserve(size_t n, const T& val = T());

	void Resize(size_t n, const T& val = T());

public:
	void PushBack(const T& x);

	void PopBack();

	void Insert(iterator pos, const T& x);

	void Erase(iterator pos);

public:
	T& operator[](size_t pos){
		assert(pos < Size());

		return _start[pos];
	}

	const T& operator[](size_t pos) const{
		assert(pos < Size());

		return _start[pos];
	}

public:
	size_t Size() const{
		return _finish - _start;
	}

	size_t Capacity() const{
		return _endofstorage - _start;
	}

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

private:
	T* _start;
	T* _finish;
	T* _endofstorage;
};

Vector.cpp

#include "Vector.h"

template<class T>
void Vector<T>::Reserve(size_t n, const T& val = T()){
	if (n > Capacity()){
		size_t size = Size();

		T* temp = new T[n];

		if (_start){
			for (size_t i = 0; i < size; ++i){
				temp[i] = _start[i];
			}
		}

		delete[] _start;

		_start = temp;
		_finish = _start + size;
		_endofstorage = _start + n;
	}
}

template<class T>
void Vector<T>::Resize(size_t n, const T& val = T()){
	if (n <= Size()){
		_finish = _start + n;
	}
	else{
		Reserve(n);

		while (_finish != _start + n){
			*_finish = val;
			++_finish;
		}
	}
}

template<class T>
void Vector<T>::PushBack(const T& x){
	if (_finish == _endofstorage){
		size_t capacity = Capacity() == 0 ? 4 : Capacity() * 2;
		Reserve(capacity);
	}

	*_finish = x;
	++_finish;
}

template<class T>
void Vector<T>::PopBack(){
	if (_finish > _start){
		--_finish;
	}
}

template<class T>
void Vector<T>::Insert(iterator pos, const T& x){
	assert(pos < _finish);

	if (_finish == _endofstorage){
		size_t offset = pos - _start;
		size_t capacity = Capacity() == 0 ? 4 : Capacity() * 2;

		Reserve(capacity);
		pos = _start + offset;
	}

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

	*pos = x;
	++_finish;
}

// 使用iterator返回值会出错，原因暂时不详
template<class T>
void Vector<T>::Erase(iterator pos){
	assert(pos < _finish);

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

	--_finish;

	return pos;
}