C++ STL---vector

vector

vector容器是一个动态的顺序表，支持像数组一样随机访问，[]访问，但是vector容器在erase与insert的时候比较费劲，需要另外申请空间，而且这个现象还可能导致迭代器失效的问题，因此如果我们在erase与insert之后还想用迭代器的话，就必须将他们的返回值接收下来，然后才能继续使用

vector相关使用

1.vector构造函数

1. 无参构造
2. 拷贝构造
3. 使用迭代器进行初始化构造
4. 构造n个val

2.vector的空间增长问题

1. size：vector的中数据的数量
2. capacity：vector的容量的大小
3. empty：判断容器是否为空
4. resize：重新分配空间，会进行初始化，会改变size
5. reserve：重新分配容量，改变的是capacity

3.vector的增删查改

1. push_back:尾插
2. pop_back:尾删
3. find：查找并且返回位置
4. insert：插入
5. erase：删除
6. swap：交换两个容器的空间
7. operator []:中括号访问

#pragma once

namespace ljc
{
template<class T>
class vector
{
	T * m_start;
	T * m_finish;
	T * m_endOfStroge;
public:
	//vector的迭代器是一个原生指针
	typedef T * iterator;
	typedef const T * const_iterator;

	vector() :
		m_start(nullptr),
		m_finish(nullptr),
		m_endOfStroge(nullptr)
	{

	}
	//默认的val为0
	vector(int n, const T &val = T()) :
		m_start(nullptr),
		m_finish(nullptr),
		m_endOfStroge(nullptr)
	{
		reserve(n);
		for (int i = 0; i < n; i++)
		{
			m_start[i] = val;
		}
		m_finish = m_start + n;
	}
	vector(T * start, T * end) :
		m_start(nullptr),
		m_finish(nullptr),
		m_endOfStroge(nullptr)
	{
		int _size = end - start;
		reserve(_size);

		for (int i = 0; i < _size; i++)
		{
			m_start[i] = start[i];
		}
		m_finish = m_start + _size;
	}
	iterator begin()
	{
		return m_start;
	}

	iterator end()
	{
		return m_finish;
	}

	size_t size()
	{
		return m_finish - m_start;
	}
	size_t capacity()
	{
		return m_endOfStroge - m_start;
	}

	T & operator [] (int i)
	{
		return m_start[i];
	}
	const T & operator [] (int i) const
	{
		return m_start[i];
	}

	void reserve(size_t _size)
	{
		int _capacity = capacity();
		
		if (_capacity < _size)
		{
			if (_capacity == 0)
			{
				_capacity = 1;
			}

			while (_capacity < _size)
			{
				_capacity *= 2;
			}
		}

		T * tmp = new T[_capacity];
		m_endOfStroge = tmp + _capacity;
		int oldsize = size();
		m_finish = tmp + oldsize;
		if (m_start != nullptr)
		{
			for (int i = 0; i < oldsize; i++)
			{
				tmp[i] = m_start[i];
			}
			delete[] m_start;
		}
		m_start = tmp;
	}

	void resize(size_t size, const T &val = T())
	{
		reverse(_size);

		for (int i = size(); i < _size; i++)
		{
			m_start[i] = val;
		}
		m_finish = m_start + _size;
	}

	iterator insert(iterator pos, const T &val)
	{
		int tmp = pos - m_start;
		reserve(size() + 1);
		pos = m_start + tmp;

		int i;
		for (i = size() - 1; i >= pos - m_start; i--)
		{
			m_start[i + 1] = m_start[i];
		}

		*pos = val;

		m_finish++;
		return pos;
	}

	iterator insert(iterator pos, int n, const T &val)
	{
		int tmp = pos - m_start;
		reserve(size() + n);
		pos = m_start + tmp;

		int i;
		for (i = size() - 1; i >= pos - m_start; i--)
		{
			m_start[i + n] = m_start[i];
		}

		for (i = 0; i < n; i++)
		{
			pos[i] = val;
		}

		m_finish += n;
		return pos;
	}

	iterator insert(iterator pos, const T * start, const T * end)
	{
		int tmp = pos - m_start;
		int extsize = end - start;
		reserve(size() + extsize);
		pos = m_start + tmp;

		int i;
		for (i = size() - 1; i >= pos - m_start; i--)
		{
			m_start[i + extsize] = m_start[i];
		}

		for (i = 0; i < extsize; i++)
		{
			pos[i] = start[i];
		}

		m_finish += extsize;

		return pos;
	}

	iterator erase(iterator pos)
	{
		int i;

		for (i = pos - m_start; i < size() - 1; i++)
		{
			m_start[i] = m_start[i + 1];
		}
		m_finish--;
		return pos;
	}

	iterator erase(iterator start, iterator end)
	{
		int i;
		int extsize = end - start;

		for (i = start - m_start; i < size() - extsize; i++)
		{
			m_start[i] = m_start[i + extsize];
		}
		m_finish -= extsize;

		return start;
	}

	void push_back(const T &val)
	{
		reserve(size() + 1);

		*m_finish = val;
		m_finish++;
	}

	void pop_back()
	{
		m_finish--;
	}

};

};