目录
vector的介绍和使用
vector的介绍
1)vector是可变数组大小的序列容器
2)与数组相比,vector提供了更多的功能
3)vector会分配一些额外的空间以适应可能得增长
vector的使用
构造函数
构造函数 | 说明 |
vector() | 无参构造 |
vector(size_type n, const value_type& val = value_type ()) | 构造并初始化n个val |
vector(const vector& x); | 拷贝构造 |
vector(InputIterator first, InputIterator last); | 使用迭代器进行初始化构造 |
代码演示:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v1; //无参构造
vector<int> v2(3, 9); //构造并初始化n个val(9 9 9)
vector<int>::iterator it2 = v2.begin();
while (it2 != v2.end())
{
cout << *it2 << " ";
++it2;
}
cout << endl;
vector<int> v3 = v2; //拷贝构造(9 9 9)
vector<int>::iterator it3 = v3.begin();
while (it3 != v3.end())
{
cout << *it3 << " ";
++it3;
}
cout << endl;
vector<int> v4(v3.begin(), v3.end()); //迭代器区间构造(9 9 9)
vector<int>::iterator it4 = v4.begin();
while (it4 != v4.end())
{
cout << *it4 << " ";
++it4;
}
cout << endl;
return 0;
}
迭代器
函数 | 说明 |
begin() | 获取第一个元素的迭代器 |
end() | 获取最后一个元素的下一个位置的迭代器 |
rbegin() | 获取最后一个元素的迭代器 |
rend() | 获取第一个元素前一个位置的迭代器 |
代码演示:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int arr[] = { 1,2,3,4,5 };
vector<int> v(arr, arr + 5); //5 4 3 2 1
vector<int>::reverse_iterator rit = v.rbegin();
while (rit != v.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
return 0;
}
空间增长问题
函数 | 说明 |
size() | 获取数据个数 |
empty() | 判断是否为空 |
capacity() | 获取容量大小 |
resize() | 改变vector的size |
reserve() | 改变vector的capacity |
1)在vs下,capacity是按1.5倍增长,g++下是按2倍增长
2)reserve只负责开辟空间,如果知道开多大的空间,reserve还可以减少扩容的代价
3)resize在开辟空间的同时还会进行初始化,影响size
测试vector在VS2019下的默认扩容机制:
#include <iostream>
#include <vector>
using namespace std;
void TestVectorExpand()
{
size_t sz;
vector<int> v;
sz = v.capacity();
for (int i = 0; i < 100; i++)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed:" << sz << endl;
}
}
}
int main()
{
TestVectorExpand();
return 0;
}
reserve的使用:
#include <iostream>
#include <vector>
using namespace std;
void TestVectorExpand()
{
size_t sz;
vector<int> v;
sz = v.capacity();
v.reserve(100);
for (int i = 0; i < 100; i++)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed:" << sz << endl;
}
}
}
int main()
{
TestVectorExpand();
return 0;
}
如果已知大概需要的空间,可以提前开好,避免频繁扩容导致效率低。
vector的增删查改等
函数 | 说明 |
push_back | 尾插 |
pop_back | 尾删 |
find | 查找(这个是算法模块实现的,并非vector的成员函数) |
insert | 在指定位置前插入 |
erase | 删除指定位置的数据 |
swap | 交换两个vector的数据空间 |
operator[ ] | 像数组一样访问 |
以上这些函数的使用相对比较简单,这里就不赘述了,直接进入重点vector的迭代器失效问题。
vector的迭代器失效问题
vector迭代器的底层其实就是个原生指针T*,之所以会导致迭代器失效,是因为vector的底层空间发生了改变,导致T*为野指针。总结起来就是一句话:任何引起vector底层改变的操作都可能会导致vector迭代器失效。比如:insert、erase、resize、reverse等。
以erase为例:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v{ 1,2,3,4 };
//找到指定删除的位置
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//删除指定位置的值
v.erase(pos);
cout << *pos << endl;
return 0;
}
删除pos位置的元素后,pos位置之后的元素会往前挪动,没有导致底层空间的变化,理论上讲迭代器应该是还没失效的。但是,我们可以想象如果删除的pos是最后一个元素,那么pos刚好是end的位置,然而end是没有存放有效数据的,这时pos就失效了。因此,删除任意位置的元素,VS都认为该位置的迭代器失效了。
迭代器失效的解决方法:在使用前,对迭代器重新赋值即可。
示例:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v{ 1,2,3,4 };
//找到指定删除的位置
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
//删除指定位置的值
pos = v.erase(pos);
cout << *pos << endl;
return 0;
}
vector的模拟实现
vector的基本框架:
namespace pcz
{
template <class T>
class vector
{
typedef T* iterator;//vector的迭代器为原生指针
typedef const T* const_iterator;//const修饰的是T指向的内容
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
//……
protected:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
}
end_of_storage是啥?
end_of_storage是指向vector容器当前分配的内存空间的末尾的指针或迭代器,是容量的边界。
insert
在指定位置进行插入,挪动数据必不可少。
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
assert(pos >= _start);
if (_finish == _end_of_storage)
{
size_t old_len = pos - _start;//扩容导致迭代器失效,需要计算偏移量
size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(new_capacity);
pos = _start + old_len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = x;
++_finish;
return pos;
}
reserve
负责开辟空间。
void reserve(size_t n)
{
if (n > capacity())
{
size_t old_size = size();//记录size,看看size的计算方法就明白了
T* tmp = new T[n];
if (_start)
{
//直接用memcpy会有问题,浅拷贝
//memcpy(tmp, _start, sizeof(T) * size());
//_start = tmp;
for (int i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
push_back
复用insert。
iterator push_back(const T& x)
{
return insert(end(), x);
}
push_front
复用insert。
iterator push_front(const T& x)
{
return insert(begin(), x);
}
resize
再谈resize的作用:
1)resize用于调整vector的大小,它可以增加或减少vector中元素的数量,以达到指定的新大小。
2)如果vector的新大小大于当前大小,则会在末尾添加足够数量的新元素。、
3)如果vector的新大小小于当前大小,则vector中超出新大小的部分会被丢弃,vector的大小变为指定的新大小。
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
return;
}
if(n > capacity())
reserve(n);
iterator it = _finish;
_finish = _start + n;
while (it != _finish)
{
*it = val;
++it;
}
}
erase
删除指定位置的元素,伴随着数据挪动。
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
pop_back
iterator pop_back()
{
return erase(_finish - 1);
}
pop_front
iterator pop_front()
{
return erase(_start);
}
代码
template <class T>
class vector
{
public:
typedef T* iterator;//vector的迭代器为原生指针
typedef const T* const_iterator;//const修饰的是T指向的内容
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
iterator begin()
{
return _start;
}
const_iterator cbegin() const
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator cend() const
{
return _finish;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t old_size = size();//记录size,看看size的计算方法就明白了
T* tmp = new T[n];
if (_start)
{
//直接用memcpy会有问题,浅拷贝
//memcpy(tmp, _start, sizeof(T) * size());
//_start = tmp;
for (int i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
return;
}
if(n > capacity())
reserve(n);
iterator it = _finish;
_finish = _start + n;
while (it != _finish)
{
*it = val;
++it;
}
}
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
assert(pos >= _start);
if (_finish == _end_of_storage)
{
size_t old_len = pos - _start;//扩容导致迭代器失效,需要计算偏移量
size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(new_capacity);
pos = _start + old_len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = x;
++_finish;
return pos;
}
iterator push_back(const T& x)
{
return insert(end(), x);
}
iterator push_front(const T& x)
{
return insert(begin(), x);
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
iterator pop_back()
{
return erase(_finish - 1);
}
iterator pop_front()
{
return erase(_start);
}
bool empty() const
{
return _start == nullptr;
}
protected:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};
完~