C++ STL 向量（vector）学习笔记：从基础到实战

前言

vector 是 C++ STL 中最常用的动态数组容器，支持动态扩容、随机访问，且接口丰富，是日常开发和学习中的高频工具。本文基于个人练习代码整理，修改了原有的简单函数名（如 test14 改为 vector_declare_and_init），并添加详细注释和知识点总结，方便后续复习时快速理解核心用法。

一、向量基础：声明与初始化（原 test14、test15）

1.1 功能说明

掌握 vector 不同场景下的初始化方式，包括直接赋值、指定大小和默认值、拷贝初始化等，覆盖日常开发中 90% 的初始化需求。

1.2 代码实现（含详细注释）

#pragma once
#include <string>
#include <iostream>
#include <vector>
#include <math.h>
#include <ctime>using namespace std;// -------------------------- 向量声明与初始化 --------------------------
// 功能：演示vector的基础声明与初始化（直接赋值初始化）
void vector_declare_and_init_basic() {// 1. 初始化int类型vector，直接赋值元素vector<int> vec_int = { 1, 2, 3, 4 };  // 2. 初始化char类型vector，存储字符串"hello"的每个字符vector<char> vec_char = { 'h', 'e', 'l', 'l', 'o' };  // 3. 初始化string类型vector，存储多个字符串vector<string> vec_str = { "hello", "abc", "world" };  // 访问vector元素：通过下标[]访问（无越界检查，需确保下标合法）cout << "vec_int第1个元素（下标0）：" << vec_int[0] << endl;  // 输出1cout << "vec_str第1个字符串（下标0）：" << vec_str[0] << endl;  // 输出hello
}// 功能：演示vector的进阶初始化（指定大小、拷贝、范围初始化）
void vector_declare_and_init_advance() {// 1. 初始化int类型vector，指定大小为10，默认值为0（未显式指定默认值时，基础类型默认初始化）vector<int> vec_size10(10);  cout << "vec_size10第1个元素（默认值）：" << vec_size10[0] << endl;  // 输出0// 2. 初始化int类型vector，指定大小为10，所有元素默认值为6vector<int> vec_size10_val6(10, 6);  cout << "vec_size10_val6第1个元素（指定默认值6）：" << vec_size10_val6[0] << endl;  // 输出6// 3. 拷贝初始化：将vec_size10_val6的所有元素拷贝到vec_copyvector<int> vec_copy(vec_size10_val6);  cout << "vec_copy第2个元素（拷贝自vec_size10_val6）：" << vec_copy[1] << endl;  // 输出6// 4. 范围初始化：将vec_size10_val6的[begin, begin+1)区间元素拷贝到vec_range（左闭右开，仅拷贝第1个元素）// 注意：vector的迭代器是随机访问迭代器，支持+/-运算vector<int> vec_range(vec_size10_val6.begin(), vec_size10_val6.begin() + 1);  cout << "vec_range的元素个数（size）：" << vec_range.size() << endl;  // 输出1（仅拷贝1个元素）cout << "vec_range第1个元素：" << vec_range[0] << endl;  // 输出6
}

1.3 知识点总结

初始化方式	语法示例	适用场景
直接赋值初始化	vector<int> vec = {1,2,3}	已知具体元素，直接初始化
指定大小（默认值）	vector<int> vec(10, 6)	需要固定大小、统一默认值的场景（如初始化数组）
拷贝初始化	vector<int> vec(src_vec)	基于已有 vector 创建副本
范围初始化（左闭右开）	vector<int> vec(src.begin(), src.end())	仅需要已有 vector 的部分元素

二、向量元素访问：at ()、front ()、back () 与迭代器遍历（原 test16）

2.1 功能说明

掌握 vector 元素的多种访问方式，包括安全访问（at()）、首尾元素快速访问（front()/back()），以及正向 / 反向迭代器遍历，覆盖不同场景下的元素读取需求。

2.2 代码实现（含详细注释）

// -------------------------- 向量元素访问与遍历 --------------------------
void vector_access_and_traverse() {// 初始化一个int类型vector，元素为1~6vector<int> vec = { 1, 2, 3, 4, 5, 6 };  // 1. 安全访问：at()方法（会做越界检查，越界时抛出out_of_range异常）cout << "vec下标3的元素（at()访问）：" << vec.at(3) << endl;  // 输出4（下标3对应第4个元素）// 2. 快速访问首尾元素：front()（首元素）、back()（尾元素）cout << "vec首元素（front()）：" << vec.front() << endl;  // 输出1cout << "vec尾元素（back()）：" << vec.back() << endl;    // 输出6// 3. 正向迭代器遍历：从begin()（首元素）到end()（尾元素的下一个位置，不可访问）cout << "正向遍历（迭代器）：";for (auto it = vec.begin(); it != vec.end(); ++it) {  // auto自动推导迭代器类型（vector<int>::iterator）cout << *it << "\t";  // 迭代器解引用获取元素值，输出：1    2    3    4    5    6}cout << endl;// 4. 反向迭代器遍历：从rbegin()（尾元素）到rend()（首元素的前一个位置，不可访问）cout << "反向遍历（迭代器）：";for (auto it = vec.rbegin(); it != vec.rend(); ++it) {  // 反向迭代器：++it表示向前移动cout << *it << "\t";  // 输出：6    5    4    3    2    1}cout << endl;
}

2.3 知识点总结

1. 访问方式对比：
   • []：无越界检查，效率高，适合确定下标合法的场景；
   • at()：有越界检查，安全，越界抛异常，适合不确定下标合法性的场景；
   • front()/back()：直接访问首尾元素，无需下标，效率最高。
2. 迭代器遍历：
   • 正向迭代器：begin() → end()，++it 向后移动；
   • 反向迭代器：rbegin() → rend()，++it 向前移动（注意：反向迭代器的 ++ 是 “反向前进”）；
   • auto 关键字可简化迭代器类型声明（C++11 及以后支持）。

三、向量元素添加：push_back () 与 insert ()（原 test17）

3.1 功能说明

掌握 vector 元素的添加方法，包括尾部添加（push_back()）和指定位置插入（insert()），理解不同添加方式的适用场景和性能差异。

3.2 代码实现（含详细注释）

// -------------------------- 向量元素添加 --------------------------
void vector_add_elements() {// 初始vector：int类型，元素为1、2vector<int> vec = { 1, 2 };  // 辅助vector：int类型，元素为100、200（用于范围插入）vector<int> vec_aux = { 100, 200 };  // 1. 尾部添加：push_back()（在vector末尾追加元素，效率高，仅需偶尔扩容）vec.push_back(3);  // vec变为：{1, 2, 3}// 2. 指定位置插入：insert(位置迭代器, 元素值)（在迭代器指向的位置前插入元素）vec.insert(vec.begin(), 66);  // 在首元素（1）前插入66，vec变为：{66, 1, 2, 3}// 3. 批量插入：insert(位置迭代器, 数量, 元素值)（在指定位置前插入n个相同元素）// 位置：vec.begin()+1（即1的前一个位置），插入10个99vec.insert(vec.begin() + 1, 10, 99);  // vec变为：{66, 99(10个), 1, 2, 3}// 4. 范围插入：insert(位置迭代器, 源.begin(), 源.end())（插入另一个容器的指定范围元素）// 位置：vec.begin()（首元素前），插入vec_aux的所有元素（100、200）vec.insert(vec.begin(), vec_aux.begin(), vec_aux.end());  // vec最终：{100, 200, 66, 99(10个), 1, 2, 3}// 遍历输出所有元素，验证插入结果cout << "插入后所有元素：";for (auto it = vec.begin(); it != vec.end(); ++it) {cout << *it << " ";}cout << endl;
}

3.3 知识点总结

1. push_back()：
   • 优势：尾部添加，无需移动元素，仅当容量不足时扩容，效率最高；
   • 适用场景：只需在末尾添加元素的场景（如收集数据）。
2. insert()：
   • 优势：支持任意位置插入（头部、中间、尾部），灵活；
   • 劣势：插入位置非尾部时，需移动后续元素，元素越多效率越低；
   • 常用形式：
     • 单个元素：insert(it, val)；
     • 批量元素：insert(it, n, val)；
     • 范围元素：insert(it, src.begin(), src.end())。

四、向量元素删除：erase ()、pop_back () 与 clear ()（原 test18）

4.1 功能说明

掌握 vector 元素的删除方法，包括指定位置删除（erase()）、尾部删除（pop_back()）和清空所有元素（clear()），注意删除后迭代器失效问题。

4.2 代码实现（含详细注释）

// -------------------------- 向量元素删除 --------------------------
void vector_remove_elements() {// 初始vector：int类型，元素为1~6vector<int> vec = { 1, 2, 3, 4, 5, 6 };  // 1. 判断vector是否为空：empty()（返回bool，true为空，false非空）cout << "删除前vector是否为空（0=非空，1=空）：" << vec.empty() << endl;  // 输出0（非空）// 2. 指定位置删除单个元素：erase(位置迭代器)（删除迭代器指向的元素）vec.erase(vec.begin() + 1);  // 删除下标1的元素（2），vec变为：{1, 3, 4, 5, 6}// 3. 指定范围删除元素：erase(起始迭代器, 结束迭代器)（左闭右开，删除[it1, it2)区间元素）vec.erase(vec.begin() + 2, vec.begin() + 4);  // 删除下标2~3的元素（4、5），vec变为：{1, 3, 6}// 4. 尾部删除：pop_back()（删除末尾元素，效率高，无需移动其他元素）vec.pop_back();  // 删除尾元素（6），vec变为：{1, 3}// 5. 清空所有元素：clear()（删除所有元素，size变为0，但capacity不变）vec.clear();  // vec变为空（size=0），但容量（capacity）仍为初始分配的大小// 再次判断vector是否为空cout << "删除后vector是否为空（0=非空，1=空）：" << vec.empty() << endl;  // 输出1（空）// 遍历输出（此时vector为空，无元素输出）cout << "清空后遍历：";for (auto it = vec.begin(); it != vec.end(); ++it) {cout << *it << " ";}cout << endl;
}

4.3 知识点总结

1. 删除方法对比：
   • pop_back()：尾部删除，效率高，无迭代器失效问题（仅尾元素删除）；
   • erase(it)：删除单个元素，删除后 it 及后续迭代器失效，需重新获取迭代器；
   • erase(it1, it2)：删除范围元素，删除后 it1 及后续迭代器失效；
   • clear()：清空所有元素，size() 变为 0，但 capacity() 不变（内存未释放，可复用）。
2. 迭代器失效注意：
   • 删除非尾部元素后，后续元素会前移，原迭代器指向的位置可能变为无效元素；
   • 解决方法：删除后通过 erase() 的返回值获取新迭代器（如 it = vec.erase(it)）。

五、向量容量操作：size ()、capacity ()、max_size () 与 empty ()（原 test19）

5.1 功能说明

理解 vector 的 “大小”（size()）和 “容量”（capacity()）的区别，掌握容量相关操作，避免因频繁扩容导致性能损耗。

5.2 代码实现（含详细注释）

// -------------------------- 向量容量操作 --------------------------
void vector_capacity_operations() {// 初始vector：int类型，元素为1~6vector<int> vec = { 1, 2, 3, 4, 5, 6 };  // 1. size()：返回vector当前存储的元素个数（实际元素数量）cout << "初始size（元素个数）：" << vec.size() << endl;  // 输出6// 2. capacity()：返回vector当前已分配的内存可容纳的元素个数（容量≥size，扩容时会增加）cout << "初始capacity（容量）：" << vec.capacity() << endl;  // 输出6（初始分配的容量刚好容纳6个元素）// 3. max_size()：返回vector理论上可容纳的最大元素个数（受系统内存限制，通常很大）cout << "max_size（最大可容纳元素数）：" << vec.max_size() << endl;  // 输出一个大整数（如2^31-1，取决于系统）// 4. 尾部删除元素：pop_back()（仅减少size，不改变capacity）vec.pop_back();  // 删除尾元素（6），size变为5，capacity仍为6// 再次查看size和capacitycout << "pop_back后size：" << vec.size() << endl;  // 输出5cout << "pop_back后capacity：" << vec.capacity() << endl;  // 输出6（容量未变，内存未释放）cout << "pop_back后max_size：" << vec.max_size() << endl;  // 输出不变（不受删除影响）
}

5.3 知识点总结

1. 核心概念区分：
   • size()：实际元素个数（“当前有多少个苹果”）；
   • capacity()：已分配内存可容纳的最大元素个数（“篮子能装多少个苹果”）；
   • max_size()：理论最大容量（“仓库最多能放多少个篮子”）。
2. 扩容机制：
   • 当 size() == capacity() 时，再添加元素会触发扩容（通常扩容为原容量的 1.5~2 倍）；
   • 扩容会分配新内存、拷贝旧元素、释放旧内存，频繁扩容会影响性能，可提前用 reserve(n) 预分配容量。

六、向量赋值与交换：assign () 与 swap ()（原 test20）

6.1 功能说明

掌握 vector 的赋值（assign()）和交换（swap()）操作，理解 assign() 与直接赋值（=）的区别，以及 swap() 的高效性。

6.2 代码实现（含详细注释）

// -------------------------- 向量赋值与交换 --------------------------
void vector_assign_and_swap() {// 1. assign()：重新赋值（覆盖原有元素，size和capacity可能改变）vector<int> vec_assign;// assign(数量, 值)：将vec_assign赋值为10个22（覆盖原有元素，原有元素会被销毁）vec_assign.assign(10, 22);  cout << "assign(10,22)后元素：";for (auto it = vec_assign.begin(); it != vec_assign.end(); ++it) {cout << *it << " ";  // 输出10个22：22 22 22 ... 22}cout << endl;// 2. swap()：交换两个vector的内容（仅交换内部指针，效率极高，无元素拷贝）vector<int> vec_swap1 = { 1, 2, 3, 4 };    // 初始vec_swap1：{1,2,3,4}vector<int> vec_swap2 = { 100, 200, 300, 400, 500, 600 };  // 初始vec_swap2：{100,200,...600}cout << "swap前vec_swap1：";for (auto it = vec_swap1.begin(); it != vec_swap1.end(); ++it) {cout << *it << " ";  // 输出：1 2 3 4}cout << endl;cout << "swap前vec_swap2：";for (auto it = vec_swap2.begin(); it != vec_swap2.end(); ++it) {cout << *it << " ";  // 输出：100 200 300 400 500 600}cout << endl;// 交换vec_swap1和vec_swap2的内容vec_swap1.swap(vec_swap2);  cout << "swap后vec_swap1：";for (auto it = vec_swap1.begin(); it != vec_swap1.end(); ++it) {cout << *it << " ";  // 输出原vec_swap2的内容：100 200 300 400 500 600}cout << endl;cout << "swap后vec_swap2：";for (auto it = vec_swap2.begin(); it != vec_swap2.end(); ++it) {cout << *it << " ";  // 输出原vec_swap1的内容：1 2 3 4}cout << endl;
}

6.3 知识点总结

1. assign() 与直接赋值（=）的区别：
   • assign(n, val)：可指定 “数量 + 值” 赋值，适合重新初始化；
   • assign(src.begin(), src.end())：可赋值另一个容器的范围元素；
   • 直接赋值（vec1 = vec2）：仅能拷贝整个容器的元素，功能不如 assign() 灵活。
2. swap() 的优势：
   • 高效：仅交换两个 vector 的内部指针（指向数据的指针、size、capacity），无元素拷贝；
   • 用途：快速交换两个 vector 的内容，或用于释放 vector 的内存（如 vector<int>().swap(vec) 清空并释放内存）。

七、向量实战案例：生成随机数并查找最值（原 test21）

7.1 功能说明

结合 vector 的初始化、元素添加、遍历操作，实现 “输入 n，生成 n 个 1~100 的随机数，存入 vector 并查找最值” 的实战需求，巩固 vector 的综合用法。

7.2 代码实现（含详细注释）

// -------------------------- 向量实战：随机数生成与最值查找 --------------------------
void vector_practice_random_max_min() {// 1. 输入需要生成的随机数个数nint n;cout << "请输入需要生成的随机数个数n：";cin >> n;// 2. 初始化vector，用于存储随机数vector<int> vec_random;// 3. 初始化随机数种子：确保每次运行生成的随机数不同（依赖系统时间）// time(0)返回当前系统时间（秒级），srand()设置随机数种子srand(time(0));  // 4. 生成n个1~100的随机数，存入vectorcout << "生成的" << n << "个随机数：";for (int i = 0; i < n; i++) {// rand()生成0~RAND_MAX的随机数，%100后范围为0~99，+1后变为1~100int num = (rand() % 100) + 1;  vec_random.push_back(num);  // 尾部添加随机数到vectorcout << num << " ";  // 实时输出随机数，方便验证}cout << endl;// 5. 查找vector中的最大值和最小值// 初始化max和min为vector的第一个元素（需确保vector非空，此处n≥1）int max_val = vec_random.at(0);  // 用at()安全访问，避免越界int min_val = vec_random[0];     // 用[]访问，效率高// 遍历vector，更新max和minfor (int i = 0; i < vec_random.size(); i++) {// 若当前元素大于max_val，更新max_valif (max_val < vec_random[i]) {max_val = vec_random[i];}// 若当前元素小于min_val，更新min_valif (min_val > vec_random[i]) {min_val = vec_random[i];}}// 6. 输出结果cout << "随机数中的最大值max：" << max_val << endl;cout << "随机数中的最小值min：" << min_val << endl;
}

7.3 知识点总结

1. 随机数生成要点：
   • 必须用 srand(time(0)) 初始化种子，否则每次运行生成的随机数序列相同；
   • rand()%100 + 1 是常用的 “范围缩放” 技巧，将随机数从 [0, RAND_MAX] 缩放到 [1, 100]。
2. 最值查找逻辑：
   • 初始值必须从 vector 中取（不能用固定值如 0，避免随机数全大于 0 导致 min 错误）；
   • 一次遍历同时更新 max 和 min，效率更高（仅遍历一次，时间复杂度 O (n)）。

八、vector 核心特性与常用操作总结

8.1 核心特性

1. 动态扩容：支持自动扩容，容量不足时自动分配更大内存（通常为原容量的 1.5~2 倍）；
2. 随机访问：支持 [] 和 at() 访问，访问任意元素的时间复杂度 O (1)；
3. 连续内存：元素存储在连续内存中，缓存友好，但插入 / 删除中间元素效率低（需移动元素）；
4. 无内置排序：需用 <algorithm> 头文件的 sort(vec.begin(), vec.end()) 排序（vector 支持随机访问迭代器，可排序）。

8.2 常用操作速查表

操作类别	函数名	功能描述
初始化	vector<T> vec	空 vector
	vector<T> vec(n, val)	大小 n，默认值 val
元素访问	vec[i]	下标访问（无越界检查）
	vec.at(i)	安全访问（越界抛异常）
	vec.front()/vec.back()	访问首尾元素
元素添加	vec.push_back(val)	尾部添加元素
	vec.insert(it, val)	指定位置插入元素
元素删除	vec.pop_back()	尾部删除元素
	vec.erase(it)	指定位置删除元素
	vec.clear()	清空所有元素（size=0，capacity 不变）
容量操作	vec.size()	元素个数
	vec.capacity()	容量（可容纳元素个数）
	vec.empty()	判断是否为空
赋值与交换	vec.assign(n, val)	重新赋值为 n 个 val
	vec1.swap(vec2)	交换两个 vector 的内容

结语

vector 是 C++ STL 中最基础也最常用的容器，掌握其初始化、访问、增删改查、容量操作和实战用法，能应对大部分日常开发需求。本文通过修改函数名、添加详细注释和知识点总结，将零散的练习代码整理为体系化的学习笔记，后续复习时可根据模块快速定位所需知识点，也可直接复用代码中的实战逻辑（如随机数生成、最值查找）。

最后附上我自己练习时的源码资料（有兴趣的可以按自己喜好自由练习修改）：

头文件：

#pragma once
#include <string>
#include <iostream>
#include <vector>
#include <math.h>
#include <ctime>using namespace std;/*声明函数方法
*/
void test14();
void test15();
void test16();
void test17();
void test18();
void test19();
void test20();
/*案例题目输入n，随机n个1~100的数字，装入vector，找出里面最大值和最小值
*/
void test21();

源文件：

#include "vector容器.h"/*函数方法定义实现
*//*案例题目输入n，随机n个1~100的数字，装入vector，找出里面最大值和最小值
*/
void test21() {//输入nint n;cin >> n;//随机n个1~100的数字  //装入vectorvector<int> v;//srand((unsigned)time(NULL));srand(time(0));//srand(time(NULL));for (int i = 0; i < n; i++) {int num = (rand() % 100)+1;//[0,100)=>[1,101)=>[1,100]v.push_back(num);}//找出里面最大值和最小值int max = v.at(0);int min = v[0];for (int i = 0; i < v.size(); i++) {if (max < v[i]) {max = v[i];}if (min > v[i]) {min = v[i];}}for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";}cout << endl;cout << "max=" << max << endl;cout << "min=" << min << endl;
}void test20() {vector<int> v;v.assign(10, 22);	//把v里面前10个元素设置成22//cout << v.size();for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";}cout << endl;vector<int> v1 = { 1,2,3,4 };vector<int> v2 = { 100,200,300,400,500,600 };//使用v1的元素替换掉v2的元素//v2.assign(v1.begin(), v1.end());	v1.swap(v2);	//v1和v2的值进行交换for (auto i = v1.begin(); i != v1.end(); i++) {cout << *i << " ";}cout << endl;for (auto i = v2.begin(); i != v2.end(); i++) {cout << *i << " ";}cout << endl;
}void test19() {vector<int> v = { 1,2,3,4,5,6 };cout << "v.size=" << v.size() << endl;cout << "v.capacity=" << v.capacity() << endl;cout << "v.max_size=" << v.max_size() << endl;v.pop_back();cout << "v.size=" << v.size() << endl;cout << "v.capacity=" << v.capacity() << endl;cout << "v.max_size=" << v.max_size() << endl;
}void test18() {vector<int> v = { 1,2,3,4,5,6 };cout << v.empty() << endl;v.erase(v.begin() + 1);//删除2//v.insert(v.begin() + 1, 2);v.erase(v.begin() + 2, v.begin() + 4);//删除4,5v.pop_back();	//删除最后一个6v.clear();	//删除所有元素cout << v.empty() << endl;for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";}cout << endl;
}void test17() {vector<int> v = { 1,2 };vector<int> v2 = { 100,200 };v.push_back(3);	//在2的后面添加3v.insert(v.begin(), 66);	//在1的前面插入66v.insert(v.begin() + 1, 10, 99);	//在1和66之间插入10个99v.insert(v.begin(), v2.begin(), v2.end());	//把v2的所有元素插入到v的头部for (auto i = v.begin(); i != v.end(); i++) {cout << *i << " ";}cout << endl;}void test16() {vector<int> v = { 1,2,3,4,5,6 };cout << v.at(3) << endl;	//取下标为3的元素4cout << v.front() << endl;	//输出首元素cout << v.back() << endl;	//输出尾元素//循环迭代打印所有元素for (auto i = v.begin(); i != v.end(); i++) {cout << *i << "\t";}cout << endl;//反向打印所有元素for (auto i = v.rbegin(); i != v.rend(); i++) {cout << *i << "\t";}cout << endl;
}void test15() {vector<int> v1(10);	//定义一个含有10个变量的整型向量，默认值是0cout << v1[0] << endl;vector<int> v2(10, 6);	//定义一个含有10个变量的整型向量，默认值是6cout << v2[0] << endl;vector<int> v3(v2);	//把v2拷贝给v3cout << v3[1] << endl;vector<int> v4(v2.begin(), v2.begin() + 1);	//把v2的[v2.begin(),v2.begin()+1)值拷贝给v4cout << v4.size() << endl;cout << v4[0] << endl;
}//vector声明和初始化
void test14() {vector<int> v1 = { 1,2,3,4 };vector<char> v2 = { 'h','e','l','l','o' };vector<string> v3 = { "hello","abc" ,"world"};cout << v1[0] << endl;cout << v3[0] << endl;
}