目录
开头
#include<iostream>
#include<assert.h>
using namespace std;
namespace Ljw
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
private:
iterator _start;//为开头的指针
iterator _finish; //为实际数量的指针
iterator _end; //为空间的指针
};
}
构造函数,初始化列表
vector()
:_start(nullptr)
,_finish(nullptr)
,_end(nullptr)
{}
析构函数
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end = nullptr;
}
}
长度
size_t size()
{
return _finish - _start;//指针减指针为数
}
空间
size_t capacity()
{
return _end - _start;//指针减指针为数
}
迭代器
const_iterator begin() const
{
return _start;
}
//迭代器
const_iterator end() const
{
return _finish;
}
//const迭代器
iterator begin()
{
return _start;
}
//迭代器
iterator end()
{
return _finish;
}
扩容
void reserve(size_t n)
{
if (n > capacity())
{
//提前保存
size_t k = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * k);
//改正string的问题
for (int i = 0; i < k; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
//_finish = tmp + size();//_start的原来空间已经释放,需要tmp,或者可以提前保存size()的大小,
//因为size()返回的是_finish-_start,_start的指向已经变了所以,size()的大小是不确定的,
// 可以提前存size()的大小,这样就解决了指向改变的问题,可以在if外面,里面也可以,因为扩容才会改变指向
_start = tmp;
_finish = _start + k;
_end = _start + n;
}
}
_finish = tmp + size();//_start的原来空间已经释放,需要tmp,或者可以提前保存size()的大小,//因为size()返回的是_finish-_start,_start的指向已经变了所以,size()的大小是不确定,// 可以提前存size()的大小,这样就解决了指向改变的问题,可以在if外面,里面也可以,因为扩容才会改变指向
尾插
void push_back(const T& v)
{
/*if (_finish==_end )
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = v;
_finish++;*/
insert(end(), v);
}
[]的模拟实现
T&operator[](size_t pos)
{
assert(pos < size());
return _start[pos];//等价于*(_start+pos)
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
insert的模拟实现
//insert的模拟实现,vector中的insert是用迭代器实现的,库里会返回pos这个位置
iterator insert(iterator pos,const T&v)
{
assert(pos <= _finish&&pos>=_start);//这是迭代器之间的比较
if (_finish == _end)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + len;
}
//扩容后pos还是指向旧空间,所以要提前保存然后再指向新的pos位置
iterator end = _finish - 1;
while (end>=pos)
{
//_start[end] = _start[end+1];是不对的,因为是end迭代器,迭代器类似于指针
*(end + 1)= *(end);
end--;
}
*_finish = v;
_finish++;
return pos;
}
erase的模拟实现
//erase的模拟实现,库里会返回删除位置的下一个位置,用的也是迭代器
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator i = pos;
while (i<_finish)
{
*i = *(i + 1);
i++;
}
_finish--;
return pos;
}
尾删
void pop_back()
{
//_finish--;
erase(end()-