vector模拟实现

星光终将不负赶路人

已于 2024-05-20 16:50:10 修改

阅读量855

点赞数 64

文章标签：开发语言 c++ 学习

于 2024-05-19 20:28:08 首次发布

本文链接：https://blog.csdn.net/qq_74319491/article/details/139046991

版权

vector当中的成员变量

在vector当中有三个成员变量_start、_finish、_end_of_storage。

在这里插入图片描述
_start指向容器的开始位置，_finish指向容器当中有效数据的末尾，_endofstorage指向容量的末尾。

默认成员函数

默认成员函数一

vector首先支持一个无参的构造函数

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

构造函数2

其次，vector还支持使用一段迭代器区间进行对象的构造。

// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	//已经在定义的地方赋初始值了,不用走初始化列表
	while (first != last)
	{
		push_back(*first);

		++first;
	}
}

如果我们希望可以接收各种类型的迭代器区间的话，我们这里可以将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中即可，这里不能提前开空间，因为有的迭代器不支持减的操作，比如：list。

构造函数3

vector还支持构n个值为val的数据的构造。

vector(size_t n, const T& val)
{
	reserve(n);

	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

该构造函数还需要实现一个重载函数。

vector(int n, const T& val)
{
	reserve(n);

	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

这两个重载函数与之不同的就是其参数n的类型不同，但这却是必要的，否则当我们使用以下代码时，编译器会优先与构造函数2相匹配。

vector<int> v(10,5)
		/*
		* 理论上将，提供了vector(size_t n, const T& value = T())之后
		* vector(int n, const T& value = T())就不需要提供了，但是对于：
		* vector<int> v(10, 5);
		* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
		* 就不会走vector(size_t n, const T& value = T())这个构造方法，
		* 最终选择的是：vector(InputIterator first, InputIterator last)
		* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
		* 但是10和5根本不是一个区间，编译时就报错了
		* 故需要增加该构造方法
		*/

因为，编译器在匹配的时候会找最合适的，字面常量会被当成int看待，与size_t类型不完全匹配，此时，编译器就会匹配到构造函数2，解引用时就会出错。

拷贝构造函数

现代写法一

拷贝构造函数的现代写法也比较简单，使用范围for（或是其他遍历方式）对容器v进行遍历，在遍历过程中将容器v中存储的数据一个个尾插过来即可。

vector(const vector<T>& v)
{
	reserve(v.capacity());

	for (const auto& e : v)
	{
		push_back(e);
	}
}

注意：在使用范围for对容器v进行遍历的过程中，变量e就是每一个要插入的数据的引用，然后将e尾插到构造出来的容器当中。就算容器v当中存储的数据是string类，在尾插时也会自动调用string的拷贝构造（深拷贝），所以也能够避免出现与使用memcpy时类似的问题。

现代写法二

vector(const vector<T>& v)
{
	vector<T> tmp(v.begin(), v.end());

	swap(tmp);
}

写法三

先开好空间，在将v迭代器中的值依次赋给要初始化对象迭代器的位置，本质上与写法一类似。

vector(const vector<T>& v)
{
		reserve(v.capacity());

		iterator it = begin();
		const_iterator vit = v.begin();//v是const对象,必须用const迭代器接收返回值
		while (vit != v.end())
		{
			*it++ = *vit++;
		}

		_finish = it;//注意改变_finish因为size改变了
	}

赋值运算符重载函数

拷贝构造函数的现代写法是通过调用构造函数构造出一个对象，然后将该对象与拷贝对象交换。

vector(const vector<T>& v)
{
	vector<T> tmp(v.begin(), v.end());

	swap(tmp);
}

析构函数

先释放容器存储数据的空间，然后将容器的各个成员变量设置为空指针即可。

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

迭代器相关函数

这里vector当中的迭代器使用的时原生指针。

typedef T* iterator;
typedef const T* const_iterator;

begin和end

string类中的begin和end函数很简单，begin函数用来返回字符串中第一个字符的地址。

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

还有一组const对象的版本，使得const对象调用begin和end函数时所得到的迭代器只能对数据进行读操作，而不能进行修改。

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

容量和大小及其相关函数

size和capacity

两个指针相减的结果，就是这两个指针之间对应类型的数据个数
在这里插入图片描述

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

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

empty 和 swap

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

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

clear 和 shrink_to_fit

void clear()
{
	_finish = _start;
}

void shrink_to_fit()
{
	size_t sz = size();

	T* tmp = new T[sz];
	
	if (_start)
	{
		for (size_t i = 0; i < sz; i++)
		{
			tmp[i] = _start[i];
		}

		delete[] _start;
	}

	_start = tmp;
	_finish = _end_of_storage = _start + sz;
}

reserve

eserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。

void reserve(size_t n)
{
	size_t sz = size();

	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)
		{
			for (size_t i = 0; i < sz; i++)
			{
				tmp[i] = _start[i];
			}

			delete[] _start;
		}

		_start = tmp;
		_finish = _start + sz;
		_end_of_storage = _start + n;
	}
}

在进行操作之前需要提前记录当前容器当中有效数据的个数，因为扩容_start发生改变，size算出来的结果就是错误的。

拷贝容器当中的数据时，不能使用memcpy函数进行拷贝，否则内部就是浅拷贝，memcpy只是把值拷贝过来。
在这里插入图片描述

当执行 delete[ ] _start的时候会把原来空间里面的值释放，因为浅拷贝，导致扩容之后的空间里面的对象里面都是随机值。

resize

resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。

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 和 pop_back

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

	*_finish = val;
	++_finish;
}

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

	--_finish;
}

insert

insert函数可以在所给迭代器pos位置插入数据，在插入数据前先判断是否需要增容，然后将pos位置及其之后的数据统一向后挪动一位，以留出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;

		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);

		pos = _start + len;
	}

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

		end--;
	}

	*pos = val;
	++_finish;

	return pos;
}

erase

erase函数可以删除所给迭代器pos位置的数据，在删除数据前需要判断容器释放为空，若为空则需做断言处理，删除数据时直接将pos位置之后的数据统一向前挪动一位，将pos位置的数据覆盖即可。

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

	while (start < _finish)
	{
		*(start - 1) = *start;
		++start;
	}

	--_finish;

	return pos;
}

全部代码实现

#include <assert.h>
#include <iostream>
#include <vector>

using namespace std;

namespace hb
{
	template <class T>
	class vector
	{
	public:
		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;
		}

		vector()
		{}

		//vector() = default;

		/*vector(const vector<T>& v)
		{
			reserve(v.capacity());

			for (const auto& e : v)
			{
				push_back(e);
			}
		}*/

		vector(const vector<T>& v)
		{
			vector<T> tmp(v.begin(), v.end());

			swap(tmp);
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);

			return *this;
		}

		vector(size_t n, const T& val)
		{
			reserve(n);

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(int n, const T& val)
		{
			reserve(n);

			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

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

				++first;
			}
		}

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

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

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

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

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

		void clear()
		{
			_finish = _start;
		}

		void shrink_to_fit()
		{
			size_t sz = size();

			T* tmp = new T[sz];
			
			if (_start)
			{
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;
			}

			_start = tmp;
			_finish = _end_of_storage = _start + sz;
		}

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

			return _start[pos];
		}

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

			return _start[pos];
		}

		void reserve(size_t n)
		{
			size_t sz = size();

			if (n > capacity())
			{
				T* tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}

					delete[] _start;
				}

				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		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++;
				}
			}
		}

		template <class InputIterator>
		void assign(InputIterator first, InputIterator last)
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
			
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		void assign(size_t n, const T& val)
		{
			reserve(n);

			T* tmp = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				tmp[i] = val;
			}
			_start = tmp;

			_finish = _end_of_storage = _start + n;
		}

		void assign(int n, const T& val)
		{
			reserve(n);

			T* tmp = new T[n];
			for (int i = 0; i < n; i++)
			{
				tmp[i] = val;
			}
			_start = tmp;

			_finish = _end_of_storage = _start + n;
		}

	/*	void assign(size_t n, const T& val)
		{
			reserve(n);

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

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}*/

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

			*_finish = val;
			++_finish;
		}

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

			--_finish;
		}

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

			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;

				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);

				pos = _start + len;
			}

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

				end--;
			}

			*pos = val;
			++_finish;

			return pos;
		}

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

			while (start < _finish)
			{
				*(start - 1) = *start;
				++start;
			}

			--_finish;

			return pos;
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}