vector类的用法

1. 引言#

什么是向量（Vector）？#

向量（Vector）是 C++ 标准模板库（STL）中的一种序列容器，能够动态地管理可变大小的数组。与传统的固定大小的数组不同，向量可以根据需要随时调整其大小，提供更高的灵活性和便利性。

向量与数组的比较#

特性	数组（Array）	向量（Vector）
大小	固定大小（编译时或运行时）	动态可变大小
内存管理	手动管理（需要预留足够空间）	自动管理（自动扩展或收缩）
支持的操作	限制较多	丰富的成员函数和操作
安全性	较低（易发生缓冲区溢出）	较高（通过成员函数进行边界检查）
与 STL 算法的兼容性	低	高

2. `std::vector` 基础#

2.1 包含头文件#

使用 std::vector 需要包含 <vector> 头文件：

1
#include <vector>

2.2 定义与初始化#

定义一个整数向量：

1
std::vector<int> numbers;

定义一个字符串向量：

1
#include <vector>
2
#include <string>
3

4
std::vector<std::string> words;

初始化向量：

默认初始化：

1
std::vector<int> vec1; // 空向量

指定大小和默认值：

1
std::vector<int> vec2(5, 10); // 5个元素，值均为10

使用初始化列表：

1
std::vector<int> vec3 = {1, 2, 3, 4, 5};

拷贝构造：

1
std::vector<int> vec4(vec3); // 复制vec3

移动构造：

1
std::vector<int> vec5(std::move(vec4)); // 移动vec4到vec5

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    // 默认初始化
6
    std::vector<int> vec1;
7

8
    // 指定大小和默认值
9
    std::vector<int> vec2(5, 10);
10

11
    // 使用初始化列表
12
    std::vector<int> vec3 = {1, 2, 3, 4, 5};
13

14
    // 拷贝构造
15
    std::vector<int> vec4(vec3);
16

17
    // 移动构造
18
    std::vector<int> vec5(std::move(vec4));
19

20
    // 输出vec2
21
    std::cout << "vec2: ";
22
    for(auto num : vec2) {
23
        std::cout << num << " ";
24
    }
25
    std::cout << std::endl;
26

27
    // 输出vec3
28
    std::cout << "vec3: ";
29
    for(auto num : vec3) {
30
        std::cout << num << " ";
31
    }
32
    std::cout << std::endl;
33

34
    // 输出vec5
35
    std::cout << "vec5: ";
36
    for(auto num : vec5) {
37
        std::cout << num << " ";
38
    }
39
    std::cout << std::endl;
40

41
    return 0;
42
}

输出：

1
vec2: 10 10 10 10 10
2
vec3: 1 2 3 4 5
3
vec5: 1 2 3 4 5

2.3 向量的大小与容量#

size()：返回向量中元素的数量。
capacity()：返回向量目前为止分配的存储容量。
empty()：检查向量是否为空。

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec = {1, 2, 3};
6

7
    std::cout << "Size: " << vec.size() << std::endl;       // 输出: 3
8
    std::cout << "Capacity: " << vec.capacity() << std::endl; // 输出: 3（或更大，取决于实现）
9

10
    std::cout << "Is empty? " << (vec.empty() ? "Yes" : "No") << std::endl; // 输出: No
11

12
    vec.reserve(10); // 预留容量
13
    std::cout << "After reserve(10), Capacity: " << vec.capacity() << std::endl; // 输出: 10
14

15
    vec.shrink_to_fit(); // 收缩到适合大小
16
    std::cout << "After shrink_to_fit(), Capacity: " << vec.capacity() << std::endl; // 输出: 3
17

18
    return 0;
19
}

输出示例：

1
Size: 3
2
Capacity: 3
3
Is empty? No
4
After reserve(10), Capacity: 10
5
After shrink_to_fit(), Capacity: 3

注意： capacity() 并不一定精确匹配 size()，它表示在需要重新分配内存之前，向量可以容纳的元素数量。

3. 向量的基本操作#

3.1 添加与删除元素#

push_back()：在向量末尾添加一个元素。
pop_back()：移除向量末尾的元素。
insert()：在指定位置插入元素。
erase()：移除指定位置的元素或范围内的元素。
clear()：移除所有元素。

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec;
6

7
    // 使用push_back添加元素
8
    vec.push_back(10);
9
    vec.push_back(20);
10
    vec.push_back(30);
11

12
    std::cout << "After push_back: ";
13
    for(auto num : vec) {
14
        std::cout << num << " ";
15
    }
16
    std::cout << std::endl; // 输出: 10 20 30
17

18
    // 使用pop_back移除最后一个元素
19
    vec.pop_back();
20

21
    std::cout << "After pop_back: ";
22
    for(auto num : vec) {
23
        std::cout << num << " ";
24
    }
25
    std::cout << std::endl; // 输出: 10 20
26

27
    // 在第二个位置插入25
28
    vec.insert(vec.begin() + 1, 25);
29

30
    std::cout << "After insert: ";
31
    for(auto num : vec) {
32
        std::cout << num << " ";
33
    }
34
    std::cout << std::endl; // 输出: 10 25 20
35

36
    // 删除第二个元素（25）
37
    vec.erase(vec.begin() + 1);
38

39
    std::cout << "After erase: ";
40
    for(auto num : vec) {
41
        std::cout << num << " ";
42
    }
43
    std::cout << std::endl; // 输出: 10 20
44

45
    // 清空向量
46
    vec.clear();
47
    std::cout << "After clear, size: " << vec.size() << std::endl; // 输出: 0
48

49
    return 0;
50
}

输出：

1
After push_back: 10 20 30
2
After pop_back: 10 20
3
After insert: 10 25 20
4
After erase: 10 20
5
After clear, size: 0

3.2 访问元素#

operator[]：通过索引访问元素。
at()：通过索引访问元素，带边界检查。
front()：访问第一个元素。
back()：访问最后一个元素。

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<std::string> fruits = {"Apple", "Banana", "Cherry"};
6

7
    // 使用operator[]访问元素
8
    std::cout << "First fruit: " << fruits[0] << std::endl; // 输出: Apple
9

10
    // 使用at()访问元素
11
    try {
12
        std::cout << "Second fruit: " << fruits.at(1) << std::endl; // 输出: Banana
13
        std::cout << "Invalid fruit: " << fruits.at(5) << std::endl; // 抛出异常
14
    }
15
    catch(const std::out_of_range& e) {
16
        std::cerr << "Exception: " << e.what() << std::endl;
17
    }
18

19
    // 使用front()和back()
20
    std::cout << "Front: " << fruits.front() << std::endl; // 输出: Apple
21
    std::cout << "Back: " << fruits.back() << std::endl;   // 输出: Cherry
22

23
    return 0;
24
}

输出：

1
First fruit: Apple
2
Second fruit: Banana
3
Exception: vector::_M_range_check: __n (which is 5) >= this->size() (which is 3)
4
Front: Apple
5
Back: Cherry

3.3 遍历向量#

使用范围 for 循环
使用传统 for 循环
使用迭代器

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> numbers = {1, 2, 3, 4, 5};
6

7
    // 使用范围 for 循环
8
    std::cout << "Using range-based for loop: ";
9
    for(auto num : numbers) {
10
        std::cout << num << " ";
11
    }
12
    std::cout << std::endl;
13

14
    // 使用传统 for 循环
15
    std::cout << "Using traditional for loop: ";
16
    for(size_t i = 0; i < numbers.size(); ++i) {
17
        std::cout << numbers[i] << " ";
18
    }
19
    std::cout << std::endl;
20

21
    // 使用迭代器
22
    std::cout << "Using iterators: ";
23
    for(auto it = numbers.begin(); it != numbers.end(); ++it) {
24
        std::cout << *it << " ";
25
    }
26
    std::cout << std::endl;
27

28
    return 0;
29
}

输出：

1
Using range-based for loop: 1 2 3 4 5
2
Using traditional for loop: 1 2 3 4 5
3
Using iterators: 1 2 3 4 5

3.4 修改元素#

通过索引或迭代器修改
使用 assign() 重新赋值
替换整个向量内容

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec = {10, 20, 30, 40, 50};
6

7
    // 通过索引修改元素
8
    vec[2] = 35;
9

10
    // 使用 at() 修改元素
11
    vec.at(4) = 55;
12

13
    // 使用迭代器修改元素
14
    for(auto it = vec.begin(); it != vec.end(); ++it) {
15
        if(*it == 20) {
16
            *it = 25;
17
        }
18
    }
19

20
    // 输出修改后的向量
21
    std::cout << "Modified vector: ";
22
    for(auto num : vec) {
23
        std::cout << num << " ";
24
    }
25
    std::cout << std::endl; // 输出: 10 25 35 40 55
26

27
    return 0;
28
}

输出：

1
Modified vector: 10 25 35 40 55

4. 向量的高级用法#

4.1 嵌套向量（二维向量）#

向量可以包含其他向量，形成多维数组结构。

示例代码：二维向量

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    // 定义一个3x4的二维向量，初始化为0
6
    std::vector<std::vector<int>> matrix(3, std::vector<int>(4, 0));
7

8
    // 填充矩阵
9
    for(int i = 0; i < 3; ++i) {
10
        for(int j = 0; j < 4; ++j) {
11
            matrix[i][j] = i * 4 + j + 1;
12
        }
13
    }
14

15
    // 输出矩阵
16
    std::cout << "Matrix:" << std::endl;
17
    for(auto row : matrix) {
18
        for(auto elem : row) {
19
            std::cout << elem << "\t";
20
        }
21
        std::cout << std::endl;
22
    }
23

24
    return 0;
25
}

输出：

1
Matrix:
2
1  2  3  4
3
5  6  7  8
4
9  10  11  12

4.2 向量与其他数据结构结合#

向量可以与结构体、类等其他数据结构结合使用，增强数据组织能力。

示例代码：向量与结构体结合

1
#include <iostream>
2
#include <vector>
3
#include <string>
4

5
// 定义学生结构体
6
struct Student {
7
    int id;
8
    std::string name;
9
    float grade;
10
};
11

12
int main() {
13
    // 定义一个学生向量
14
    std::vector<Student> students;
15

16
    // 添加学生
17
    students.push_back({1001, "Alice", 89.5});
18
    students.push_back({1002, "Bob", 92.0});
19
    students.push_back({1003, "Charlie", 85.0});
20

21
    // 遍历并输出学生信息
22
    for(const auto& student : students) {
23
        std::cout << "ID: " << student.id
24
                  << ", Name: " << student.name
25
                  << ", Grade: " << student.grade << std::endl;
26
    }
27

28
    return 0;
29
}

输出：

1
ID: 1001, Name: Alice, Grade: 89.5
2
ID: 1002, Name: Bob, Grade: 92
3
ID: 1003, Name: Charlie, Grade: 85

4.3 使用迭代器操作向量#

迭代器是一种指针类型，用于遍历和操作容器中的元素。

示例代码：使用迭代器

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec = {10, 20, 30, 40, 50};
6

7
    // 使用迭代器遍历并修改元素
8
    for(auto it = vec.begin(); it != vec.end(); ++it) {
9
        *it += 5;
10
    }
11

12
    // 输出修改后的向量
13
    std::cout << "After modifying: ";
14
    for(auto it = vec.begin(); it != vec.end(); ++it) {
15
        std::cout << *it << " ";
16
    }
17
    std::cout << std::endl; // 输出: 15 25 35 45 55
18

19
    return 0;
20
}

输出：

1
After modifying: 15 25 35 45 55

5. 常用算法与向量#

5.1 排序#

可以使用 <algorithm> 头文件中的 sort() 函数对向量进行排序。

示例代码：对整数向量排序

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<int> numbers = {50, 20, 40, 10, 30};
7

8
    // 排序前
9
    std::cout << "Before sorting: ";
10
    for(auto num : numbers) {
11
        std::cout << num << " ";
12
    }
13
    std::cout << std::endl;
14

15
    // 使用sort()排序
16
    std::sort(numbers.begin(), numbers.end());
17

18
    // 排序后
19
    std::cout << "After sorting: ";
20
    for(auto num : numbers) {
21
        std::cout << num << " ";
22
    }
23
    std::cout << std::endl;
24

25
    return 0;
26
}

输出：

1
Before sorting: 50 20 40 10 30
2
After sorting: 10 20 30 40 50

自定义排序规则：降序

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<int> numbers = {50, 20, 40, 10, 30};
7

8
    // 使用sort()并传入lambda表达式进行降序排序
9
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
10
        return a > b;
11
    });
12

13
    // 输出排序后的向量
14
    std::cout << "After sorting in descending order: ";
15
    for(auto num : numbers) {
16
        std::cout << num << " ";
17
    }
18
    std::cout << std::endl;
19

20
    return 0;
21
}

输出：

1
After sorting in descending order: 50 40 30 20 10

5.2 反转#

使用 reverse() 函数可以反转向量中的元素顺序。

示例代码：

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<char> letters = {'A', 'B', 'C', 'D', 'E'};
7

8
    std::cout << "Before reversing: ";
9
    for(auto c : letters) {
10
        std::cout << c << " ";
11
    }
12
    std::cout << std::endl;
13

14
    // 反转向量
15
    std::reverse(letters.begin(), letters.end());
16

17
    std::cout << "After reversing: ";
18
    for(auto c : letters) {
19
        std::cout << c << " ";
20
    }
21
    std::cout << std::endl;
22

23
    return 0;
24
}

输出：

1
Before reversing: A B C D E
2
After reversing: E D C B A

5.3 查找#

使用 find() 函数可以在向量中查找特定元素。

示例代码：

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
int main() {
6
    std::vector<std::string> fruits = {"Apple", "Banana", "Cherry", "Date"};
7
    std::string target = "Cherry";
8

9
    // 使用find()查找元素
10
    auto it = std::find(fruits.begin(), fruits.end(), target);
11

12
    if(it != fruits.end()) {
13
        std::cout << target << " found at position " << std::distance(fruits.begin(), it) << std::endl;
14
    }
15
    else {
16
        std::cout << target << " not found." << std::endl;
17
    }
18

19
    return 0;
20
}

输出：

1
Cherry found at position 2

6. 向量的性能与优化#

6.1 内存管理#

向量会动态地管理内存，自动调整其容量以适应新增或删除的元素。频繁的内存分配可能会影响性能。

6.2 预留空间#

使用 reserve() 可以提前为向量分配足够的内存，减少内存重新分配的次数，提高性能。

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec;
6

7
    // 预留空间
8
    vec.reserve(1000);
9
    std::cout << "Capacity after reserve(1000): " << vec.capacity() << std::endl;
10

11
    // 添加元素
12
    for(int i = 0; i < 1000; ++i) {
13
        vec.push_back(i);
14
    }
15

16
    std::cout << "Size after adding elements: " << vec.size() << std::endl;
17
    std::cout << "Capacity after adding elements: " << vec.capacity() << std::endl;
18

19
    return 0;
20
}

输出示例：

1
Capacity after reserve(1000): 1000
2
Size after adding elements: 1000
3
Capacity after adding elements: 1000

6.3 收缩容量#

使用 shrink_to_fit() 可以请求收缩向量的容量以匹配其大小，释放多余的内存。

示例代码：

1
#include <iostream>
2
#include <vector>
3

4
int main() {
5
    std::vector<int> vec;
6

7
    // 预留较大的空间
8
    vec.reserve(1000);
9
    std::cout << "Capacity before adding: " << vec.capacity() << std::endl;
10

11
    // 添加少量元素
12
    vec.push_back(1);
13
    vec.push_back(2);
14
    vec.push_back(3);
15
    std::cout << "Size after adding: " << vec.size() << std::endl;
16
    std::cout << "Capacity after adding: " << vec.capacity() << std::endl;
17

18
    // 收缩容量
19
    vec.shrink_to_fit();
20
    std::cout << "Capacity after shrink_to_fit: " << vec.capacity() << std::endl;
21

22
    return 0;
23
}

输出示例：

1
Capacity before adding: 1000
2
Size after adding: 3
3
Capacity after adding: 1000
4
Capacity after shrink_to_fit: 3

1. 引言#

什么是向量（Vector）？#

向量与数组的比较#

2. `std::vector` 基础#

2.1 包含头文件#

2.2 定义与初始化#

2.3 向量的大小与容量#

3. 向量的基本操作#

3.1 添加与删除元素#

3.2 访问元素#

3.3 遍历向量#

3.4 修改元素#

4. 向量的高级用法#

4.1 嵌套向量（二维向量）#

4.2 向量与其他数据结构结合#

4.3 使用迭代器操作向量#

5. 常用算法与向量#

5.1 排序#

5.2 反转#

5.3 查找#

6. 向量的性能与优化#

6.1 内存管理#

6.2 预留空间#

6.3 收缩容量#

文章分享

评论区

1. 引言#

什么是向量（Vector）？#

向量与数组的比较#

2. std::vector 基础#

2.1 包含头文件#

2.2 定义与初始化#

2.3 向量的大小与容量#

3. 向量的基本操作#

3.1 添加与删除元素#

3.2 访问元素#

3.3 遍历向量#

3.4 修改元素#

4. 向量的高级用法#

4.1 嵌套向量（二维向量）#

4.2 向量与其他数据结构结合#

4.3 使用迭代器操作向量#

5. 常用算法与向量#

5.1 排序#

5.2 反转#

5.3 查找#

6. 向量的性能与优化#

6.1 内存管理#

6.2 预留空间#

6.3 收缩容量#

文章分享

评论区

2. `std::vector` 基础#