vector的介绍
- vector是表示可变大小数组的序列容器。
- 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。
- 本质讲,vector使用动态分配数组来存储它的元素。当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是一个相对代价高的任务。
- vector分配空间策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此,vector占用了更多的存储空间,为了获得管理存储空间的能力,并且以一种有效的方式动态增长。
- 与其它动态序列容器相比(deques, lists ), vector在访问元素的时候更加高效,在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率则较低。
vector里迭代器失效场景
1.删除pos位置的数据,导致pos迭代器失效
v.erase(pos); //此时pos位置被删除
//pos++;
cout << *pos << endl; // 此处会导致非法访问,只要是对pos操作都会导致非法访问
举例说明:
// 实现删除v中的所有偶数
// 但是程序会崩溃掉,因为如果是偶数,erase导致it失效
// 对失效的迭代器进行++it,会导致程序崩溃
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
v.erase(it);
++it;
}
// 以上程序要改成下面这样,erase会返回删除位置的下一个位置 ,erase函数是有返回值的
it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
it = v.erase(it);
else
++it;
}
2.可能会引起vector底层空间改变的操作,比如:push_back、insert、resize、reserve等
// 在pos位置插入数据,导致pos迭代器失效。
// insert会导致迭代器失效,是因为insert可能会导致增容,增容后pos还指向原来的空间,而原来的空间已经释放了。
pos = find(v.begin(), v.end(), 3);
v.insert(pos, 30);
cout << *pos << endl; // 此处也会导致非法访问
模拟实现
namespace Myvector
{
template <class T>
class vector
{
public:
typedef T* iterator; //定义迭代器指针
typedef const T* const_iterator;
vector() //无参默认构造函数
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
vector(size_t n, const T& value = T()) //带参全缺省构造函数
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
reserve(n);
while (n--)
{
push_back(value);
}
}
vector(const vector<T>& v)//拷贝构造
{
_start = new T[v.size()];//开空间
_finish = _start + v.size();
_endofstorage = _start + v._endofstorage;
memcpy(_start, v._start, v.size()*sizeof(T); //拷贝数据
}
~vector()//析构
{
delete _start;
_start = _finish = _endofstorage = nullptr;
}
vector<T>& operator=(vector<T> v) //赋值运算符重载
{
this->swap(v);
return *this;
}
iterator begin() { return _start;}
const_iterator begin() const { return _start; }
iterator end(){ return _finish; }
const_iterator end() const { return _finish; }
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
size_t size()
{
return _finish - _start;
}
size_t capacity()
{
return _endofstorage - _start;
}
//resize 与 reserve
void reserve(size_t n)//增容
{
if (n > capacity())//需要扩容 新开空间,再拷贝,再删去原来的空间,这也是vector的缺点,就是涉及的这些空间操作
{
size_t size = size();
T* tmp;
tmp = new T[n];
if (tmp)//开辟成功,拷数据
{
memcpy(tmp, _start, size*sizeof(T));
}
_start = tmp;//再改变指向
_finish = _start + size;
_endofstorage = _start + n;
}
}
void resize(size_t n,const T& value=T())//对有效元素个数操作
{
if (n <= size())//小于等于
{
_finish = _start + n;
}
else //大于原始数量
{
if (n > capacity())//且大于原始容量,需要扩容
{
reserve(n);
}
//增长的要赋值
while (_finish != _start + n)
{
*_finish = value;
_finish++;
}
}
}
//增删查改
void push_back(const T& val)
{
//if (_finish == _endofstorage) //要扩容
//{
// size_t newcapaticy = capacity() == 0 ? 1 : capacity() * 2; //可能刚开始为空,需要特判
// reserve(newcapaticy);
//}
//*_finish = value;
//_finish++;
//可以直接复用insert()
insert(end(), val);
}
void pop_back()
{
//--_finish;
//复用erase
erase(--end());//z注意最后一个位置是_finish的前一个,这和C语言顺序表里的表示是一样的
}
iterator insert(iterator pos, const T& val)//pos位置的前一个位置插入一个
{
assert(pos < _finish);//判断pos有效性
if (_finish == _endofstorage)//需要扩容
{
size_t len = pos - _start;//保留相对位置 ,扩容后原来空间不会同的,所以保存pos位置
size_t newcapacity = capacity() == 0 ? 1 : capacity() * 2;
reserve(newcapacity);
pos = _start + len;
iterator end = _finish - 1;//由于是连续空间,所以插入数据后还要保持相对位置,所以后面的元素要后移一位
while (end>=pos)
{
*(end + 1) = *end;
end--;
}
*pos = value;//插入
_finish++;//有效个数加一
return pos;
}
}
iterator erase(iterator pos)//删除当前pos位置的元素 返回值为删除位置的下一个位置。存在迭代器失效的情况,失效具体指的是无法使用或者继续使用会输出错误的结果等等
{
assert(pos < _finish);
//直接依次让后面的元素覆盖即可达到删除的效果 ,但是
iterator begin = pos + 1;
whiel(begin != _finish)
{
*(begin - 1) = *begin;
begin++;
}
_finish--;
return pos;//此时的pos是删除前pos的下一个位置
}
//元素访问,因为是连续空间,所以支持随机访问 []下标访问
T& operator[](size_t x)
{
return _start[x];
}
const T& operator[](size_t x) const
{
return _start[x];
}
private:
iterator _start; //只想数据块的开始
iterator _finish; //指向有效元素的末尾
iterator _endofstorage; //指向存储容量的尾
//对应于之前写C语言顺序表的 结构体成员 T* arr 指向数组的指针, size_t size有效元素个数, size_t capacity//总容量,只不过vector底层用了三个指针,利用指针运算来标识数量
};
}