vector的模拟实现
一. vector的模拟实现
我们知道:
在STL中,我们上次学了string
但其实准确来说string并不算是STL中的成员。
因为string出现的比STL要早
所以string的设计相比于STL中其他的容器要麻烦的多。
但是今天带来的vector可以说是是完完全全的STL中的容器。
这里可能还有人不知道容器是什么东西。
容器准确来说是用来处理数据的
就比如我们之前学习进程的时候,在管理文件的时候
文件:文件内容+文件属性
本质都是数据,所以我们能看到很多的链表和顺序表的成分在。
而之后我们要学习的算法
作用则是:处理数据
存储数据+处理数据可以说是组成了程序
1.0 与string的区别
为什么这里要讲string和vector的区别?
因为string和vector一样实际上就是一个顺序表
但是还是有很大的区别:
而vector通过模板的功能来实现,能存储多种类型的数据
string相当于将char类型的数据拎出来,为它拓宽了很多接口的同时,为了兼容C语言,保留了很多字符串的特殊点。
所以:
i. string只能存储char类型
ii. string保留了末尾是’\0’的成分
而vector则是全新的对象,不需要兼容C语言。
i. 所以vector能存储各种类型
ii. 同时末尾不用添加’\0’
1.1 实现内容
我们模拟实现vector的目的:
是为了更好的了解vector来帮助我们更好的使用和学习。
所以这里就挑几个比较重要的接口进行实现
做到一个比较基础的vector。
这个就是大致的实现内容。
因为这个和string的实现实在是太像了,所以就选几个比较重点的讲
其他未讲到的会后面会放在整体代码中。
实现方法
这里不同于string的capacity和data实现方法
这里vector用的是三个指针成员变量的实现方法,但是实际上没有相差多少,用string的同样可以实现。
class vector
{
public:
private:
iterator _start;
iterator _finish;
iterator _eofstorage;
};
这里的:
_start:就是开辟数组的开始指针
_finishi:就是开辟数组最后一个元素的指针
_eofstorage:数组开辟空间的空间的最后位置的地址
这个实现方法区别其实不重要,用string的实现方法依旧可以实现。
二. vector模拟中重点讲解内容(坑)
2.1 erase的使用问题
erase
这个函数的功能是:
删除指定位置的元素。
int main()
{
std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
std::vector<int>::iterator begin = v1.begin();
v1.erase(begin);
for (auto i : v1)
{
std::cout << i;
}
}
具体就是这样使用。
接下来就来演示erase的一个非常经典的错误用法。
这里用的是STL中的vector,因为官方的使用中,这个问题也是十分常见的。
#include<iostream>
#include<vector>
#include"vector.h"
int main()
{
std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
std::vector<int>::iterator begin = v1.begin();
v1.erase(begin);
while (begin != v1.end())
{
std::cout << *begin;
begin++;
}
}
这里能发现程序崩掉了。
这是我们发现
这里我们把begin迭代器指定的内容删除后
然后继续使用了begin迭代器。
但是按照我们的道理来讲
这个begin的指向的方向应该还是老方向。
erase之后,各类元素会向前面补位,begin应该指向新补位的2了。
按道理来说这个begin应该是可以继续使用的。
因为在vs中,这个问题算是迭代器失效
在使用迭代器对象进行insert与erase之后。
vs会默认该迭代器无法继续使用
我们知道STL不同编译器下是不同的,因为官方给了一个STL的最基本的设定,具体的修改和实现方法是取决于公司自己
所以在linux中,可能就不会判断这个迭代器失效的效果。
这里我们来试一下。
还是同样的代码
这里能发现在linux中能进行访问。
但是这样的话为什么vs要禁止用户使用呢?
这里就要讲下允许使用这个的坏处了。
这里我们在linux中用这个测试一道题:
删除数组中的所有偶数
这里结果我们发现少删除了一个2。
这里其实仔细观察一下我们就能发现问题所在。
这里就能发现it删除完,还会进行一次++,会略过连续的偶数。
这里掠过算是比较ok一点的错误了,但是如果想象一下最后一位是偶数,这样的话会直接掠过数组的最后一位,直接向后面遍历,非常容易导致越界访问。
这里其实要解决也是很简单。
只要在其中加一个else就可以了。
但是这样虽然能解决问题,但是大大限制了它的平台可移植性。
所以这个情况也是开发者所在意的。
这里能发现erase有一个iterator 的返回值。
这个iterator是用来返回下一个位置的值的。
所以这里需要去接受一下返回值,才能继续用这个begin变量。
2.2 resize的特殊写法
void resize(int n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
_finish++;
}
}
}
这个是resize的函数实现。
我们知道:
reserve:开辟空间,插入数据时不扩容
resize:开空间+初始化为指定值
但是resize初始化为指定值的时候,指定值有多种不同的类型。
但是有时候如果用户不输入初始化的值该怎么办?
void resize(int n, const T& val = T())
这个第二个参数,const T& val=T()
;
这个可以说是一个新写法,这个前面是类型
val=T();
是缺省值。
那这个T();
其实就是调用T类型的构造函数的的意思。
那这样我们大致就能明白是什么意思了
如果用户没有给初始化值,那就去调用vector类型T的构造函数
2.3 operator =
这里的operator和string的的一样,要注意深浅拷贝的问题。
所以同样可以用到swap深拷贝函数。
void check_capacity()
{
if (_finish == _eofstorage)
{
if (_start == NULL)
reserve(4);
else
reserve(capacity() * 2);
}
}
2.4 reserve
void reserve(int n)
{
if (n > capacity())
{
int oldsize = capacity();
T* new_vec = new T[n];
if (_start != nullptr)
{
for(int i=0;i<oldsize;i++)
{
new_vec[i]=_start[i];
}
delete _start;
}
_start = new_vec;
_finish = _start + oldsize;
_eofstorage = _start + n;
}
}
这个是完成版的reserve
void reserve(int n)
{
if (n > capacity())
{
int oldsize = capacity();
T* new_vec = new T[n];
if (_start != nullptr)
{
memcpy(new_vec, _start, oldsize*sizeof(T));
delete _start;
}
_start = new_vec;
_finish = _start + oldsize;
_eofstorage = _start + n;
}
}
这个是改版前的reserve函数
这里发现只有一个地方发生了了改变。
if (_start != nullptr)
{
memcpy(new_vec, _start, oldsize*sizeof(T));
delete _start;
}
这里乍一看好像没有什么问题。
但是我们仔细想想,如果vector的类型是一个自定义类型,具有地址成员变量。
那memcpy对new_vec与_start进行改变时,就会这个是浅拷贝,无法进行深拷贝,就会发生严重的问题
所以就改成了
for(int i=0;i<oldsize;i++)
{
new_vec[i]=_start[i];
}
这里使用赋值重载来进行深度拷贝。
就没有这样的问题了
三. 整体代码
#include<string.h>
#include<assert.h>
#include<iostream>
namespace my_vector
{
template<typename T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
,_finish(nullptr)
,_eofstorage(nullptr)
{}
vector(const vector<T>& v)
{
_eofstorage=_finish=_start=nullptr;
for(int i=0;i<v.size();i++)
{
push_back(v[i]);
}
}
vector(int n,const T& data)
{
_start=nullptr;
_finish=nullptr;
_eofstorage=nullptr;
resize(n,data);
}
template<class alliterator>
vector(alliterator first,alliterator end)
{
_finish=nullptr;
_start=nullptr;
_eofstorage=nullptr;
while(first!=end)
{
push_back(*first);
first++;
}
}
~vector()
{
delete _start;
_start = _finish =_eofstorage = nullptr;
}
void check_capacity()
{
if (_finish == _eofstorage)
{
if (_start == NULL)
reserve(4);
else
reserve(capacity() * 2);
}
}
vector<T>& operator= (const vector<T>& v)
{
if(this!=v)
{
std::swap(_start,v._start);
std::swap(_finish,v.finish);
std::swap(_eofstorage,v._eofstorage);
}
return *this;
}
void push_back(const T& data)
{
check_capacity();
insert(size(), data);
}
void reserve(int n)
{
if (n > capacity())
{
int oldsize = capacity();
T* new_vec = new T[n];
if (_start != nullptr)
{
for(int i=0;i<oldsize;i++)
{
new_vec[i]=_start[i];
}
delete _start;
}
_start = new_vec;
_finish = _start + oldsize;
_eofstorage = _start + n;
}
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
size_t size() const
{
return _finish - _start;
}
void insert(int pos,const T& data)
{
assert(pos >= 0 && pos <= size());
check_capacity();
T* end = _finish;
while (end > _start+pos)
{
*end = *(end - 1);
end--;
}
_start[pos] = data;
_finish++;
}
void erase(int pos)
{
assert(pos >=0 && pos <= size());
T* end = _start+pos;
while (end <_finish)
{
*end = *(end + 1);
end++;
}
_finish--;
}
size_t capacity() const
{
return _eofstorage - _start;
}
T& operator[](int pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](int pos) const
{
assert(pos < size());
return _start[pos];
}
void pop_back()
{
erase(_finish - _start);
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
void resize(int n,const T& val=T())
{
if (n < size())
{
_finish=_start + n;
}
else
{
reserve(n);
while(_finish!=_start+n)
{
*_finish=val;
_finish++;
}
}
}
private:
iterator _start;
iterator _finish;
iterator _eofstorage;
};
}