Hello大家好！很高兴我们又见面啦！给生活添点passion，开始今天的编程之路！

我的博客：<但凡.

我的专栏：《编程之路》、《数据结构与算法之美》、《题海拾贝》、《C++修炼之路》

欢迎点赞，关注！

         这一篇主要讲讲vector的模拟实现。由于我们之前介绍过string的各种接口了，vector的各种接口和string都大差不差，所以就不讲vector的使用了直接讲vector的模拟实现。

目录

1、类的封装

 2、迭代器

3、写一些简单接口

4、reserve  

5、 insert

6、erase

7、完善构造函数

7.1、多个初始化构造

7.2、迭代器构造

7.3、初始化链表

 7.4、拷贝构造

8、赋值运算符重载

1、类的封装

        我们把我们的vector类初始化好，先把大致的模子，也就是vector类的成员变量，构造函数，析构函数写出来。

template<class T>
class vector
{
public:
	vector()
	:_start(nullptr),
	_finish(nullptr),
	_end_of_storage(nullptr)
    {
    }
    ~vector()
    {
    	if (_start)
    	{
    		//如果这个地址不是野指针在进行delete
    		delete[] _start;
    		_start = _end=_end_of_storage;//让他们都等于_end_of_storage
    	}
    }
private:
	T* _start;
	T* _finish;
	T* _end_of_storage;
};

        其中first是这个顺序表的起始地址，_end是这个顺序表最后一个元素的下一个位置的地址，_end_of_storage是能够容纳最大元素的下一个位置的地址。

 2、迭代器

        现在我们写一下vector迭代器的部分。

typedef T* iterator;
typedef const T* const_iterator;//指针的指向可以修改，指针指向的值不能修改

iterator begin()
{
	return _start;
}
iterator end()
{
	return _finish;
}
const_iterator begin() const
{
	return _start;
}
const_iterator end() const
{
	return _finish;
}

3、写一些简单接口

        这一部分就不细说了，实现几个简单的接口:

//简单接口
size_t size() const
{
	return _finish - _start;
}
size_t capacity() const
{
	return _end_of_storage - _start;
}
T& operator[](size_t pos)
{
	assert(pos < size());
	return _start[pos];
}
void pop_back()
{
	assert(size());//不为空才能删
	--_finish;//最后一个地址-1
}

4、reserve  

        有一点我们需要着重注意，在拷贝数据的时候我们不能使用memcpy，因为如果我们的vector中存的是string（或其他自定义类），在这时候如果进行memcpy的话其实是进行的浅拷贝，也就是说我们的每个节点指向的都是同一块地址。

        类似这样，我们新得到的节点都是指向原来的地址的。这样是肯定不是我们想要的效果。所以说我们应该进行深拷贝。我们使用for循环对于每个节点依次进行深拷贝，对于每个节点的赋值我们都会调用string(自定义类)的赋值运算符重载（深拷贝）。

void reserve(size_t n)
{
	if (n > capacity())
	{
		T* tmp = new T[n];
		size_t oldsize = size();
		if (_start)//如果这个_start不是野指针或者空指针就进行拷贝
		{
			//深拷贝内容
			for (size_t i = 0;i < oldsize;i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
		_finish = tmp + oldsize;
		_end_of_storage = tmp + n;
	}
}

5、 insert

        insert我们需要注意的就是迭代器失效的问题。那么什么是迭代器失效呢？举个简单的例子，如果我们先在原地址上定义了一个迭代器，我们reserve扩容是异地扩容，那么对于新的这块空间，如果我们要想访问之前定义的迭代器那个位置的值是肯定访问不到的，所以我们得把相应的迭代器也挪到新的地址上来。

iterator insert(iterator pos, const T& x)
{
	//在当前位置插入
	assert(pos <= _finish);
	assert(pos >= _start);

	//扩容
	if (_finish = _end_of_storage)
	{
		size_t len = pos - _start;//这个len是用来标记pos的位置的，因为reserve是异地扩容会导致迭代器失效
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);
		pos = _start + len;//这里的start已经是新的start了
	}

	//将插入位置之后的所有元素向后挪动一位
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		it--;
	}

	//更改pos位置值
	*pos = x;
	++_finish;

	return pos;//防止迭代器失效
}

6、erase

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);//注意我们不能让pos等于最后一个位置的下一个位置

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

	--_finish;
	return pos;
}

7、完善构造函数

        我们回过头来完善之前写的构造函数，因为实际上vecot提供了很多种的构造函数，我们再多写几个：

7.1、多个初始化构造

	vector(size_t n.const T& val = T())
	{
		reserve(n);//这里一次性把空间开好防止后面多次调用reserve浪费时间
		while (n--)
		{
			push_back(val);
		}
	}

7.2、迭代器构造

        因为迭代器构造实际上是对于push_back的复用，所以我们没有一开始写出来。

        在这里有一点很重要，如果我们构造的时候传入5,5，我们是想构造含有五个元素，每个元素为5的vector，但是很明显他会调用我们的迭代器构造模版，因为如果传入两个int类型的值的话其实和我们迭代器模板更加匹配。所以我们提供多个初始化构造还得额外提供一个int版本的。

template<class it1, class it2>
vector(it1, it2)
{
	while (it1 != it2)
	{
		push_back(*it1);
		++it1;//使用前置加加不设计临时对象效率更高
	}
}

额外提供int版本初始化：

	vector(int n.const T& val = T())
	{
		reserve(n);//这里一次性把空间开好防止后面多次调用reserve浪费时间
		while (n--)
		{
			push_back(val);
		}
	}

7.3、初始化链表

        这个初始化链表其实就是大括号初始化。

vector(std::initializer_list li)
{
	rserve(li.size());
	for (auto& e : li)
	{
		push_back(e);
	}
}

 7.4、拷贝构造

	vector(const vector<T>& v)
	{
		reserve(v.size());
		for (auto& e : v)
		{
			push_back(e);
		}
	}

8、赋值运算符重载

        赋值运算符重载实际上是复用swap，所以我们先来实现swap:

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_end, v._end);
	std::swap(_end_of_storage,v._end_of_storage)
}
vector<T>& operator=(vector<T> v)//注意这里是传值拷贝
{
	swap(v);
	return *this;
}

        好了，今天的内容就分享到这，我们下期再见！ 

 

 

.