C++--vector的模拟实现

1. 构造函数

• 成员函数

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

1）无参构造

	//无参构造
	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{}

2）n个缺省值的构造

	//给n个缺省值的构造
	Vector(int n, const T& value = T())
		:_start(new T[n])
		, _finish(_start + n)
		, _endOfStorage(_start + n)
	{
		for (size_t i = 0; i < n; ++i)
		{
			_start[i] = value;
		}
	}

3）迭代器区间的构造

	//迭代器区间的构造
	template<class InputIterator>
	Vector(InputIterator first, InputIterator last)
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{
		while (first != last)
		{
			//元素遍历：尾插
			push_back(*first);
			++first;
		}

4）拷贝构造

	//拷贝构造
	Vector(const Vector<T>& v)
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{
		reserve(v.capacity());
		iterator it = begin();
		const_iterator cit = v.cbegin();
		while (cit != v.cend())
		{
			*it++ = *cit++;
		}
		_finish = _start + v.size();
		_endOfStorage = _start + v.capacity();
	}

2. 析构函数

	//析构
	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}

3. 增容

1) reserve

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			//保存有效元素个数
			size_t sz = size();
			//申请空间
			T* tmp = new T[n];
			//拷贝内容
			if (_start)
			{
				//深拷贝
				for (size_t i = 0; i < sz; i++)
				{
					//调用当前数据的赋值运算符重载函数，完成深拷贝
					tmp[i] = _start[i];
				}
				//释放原有空间
				delete[] _start;
			}
			//更新
			_start = tmp;
			_finish = _start + sz;
			_endOfStorage = _start + n;
		}
	}

2) resize

	void resize(size_t n, const T& value = T())
	{
		//n > capacity
		if (n > capacity())
		{
			reserve(n);
		}
		//size < n <= capacity
		if (n > size)
		{
			//(size, n):填充value
			while (_finish != _start + n)
			{
				*_finish = value;
				++_finish;
			}
		}
		//n <= size
		_finish = _start + n;
	}

4.vector容量、长度

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

5. 插入、删除、尾插、尾删

1）insert

	//插入
	iterator insert(iterator pos, const T& x)
	{
		//检查位置
		assert(pos >= _start && pos <= _finish);
		//检查容量
		if (_finish == _endOfStorage)
		{
			//增容会导致迭代器失效
			//保存pos和_start的偏移量
			size_t offset = pos - _start;
			size_t newC = (0 == capacity()) ? 1 : 2 * capacity();
			reserve(newC);
			//更新pos
			pos = _start + offset;
		}
		//移动元素，从后向前
		iterator end = _finish;
		while(end != pos)
		{
			*end = *(end - 1);
			--end;
		}
		//插入
		*pos = x;
		//更新
		++_finish;
		return pos;
	}

2）erase

	//删除
	iterator erase(iterator pos)
	{
		//检查范围
		assert(pos >= _start && pos < _finish);
		//元素移动：从后向前
		iterator start = pos + 1;
		while(start != _finish)
		{
			*(start - 1) = *start;
			++start;
		}
		//更新
		--_finish;
		return pos;
	}

3）push_back

	void push_back(const T& x)
	{
		//insert(end(), x);
		//检查容量
		if (_finish == _endOfStorage)
		{
			size_t newC = _endOfStorage == nullptr ? 1 : 2 * capacity();
			reserve(newC);
		}
		//插入
		*_finish = x;
		//更新
		++_finish;
	}

4）pop_back

	//尾删
	void pop_back()
	{
		if (size() > 0)
		{
			erase(end() - 1);
		}
	}

6. 迭代器

	//Vector的迭代器是一个原生指针
	typedef T* iterator;
	typedef const T* const_iterator;
	iterator begin()
	{
		return _start;
	}
	iterator end()
	{
		return _finish;
	}
	const_iterator cbegin()const
	{
		return _start;
	}
	const_iterator cend()const
	{
		return _finish;
	}

7. []接口

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

8. 可读可写与只读的迭代器、范围for、[]

1）迭代器

//迭代器
//可读可写
template<class T>//函数模板
void printVector(Vector<T>& vec, const T& val) 
{
	typename Vector<T>::iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		*it = val;
		++it;
	}
	cout << endl;
}
//只读
template<class T>
void printVector(const Vector<T>& vec) 
{
	typename Vector<T>::const_iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

2）范围for

//范围for
//可读可写
template<class T>
void printVectorFor(Vector<T>& vec, const T& val)
{
	for (auto& e : vec)
	{
		cout << e << " ";
		e = val;
	}
	cout << endl;
}
//只读
template<class T>
void printVectorFor(const Vector<T>& vec)
{
	for (const auto& e : vec)
	{
		cout << e << " ";
	}
	cout << endl;
}

3）[]

//[]
//可读可写
template<class T>
void printOperator(Vector<T>& vec, const T& val)
{
	for (size_t i = 0; i < vec.size(); ++i)
	{
		cout << vec.operator[](i) << " ";
		vec[i] = val;
	}
	cout << endl;
}
//只读
template<class T>
void printOperator(const Vector<T>& vec)
{
	for (size_t i = 0; i < vec.size(); ++i)
	{
		cout << vec.operator[](i) << " ";
	}
	cout << endl;
}