vector的模拟实现

目录

构造函数，初始化列表

析构函数

长度

空间

迭代器

扩容

尾插 

[]的模拟实现

insert的模拟实现

erase的模拟实现

尾删

resize的模拟实现

深拷贝模拟,vectorv1(v)

swap的模拟实现

=的模拟实现

vectorv(10,1)

支持多样类型的迭代器

text

总代码

---

开头 

#include<iostream>
#include<assert.h>
using namespace std;

namespace Ljw
{
	template<class T>
	class   vector
	{	
        public:
		typedef T* iterator;
		typedef const T*  const_iterator;
        	private:
		iterator _start;//为开头的指针
		iterator _finish; //为实际数量的指针
		iterator _end; //为空间的指针
	};
}

构造函数，初始化列表

vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_end(nullptr)
{}

析构函数

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

长度

	size_t size()
	{
		return _finish - _start;//指针减指针为数
	}

空间

size_t capacity()
{
	return _end - _start;//指针减指针为数
}

迭代器

const_iterator begin() const
{
	return _start;
}
//迭代器
const_iterator end() const
{
	return _finish;
}
//const迭代器
iterator begin() 
{
	return _start;
}
//迭代器
iterator end() 
{
	return _finish;
}

扩容

void reserve(size_t n)
{	
	if (n > capacity())
	{
		//提前保存
		size_t k = size();
		T* tmp = new T[n];
		if (_start)
		{
			//memcpy(tmp, _start, sizeof(T) * k);
		
			//改正string的问题
			for (int i = 0; i <  k; i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}	
		//_finish = tmp + size();//_start的原来空间已经释放，需要tmp,或者可以提前保存size()的大小,
		                                        //因为size()返回的是_finish-_start,_start的指向已经变了所以，size()的大小是不确定的，
												// 可以提前存size()的大小,这样就解决了指向改变的问题，可以在if外面，里面也可以，因为扩容才会改变指向
		_start = tmp;
		_finish = _start + k;
		_end = _start + n;
	}
}

_finish = tmp + size();//_start的原来空间已经释放，需要tmp,或者可以提前保存size()的大小,//因为size()返回的是_finish-_start,_start的指向已经变了所以，size()的大小是不确定，// 可以提前存size()的大小,这样就解决了指向改变的问题，可以在if外面，里面也可以，因为扩容才会改变指向

尾插 

void push_back(const T& v)
{
	/*if (_finish==_end )
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}
	*_finish = v;
	_finish++;*/

	insert(end(), v);
}

[]的模拟实现

	T&operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];//等价于*(_start+pos)
	}
	const T& operator[](size_t pos)const
	{
		assert(pos < size());
		return _start[pos];
	}

insert的模拟实现

//insert的模拟实现，vector中的insert是用迭代器实现的,库里会返回pos这个位置

iterator insert(iterator pos,const T&v)
{
	assert(pos <= _finish&&pos>=_start);//这是迭代器之间的比较
	if (_finish == _end)
	{
		size_t len = pos - _start;
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
		pos = _start + len;
	} 
	//扩容后pos还是指向旧空间，所以要提前保存然后再指向新的pos位置
	iterator  end = _finish - 1;
	while (end>=pos)
	{
		//_start[end] = _start[end+1];是不对的，因为是end迭代器，迭代器类似于指针
		*(end + 1)= *(end);
		end--;
	}
	*_finish = v;
	_finish++;
	return pos;
}

erase的模拟实现

//erase的模拟实现，库里会返回删除位置的下一个位置,用的也是迭代器

iterator erase(iterator pos)
{
	assert(pos >= _start && pos < _finish);
	iterator i = pos;
	while (i<_finish)
	{
		*i = *(i + 1);
		i++;
	}
	_finish--;
	return pos;
}

尾删

void pop_back()
{
	//_finish--;
	erase(end()-