引言：
什么是vector？
vector是一个封装了动态数组的顺序容器，与其他类型容器一样，能够存放各种类型的对象，可以简单的认为，vector是一个能够存放任意类型的动态数组，但与顺序表不同的是vector的成员遍历是三个迭代器，也可以说是三个指针。
template<class T>
class vector
{
public:
typedef T* iterator;
//...
private:
iterator _start=nullptr;
iterator _finish=nullptr;
iterator _end_of_storage=nullptr;
};
其中_start指向起始位置，_finish指向有效数据末尾的后一个位置， _end_of_storag指向容量大小末尾的后一个位置。
一、成员函数
1.1构造函数
1.1.1无参构造
只需将三个成员变量置为空指针即可
//无参构造
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
}1.1.2使用迭代器区间构造
当我们想要以某个对象的区间来进行初始化时，需要用到模板
//迭代器区间构造
//类模板的成员函数，可以继续是函数模板
template<class Inputiterator>
vector(Inputiterator first, Inputiterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}1.1.3构造并初始化n个val
vector也支持容器中含有n个值为val的数据，注意在尾插之前要先进行扩容
//n个val构造
vector(size_t n, const T& val=T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}注：在设计带参构造函数时需要使用匿名对象作为缺省值（ const T& val=T() ），因为T类型不确定，在设置缺省值时只能使用匿名对象的方式。
这里其实还要将n重载为int类型
//n个val构造
vector(int n, const T& val=T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}这是为了防止传两个int型参数时被编译器交给1.1.2中的模板 Inputiterato识别，会报错，因为其中的*first只能对指针和迭代器解引用，而不能对数据解引用。
1.2拷贝构造
开辟一个新空间，在进行一个个拷贝即可
//拷贝构造
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
//一个个进行深拷贝
for (size_t i = 0; i < v.size(); ++i)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
这里要注意的是：对于自定义类型，不能用memcpy进行拷贝，因为它进行的是浅拷贝，如果模板T是string,vector等自定义类型，则程序结束回收时就会引发内存错误。而对于内置类型则可以用memcpy。
这里还有一种写法更简洁：
//拷贝构造
vector(const vector<T>& v)
{
//预留空间
reserve(v.size());
//深拷贝 遍历尾插
for (auto& e : v)
{
push_back(e);
}
}1.3运算符赋值重载
传统写法：开辟一个新空间然后将容器中的数据一个个拷贝过去
//赋值重载
//传统写法
vector <T>& operator=(const vector<T>& v)
{
if (this != &v)
{
//将this清理干净
clear();
reserve(v.size());
for (auto& e : v)
{
push_back(e);
}
}
return *this;
}现代写法：
注意：这里在传参时并没有引用传参，因为这样可以间接调用vector的拷贝构造函数，然后将拷贝构造出来的容器v与this进行交换，即可完成赋值操作，而容器v会在函数调用结束时自动析构进行释放。
//赋值重载现代写法
//v1=v3
//这里不能用&，这样v3就变成v1了，而我们的目的是让v1=v3
vector <T>& operator=( vector<T> v)//传值传参
{
swap(v);
return *this;
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}1.4析构函数
清理资源即可
~vector()
{
delete[]_start;
_start = _finish = _end_of_storage;
}二、元素访问
2.1迭代器
我们访问vector中的元素时，可以用迭代器的形式去遍历
typedef T* iterator;
typedef const T* const_iterator;非const
//迭代器
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}const
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}2.2operator[ ]
对于vector中的元素的访问最常用的是下标+[ ]
//访问第i位 数据
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
三、容量
3.1size
size是有效元素的个数，只需_finish-_start即可
size_t size()const
{
return _finish - _start;
}
3.2capacity
capacity是空间大小，只需_end_of_storage - _start即可
size_t capacity()const
{
return _end_of_storage - _start;
}3.3reserve扩容
这里我们采用的逻辑是：若n>capacity,则扩容到n，若n<capacity则不变化
有一个注意的点是：先将size()记录下来， 方便后面操作 ，因为size()是finish-start，要防止异地扩容原数组释放之后找不到_start指针，进而找不到原数组的大小
//扩容
void reserve(size_t n)
{
if (n > capacity())
{
//先将size()赋值给一个变量 方便后面操作 因为size()是finish-start
//_start后面是要变得
size_t old_size = size();
T* tmp = new T[n];
//写反了就完蛋
memcpy(tmp, _start, size() * sizeof(T));
delete[]_start;
_start = tmp;
_finish = tmp + old_size;
_end_of_storage = tmp + n;
}
}3.4resize
这里分成三个逻辑：
1.当n<size时，resize要删除字符到指定大小
2.当size<n<capacity，resize会补充有效字符（默认为0）到指定大小
3.当n>capacity，resize会补充有效字符（默认为0）到指定大小
void resize(size_t n, const T& x = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish < _start + n)
{
*_finish = x;
++_finish;
}
}
}四、修改器
4.1尾插push_back
这里要注意会涉及到扩容的问题
//尾插
void push_back(const T&x)
{
//如果满了
if (_finish == _end_of_storage)
{
reserve(capacity()==0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}4.2尾删pop_back
要注意进行判空操作
bool empty()
{
return _start == _finish;
}
//尾删
void pop_back()
{
assert(!empty());
--_finish;
}
4.3insert
我们要从pos位置，先去挪动pos后面的数据，从后往前挪，避免数据覆盖，挪完之后再在pos位置插入数据即可，同时我们也需要插入数据之后的扩容问题
//在pos位置插入
iterator insert(iterator pos, const T& x)
{
//扩容
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
iterator end = _finish - 1;
while (end >= pos)
{
//把pos之后的数据一个个往后挪
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}注：这里存在迭代器失效的问题
1.若存在扩容，扩容完之后，当前对象的_start已经指向了新的空间，而pos还指向原来的已经释放了的空间，这时候pos就有点类似野指针的问题，造成pos迭代器失效。
这种情况的解决方法可以记录pos的相对位置，以便在新空间中还能找到正确的pos位置
2.不存在扩容，但是由于数据从后往前依次挪动而pos指向的位置不变，所以pos这个迭代器也已经失效，位置意义已经改变。
所以迭代器insert之后就不要直接访问，如果要访问就要更新这个失效的迭代器的值
//在pos位置插入
iterator insert(iterator pos, const T& x)
{
//扩容
if (_finish == _end_of_storage)
{
//需要记录pos的相对位置，避免迭代器失效的问题
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
//把pos之后的数据一个个往后挪
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
4.4erase
这里挪动数据需要一个个往前挪，防止覆盖
iterator erase(iterator pos)
{
assert(pos<_finish && pos>_start);
iterator it = pos + 1;//记录pos下一个元素的位置
//从后往前挪
while (it != v.end())
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}注：erase删除pos位置元素后，pos位置之后的元素会往前挪，没有导致底层空间的改变，理论上迭代器不会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上的元素时，vs就认为该位置迭代器失效了。
测试：
以上就是我对vector模拟实现的理解！
扫一扫
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
