文章目录
- 1.vector的介绍及使用
- 1.1 vector基本概念
- 1.2 vector的使用
- 1.2.1 vector的定义 (构造函数)
- 1.2.2 vector的迭代器使用
- 1.2.3 vector 增删查改
- 1.2.4 vector 迭代器失效问题（重点）
- 1.2.5 vector 空间增长问题
- 2. vector的模拟实现
- 2.1 SGI版vector实现示意图
- 2.2 具体实现代码
1.vector的介绍及使用
vector的文档介绍（包含函数接口使用）
1.1 vector基本概念
vector是表示可变大小数组的序列容器
就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素
进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自
动处理
功能：
- vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别：
- 不同之处在于数组是静态空间，而vector可以动态扩展
1.2 vector的使用
vector学习时一定要学会查看文档：>vector的文档介绍<
vector在实际中非常的重要，在实际中我们熟悉常
见的接口就可以，下面列出了哪些接口是要重点掌握的。
1.2.1 vector的定义 (构造函数)
| (constructor)构造函数声明 | 接口说明 |
|---|---|
| vector()（重点） | 无参构造 |
| vector（size_type n, const value_type& val = value_type()） | 构造并初始化n个val |
| vector (const vector& x); （重点） | 拷贝构造 |
| vector (InputIterator first, InputIterator last); | 使用迭代器进行初始化构造 |
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main() {
vector<int> v1; //无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector<int> v2(v1.begin(), v1.end());//使用迭代器进行初始化构造
printVector(v2);
vector<int> v3(10, 100); //构造并初始化10个100
printVector(v3);
vector<int> v4(v3);//拷贝构造
printVector(v4);
return 0;
}
小提醒：vector的多种构造方式比较多，灵活运用即可
1.2.2 vector的迭代器使用
在上面的构造函数中，我们可以看到其中有一个接口是用迭代器构造的，这里有一个新的概念，什么是迭代器？
简单来讲，迭代器和 C++ 的 指针 非常类似，它可以是需要的任意类型，通过迭代器可以指向容器中的某个元素，如果需要，还可以对该元素进行读/写操作。
注意：迭代器的行为像指针，也就是说可以像用指针一样使用迭代器，但它不一定是指针（比如list的迭代器），具体是什么，后续学习其他容器模拟实现即可理解！！！
| iterator的使用 | 接口说明 |
|---|---|
| begin + end（重点） | 获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置 的iterator/const_iterator |
| rbegin + rend | 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v(10, 1);//构造10个1
std::vector<int>::iterator it = v.begin();//获取v的开始的迭代器，类型是std::vector<int>::iterator
//auto it1 = v.begin();//类型太长，可以使用auto
std::vector<int>::iterator end = v.end();//获取v的结尾的迭代器
while (it != end)
{
cout << *it << " "; //*解引用之后，就可以拿到数据，跟指针*p的操作一样
++it;//让迭代器往后移一位，跟指针的++p类似
}
cout << endl;
return 0;
}
小提醒：迭代器在STL中非常好用，它屏蔽了底层的细节，保证了用户使用的一致性，而且在后续学习更多容器的时候，迭代器的用法几乎一样
1.2.3 vector 增删查改
| vector增删查改 | 接口说明 |
|---|---|
push_back（重点） | 尾插 |
pop_back （重点） | 尾删 |
| find | 查找。（注意这个是算法模块实现，不是vector的成员接口） |
| insert | 在position之前插入val |
| erase | 删除position位置的数据 |
| swap() | 交换两个vector的数据空间 |
operator[] （重点） | 像数组一样访问 |
| clear(); | 删除容器中所有元素 |
插入和删除示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
//插入和删除
vector<int> v1;
//尾插
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
printVector(v1);
//尾删
v1.pop_back();
printVector(v1);
//插入
v1.insert(v1.begin(), 100);
printVector(v1);
v1.insert(v1.begin(), 2, 1000);
printVector(v1);
//删除
v1.erase(v1.begin());
printVector(v1);
//清空
v1.erase(v1.begin(), v1.end());
v1.clear();
printVector(v1);
return 0;
}
总结：
- 尾插 — push_back
- 尾删 — pop_back
- 插入 — insert (位置迭代器)
- 删除 — erase （位置迭代器）
- 清空 — clear
数据存取示例：
#include <vector>
int main()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";
}
cout << endl;
cout << "v1的第一个元素为： " << v1.front() << endl;
cout << "v1的最后一个元素为： " << v1.back() << endl;
return 0;
}
总结：
- 除了用迭代器获取vector容器中元素，[ ]和at也可以
- front返回容器第一个元素
- back返回容器最后一个元素
赋值重载示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int> v1; //无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector<int>v2;
v2 = v1;//赋值重载
printVector(v2);
vector<int>v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);
vector<int>v4;
v4.assign(10, 100);
printVector(v4);
return 0;
}
总结： vector赋值方式比较简单，使用operator=或者assign都可以
1.2.4 vector 迭代器失效问题（重点）
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了
封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的
空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，
程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
-
会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、
push_back等。 -
指定位置元素的删除操作--erase
迭代器失效解决办法：在使用前，对迭代器重新赋值即可
示例1
下面的程序运行会崩溃，原因就是因为底层空间发生改变导致迭代器失效
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{ 1, 2, 3, 4, 5, 6 };
auto it = v.begin();
// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间，可能会引起扩容，而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值，可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
*/
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
示例2
#include <iostream>
using namespace std;
#include <vector>
int main()
{
int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据，导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;
}
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代
器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是
没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。
erase删除任意位置代码后，linux下迭代器并没有失效
因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的 ,但是如果是删除最后一个元素Linux下也同样会失效
迭代器失效解决办法：在使用前，对迭代器重新赋值即可
1.2.5 vector 空间增长问题
| 容量空间 | 接口说明 |
|---|---|
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| resize（重点） | 改变vector的size |
| reserve （重点） | 改变vector的capacity |
-
capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。
这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义
的。vs是PJ版本STL，g++是SGI版本STL。 -
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
题。 -
resize在开空间的同时还会进行初始化，影响size
// 测试vector的默认扩容机制
void TestVectorExpand()
{
size_t sz;
vector<int> v;
sz = v.capacity();
cout << "making v grow:\n";
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 3
capacity changed : 4
capacity changed : 6
capacity changed : 9
capacity changed : 13
capacity changed : 19
capacity changed : 28
capacity changed : 42
capacity changed : 63
capacity changed : 94
capacity changed : 141
g++运行结果：linux下使用的STL基本是按照2倍方式扩容
making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 4
capacity changed : 8
capacity changed : 16
capacity changed : 32
capacity changed : 64
capacity changed : 128
// 如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够
// 就可以避免边插入边扩容导致效率低下的问题了
void TestVectorExpandOP()
{
vector<int> v;
size_t sz = v.capacity();
v.reserve(100); // 提前将容量设置好，可以避免一遍插入一遍扩容
cout << "making bar grow:\n";
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
总结：
-
判断是否为空 — empty
-
返回元素个数 — size
-
返回容器容量 — capacity
-
重新指定大小 — resize（减少vector在动态扩展容量时的扩展次数）
动态扩展：
- 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
2. vector的模拟实现
2.1 SGI版vector实现示意图
vector的实现版本也有不少，我们这次实现的对象是相对来说比较简单的SGI 版的vector
SGI版实现vector的示意图
2.2 具体实现代码
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
//为了和标准库里的vector不冲突，建议用命名空间封装起来
namespace hdm
{
template <class T>
class vector
{
public:
// vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
//无参构造
vector()
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
vector(size_t n,const T& val=T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
while (n--)
{
push_back(val);
}
}
/*
* 理论上将，提供了vector(size_t n, const T& value = T())之后
* vector(int n, const T& value = T())就不需要提供了，但是对于：
* vector<int> v(10, 5);
* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
* 就不会走vector(size_t n, const T& value = T())这个构造方法，
* 最终选择的是：vector(InputIterator first, InputIterator last)
* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
* 但是10和5根本不是一个区间，编译时就报错了
* 故需要增加该构造方法
*/
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
while (n--)
{
push_back(val);
}
}
// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
//拷贝构造
//传统写法
//vector(const vector<T>& v)
// :_start(nullptr)
// , _finish(nullptr)
// , _end_of_storage(nullptr)
//{
// reserve(v.capacity());
// auto it = v.begin();
// auto it1 = begin();
// while (it != v.end())
// {
// *it1++ = *it++;
// }
// _finish = it1;
//}
//拷贝构造
//现代写法
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
//赋值重载
//现代写法
vector& operator=(vector<T> tmp)
{
swap(tmp);
return *this;
}
/
// vector的修改操作
void push_back(const T& val)
{
if (_finish == _end_of_storage)
{
//空间满了就2倍扩容，
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = val;
++_finish;
}
void pop_back()
{
erase(end() - 1);
}
iterator insert(iterator pos,const T& x)
{
assert(pos >= _start &&pos <= _finish);
if (_finish == _end_of_storage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
auto cur = end();
while (cur>pos)
{
*cur = *(cur - 1);
--cur;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish && pos!=nullptr);
auto cur = pos;
while (cur < _finish - 1)
{
*cur = *(cur + 1);
++cur;
}
--_finish;
return pos;
}
void swap(vector<T> & v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
//
// 容量相关
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldsize = size();
T* tmp = new T[n];
if (size() != 0)
{
for (size_t i = 0; i < oldsize; i++)
{
tmp[i] = _start[i];//这种赋值，即使在vector<vector>这样的深拷贝中也不会出现问题
} //因为它在这种情况下它会调用赋值重载
//这种写法在深一层的拷贝就会出错，比如vector<vector>二维数组
/*memcpy(tmp, _start, size()*sizeof(T));*/
delete[] _start;
}
_start = tmp;
_finish = _start + oldsize;
_end_of_storage = _start + n;
}
}
void resize(size_t n,const T& x=T())
{
//容量不够先扩容
if (n > capacity())
{
reserve(n);
}
for (size_t i = size(); i < n; ++i)
{
_start[i] = x;
}
_finish = _start + n;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
size_t size() const
{
return _finish - _start;
}
bool empty()
{
return _finish == _start;
}
///
// 元素访问
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
T& front()
{
return *_start;
}
const T& front() const
{
return *_start;
}
T& back()
{
return *(_finish - 1);
}
const T& back() const
{
return *(_finish - 1);
}
~vector()
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
private:
T* _start; //容量空间的首地址
T* _finish; // 指向有效数据的尾
T* _end_of_storage; //容量空间的尾地址
};
/// /
/// 对模拟实现的vector进行严格测试
void TestVector1()
{
hdm::vector<int> v1;
hdm::vector<int> v2(10, 5);
int array[] = { 1, 2, 3, 4, 5 };
hdm::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));
hdm::vector<int> v4(v3);
for (size_t i = 0; i < v2.size(); ++i)
{
cout << v2[i] << " ";
}
cout << endl;
auto it = v3.begin();
while (it != v3.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
}
void TestVector2()
{
hdm::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
cout << v.size() << endl;
cout << v.capacity() << endl;
cout << v.front() << endl;
cout << v.back() << endl;
cout << v[0] << endl;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.pop_back();
v.pop_back();
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.insert(v.begin(), 0);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.erase(v.begin() + 1);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
}
测试示例一
测试示例二
![[数据结构基础]树和二叉树的概念、结构及性质](https://img-blog.csdnimg.cn/36de28775dd34f598dbc79e7a6707c20.png)
