C++语法（10）---- 模拟实现vector

接上面内容：

C++语法（9）---- 模拟string

---

目录

1.成员变量

2.迭代器

3.运算符重载[]

4.插入删除

5.属性

6.改变容量

7.构造析构

---

1.成员变量

template<class T>
class vector
{
    typedef T* iterator;
private:
	iterator _start;
	iterator _finish;
	iterator _endofstorge;
};

这里直接定义vector数据的指针为迭代器，给出的成员变量为开头位置/结尾位置/容量位置

2.迭代器

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

const iterator begin() const
{
	return _start;
}

const iterator end() const
{
	return _finish;
}

3.运算符重载[]

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

4.插入删除

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

void pop_back()
{
	assert(!empty());
	--_finish;
}

void insert(iterator pos, const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _endofstorge)
	{
		size_t len = pos - _start;
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
		pos = _start + len;
	}

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

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

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

需要注意的是：针对erase在stl中，对使用的迭代器不能再进行任何操作，相当于当我们删除掉迭代器位置的数据时，迭代器指向非常模糊，这里就不允许迭代器被重新使用。

5.属性

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

size_t capacity() const
{
	return _endofstorge - _start;
}

bool empty()
{
	return _finish == nullptr;
}

6.改变容量

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t oldSize = size();
		T* tmp = new T[n];
		if (_start)
		{
			//memcpy(tmp, _start, sizeof(T) * oldSize);
			for (size_t i = 0; i < oldSize; i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + oldSize;
		_endofstorge = _start + n;
	}
}

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

7.构造析构

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

void clear()
{
	_finish = _start;
}

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

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

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

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

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

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