【C++】vector的简单模拟实现

最新推荐文章于 2024-11-15 16:06:58 发布

我言秋日胜春朝★

最新推荐文章于 2024-11-15 16:06:58 发布

阅读量1.3k

点赞数 25

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2303_80828380/article/details/141302253

版权

C++ 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、vector的基本实现机制：

如上所示，其主要由三个成员变量：start，finish，endofstoratge，这三个组成，分别是指向头，有效数据的尾，总容量的尾，

start和finish之间的数据就是size，

start和endofstorage之间的是capacity。

所以，可以用两个函数来直接找到size与capacity，最好也用const修饰，这样的话就不会有权限放大的问题的。

底层其实就是顺序表，也可以理解为数组。

在模拟实现中，要尽量保持和数据库一样的，所以部分使用迭代器的方法来实现，在自己模拟实现的时候推荐在自己定义的命名空间里面进行，这样的话，可以和标准库里面的分开。

在实现迭代器的时候，要实现两个版本的迭代器，一个是正常版本，另外一个是const版本，这样的话就不会有权限放大的问题了。

namespace ppr
{
	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;
		}

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

        size_t capacity() const
        {
	        return _endofstorage - _start;
        }
	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};

二、vector的部分接口模拟实现：

1、构造与析构：

1、普通构造：

在构造的时候初始化即可：

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

2、拷贝构造：

思路：

通过capacity（）的大小来开辟一个新空间

然后将目标所指向的空间拷贝过去，拷贝目标size的大小，

最后将finish和endofstorage修改为目标大小

vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	_start = new T[v.capacity()];
	memcpy(_start, v._start.sizeof(T) * v.size());
	_finish = _start + v.size();
	_endofstorage = _start + v.capacity();
}

3、析构函数：

思路：

首先检查_start指向的空间是否为空，如果不是空就可以析构，

析构的话，直接delete[] _start即可，

最后将那三者都置为空

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

2、关于扩容：

1、reserve：

思路：

是采用深拷贝来进行扩容的，所以就要新指针来指向新空间。

首先，根据传过来的n来决定要开辟多少大小的空间就new多大的空间，给一个指针指向。

然后将原来的空间拷贝size过去，释放原来的空间。

最后将原来的start指向新空间，finish和endofstorage搞为新的大小。

注意：

必须在最开始之前将原来的size存好，不然在后面计算finish会出问题。

void reserve(size_t n)
{
	size_t sz = size();
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start != nullptr)
		{
			memcpy(tmp, _start, sizeof(T) * sz);
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + sz;
		_endofstorage = _start + n;
	}
}

2、resize

思路：

首先了解两点：
1、n小于当前的大小，那么则保留前n个元素，去除超过的部分。

2、n大于当前的大小，那么在结尾插入适合数量的元素使得整个容器大小达到n。如果给出val，插入的新元素全为val，否则，执行默认构造函数。

那么就可有：

首先进行判断：如果n小于此时的size（），那么直接调整finish即可，

否则，用reserve进行扩容，在用while循环进行赋值。

注意：

这里给val的缺省参数不能够是0，因为我不知道这个val是什么类型，（如果是0就不能够初始化string，vector等等）所以要用T（），这样就会调用它的默认构造，如果是内置类型，那么在有模版后就会对内置类型进行升级，支持内置类型有这种构造。

void resize(size_t n,const T& val = T())
{
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		reserve(n);

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

3、增删查改：

1、在pos位置插入：

思路：

首先断言检查：pos位置必须在start和finish中间，

接着写扩容逻辑，然后通过while循环来挪动pos位置之后的数据，

最后将pos位置修改为所插入的数据，修改finish即可。

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

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

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

		pos = _start + len;
	}

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

	*pos = x;
	_finish++; 

	return pos;
}

2、[]符号访问修改：

断言要保证pos不能大于size，直接返回pos所在的位置即可。

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

	return _start[pos];
}

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

	return _start[pos];
}

3、删除pos位置的值：

思路：

首先断言，要保证在_start和在_finish之间，接着定义一个pos+1位置的迭代器，将后面的都向前挪动一个位置，最后改变finish即可完成。

为了和库里面保持一致和平台的可移植性，我们需要给一个返回值，返回删除位置的下一个位置（就是pos的位置）。

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

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

4、重载=运算符：

思路：
先通过形参的拷贝，接着交换this和v的空间，最后返回this即可。

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

vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}