成员变量
class vector
{
private:
iterator _start; // 指向数据块的开始
iterator _finish; // 指向有效数据的尾
iterator _endOfStorage; // 指向存储容量的尾
};
构造函数
无参构造
vector()
{
T* v=new T[2];
_start = _finish = v;
_endOfStorage=v+2;
}
构造前n个数
vector(int n, const T& value = T())
{
_start=_finish = new T[n];
while (n--)
{
*_finish = value;
_finish++;
}
_endOfStorage = _finish;
}
迭代器区间构造
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
_start = _finish = new T[last-first];
while (first != last)
{
*_finish = *first;
_finish++;
first++;
}
_endOfStorage = _finish;
}
拷贝构造
vector(const vector<T>& v)
{
_finish=_start = new T[v.capacity()];
// memcpy(begin(), v.begin(), v.size()); 浅拷贝(错误写法)
for (auto e : v)
{
*_finish = T(e);
_finish++;
}
_endOfStorage = _start + v.capacity();
}
析构函数
~vector()
{
delete[] _start;
_start = _finish = _endOfStorage = nullptr;
}
迭代器
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()const
{
return _start;
}
iterator end()const
{
return _finish;
}
const_iterator cbegin()const
{
//const iterater
return _start;
}
const_iterator cend() const
{
return _finish;
}
运算符重载
赋值重载
void clean()
{
_finish = _start;
}
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)
{
clean();
swap(v);
return *this;
}
下标方括号**[]**重载
T& operator[](size_t pos)
{
return _start[pos];
}
const T& operator[](size_t pos)const
{
return _start[pos];
}
容量相关操作
reserve
注意区分深浅拷贝
void reserve(size_t n)
{
if (n > capacity())
{
int old_size = size();
T* tmp = new T[2 * capacity()];
T* cur = tmp;
// memcpy(tmp, _start, size() ); 浅拷贝(错误写法)
for (auto e : *this)
{
*tmp = e; //深拷贝
tmp++;
}
delete[] _start;
_start =cur;
tmp = nullptr;
_finish = _start + old_size;
_endOfStorage = _start+ 2 * capacity();
}
}
risize
void resize(size_t n, const T& value = T())
{
if (n < size())
{
_finish = _start + n;
}
if (n >= size())
{
reserve(n);
size_t count = n - size();
while (count--)
{
*_finish = value;
_finish++;
}
}
}
size()
size_t size() const
{
return _finish-_start;
}
capacity()
size_t capacity() const
{
return _endOfStorage - _start;
}
尾插尾删函数
void push_back(const T& x)
{
reserve(size() + 1);
*(_finish) = x;
_finish++;
}
void pop_back()
{
_finish--;
}
insert在指定位置插入函数
注意如果扩容要更新pos的值
iterator insert(iterator pos, const T& x)
{
if(_finish==_endOfStorage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
pos = _start + len;//更新pos
}
//把从pos位置开始,往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
*pos = x;//挪动之后再把x放到pos位置
++_finish;
return pos;
}