|
目录
一、整体框架
二、构造和析构函数
1.无参构造
2.迭代器区间构造
3.拷贝构造
4.赋值
5.析构
三、大小和容量相关函数
1.大小和容量
2.reserve
3.resize
四、插入和删除
1.尾插
2.尾删
3.插入
4.删除
一、整体框架
template<class T>
class vector
{
public:
// Vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()；
iterator end()；
const_iterator cbegin() const；
const_iterator cend() const；
// construct and destroy
vector()；
vector(int n, const T& value = T())；
template<class InputIterator>
vector(InputIterator first, InputIterator last)；
vector(const vector<T>& v)；
vector<T>& operator= (vector<T> v)；
~vector()；
// capacity
size_t size() const；
size_t capacity() const；
void reserve(size_t n)；
void resize(size_t n, const T& value = T())；
///access///
T& operator[](size_t pos)；
const T& operator[](size_t pos) const；
///modify/
void push_back(const T& x)；
void pop_back()；
void swap(vector<T>& v)；
iterator insert(iterator pos, const T& x)；
iterator erase(iterator pos)；
private:
iterator _start; // 指向数据块的开始
iterator _finish; // 指向有效数据的尾
iterator _endOfStorage; // 指向存储容量的尾
};
二、构造和析构函数
1.无参构造
? ? ? ? 将三个指针置空即可。
vector()
: _start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{}
2.迭代器区间构造
? ? ? ? 复用尾插函数，遍历迭代器范围。
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{
for (InputIterator it = first; it != last; it++)
{
push_back(*it);
}
}
3.拷贝构造
? ? ? ? 利用迭代器区间构造临时的变量，与临时变量交换即可完成拷贝构造。也可以重新开空间，再进行内容的拷贝，但明显以下写法更好。
vector(const vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _endOfStorage(nullptr)
{
vector<T> temp(v.cbegin(), v.cend());
swap(temp);
}
? ? ? ? 交换函数内容如下，交换两个实例中的指针内容。
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endOfStorage, v._endOfStorage);
}
4.赋值
? ? ? ? 赋值可复用参数传递中的拷贝构造，交换内部的指针即可完成赋值。
vector<T>& operator= (vector<T> v)
{
swap(v);
return *this;
}
5.析构
? ? ? ? 释放空间，指针置空。
~vector()
{
delete[] _start;
_start = nullptr;
_finish = nullptr;
_endOfStorage = nullptr;
}
三、大小和容量相关函数
1.大小和容量
? ? ? ? 返回大小或容量，利用指针相减即可。
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endOfStorage - _start;
}
2.reserve
? ? ? ? 传入参数大于当前容量就会增容，不大于当前容量不会操作。
????????由于增容需要开辟新的空间，原来的指针指向原来的空间，因此需要提前记录指针的相对位置，保证新空间的指针正确。同时在旧的内容拷贝上不要使用memcopy浅拷贝，否则在容器存放内置类型的数据时会导致多次析构出错。
void reserve(size_t n)
{
if (n > capacity())
{
size_t size = _finish - _start;
T* temp = new T[n];
if (_start)
{
for (int i = 0; i < size; i++)
{
temp[i] = _start[i];
}
delete[] _start;
}
_start = temp;
_finish = _start + size;
_endOfStorage = _start + n;
}
}
3.resize
? ? ? ? 传入参数大于当前数据个数，对原有数据不改变，多出来的部分会初始化。如果大于当前容量，则先增容再初始化。小于当前数据个数，则会对数据进行截断。
void resize(size_t n, const T& value = T())
{
if (n > size())
{
reserve(n);
while (_finish != _start + n)
{
*_finish = value;
_finish++;
}
}
else
{
_finish = _start + n;
}
}
四、插入和删除
1.尾插
? ? ? ? 使用_finish指针操作即可，再扩容时如果容量为0，应给一个起始容量。
void push_back(const T& x)
{
if (_finish == _endOfStorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
_finish++;
}
2.尾删
? ? ? ? 需要保证不会在容器为空的情况下尾删。
void pop_back()
{
assert(_finish > _start);
_finish--;
}
3.插入
? ? ? ? 利用指针，移位数据，再将新数据插入。要考虑移位的方向会不会数据的覆盖，导致数据丢失。
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _endOfStorage)
{
size_t sz = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + sz;
}
iterator it = _finish - 1;
while (it != pos)
{
*(it + 1) = *it;
it--;
}
*pos = x;
_finish++;
return pos;
}
4.删除
? ? ? ? 同上，用指针对数据移位，覆盖删除的位置。
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos+1;
while (it != _finish)
{
*(it-1) = *it;
it++;
}
_finish--;
return pos;
}
|