目录
一、vector的基本实现机制:
二、vector的部分接口模拟实现:
1、构造与析构:
1、普通构造:
2、拷贝构造:
3、析构函数:
2、关于扩容:
1、reserve:
2、resize
3、增删查改:
1、在pos位置插入:
2、[]符号访问修改:
3、删除pos位置的值:
4、重载=运算符:
一、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;
}