《C++学习笔记》 ——vector深度剖析
第六章 vector类深度剖析
文章目录
- 第六章 vector类深度剖析
- 一、vector类简介
- 二、vector类常用接口
-
- 1. vector类的默认成员函数
- 2. vector类的迭代器及访问遍历操作
- 3. vector类的容量操作
- 4. vector类的修改操作
- 三、vector迭代器失效问题
- 三、STL中vector模拟实现
一、vector类简介
标准库中的vector类:
- vector是表示可变大小数组的序列容器，可以动态增长的数组。
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。
以上内容来自：www.cplusplus.com vector类文档的介绍，在STL的学习中，推荐大家看这个文档，对每个类都有详细的介绍。
既然有了 vector，为什么不能把 string 类取消掉呢？
- string类的数据结尾有 \0
- string类有find成员函数，支持比较大小
- 输入>>、输出<< 运算符重载等
综上：因为string类有着vector无法替代的特性，所以vector无法替代string。
二、vector类常用接口
1. vector类的默认成员函数
| 函数名称 | 功能说明 |
|---|---|
| vector（size_type n, const value_type& val = value_type() ） | 构造并初始化n个val |
| vector () | 构造空的vector类对象，即无参构造 |
| vector (InputIterator first, InputIterator last) | 使用迭代器进行初始化构造 |
| vector (const vector& x) | 拷贝构造 |
| operator = (const vector& x) | 赋值运算符重载 |
举例：
vector的默认成员函数//
vector<int> v1; // 无参构造
vector<int> v2(5, 100); // 构造并初始化5个大小为100的整型
vector<int> v3(v2.begin(), v2.end()); // 使用迭代器进行初始化构造
vector<int> v4(v3); // 拷贝构造
v1 = v4; //赋值重载函数
vector<int> v{ 1, 2, 3, 4 }; //使用列表方式初始化，C++11新语法
2. vector类的迭代器及访问遍历操作
| 函数名称 | 功能说明 |
|---|---|
| begin+ end | 获取第一个数据位置的 iterator/const_iterator， 获取最后一个数据的下一个位置的 iterator/const_iterator |
| rbegin + rend | 获取最后一个数据位置的 reverse_iterator，获取第一个数据前一个位置的 reverse_iterator |
| operator[ ] | 返回vector容器中位置 n 处元素的引用 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
| back | 返回顺序表中最后一个元素的引用 |
| front | 返回顺序表中第一个元素的引用 |
vector类的三种遍历方式：
//vector类的迭代器及访问遍历操作
vector<int> v{1, 2, 3, 4};
// 通过[]读写第0个位置。
v[0] = 10;
cout << v[0] << endl;
// 1. 使用for+[]小标方式遍历
for (size_t i = 0; i < v.size(); ++i)
{
cout << v[i] << " ";
}
cout << endl;
// 2. 使用迭代器遍历
vector<int>::iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
// const对象使用const迭代器进行遍历打印
vector<int>::const_iterator it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
// 3. 使用范围for遍历
for (auto x : v)
cout << x << " ";
cout << endl;
1.下标+[ ]，和at( )的用法相同，但是 [ ]越界断言报错，at 抛异常报错。
2. 迭代器
- [begin(), end()) ; end()返回的不是最后一个数据位置的迭代器，返回是最后一个位置下一个位置。
- 也要注意的是，C++中凡是给迭代器一般都是给的[ ) 左闭右开的区间,迭代器是类似指针一样东西。
- 当对象是const类型时，要使用 vector::const_iterator迭代器 保证权限不被放大。
- 迭代器意义：像string、vector这种底层是连续存放的容器支持[ ]遍历，但是list、map等链式结构的容器不支持[ ]。我们就要用迭代器遍历，所以迭代器是一种统一使用的方式。
- 迭代器的比较，都是用 == 或 != 不用< 和 >，因为底层是连续内存的容器可以用< 和 >比较，但是面对list和map等链式结构就不行了。
3.C++11 提供范围for， 特点：写起来简洁，依次取容器中的数据，自动赋值给e，自动判断结束。
3. vector类的容量操作
| 函数名称 | 功能说明 |
|---|---|
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| resize | 改变vector的size |
| reserve | 改变vector的capacity |
注意事项：
- capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。因为vs是PJ版本STL，g++是SGI版本STL。
- reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
- resize在开空间的同时还会进行初始化，影响size。
vector类的容量操作/
vector<int> v{ 1, 2, 3, 4 ,5, 6, 7};
cout << v.size() << endl; //7
cout << v.capacity() << endl; //7
cout << v.empty() << endl; //0
v.resize(5);
cout << v.size() << endl; //5
v.resize(12);
cout << v.size() << endl; //12
//如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够 就可以避免边插入边扩容导致效率低下的问题了
v.reserve(50);
cout << v.capacity() << endl;//50 提前将容量设置好，可以避免一遍插入一遍扩容
4. vector类的修改操作
| 函数名称 | 功能说明 |
|---|---|
| push_back | 尾插 |
| pop_back | 尾删 |
| find | 查找（注意这个是算法模块实现，不是vector的成员接口） |
| insert | 在position之前插入val |
| erase | 删除position位置的数据 |
| swap | 交换两个vector的数据空间 |
注意事项：
- 一般少用insert和erase，因为他们两如果是头部或者中间插入删除，效率是O(N),因为他们要挪动数据。
- vector没有提供find函数接口，而是放到STL的algorithm算法库中，不是vector的成员接口函数
- 一般不用STL的algorithm算法库中的swap，因为如果自定义类型，用算法库中的swap函数会涉及到深拷贝和赋值重载，效率低。
//vector类的修改操作
vector<int> v{1, 2};
v.push_back(3); //尾插
v.push_back(4);
auto it = v.begin();
while (it != v.end())
{
cout << *it << " "; //1 2 3 4
++it;
}
cout << endl;
v.pop_back(); //尾删
it = v.begin();
while (it != v.end())
{
cout << *it << " "; //1 2 3
++it;
}
cout << endl;
// 在指定位置前插入值为val的元素，比如：2之前插入30,如果没有则不插入
// 1. 先使用find查找3所在位置
// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
auto pos = find(v.begin(), v.end(), 2);
if (pos != v.end())
{
// 2. 在pos位置之前插入30
v.insert(pos, 30);
}
auto i = v.begin();
while (i != v.end())
{
cout << *i << " "; // 1 30 2 3
++i;
}
cout << endl;
三、vector迭代器失效问题
-
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装。
-
例如：vector的迭代器就是原生态指针T*。
-
因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃）。
1. 引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
vector<int>v{1,2,3,4,5};
auto pos = find(v.begin(), v.end(), 3);
if (pos != v.end())
{
v.insert(pos, 30); //在3前面插入30
}
for (auto e : v)
{
cout << e << " ";
}cout << endl;
上述程序会报错
-
v.insert(pos, 30)报错的主要原因是再插入数据，容量就满了要增容，把数据拷贝到新的空间，释放旧的空间。
-
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给pos重新赋值即可。
2 .指定位置元素的删除操作–erase
vector<int> v{1,2,3,4};
auto pos = find(v.begin(), v.end(), 3);
v.erase(pos);// 删除pos位置的数据，导致pos迭代器失效。
cout << *pos << endl; // 此处会导致非法访问。
- 因为删除vector中任意位置上元素时，vs就认为该位置迭代器失效了
常见错误：
删除vector中所有的偶数
vector<int> v{1, 2, 30, 3, 4 ,5 ,6};
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
v.erase(it);
++it;
}
- 因为erase(it）会⭐返回删除位置it的下一个位置，迭代器的意义变了。
- 在vs下 erase(it）后it失效，不能++。
- 2为偶数，会earse(2)的位置，并且earse会导致数据前移覆盖，然后it++后就到了3的位置，跳过了30，导致30没有被检查到。
- 当执行到最后一个偶数的时候，程序删除6同时it移动6的下一位，此时vector的end在it前面，会导致越界，直接报错。
正确写法：
vector<int> v{1, 2, 30, 3, 4 ,5 ,6};
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
it = v.erase(it);
else
++it;
}
综上：迭代器失效有两种情况
1.迭代器失效，it变成野指针(增容/缩容）
2.迭代器意义变了。
迭代器失效解决办法：在使用前，对迭代器重新赋值即可。
三、STL中vector模拟实现
在侯捷老师的《STL源码剖析》中，对vector类的描述如下图所示。
namespace MyVector
{
template<class T>
class vector
{
public:
/默认成员函数/
//构造函数
vector()
: _start(nullptr)
, _finish(nullptr)
, _end_Of_Storage(nullptr)
{}
// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器，迭代器区间[first,last)可以是任意容器的迭代器
// 类模板的成员函数，还可以再是函数模板
template<class InputIterator>
vector(InputIterator first, InputIterator last)
: _start(nullptr)
, _finish(nullptr)
, _end_Of_Storage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(size_t n, const T& value = T())//T类的匿名对象作为缺省值，T会调用自己的默认构造初始化
: _start(nullptr)
, _finish(nullptr)
, _end_Of_Storage(nullptr)
{
reserve(n);
while (n--)
{
push_back(value);
}
}
//拷贝构造函数----注意要实现深拷贝
vector(const vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _end_Of_Storage(nullptr)
{
reserve(v.capacity());//不初始化，reserve会崩溃
for (const auto& e : v)
{
push_back(e);//拷贝数值
}
}
// 现代写法，实现拷贝构造函数
vector(const vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _end_Of_Storage(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(_end_Of_Storage, v._end_Of_Storage);
}
//赋值重载函数
vector<T>& operator=(const vector<T> v)
{
swap(v);
return *this;
}
//析构函数
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_Of_Storage = nullptr;
}
}
//迭代器及访问遍历操作
// Vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
//const对象调用const迭代器，只读
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
//vector类的容量操作
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_Of_Storage - _start;
}
bool empty() const
{
return _start == _finish;
}
void resize(size_t n, const T& value = T()) //T类的匿名对象作为缺省值，T会调用自己的默认构造初始化
{
// 1.如果n小于当前的size，则数据个数缩小到n
if (n <= size())
{
_finish = _start + n;
return;
}
else
{
// 2.空间不够则增容
if (n > capacity())
reserve(n);
// 3.将size扩大到n
while (_finish < _start + n)
{
*_finish = value;
++_finish;
}
}
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
// 1. 开辟新空间
T* tmp = new T[n];
// 2. 拷贝元素
// memcpy(tmp, _start, sizeof(T)*size);
//不可以用memcpy,如果T是内置类型或浅拷贝类型，他们增容或者拷贝构造中，我们用memcpy是没有问题的(浅拷贝)
//但是T是深拷贝的自定义类型，比如string类，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，可能会引起内存泄漏甚至程序崩溃
//在vs中，string的结构跟g++不同，在T(自定义类型)对象加了一个buf[16]的数组存储数据，如果数据小于16可能不会报错，实际还是有问题。
if (_start)
{
for (size_t i = 0; i < oldSize; ++i)
{
tmp[i] = _start[i]; //这个调用T(自定义类型)::operator=,赋值重载函数本来就是深拷贝
}
// 3. 释放旧空间
delete[] _start;
}
_start = tmp;
_finish = _start + oldSize;
_end_Of_Storage = _start + n;
}
}
///vector类的修改操作//
void push_back(const T& x)
{
if (_finish == _end_Of_Storage)
{
size_t newCapacity = 0 == capacity()) ? 1 : capacity() * 2;
reserve(newCapacity);
}
*_finish = x;
++_finish;
//insert(end(), x);
}
void pop_back()
{
assert(!empty());
--_finish;
//erase(end() - 1);
}
//返回值指向新插入这个元素的位置
//有返回值的函数，不一定要定义变量来接收
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
// 空间不够先进行增容
if (_finish == _endOfStorage)
{
size_t len = pos - _start; //计算pos相对_start是第几个位置
size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
reserve(newCapacity);
// 如果发生了增容，更新pos，解决增容后pos失效的问题
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
// 方便解决:一边遍历一边删除的迭代器失效问题
iterator erase(iterator pos)
{
// 挪动数据进行删除
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;//返回删除数据的下一个位置
}
T& front()
{
return *_start;
}
const T& front()const
{
return *_start;
}
T& back()
{
return *(_finish - 1);
}
const T& back()const
{
return *(_finish - 1);
}
private:
iterator _start; // 指向数据块的开始
iterator _finish; // 指向有效数据的尾
iterator _end_Of_Storage; // 指向存储容量的尾
};
}