#c

C++向量(vector)容器

从普通数组到动态数组的进阶

#c
@鞠大龙
魅客科创中心

CONTENTS

目录

1. 普通数组的局限性

1.1 普通数组的问题

  • 固定大小：创建时必须指定大小，无法动态调整

    int arr[100]; // 即使只用10个元素，也要分配100个空间

  • 无法获取大小：没有内置方法获取数组长度

    int arr[] = {1, 2, 3, 4, 5};
// 需要手动计算: sizeof(arr) / sizeof(arr[0])

  • 传递困难：作为函数参数时退化为指针，丢失大小信息

    void process(int arr[]) { // 实际上是 int* arr
    // 无法在函数内部知道数组大小
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

1.2 普通数组的安全隐患

越界访问：

int arr[5] = {1, 2, 3, 4, 5};
arr[10] = 100; // 危险！越界访问

无边界检查：

  • C++不检查数组边界
  • 可能导致程序崩溃
  • 可能导致难以发现的bug
  • 可能导致安全漏洞

内存管理：

// 动态分配数组
int* arr = new int[10];
// 使用数组...
// 忘记释放内存
// delete[] arr;

问题：

  • 内存泄漏
  • 手动管理内存容易出错
  • 难以处理大小变化
返回目录 信息学 C++向量(vector)容器 魅客科创中心

1.3 需要更好的解决方案

理想的数组应该具备：

  1. 动态大小：根据需要自动调整大小
  2. 安全访问：提供边界检查
  3. 内置功能：自带大小查询、添加、删除等操作
  4. 自动内存管理：不需要手动释放内存
  5. 丰富的操作：支持排序、查找、遍历等常见操作

解决方案：C++标准库中的vector容器

返回目录 信息学 C++向量(vector)容器 魅客科创中心

2. vector基本概念

2.1 什么是vector？

vector是C++ 标准模板库(STL) 中的动态数组容器

  • 可以自动调整大小的数组
  • 存储在连续内存位置的元素集合
  • 支持随机访问和动态增长
  • 提供丰富的成员函数和操作
  • 需要包含头文件<vector>
#include <iostream>
#include <vector>  // 必须包含此头文件
using namespace std;

int main() {
    vector<int> numbers; // 创建一个空的整数vector
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

2.2 vector与普通数组的对比

普通数组：

// 创建
int arr[5] = {1, 2, 3, 4, 5};

// 访问
int x = arr[2]; // x = 3

// 修改
arr[0] = 10;

// 获取大小
int size = sizeof(arr) / sizeof(arr[0]);

// 无法动态调整大小
// 无法直接添加或删除元素

vector：

// 创建
vector<int> vec = {1, 2, 3, 4, 5};

// 访问
int x = vec[2]; // x = 3
int y = vec.at(2); // 带边界检查的访问

// 修改
vec[0] = 10;

// 获取大小
int size = vec.size();

// 添加和删除元素
vec.push_back(6); // 添加到末尾
vec.pop_back();   // 删除末尾元素
返回目录 信息学 C++向量(vector)容器 魅客科创中心

2.3 创建vector的方法

// 1. 创建空vector
vector<int> vec1;
// 2. 指定大小
vector<int> vec2(5);      // 5个元素，初始值为0
vector<int> vec3(5, 10);  // 5个元素，初始值为10
// 3. 使用初始化列表
vector<int> vec4 = {1, 2, 3, 4, 5};
vector<int> vec5{1, 2, 3, 4, 5};  // 与上面等价
// 4. 从另一个vector复制
vector<int> vec6(vec5);
vector<int> vec7 = vec5;
// 5. 从数组创建
int arr[] = {10, 20, 30, 40, 50};
vector<int> vec8(arr, arr + 5);
// 6. 创建二维vector
vector<vector<int>> matrix(3, vector<int>(4, 0));  // 3行4列，初始值为0
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3. vector常用操作

3.1 基本操作

vector<int> vec = {10, 20, 30, 40, 50};
// 访问元素
cout << vec[0] << endl;      // 10 (不检查边界)
cout << vec.at(1) << endl;   // 20 (检查边界)
cout << vec.front() << endl; // 10 (第一个元素)
cout << vec.back() << endl;  // 50 (最后一个元素)
// 修改元素
vec[0] = 100;
vec.at(1) = 200;
// 获取大小和容量
cout << vec.size() << endl;     // 元素个数
cout << vec.capacity() << endl; // 当前分配的存储空间
cout << vec.empty() << endl;    // 是否为空
// 调整大小
vec.resize(7);     // 调整为7个元素，新元素为0
vec.resize(10, 8); // 调整为10个元素，新元素为8
vec.shrink_to_fit(); // 减少容量以适应实际大小
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3.1.1 front()和back()方法详解

front()和back()方法：

vector<int> vec = {10, 20, 30, 40, 50};

// front() - 访问第一个元素
int first = vec.front();  // 10
// 等价于 vec[0]，但更安全，因为它不会在空vector上导致未定义行为

// back() - 访问最后一个元素
int last = vec.back();    // 50
// 等价于 vec[vec.size()-1]，但更简洁且安全
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3.1.2 安全访问

安全访问的最佳实践：

vector<int> vec = {10, 20, 30, 40, 50};

// 在访问元素前检查vector是否为空
if (!vec.empty()) {
    cout << "第一个元素: " << vec.front() << endl;
    cout << "最后一个元素: " << vec.back() << endl;
}

// 使用at()进行带边界检查的访问
try {
    cout << vec.at(2) << endl;  // 安全访问第三个元素
    cout << vec.at(10) << endl; // 会抛出std::out_of_range异常
} catch (const std::out_of_range& e) {
    cout << "越界访问: " << e.what() << endl;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3.2 添加和删除元素

添加元素：

vector<int> vec = {1, 2, 3};
// 在末尾添加
vec.push_back(4);  // {1, 2, 3, 4}
// 在指定位置插入
vec.insert(vec.begin() + 1, 5);  
// {1, 5, 2, 3, 4}

// 在指定位置插入多个相同元素
vec.insert(vec.begin(), 3, 0);  
// {0, 0, 0, 1, 5, 2, 3, 4}

// 插入另一个vector的内容
vector<int> v2 = {9, 8};
vec.insert(vec.end(), v2.begin(), v2.end());
// {0, 0, 0, 1, 5, 2, 3, 4, 9, 8}

删除元素：

vector<int> vec = {1, 2, 3, 4, 5};
// 删除末尾元素
vec.pop_back();  // {1, 2, 3, 4}
// 删除指定位置的元素
vec.erase(vec.begin() + 1);  // {1, 3, 4}
// 删除一个范围内的元素
vec.erase(vec.begin(), vec.begin() + 2);  
// {4}
// 清空所有元素
vec.clear();  // {}

注意：

  • erase和insert操作后，迭代器可能失效
  • 这些操作的时间复杂度为
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3.3 迭代器和遍历

迭代器是用于访问容器元素的对象，类似于指针

begin()和end()方法：

vector<int> vec = {10, 20, 30, 40, 50};

// begin() - 返回指向第一个元素的迭代器
auto it_begin = vec.begin();
cout << *it_begin << endl;  // 10
// 可以通过迭代器修改元素
*it_begin = 100;  // 现在vec是 {100, 20, 30, 40, 50}

// end() - 返回指向末尾后一个位置的迭代器（不指向实际元素）
auto it_end = vec.end();
// 注意：不能直接解引用end()迭代器，因为它指向末尾之后的位置

// 使用迭代器访问特定位置
auto third = vec.begin() + 2;  // 指向第三个元素
cout << *third << endl;  // 30
返回目录 信息学 C++向量(vector)容器 魅客科创中心

3.4 迭代器遍历

迭代器的使用方式：

vector<int> vec = {10, 20, 30, 40, 50};
// 使用迭代器遍历
for (vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    cout << *it << " ";  // 10 20 30 40 50
}
// 使用auto简化（C++11）
for (auto it = vec.begin(); it != vec.end(); ++it) {
    cout << *it << " ";  // 10 20 30 40 50
}
// 使用范围for循环（C++11）
for (int val : vec) {
    cout << val << " ";  // 10 20 30 40 50
}
// 反向迭代器
for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    cout << *it << " ";  // 50 40 30 20 10
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

4. vector高级用法

4.1 vector的内存管理

vector如何管理内存：

  • 在连续内存块中存储元素
  • 当空间不足时，分配更大的新内存块
  • 通常是当前容量的1.5倍或2倍
  • 将旧元素复制到新内存，释放旧内存
  • 这个过程称为"重新分配"(reallocation)
vector<int> vec;
cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << endl;

for (int i = 0; i < 10; i++) {
    vec.push_back(i);
    cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() << endl;
}

// 输出可能类似于：
// Size: 0, Capacity: 0
// Size: 1, Capacity: 1
// Size: 2, Capacity: 2
// Size: 3, Capacity: 4
// Size: 4, Capacity: 4
// Size: 5, Capacity: 8
// ...
返回目录 信息学 C++向量(vector)容器 魅客科创中心

4.2 预分配内存

为什么预分配内存：

  • 减少重新分配次数
  • 提高性能
  • 避免迭代器失效
  • 适用于已知大致元素数量的情况

reserve vs resize：

  • reserve：仅分配内存，不创建元素
  • resize：调整大小并创建元素
// 不预分配
vector<int> v1;
for (int i = 0; i < 10000; i++) {
    v1.push_back(i);  // 可能多次重新分配
}
// 预分配
vector<int> v2;
v2.reserve(10000);  // 一次性分配足够空间
for (int i = 0; i < 10000; i++) {
    v2.push_back(i);  // 不会重新分配
}
// 使用resize
vector<int> v3;
v3.resize(10000);  // 创建10000个值为0的元素
for (int i = 0; i < 10000; i++) {
    v3[i] = i;  // 直接赋值，不使用push_back
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

4.3 自定义类型的vector

vector可以存储任何类型的元素，包括结构体。

// 定义一个学生结构体
struct Student {
    string name;
    int age;
    double score;
    
    // 构造函数
    Student(string n, int a, double s) : 
    name(n), age(a), score(s) {}
    
    // 显示学生信息
    void display() const {
        cout << "Name: " << name 
             << ", Age: " << age 
             << ", Score: " << score << endl;
    }
};

int main() {
    // 创建Student结构体的vector
    vector<Student> students;
    
    // 添加学生
    students.push_back(Student("Alice", 15, 92.5));
    students.push_back(Student("Bob", 16, 85.0));
    students.push_back(Student("Charlie", 15, 97.5));
    
    // 遍历并显示所有学生
    for (const auto& student : students) {
        student.display();
    }    
    // 直接访问结构体成员
    cout << "第一名学生: " << students[0].name 
         << ", 分数: " << students[0].score << endl; 
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

4.4 二维vector和多维vector

二维vector：

// 创建5x4的二维vector
vector<vector<int>> matrix(5, vector<int>(4, 0));

// 访问和修改元素
matrix[2][3] = 10;

// 获取行数和列数
int rows = matrix.size();
int cols = matrix[0].size();

// 遍历二维vector
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        cout << matrix[i][j] << " ";
    }
    cout << endl;
}

不规则二维vector：

// 创建行数不固定的二维vector
vector<vector<int>> irregular;
// 添加不同长度的行
irregular.push_back({1, 2, 3});
irregular.push_back({4, 5});
irregular.push_back({6, 7, 8, 9});
// 遍历不规则二维vector
for (const auto& row : irregular) {
    for (int val : row) {
        cout << val << " ";
    }
    cout << endl;
}
// 输出:
// 1 2 3
// 4 5
// 6 7 8 9
返回目录 信息学 C++向量(vector)容器 魅客科创中心

4.5 多维vector

三维及更高维：

// 三维vector (2x3x4)
vector<vector<vector<int>>> cube(2,vector<vector<int>>(3, vector<int>(4, 0)));
返回目录 信息学 C++向量(vector)容器 魅客科创中心

5. vector与算法库

5.1 常用算法

C++标准库提供了许多可以与vector一起使用的算法，需要包含<algorithm>头文件

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main() {
    vector<int> vec = {5, 2, 8, 1, 9, 3, 7, 4, 6};  
    sort(vec.begin(), vec.end());  // 排序 {1, 2, 3, 4, 5, 6, 7, 8, 9}  
    sort(vec.begin(), vec.end(), greater<int>());  //反向排序 {9, 8, 7, 6, 5, 4, 3, 2, 1}    
    auto it = find(vec.begin(), vec.end(), 7); // 查找元素
    if (it != vec.end()) {
        cout << "Found 7 at position: " << (it - vec.begin()) << endl;
    }      
    int count = count(vec.begin(), vec.end(), 5);   // 计算元素出现次数    
    auto minmax = minmax_element(vec.begin(), vec.end()); // 最大值和最小值
    cout << "Min: " << *minmax.first << ", Max: " << *minmax.second << endl;   
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

5.2 自定义排序

使用比较函数：

// 自定义比较函数
bool compareByAbsValue(int a, int b) {
    return abs(a) < abs(b);
}

int main() {
    vector<int> vec = {-5, 3, -2, 8, -1, 0, 4};
    
    // 按绝对值排序
    sort(vec.begin(), vec.end(), compareByAbsValue);
    // {0, -1, -2, 3, 4, -5, 8}
    
    return 0;
}

使用lambda表达式(C++11)：

vector<int> vec = {-5, 3, -2, 8, -1, 0, 4};
// 使用lambda表达式按绝对值排序
sort(vec.begin(), vec.end(), 
    [](int a, int b) {
        return abs(a) < abs(b);
    }
);// {0, -1, -2, 3, 4, -5, 8}

排序自定义类型：

// 按学生成绩排序
sort(students.begin(), students.end(),
    [](const Student& a, const Student& b) {
        return a.score > b.score;  // 直接访问公开成员
    }
);
返回目录 信息学 C++向量(vector)容器 魅客科创中心

5.3 其他常用算法

vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6, 5};
vector<int> vec2(5);

reverse(vec.begin(), vec.end());  //反转 {5, 6, 2, 9, 5, 1, 4, 1, 3}
random_shuffle(vec.begin(), vec.end());// 随机打乱

sort(vec.begin(), vec.end());
auto last = unique(vec.begin(), vec.end());// 去除重复元素（需要先排序）
vec.erase(last, vec.end());  // {1, 2, 3, 4, 5, 6, 9}

copy(vec.begin(), vec.begin() + 5, vec2.begin());// 复制元素
fill(vec2.begin(), vec2.end(), 10);  // 填充元素所有元素设为10

vector<int> seq(10);
iota(seq.begin(), seq.end(), 1);  //生成序列 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

int sum = accumulate(vec.begin(), vec.end(), 0);// 累加
vector<int> partialSums(vec.size());
partial_sum(vec.begin(), vec.end(), partialSums.begin());// 部分和
返回目录 信息学 C++向量(vector)容器 魅客科创中心

6. 应用实例

6.1 区间合并 (CSES - Range Merge)

题目说明：

  • 目标：给定n个区间[a,b]，合并所有重叠的区间
  • 输入：n个区间的起点和终点
  • 输出：合并后的区间数量和这些区间

问题分析：

  • 使用vector存储所有区间，每个区间是一个pair<int,int>
  • 对区间按照起点排序
  • 遍历排序后的区间，合并重叠的区间
  • vector的排序和动态增长特性非常适合此问题
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    // 存储所有区间
    vector<pair<int, int>> intervals;
    
    // 读取区间
    for (int i = 0; i < n; i++) {
        int start, end;
        cin >> start >> end;
        intervals.push_back({start, end});
    }
    
    // 按区间起点排序
    sort(intervals.begin(), intervals.end());
    
    // 合并重叠区间
    vector<pair<int, int>> merged;
    merged.push_back(intervals[0]);
    
    for (int i = 1; i < n; i++) {
        // 如果当前区间的起点小于等于上一个合并区间的终点，则合并
        if (intervals[i].first <= merged.back().second) {
            merged.back().second = max(merged.back().second, intervals[i].second);
        } else {
            // 否则添加新区间
            merged.push_back(intervals[i]);
        }
    }
    
    // 输出结果
    cout << "合并后的区间数量: " << merged.size() << endl;
    for (const auto& interval : merged) {
        cout << "[" << interval.first << ", " << interval.second << "] ";
    }
    cout << endl;
    
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

6.2 滑动窗口最大值 (CSP-S 2019)

题目说明：

  • 目标：给定一个数组和一个窗口大小k，找出所有长度为k的窗口中的最大值
  • 输入：数组长度n，窗口大小k，以及n个整数
  • 输出：每个窗口的最大值

问题分析：

  • 使用vector存储输入数组和结果
  • 使用双端队列(deque)维护窗口内的元素索引，保持队列中的元素单调递减
  • 对于每个新元素，移除队列中所有小于它的元素
  • vector与其他STL容器的结合使用展示了C++的强大功能
#include <iostream>
#include <vector>
#include <deque>
using namespace std;

vector<int> maxSlidingWindow(const vector<int>& nums, int k) {
    vector<int> result;
    deque<int> dq; // 存储元素的索引
    
    for (int i = 0; i < nums.size(); i++) {
        // 移除不在当前窗口的元素
        while (!dq.empty() && dq.front() < i - k + 1) {
            dq.pop_front();
        }
        
        // 移除所有小于当前元素的值
        while (!dq.empty() && nums[dq.back()] < nums[i]) {
            dq.pop_back();
        }
        
        // 添加当前元素的索引
        dq.push_back(i);
        
        // 当窗口形成后，记录最大值
        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }
    
    return result;
}

int main() {
    int n, k;
    cin >> n >> k;
    
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    
    vector<int> result = maxSlidingWindow(nums, k);
    
    cout << "滑动窗口最大值: ";
    for (int val : result) {
        cout << val << " ";
    }
    cout << endl;
    
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

6.3 最长上升子序列 (POJ 2533)

题目说明：

  • 目标：找出一个数列中的最长上升子序列的长度
  • 输入：数列长度n和n个整数
  • 输出：最长上升子序列的长度

问题分析：

  • 使用vector存储输入数列和动态规划数组
  • 对于每个位置i，计算以i结尾的最长上升子序列长度
  • 使用二分查找优化算法，将时间复杂度从O(n²)降低到O(nlogn)
  • 展示了vector在动态规划和二分查找中的应用
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int lengthOfLIS(const vector<int>& nums) {
    if (nums.empty()) return 0;
    
    // tails[i]表示长度为i+1的上升子序列的最小结尾值
    vector<int> tails;
    
    for (int num : nums) {
        // 使用二分查找找到第一个大于等于num的位置
        auto it = lower_bound(tails.begin(), tails.end(), num);
        
        if (it == tails.end()) {
            // 如果所有值都小于num，添加到末尾
            tails.push_back(num);
        } else {
            // 否则更新该位置的值
            *it = num;
        }
    }
    
    return tails.size();
}

int main() {
    int n;
    cin >> n;
    
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }
    
    int result = lengthOfLIS(nums);
    cout << "最长上升子序列的长度: " << result << endl;
    
    return 0;
}
返回目录 信息学 C++向量(vector)容器 魅客科创中心

6.4 二维前缀和 (USACO 2019)

返回目录 信息学 C++向量(vector)容器 魅客科创中心

7. 练习题

7.1 基础练习 (CSP-J)

  1. 成绩统计：

    • 输入：n个学生的成绩
    • 输出：平均分、最高分、最低分
    • 要求：使用vector存储成绩，计算统计值

  2. 数字反转：

    • 输入：一个整数
    • 输出：各位数字反转后的数
    • 要求：使用vector存储各位数字

  3. 简单排序：

    • 输入：n个整数
    • 输出：排序后的结果
    • 要求：使用vector和sort函数
返回目录 信息学 C++向量(vector)容器 魅客科创中心

7.2 中级练习 (CSES)

  1. 删除重复元素：

    • 输入：n个可能有重复的整数
    • 输出：删除重复元素后的vector
    • 要求：保持原始顺序

  2. 区间查询：

    • 输入：n个区间和q个查询
    • 输出：每个查询区间内包含的区间数量
    • 要求：使用vector存储区间

  3. 滑动窗口最小值：

    • 输入：n个整数和窗口大小k
    • 输出：每个窗口的最小值
    • 要求：使用vector和deque
返回目录 信息学 C++向量(vector)容器 魅客科创中心

7.3 高级练习 (USACO/POJ)

1. 学生成绩管理系统：

  • 使用vector存储学生信息（姓名、多科成绩）
  • 实现按总分、单科成绩排序
  • 计算各科平均分、最高分、最低分

2. 通讯录管理：

  • 使用vector存储联系人（姓名、电话、邮箱）
  • 实现添加、删除、查找、修改功能
  • 支持按姓名排序

3. 矩阵运算：

  • 使用二维vector表示矩阵
  • 实现矩阵加、减、乘、转置
  • 可选：行列式计算

4. 图像处理：

  • 使用二维vector表示灰度图像
  • 实现旋转、翻转、缩放
  • 可选：边缘检测滤镜
返回目录 信息学 C++向量(vector)容器 魅客科创中心

7.4 在线评测平台题目

USACO：

  1. Livestock Lineup (★★☆☆☆)

    • 使用vector存储和排序奶牛名称
    • 练习vector的排序和条件处理

  2. Why Did the Cow Cross the Road (★★★☆☆)

    • 使用vector存储和处理区间
    • 练习vector的排序和查找操作

POJ/HDU：

  1. POJ 3069 - Saruman's Army (★★☆☆☆)

    • 使用vector存储点的位置
    • 练习贪心算法和vector操作

  2. HDU 1232 - 畅通工程 (★★☆☆☆)

    • 使用vector存储图的边
    • 练习vector在图论中的应用
**2. 简易通讯录** - 创建一个联系人类，包含姓名、电话、邮箱等信息 - 使用vector存储联系人 - 实现添加、删除、查找、修改联系人的功能 - 实现按姓名排序的功能

3. 矩阵计算器

  • 使用二维vector表示矩阵
  • 实现矩阵加法、减法、乘法
  • 实现矩阵转置
  • 计算行列式（选做）

4. 图像处理

  • 使用二维vector表示灰度图像
  • 实现图像旋转、翻转
  • 实现图像缩放
  • 应用不同的滤镜效果（如边缘检测）
返回目录 信息学 C++向量(vector)容器 魅客科创中心

7.4 在线评测平台题目

USACO：

  1. Livestock Lineup (★★☆☆☆)
    • 使用vector存储和排序奶牛名称
    • 练习vector的排序和条件处理
  2. Why Did the Cow Cross the Road (★★★☆☆)
    • 使用vector存储和处理区间
    • 练习vector的排序和查找操作

POJ：

  1. POJ 3069 - Saruman's Army (★★☆☆☆)
    • 使用vector存储点的位置
    • 练习贪心算法和vector操作

HDU：

  1. HDU 1213 - How Many Tables (★★☆☆☆)
    • 使用vector实现并查集
    • 练习vector作为数据结构的应用
  2. HDU 1232 - 畅通工程 (★★☆☆☆)
    • 使用vector存储图的边
    • 练习vector在图论中的应用
返回目录 信息学 C++向量(vector)容器 魅客科创中心

8. 总结

8.1 vector的优势

  • 动态大小：可以根据需要自动调整大小
  • 安全访问：提供边界检查（通过at()方法）
  • 丰富功能：自带大量成员函数和可用算法
  • 自动内存管理：不需要手动释放内存
  • 高效操作：支持快速随机访问和尾部操作
  • 灵活性：可以存储任何类型的元素
  • 与算法库配合：可以使用STL算法进行各种操作
返回目录 信息学 C++向量(vector)容器 魅客科创中心

8.2 学习建议

  1. 从简单开始：先掌握基本操作，如创建、访问、添加和删除
  2. 理解内存管理：了解vector如何管理内存，以及何时使用reserve
  3. 熟悉迭代器：学会使用迭代器遍历和操作vector
  4. 结合算法库：学习如何将vector与STL算法结合使用
  5. 实践应用：通过解决实际问题来巩固所学知识
  6. 阅读文档：查阅C++参考文档，了解更多vector的功能

#c

返回目录 信息学 C++向量(vector)容器 魅客科创中心
C++向量(vector)容器

#c

感谢学习！
如有疑问，请联系：
judal@xmaker.org
魅客科创中心

这个讲义使用了Awesome Marp主题的蓝色风格。 内容针对中小学生设计，使用简单易懂的语言和示例。 假设学生已经了解普通数组的使用。