c语言c++

李余博睿（新疆）

已于 2023-08-20 13:21:18 修改

阅读量89

点赞数

文章标签： c++

于 2023-08-12 11:27:21 首次发布

本文链接：https://blog.csdn.net/lybr513208/article/details/132246600

版权

文章目录
序列式容器
vector 简介
vector ( 向量 ) 头文件
vector ( 向量 ) 声明及初始化
vector ( 向量 ) 添加元素
vector ( 向量 ) 查询元素
vector ( 向量 ) 删除元素
vector ( 向量 ) 容量改变
vector ( 向量 ) 涉及到的运算符重载
vector ( 向量 ) 相关源码

序列式容器

1. 常用的数据结构 ( 容器 ) 及分类 : 数组 , 链表 , 树 , 栈 , 队列 ; 容器可以分为序列式 , 与关联式两种 ;

2. 序列式容器 : 序列式容器的元素排列的顺序与元素本身无关 , 其先后顺序由元素添加到容器中的顺序决定 ;

3. 常用的序列式容器 : C++ 的 STL ( 标准模板库 ) , 包括 vector ( 向量 ) , list ( 列表 ) , queue ( 队列 ) , dequeue ( 双向队列 ) , stack ( 栈 ) , priority_queue ( 优先队列 ) ;

vector 简介

vector 向量是一种支持快速随机访问的 , 连续存储元素的容器 ;

vector , dequeue , list 调用方式基本一致 , 这里只研究 vector 一种 ;

vector ( 向量 ) 头文件

vector 头文件 : 使用 vector 首先要导入头文件 , 之后才能使用 vector 容器 ;

//vector 是 C++ 中定义的模板类
#include <vector>
1
2

vector ( 向量 ) 声明及初始化

1. 声明 vector ( 基本用法 ) : 格式 " vector <元素类型名称> 容器名称 ; " ; 声明 vector 容器 , 尖括号中的元素类型名称 , 是容器中存储的元素的类型 ;

//声明向量
vector<int> vector_1;
1
2
2. 声明 vector ( 指定容量 ) : 调用构造方法 , 并传入 int 类型参数 , 该参数就是 vector 容器的元素个数 ;

   //调用向量的构造方法 , 并传入一个 int 类型参数
   //表示创建一个有 8 个 int 类型元素空间的向量
   vector<int> vector_2(8);
1
2
3
3. 声明 vector ( ① 指定容量 ② 初始化内容 ) : 调用构造方法 , 传入 2 个参数 ;

① 容量 : 第一个参数是 vector 容量 ;
② 元素 : 第二个参数是 vector 中初始化的元素内容 ;
//表示创建有 8 个元素的向量 , 8 个元素的值都是 2
vector<int> vector_3(8 , 2);
1
2
4. 声明 vector ( 使用另外 vector 初始化 ) : 调用构造方法 , 传入vector 对象 ;

//初始化向量时 , 传入另一个向量
vector<int> vector_4(vector_3);
1
2

vector ( 向量 ) 添加元素

添加元素 : 调用 push_back 方法 , 容器出入策略 , 后进先出 ;

   // ( 1 ) 增加元素 : 调用 push_back 方法 , 容器出入策略 , 后进先出
   vector_1.push_back(8);
   vector_1.push_back(88);
1
2
3

vector ( 向量 ) 查询元素

下面获取的元素都是基于上面小节添加的元素 ;

1. 通过下标获取元素 : 使用格式 " vector 变量名称 [ 下标索引 ] " , 这里的 [] 在 vector 中进行了运算符重载 ;

   // <1> 通过下标获取元素
   //   这里的 [] 在 vector 中进行了运算符重载
   cout << "通过下标获取 vector_1 第 0 个元素 : vector_1[0] : " << vector_1[0] << endl;
1
2
3
2. 通过 at() 方法获取对应索引的元素 ;

// <2> 通过 at() 方法获取对应索引的元素
cout << "通过 at 方法获取 vector_1 第 0 个元素 : vector_1.at(0) : " << vector_1.at(0) << endl;
1
2
3. 获取第一个元素 ;

// <3> 获取第一个元素
cout << "通过 front 方法获取 vector_1 第 1 个元素 : vector_1.front() : " << vector_1.front() << endl;
1
2
4. 获取最后一个元素 ;

// <4> 获取最后一个元素
cout << "通过 back 方法获取 vector_1 最后 1 个元素 : vector_1.back() : " << vector_1.back() << endl;
1
2
5. 执行结果 :

通过下标获取 vector_1 第 0 个元素 : vector_1[0] : 8
通过 at 方法获取 vector_1 第 0 个元素 : vector_1.at(0) : 8
通过 front 方法获取 vector_1 第 1 个元素 : vector_1.front() : 8
通过 back 方法获取 vector_1 最后 1 个元素 : vector_1.back() : 88
1
2
3
4

vector ( 向量 ) 删除元素

1. 删除最后加入的元素 : 调用 pop_back 方法 , 容器出入策略 , 后进先出 ; 注意这里并没有修改 vector 容量大小 , 只是将最后的元素清空了 ;

// <1> 调用 pop_back 方法 , 容器出入策略 , 后进先出
vector_1.pop_back();
1
2
之前向 vector 中先后放入了 8 和 88 两个数 , 然后将后面的 88 元素设置成了 0 , 目前只剩下一个元素 8 , 但容器的元素个数是 2 个 ;

2. 删除所有元素 , 这里只是清空元素内容为 0

// <2> 删除所有元素 , 这里只是清空元素内容为 0
vector_1.clear();
1
2
3. 删除指定位置区间的元素 , 这里只是清空元素内容为 0 , 传入 2 个参数 ;

① 第 1 个是删除的起始位置 ;
② 第 2 个参数是删除的结束位置 ;
   // <3> 删除指定位置区间的元素 , 这里只是清空元素内容为 0
   //       第 1 个是删除的起始位置 ,
   //       第 2 个参数是删除的结束位置 ;
   //删除从开始到结束的所有元素
   vector_1.erase(vector_1.begin() , vector_1.end());
1
2
3
4
5
4. 关于删除元素的内存说明 : 删除若干元素后 , vector 的容量 , 即内存所占的空间是不会减小的 ;

5. 打印删除元素后的 vector 容器大小 : 调用 vector 的 capacity() 方法即可获取其容量大小 ;

① 代码示例 :
   //打印 vector 容器容量大小 , 调用 vector 的 capacity() 方法即可获取其容量大小
   //   这个容量大小是元素个数 , 不是内存字节数
   cout << "打印 vector_1 容量大小 : vector_1.capacity() : " << vector_1.capacity() << endl;
1
2
3
② 执行结果 :
打印 vector_1 容量大小 : vector_1.capacity() : 2
1
这个容量大小是元素个数 , 不是内存字节数 ;

vector ( 向量 ) 容量改变

1. 容量修改 : 删除元素 , 并不能修改容器的容量 , 如果要修改容量 , 需要使用其他容器与该容器进行交换 ;

2. 容器交换 : 调用 vector 的 swap() 方法 , 进行容器交换 , 传入 vector 容器对象当做参数 ;

① 代码示例 :
   //创建一个新的 vector , 此时其容量为 0
   vector<int> vector_swap;
   //将创建的新的 vector_swap 与 vector_1 容器进行交换
   vector_swap.swap(vector_1);
   cout << "打印 vector_1 交换后的容量大小 : vector_1.capacity() : " << vector_1.capacity() << endl;
1
2
3
4
5
② 执行结果 :
打印 vector_1 交换后的容量大小 : vector_1.capacity() : 0
1

vector ( 向量 ) 涉及到的运算符重载

vector 运算符重载 : 使用 " [] " 可以访问 vector 中指定索引的变量 , vector 对 " [] " 符号进行了重载 , Ctrl + 左键点击中括号符号 , 就可以跳转到 vector 定义的位置 , 下面的内容是 vector 对 " [] " 进行运算符重载的内容 ;

_NODISCARD _Ty& operator[](const size_type _Pos) {
auto& _My_data = _Mypair._Myval2;
#if _CONTAINER_DEBUG_LEVEL > 0
_STL_VERIFY(
_Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
#endif // _CONTAINER_DEBUG_LEVEL > 0

return _My_data._Myfirst[_Pos];
}
1
2
3
4
5
6
7
8
9

vector ( 向量 ) 相关源码

1. 代码示例 :

// 004_Container.cpp: 定义应用程序的入口点。
//

#include "004_Container.h"

//vector 是 C++ 中定义的模板类
#include <vector>

using namespace std;

int main()
{
cout << "Hello Container。" << endl;

// I . vector 向量 ( vector , dequeue , list 调用方式基本一致 )

//vector 向量是一种支持快速随机访问的 , 连续存储元素的容器

//声明向量
vector<int> vector_1;

   //调用向量的构造方法 , 并传入一个 int 类型参数
   //表示创建一个有 8 个 int 类型元素空间的向量
   vector<int> vector_2(8);

//表示创建有 8 个元素的向量 , 8 个元素的值都是 2
vector<int> vector_3(8 , 2);

//初始化向量时 , 传入另一个向量
vector<int> vector_4(vector_3);

// 2. 使用向量 : 增删查改

   // ( 1 ) 增加元素 : 调用 push_back 方法 , 容器出入策略 , 后进先出
   vector_1.push_back(8);
   vector_1.push_back(88);

   // ( 2 ) 查询元素 :

   // <1> 通过下标获取元素
   //   这里的 [] 在 vector 中进行了运算符重载
   cout << "通过下标获取 vector_1 第 0 个元素 : vector_1[0] : " << vector_1[0] << endl;

   // <2> 通过 at() 方法获取对应索引的元素
   cout << "通过 at 方法获取 vector_1 第 0 个元素 : vector_1.at(0) : " << vector_1.at(0) << endl;

   // <3> 获取第一个元素
   cout << "通过 front 方法获取 vector_1 第 1 个元素 : vector_1.front() : " << vector_1.front() << endl;

// <4> 获取最后一个元素
cout << "通过 back 方法获取 vector_1 最后 1 个元素 : vector_1.back() : " << vector_1.back() << endl;

// ( 4 ) 删除元素 :

// <1> 调用 pop_back 方法 , 容器出入策略 , 后进先出
vector_1.pop_back();

//之前向 vector 中先后放入了 8 和 88 两个数 ,
// 然后删除了后一个元素 88 , 目前只剩下一个元素 8

// <2> 删除所有元素 , 这里只是清空元素内容为 0
vector_1.clear();

   // <3> 删除指定位置区间的元素 , 这里只是清空元素内容为 0
   //       第 1 个是删除的起始位置 ,
   //       第 2 个参数是删除的结束位置 ;
   //删除从开始到结束的所有元素
   vector_1.erase(vector_1.begin() , vector_1.end());

   //关于删除元素内存说明 :
   //   删除若干元素后 , vector 的容量 , 即内存所占的空间是不会减小的 ;
   //   调用删除方法后 , 就不能在查询上述元素了

   //打印 vector 容器容量大小 , 调用 vector 的 capacity() 方法即可获取其容量大小
   //   这个容量大小是元素个数 , 不是内存字节数
   cout << "打印 vector_1 容量大小 : vector_1.capacity() : " << vector_1.capacity() << endl;

// ( 5 ) 改变容量 , 容器交换 , 这里使用一个容量为 0 的容器与之交换即可

   //创建一个新的 vector , 此时其容量为 0
   vector<int> vector_swap;
   //将创建的新的 vector_swap 与 vector_1 容器进行交换
   vector_swap.swap(vector_1);
   cout << "打印 vector_1 交换后的容量大小 : vector_1.capacity() : " << vector_1.capacity() << endl;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
2.执行结果 :

Hello Container。
通过下标获取 vector_1 第 0 个元素 : vector_1[0] : 8
通过 at 方法获取 vector_1 第 0 个元素 : vector_1.at(0) : 8
通过 front 方法获取 vector_1 第 1 个元素 : vector_1.front() : 8
通过 back 方法获取 vector_1 最后 1 个元素 : vector_1.back() : 88
打印 vector_1 容量大小 : vector_1.capacity() : 2
打印 vector_1 交换后的容量大小 : vector_1.capacity() : 0
1
2
3
4
5
6
7