STL——vector的使用及模拟实现

目录

 创建vector对象

深浅拷贝 

销毁对象

迭代器

begin()和end()

reserve

resize

增加元素

删除元素

operator[ ]

---

 

        vector向量容器不但能像数组一样对元素进行随机访问，还能在尾部插入，是一种简单的、高效的容器，值得注意的是，vector具有内存自动管理功能，对元素的插入和删除，可以动态调整对象所占空间的大小。现在我们来尝试模拟vector容器模拟。为与标准库中的vector区别，我们在my_vector命名空间模拟实现。

vector的成员变量：

private:
		iterator _start=nullptr;//表示目前使用空间的头
		iterator _finish=nullptr;//表示目前使用空间的尾
		iterator _end_of_storage=nullptr;//表示目前可用空间的尾

 创建vector对象

1.不指定容器的元素个数只是定义容器的存储数据的类型。

my_vector::vector<int>v;

对应的构造函数：

vector()
		{}

2.创建时指定容器的大小。如定义一个用来存储10个int数据类型的容器。

my_vector::vector<int>v1(10);

对应的构造函数：

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

创建时使用了缺省值进行初始化。

my_vector::vector<int>v2(5, 4);

创建时传值初始化进行初始化。

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

3.使用已存在的对象构造一个新的对象（拷贝构造）

  vector支持使用一段迭代器区间进行对象的构造。该迭代器区间可以是其他容器的迭代器区间，也就是说该函数接收到的迭代器的类型是不确定的，所以我们这里需要将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中即可。
 

​
template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

​

	my_vector::vector<int>v3(v2);

传统的拷贝构造函数：

		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			//memcpy(_start, v._start, sizeof(T)*v.size());
			for (size_t i = 0; i < v.size(); ++i)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

现代写法

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

   

vector<T>& operator=(vector<T> v)//不能加引用  零时拷贝
		{
			swap(v);
			return *this;
		}

深浅拷贝 

        需要注意的是我们在模拟实现拷贝构造时，因为我们需要支持自定义类型，自定义类型中可能含有指针，指向别的地址空间，如果我们使用memcpy()实现的是浅拷贝这时我们用一个存在的对象去构造另一个对象时，这个对象的成员变量也会和用于构造的对象指向同一块空间，在调用析构函数时会对同一空间析构两次，这是不允许的。例如当Vector容器里存放的是一些不包含指针变量的对象时，使用memcpy（）是可以的。

例如 

当对象中有指针类型指向别的空间时

销毁对象

析构函数

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

迭代器

typedef T* iterator;
typedef const T* const_iterator;

begin()和end()

iterator begin()
{

return _start;//返回容器的首地址
}

iterator end()
{    
    return _finish;//返回容器最后一个元素的下一个地址
}

还需要重载适用于const对象的begin和end函数，使得const对象调用begin和end函数时所得到的迭代器只能对数据进行读操作，而不能进行修改。
 

const_iterator begin() const
{

return _start;//返回容器的首地址
}

const_iterator end() const
{    
    return _finish;//返回容器最后一个元素的下一个地址
}

返回已用空间和总空间,两个地址相减。

void size()
{

    return _finish-_start;
}

void capacity()
{
    return _end_of_storage-_start;
}

reserve

规则：

1.当n大于当前对象的capacity(),也就是大于对象的最大容量空间时，则申请新的空间，将容量扩大到n或大于n。

2.当n小于当前容器的容量时，则什么也不做。

当n大于capacity()时需要调用reserve扩容，申请新的内存空间后旧空间将数据拷贝到新空间，在释放旧空间前我们需要记住_start和_finish的相对位置。然后再更新成员变量的指向。

void reserve(size_t n)
		{
			if (n > capacity())//判断是否需要扩容
			{
				size_t sz = size();//记录_finish相对于_start的位置
				T* tmp = new T[n];
				if (_start)//判断容器是否为空
				{
					//memcpy(tmp, _start, sizeof(T)*size());
					for (size_t i = 0; i < sz; ++i)//数据的拷贝
					{
						tmp[i] = _start[i];
					}
					delete[] _start;//释放旧空间
				}

				_start = tmp;
				_finish = _start + sz;//更新_finish;
				_end_of_storage = _start + n;//更新	_end_of_storage
			}
		}

resize

规则：

void resize(size_t n, T val = T())
		{
			if (n < size())
			{
				// 删除数据
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
					reserve(n);

				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

增加元素

push_back,在增加元素前我们需要先判断容器中是否还有空间可以使用，如果没有则需要进行扩容，还有可用空间的话，将元素的值插入_finish指向的位置，然后将_finish指向下一个位置就可以了。

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

			*_finish = x;
			++_finish;
		}

任意位置增加元素

任意位置是指位置在_start和_finish之间的位置

这里要注意的是如果需要扩容，在扩容时释放旧空间，如果不更新pos的位置，那么pos就是一个野指针。

iterator insert(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);

				// 扩容后更新pos，解决pos失效的问题
				pos = _start + len;
			}

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

			*pos = val;
			++_finish;

			return pos;
		}

删除元素

pop_back,先判断容器是否为空，不为空则--finish即可。

判断容器是否为空

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

void pop_back()
		{
			assert(!empty());

			--_finish;
		}

删除任意位置元素

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

			iterator start = pos + 1;
			while (start != _finish)
			{
				*(start - 1) = *start;
				++start;
			}

			--_finish;

			return pos;
		}

operator[ ]

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

			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());

			return _start[pos];
		}