vector
1、vector容器介绍
- vector是表示可变大小数组的序列容器。
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好
vector的存在形式
2、整体框架
namespace bit
{
template<class T>
//模板
class vector
{
public:
//模板类型（任意类型）
typedef T* iterator;//迭代器
typedef T* const_iterator;//
private:
iterator _start;//起始地址处
iterator _finish;//大小地址处
iterator _endofstorage;//容量地址处
}
}
3、begin 和 end
数据的起始地址和终止地址
//常迭代器记得加const 变成常函数
const_iterator begin() const
{
return _start;//返回起始地址
}
const_iterator end() const
{
return _finish;//返回终止地址
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
4、size 和 capacity
size()：返回_finish - _start 就等于整个数据个数
capacity()：返回 _endofstorage - _start 就等于整个容量大小
size_t size() const //不修改其值，最好写成只读形式（const)
{
return _finish - _start;//数据个数
}
size_t capacity() const
{
return _endofstorage - _start;//容量大小
}
5、[ ] 重载
【】 的重载先检查 i 的返回超过了数据大小没有，在返回_start[ i ]即可，跟数组的访问一样。vector可以看成数组，但不要忘记它是容器。
//返回引用，减少一次临时拷贝
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
//加const只读
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}
6、reserve 容量大小
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();//获取数据个数
T* tmp = new T[n];//开辟新的空间存放数据
memcpy(tmp, _start, sizeof(T) * sz);//拷贝过去
_start = tmp;//起始地址，finish、endofstorage也要跟着改变
_finish = _start + sz;
_endofstorage = _start + n;
}
}
7、resize 重新定义大小
两种情况：
1、将数据个数变少，直接修改 _finish 即可
2、数据个数变多，先检查容量是否足够，不够需要先扩容，在将匿名对象的值拷贝给 _finish 到 _endofstorage 这段空间进行填充
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;//小于size就直接修改finish
}
else
{
if (n > capacity())
{
reserve(n);//大于capacity就扩容
}
while (_finish < _start + n)
{
*_finish = val;//finish后就填构造值val
_finish++;
}
}
}
8、push_back 尾插
1、先判断容量是否已满，满则扩容，在赋值，finish++
2、可以复用insert
void push_back(const T& x)
{
//相等就扩容
/*if (_finish == _endofstorage)
{
size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newCapacity);
}
*_finish = x;
_finish++;*/
insert(end(), x);
}
9、pop_back 尾删
//尾删
void pop_back()
{
/*assert(!empty());
--_finish;*/
erase(--end());//最后一个元素
}
10、insert 插入
注意：pos的问题，这里 pos指向之前的位置，重新扩容导致失效，野指针，所以需要重新指定，可以算出len的长度，在+回去 就可解决迭代器失效问题。
//返回插入数据的下一位置
iterator insert(iterator pos, const T& x)
{
//检查是否越界，可以 = _finish 可能属于尾插
assert(pos >= _start && pos <= _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;//pos是指向之前的位置
size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newCapacity);//这里pos还是指向原来的位置，导致迭代器失效
pos = _start + len;//pos指向之前的位置，重新开辟了空间，pos已经失效，野指针，需要重新指定
}
iterator end = _finish - 1;//最后一个元素的位置
while (end >= pos)
{
*(end + 1) = *end;//往后挪数据
--end;
}
*pos = x;
++_finish;
return pos;
}
11、erase 删除
iterator erase(iterator pos)
{
//检查是否越界，_finish不可以等于，这里是删除，不是插入。
assert(pos >= _start && pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;//往前挪数据
++it;
}
--_finish;
return pos;
}
迭代器失效问题
insert
vector<int> v;
v.reserve(8);
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
vector<int>::iterator it = find(v.begin(), v.end(), 3);
if (it != v.end())
{
it = v.insert(it, 20);
}
// 在insert以后pos就失效了 -- insert时增容导致的
cout << *it << endl;
*it = 100;
要想使迭代器不失效，要用迭代器接回插入后的位置
erase
vector<int> v;
v.reserve(8);
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
vector<int>::iterator it = find(v.begin(), v.end(), 2);
if (it != v.end())
{
v.erase(it);//erase导致it失效，it不是野指针，只是意义变了，
}
// 在erase以后pos就失效了
cout << *it << endl;
*it = 100;
删除所有的偶数
刚好跳过 it != v.end()的位置，所有会报错，奇数个数虽然理论上不会报错，但是由于vs机制的强行检查，依然会报错
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
vector<int>::iterator it = v.begin();
while (it != v.end())
{
//删除偶数
if (*it % 2 == 0)
{
v.erase(it);
}
++it;
}
12、构造函数
推荐现代写法
无参构造
vector()
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)//初始化列表
{}
有参构造
//1、传统写法
//vector<T>& operator=(const vector<T>& v)
//{
// //不相等时
// if (this != &v)
// {
// delete[] _start;
// _start = _finish = _endofstorage = nullptr;
// //还是预先开好空间
// reserve(v.capacity());
// for (const auto& e : v)
// {
// push_back(e);
// }
// }
// return *this;
//}
//2、现代写法 直接进行交换，返回即可
vector<T>& operator=(const vector<T>& v)
{
swap(v);
return *this;
}
拷贝构造
防止浅拷贝带来的问题
1、推荐现代写法
//1、传统写法，自己开辟空间
//v2(v1)
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
memcpy(_start, v._start, sizeof(T) * v.size());//将v的内容拷贝过去
_finish = _start + v.size();//终止地址和容量地址都要修改
_endofstorage = _satrt + v.capacity();
}
//直接开辟空间，利用push_back插入进去
//vector(const vector<T>& v)
// :_start(nullptr)
// , _finish(nullptr)
// , _endofstorage(nullptr)
//{
// //有可能插入的数据量过大，预先开辟好空间
/*reserve(v.capacity());
for (const auto& e : v)
{
push_back(e);
}*/
//}
//类模板的成员函数，还可以再定义模板参数
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
//2、现代写法
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
vector<T> tmp(v.begin(), v.end());//传的迭代器区间，这里还要写一个模板参数
swap(tmp);
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
浅拷贝：对同一块空间释放两次
地址不一样，拷贝成功
析构
释放空间
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
更新不易，记得三连
1627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
