青少年编程与数学 02-010 C++程序设计基础 39课题、标准库

课题摘要: C++标准库是一组预定义的类、函数、对象和模板，旨在提升编程效率。它包含容器（如std::vector、std::list等）、迭代器（遍历容器元素）、算法（处理容器中元素，如排序、查找）、函数对象（重载了()运算符的类对象）、数值计算（随机数生成、复数运算）、输入输出（流类和格式化功能）、字符串处理（如std::string和正则表达式）、内存管理（智能指针）及线程支持（多线程编程）。此外，C++标准模板库（STL）作为其一部分，核心组件包括容器、迭代器、算法和函数对象，提供了丰富的数据结构与算法，帮助程序员高效编程。

---

一、C++标准库

C++标准库（C++ Standard Library）是一组预定义的类、函数、对象和模板，它们提供了一套丰富的功能，帮助程序员更高效地编写C++程序。C++标准库是C++语言的一部分，由国际标准化组织（ISO）定义，并在C++编译器中实现。以下是C++标准库的主要组成部分：

1. 容器（Containers）

容器是用于存储和管理数据的类模板。C++标准库提供了多种类型的容器，每种容器都有其特定的用途和性能特点。

• 序列容器（Sequence Containers）：
  • std::vector：动态数组，支持动态内存分配。
  • std::list：双向链表，支持高效的插入和删除操作。
  • std::deque：双端队列，支持在两端高效地插入和删除元素。
  • std::array：固定大小的数组，性能高效。
  • std::forward_list：单向链表，支持高效的插入和删除操作。
• 关联容器（Associative Containers）：
  • std::set：存储唯一元素的排序集合。
  • std::multiset：存储元素的排序集合，允许重复元素。
  • std::map：存储键值对的排序集合，键唯一。
  • std::multimap：存储键值对的排序集合，允许重复键。
• 无序关联容器（Unordered Associative Containers）：
  • std::unordered_set：存储唯一元素的哈希集合。
  • std::unordered_multiset：存储元素的哈希集合，允许重复元素。
  • std::unordered_map：存储键值对的哈希集合，键唯一。
  • std::unordered_multimap：存储键值对的哈希集合，允许重复键。

2. 迭代器（Iterators）

迭代器是用于遍历容器中元素的指针-like对象。C++标准库提供了多种迭代器，每种迭代器都支持不同的操作。

• 输入迭代器（Input Iterators）：只读迭代器，支持单向遍历。
• 输出迭代器（Output Iterators）：只写迭代器，支持单向遍历。
• 前向迭代器（Forward Iterators）：支持单向遍历，可以多次遍历。
• 双向迭代器（Bidirectional Iterators）：支持双向遍历。
• 随机访问迭代器（Random Access Iterators）：支持随机访问，可以进行任意位置的访问。

3. 算法（Algorithms）

算法是用于处理容器中元素的函数模板。C++标准库提供了丰富的算法，可以对容器进行排序、查找、修改等操作。

• 排序算法：
  • std::sort：对容器中的元素进行排序。
  • std::stable_sort：对容器中的元素进行稳定排序。
  • std::partial_sort：对容器中的部分元素进行排序。
• 查找算法：
  • std::find：在容器中查找特定元素。
  • std::find_if：在容器中查找满足特定条件的元素。
  • std::binary_search：在有序容器中进行二分查找。
• 修改算法：
  • std::copy：复制容器中的元素。
  • std::transform：对容器中的元素进行转换。
  • std::remove：从容器中移除特定元素。

4. 函数对象（Function Objects）

函数对象是重载了函数调用运算符 () 的类对象。C++标准库提供了多种预定义的函数对象，可以用于算法中。

• 比较函数对象：
  • std::less：小于比较。
  • std::greater：大于比较。
  • std::equal_to：等于比较。
  • std::not_equal_to：不等于比较。
• 算术函数对象：
  • std::plus：加法。
  • std::minus：减法。
  • std::multiplies：乘法。
  • std::divides：除法。

5. 数值（Numerics）

数值库提供了用于数值计算的类和函数，包括随机数生成、复数运算、数值算法等。

• 随机数生成：
  • std::random_device：随机数设备。
  • std::mt19937：Mersenne Twister 随机数生成器。
  • std::uniform_int_distribution：均匀分布的整数生成器。
  • std::normal_distribution：正态分布的生成器。
• 复数运算：
  • std::complex：复数类。
• 数值算法：
  • std::accumulate：计算容器中元素的累加和。
  • std::inner_product：计算容器中元素的内积。
  • std::iota：生成递增序列。

6. 输入输出（Input/Output）

输入输出库提供了用于输入和输出的类和函数，包括文件输入输出、格式化输入输出等。

• 流类：
  • std::cin、std::cout、std::cerr、std::clog：标准输入输出流。
  • std::ifstream、std::ofstream、std::fstream：文件输入输出流。
  • std::istringstream、std::ostringstream、std::stringstream：字符串流。
• 格式化：
  • std::setw、std::setprecision、std::fixed、std::hex：格式化输入输出。

7. 字符串（Strings）

字符串库提供了用于处理字符串的类和函数，包括字符串操作、正则表达式等。

• 字符串类：
  • std::string：动态字符串。
  • std::wstring：宽字符字符串。
  • std::u16string：16位字符字符串。
  • std::u32string：32位字符字符串。
• 正则表达式：
  • std::regex：正则表达式类。
  • std::smatch：匹配结果类。
  • std::regex_search：在字符串中搜索正则表达式。
  • std::regex_replace：替换字符串中的匹配项。

8. 内存管理（Memory Management）

内存管理库提供了用于动态内存管理的类和函数，包括智能指针、分配器等。

• 智能指针：
  • std::unique_ptr：独占所有权的智能指针。
  • std::shared_ptr：共享所有权的智能指针。
  • std::weak_ptr：弱引用智能指针。
• 分配器：
  • std::allocator：默认分配器。

9. 线程支持（Thread Support）

线程支持库提供了用于多线程编程的类和函数，包括线程、互斥锁、条件变量等。

• 线程类：
  • std::thread：线程类。
• 互斥锁：
  • std::mutex：互斥锁。
  • std::recursive_mutex：递归互斥锁。
  • std::timed_mutex：定时互斥锁。
  • std::recursive_timed_mutex：递归定时互斥锁。
• 条件变量：
  • std::condition_variable：条件变量。
  • std::condition_variable_any：通用条件变量。

10. 时间（Time）

时间库提供了用于处理时间的类和函数，包括时钟、时间点、时间间隔等。

• 时钟：
  • std::chrono::system_clock：系统时钟。
  • std::chrono::steady_clock：稳定时钟。
  • std::chrono::high_resolution_clock：高分辨率时钟。
• 时间点和时间间隔：
  • std::chrono::time_point：时间点。
  • std::chrono::duration：时间间隔。

总结

C++标准库是一套功能强大的工具，提供了丰富的容器、算法、函数对象、数值计算、输入输出、字符串处理、内存管理、多线程支持和时间处理等功能。通过合理使用C++标准库，可以显著提高编程效率和代码质量。希望这些内容能帮助你更好地理解和使用C++标准库。

二、C++标准模板库

C++标准模板库（Standard Template Library，STL）是C++标准库的一部分，提供了一套丰富的数据结构和算法，帮助程序员更高效地编写C++程序。STL的核心组件包括容器（Containers）、迭代器（Iterators）、算法（Algorithms）和函数对象（Function Objects）。以下是对这些组件的详细介绍：

1. 容器（Containers）

容器是用于存储和管理数据的类模板。STL提供了多种类型的容器，每种容器都有其特定的用途和性能特点。

序列容器（Sequence Containers）

• std::vector：动态数组，支持动态内存分配。

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

• std::list：双向链表，支持高效的插入和删除操作。

  std::list<int> lst = {1, 2, 3, 4, 5};
  lst.push_back(6);
  

• std::deque：双端队列，支持在两端高效地插入和删除元素。

  std::deque<int> deq = {1, 2, 3, 4, 5};
  deq.push_back(6);
  deq.push_front(0);
  

• std::array：固定大小的数组，性能高效。

  std::array<int, 5> arr = {1, 2, 3, 4, 5};
  

• std::forward_list：单向链表，支持高效的插入和删除操作。

  std::forward_list<int> flst = {1, 2, 3, 4, 5};
  flst.push_front(0);
  

关联容器（Associative Containers）

• std::set：存储唯一元素的排序集合。

  std::set<int> s = {1, 2, 3, 4, 5};
  s.insert(6);
  

• std::multiset：存储元素的排序集合，允许重复元素。

  std::multiset<int> ms = {1, 2, 2, 3, 4, 5};
  ms.insert(6);
  

• std::map：存储键值对的排序集合，键唯一。

  std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
  m[4] = "four";
  

• std::multimap：存储键值对的排序集合，允许重复键。

  std::multimap<int, std::string> mm = {{1, "one"}, {1, "uno"}, {2, "two"}};
  mm.insert({3, "three"});
  

无序关联容器（Unordered Associative Containers）

• std::unordered_set：存储唯一元素的哈希集合。

  std::unordered_set<int> us = {1, 2, 3, 4, 5};
  us.insert(6);
  

• std::unordered_multiset：存储元素的哈希集合，允许重复元素。

  std::unordered_multiset<int> ums = {1, 2, 2, 3, 4, 5};
  ums.insert(6);
  

• std::unordered_map：存储键值对的哈希集合，键唯一。

  std::unordered_map<int, std::string> um = {{1, "one"}, {2, "two"}, {3, "three"}};
  um[4] = "four";
  

• std::unordered_multimap：存储键值对的哈希集合，允许重复键。

  std::unordered_multimap<int, std::string> umm = {{1, "one"}, {1, "uno"}, {2, "two"}};
  umm.insert({3, "three"});
  

2. 迭代器（Iterators）

迭代器是用于遍历容器中元素的指针-like对象。STL提供了多种迭代器，每种迭代器都支持不同的操作。

• 输入迭代器（Input Iterators）：只读迭代器，支持单向遍历。
• 输出迭代器（Output Iterators）：只写迭代器，支持单向遍历。
• 前向迭代器（Forward Iterators）：支持单向遍历，可以多次遍历。
• 双向迭代器（Bidirectional Iterators）：支持双向遍历。
• 随机访问迭代器（Random Access Iterators）：支持随机访问，可以进行任意位置的访问。

示例

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}
std::cout << std::endl;

3. 算法（Algorithms）

算法是用于处理容器中元素的函数模板。STL提供了丰富的算法，可以对容器进行排序、查找、修改等操作。

• 排序算法：
  • std::sort：对容器中的元素进行排序。
  • std::stable_sort：对容器中的元素进行稳定排序。
  • std::partial_sort：对容器中的部分元素进行排序。
• 查找算法：
  • std::find：在容器中查找特定元素。
  • std::find_if：在容器中查找满足特定条件的元素。
  • std::binary_search：在有序容器中进行二分查找。
• 修改算法：
  • std::copy：复制容器中的元素。
  • std::transform：对容器中的元素进行转换。
  • std::remove：从容器中移除特定元素。

示例

std::vector<int> vec = {5, 3, 8, 1, 2};
std::sort(vec.begin(), vec.end());

for (int i : vec) {
    std::cout << i << " ";
}
std::cout << std::endl;

auto it = std::find(vec.begin(), vec.end(), 3);
if (it != vec.end()) {
    std::cout << "Found 3 at position " << (it - vec.begin()) << std::endl;
} else {
    std::cout << "3 not found" << std::endl;
}

4. 函数对象（Function Objects）

函数对象是重载了函数调用运算符 () 的类对象。STL提供了多种预定义的函数对象，可以用于算法中。

• 比较函数对象：
  • std::less：小于比较。
  • std::greater：大于比较。
  • std::equal_to：等于比较。
  • std::not_equal_to：不等于比较。
• 算术函数对象：
  • std::plus：加法。
  • std::minus：减法。
  • std::multiplies：乘法。
  • std::divides：除法。

示例

std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> result(vec.size());

std::transform(vec.begin(), vec.end(), result.begin(), std::bind(std::plus<int>(), std::placeholders::_1, 10));

for (int i : result) {
    std::cout << i << " ";
}
std::cout << std::endl;

总结

C++标准模板库（STL）是一套功能强大的工具，提供了丰富的容器、迭代器、算法和函数对象。通过合理使用STL，可以显著提高编程效率和代码质量。希望这些内容能帮助你更好地理解和使用C++标准模板库。

三、C++标准库（包括STL）应用

使用C++标准库（包括STL）可以显著提高编程效率和代码质量。以下是一些基本步骤和最佳实践，帮助你更有效地使用C++标准库：

1. 包含必要的头文件

C++标准库的每个组件都有对应的头文件。在使用标准库的任何功能之前，需要包含相应的头文件。

示例

• 使用 std::vector：

  #include <vector>
  

• 使用 std::sort：

  #include <algorithm>
  

• 使用 std::string：

  #include <string>
  

2. 使用命名空间

C++标准库中的所有类、函数和对象都位于 std 命名空间中。你可以使用 using 声明或 using 指令来简化代码。

示例

• 使用 using 声明：

  using std::vector;
  using std::sort;
  

• 使用 using 指令（不推荐在头文件中使用）：

  using namespace std;
  

3. 使用容器

容器是用于存储和管理数据的类模板。选择合适的容器可以显著提高程序的性能和可维护性。

示例：使用 std::vector

#include <iostream>
#include <vector>

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

    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

示例：使用 std::map

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    m[4] = "four";

    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

4. 使用算法

算法是用于处理容器中元素的函数模板。C++标准库提供了丰富的算法，可以对容器进行排序、查找、修改等操作。

示例：使用 std::sort

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 3, 8, 1, 2};
    std::sort(vec.begin(), vec.end());

    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

示例：使用 std::find

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = std::find(vec.begin(), vec.end(), 3);

    if (it != vec.end()) {
        std::cout << "Found 3 at position " << (it - vec.begin()) << std::endl;
    } else {
        std::cout << "3 not found" << std::endl;
    }

    return 0;
}

5. 使用迭代器

迭代器是用于遍历容器中元素的指针-like对象。C++标准库中的每个容器都提供了迭代器，可以用于遍历、插入和删除元素。

示例：使用迭代器遍历 std::list

#include <iostream>
#include <list>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};

    for (auto it = lst.begin(); it != lst.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

6. 使用函数对象

函数对象是重载了函数调用运算符 () 的类对象。C++标准库提供了多种预定义的函数对象，可以用于算法中。

示例：使用 std::plus

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

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

    std::transform(vec.begin(), vec.end(), result.begin(), std::bind(std::plus<int>(), std::placeholders::_1, 10));

    for (int i : result) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

7. 使用智能指针

智能指针是用于自动管理动态分配内存的类。C++标准库提供了多种智能指针，可以防止内存泄漏和悬空指针。

示例：使用 std::unique_ptr

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    std::cout << *ptr << std::endl;

    return 0;
}

8. 使用线程

C++标准库提供了线程支持，可以用于多线程编程。

示例：使用 std::thread

#include <iostream>
#include <thread>

void print_block(int n, char c) {
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
}

int main() {
    std::thread t1(print_block, 50, '*');
    std::thread t2(print_block, 50, '$');

    t1.join();
    t2.join();

    return 0;
}

9. 使用时间库

C++标准库提供了时间支持，可以用于处理时间相关的操作。

示例：使用 std::chrono

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    auto start = std::chrono::high_resolution_clock::now();

    std::this_thread::sleep_for(std::chrono::seconds(1));

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = end - start;

    std::cout << "Elapsed time: " << elapsed.count() << " s\n";

    return 0;
}

总结

C++标准库提供了丰富的功能，帮助你更高效地编写C++程序。通过合理使用容器、算法、迭代器、函数对象、智能指针、线程和时间库，可以显著提高编程效率和代码质量。希望这些示例能帮助你更好地理解和使用C++标准库。

四、容器（Containers）

在C++中，容器（Containers）是用于存储和管理数据的类模板。它们提供了各种数据结构，可以方便地存储、访问和操作数据。C++标准库（STL）提供了多种类型的容器，每种容器都有其特定的用途和性能特点。以下是对C++标准库中主要容器的详细介绍：

1. 序列容器（Sequence Containers）

序列容器是按顺序存储元素的容器，支持在特定位置插入和删除元素。

• std::vector：动态数组，支持动态内存分配。提供高效的随机访问，但在中间插入和删除元素时效率较低。

  std::vector<int> vec = {1, 2, 3, 4, 5};
  vec.push_back(6); // 在末尾添加元素
  

• std::list：双向链表，支持高效的插入和删除操作。不支持高效的随机访问。

  std::list<int> lst = {1, 2, 3, 4, 5};
  lst.push_back(6); // 在末尾添加元素
  lst.push_front(0); // 在开头添加元素
  

• std::deque：双端队列，支持在两端高效地插入和删除元素。提供高效的随机访问。

  std::deque<int> deq = {1, 2, 3, 4, 5};
  deq.push_back(6); // 在末尾添加元素
  deq.push_front(0); // 在开头添加元素
  

• std::array：固定大小的数组，性能高效。提供高效的随机访问，但大小在编译时确定，不能动态改变。

  std::array<int, 5> arr = {1, 2, 3, 4, 5};
  

• std::forward_list：单向链表，支持高效的插入和删除操作。不支持高效的随机访问。

  std::forward_list<int> flst = {1, 2, 3, 4, 5};
  flst.push_front(0); // 在开头添加元素
  

2. 关联容器（Associative Containers）

关联容器是基于排序的容器，元素按特定顺序存储。它们支持高效的查找、插入和删除操作。

• std::set：存储唯一元素的排序集合。元素按升序排列，不允许重复元素。

  std::set<int> s = {1, 2, 3, 4, 5};
  s.insert(6); // 插入元素
  

• std::multiset：存储元素的排序集合，允许重复元素。元素按升序排列。

  std::multiset<int> ms = {1, 2, 2, 3, 4, 5};
  ms.insert(6); // 插入元素
  

• std::map：存储键值对的排序集合，键唯一。元素按键的升序排列。

  std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
  m[4] = "four"; // 插入键值对
  

• std::multimap：存储键值对的排序集合，允许重复键。元素按键的升序排列。

  std::multimap<int, std::string> mm = {{1, "one"}, {1, "uno"}, {2, "two"}};
  mm.insert({3, "three"}); // 插入键值对
  

3. 无序关联容器（Unordered Associative Containers）

无序关联容器是基于哈希表的容器，元素存储在哈希表中。它们支持高效的查找、插入和删除操作，但不保证元素的顺序。

• std::unordered_set：存储唯一元素的哈希集合。元素存储在哈希表中，不允许重复元素。

  std::unordered_set<int> us = {1, 2, 3, 4, 5};
  us.insert(6); // 插入元素
  

• std::unordered_multiset：存储元素的哈希集合，允许重复元素。元素存储在哈希表中。

  std::unordered_multiset<int> ums = {1, 2, 2, 3, 4, 5};
  ums.insert(6); // 插入元素
  

• std::unordered_map：存储键值对的哈希集合，键唯一。元素存储在哈希表中。

  std::unordered_map<int, std::string> um = {{1, "one"}, {2, "two"}, {3, "three"}};
  um[4] = "four"; // 插入键值对
  

• std::unordered_multimap：存储键值对的哈希集合，允许重复键。元素存储在哈希表中。

  std::unordered_multimap<int, std::string> umm = {{1, "one"}, {1, "uno"}, {2, "two"}};
  umm.insert({3, "three"}); // 插入键值对
  

4. 容器适配器（Container Adapters）

容器适配器是基于其他容器的简单接口，提供特定的数据结构。它们不支持完整的容器接口，但提供了特定的操作。

• std::stack：后进先出（LIFO）的栈。

  std::stack<int> stk;
  stk.push(1);
  stk.push(2);
  stk.push(3);
  std::cout << stk.top() << std::endl; // 输出 3
  stk.pop();
  

• std::queue：先进先出（FIFO）的队列。

  std::queue<int> q;
  q.push(1);
  q.push(2);
  q.push(3);
  std::cout << q.front() << std::endl; // 输出 1
  q.pop();
  

• std::priority_queue：优先级队列，元素按优先级排序。

  std::priority_queue<int> pq;
  pq.push(1);
  pq.push(3);
  pq.push(2);
  std::cout << pq.top() << std::endl; // 输出 3
  pq.pop();
  

总结

容器是C++标准库中的重要组成部分，提供了多种数据结构，可以方便地存储、访问和操作数据。通过合理选择和使用容器，可以显著提高程序的性能和可维护性。希望这些内容能帮助你更好地理解和使用C++中的容器。

五、迭代器（Iterators）

在C++中，迭代器（Iterators）是用于遍历容器中元素的指针-like对象。它们提供了一种统一的接口，可以遍历、访问和修改容器中的元素，而不需要关心容器的具体实现细节。迭代器是C++标准模板库（STL）的核心组件之一，使得算法可以独立于容器类型进行操作。

迭代器的分类

C++标准库定义了五种主要的迭代器类型，每种类型支持不同的操作：

1. 输入迭代器（Input Iterators）
   • 只读迭代器，支持单向遍历。
   • 可以用于读取容器中的元素，但不能修改元素。
   • 支持的操作：*it、++it、it1 == it2、it1 != it2。
2. 输出迭代器（Output Iterators）
   • 只写迭代器，支持单向遍历。
   • 可以用于写入容器中的元素，但不能读取元素。
   • 支持的操作：*it = value、++it。
3. 前向迭代器（Forward Iterators）
   • 支持单向遍历，可以多次遍历。
   • 支持的操作：*it、++it、it1 == it2、it1 != it2、*it = value。
4. 双向迭代器（Bidirectional Iterators）
   • 支持双向遍历，可以向前和向后移动。
   • 支持的操作：*it、++it、--it、it1 == it2、it1 != it2、*it = value。
5. 随机访问迭代器（Random Access Iterators）
   • 支持随机访问，可以进行任意位置的访问。
   • 支持的操作：*it、++it、--it、it1 == it2、it1 != it2、*it = value、it + n、it - n、it[n]、it1 - it2。

迭代器的使用

示例：使用迭代器遍历 std::vector

#include <iostream>
#include <vector>

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

    // 使用迭代器遍历
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用范围基于的 for 循环（C++11 及以后）
    for (const auto& element : vec) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

示例：使用迭代器修改 std::vector 中的元素

#include <iostream>
#include <vector>

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

    // 使用迭代器修改元素
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        *it *= 2; // 将每个元素乘以 2
    }

    // 输出修改后的元素
    for (const auto& element : vec) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

迭代器的常见操作

• 获取迭代器：
  • begin()：返回指向容器第一个元素的迭代器。
  • end()：返回指向容器最后一个元素之后的迭代器。
  • rbegin()：返回指向容器最后一个元素的反向迭代器。
  • rend()：返回指向容器第一个元素之前的反向迭代器。
• 迭代器运算：
  • ++it：将迭代器向前移动一个位置。
  • --it：将迭代器向后移动一个位置（对于双向和随机访问迭代器）。
  • it + n：将迭代器向前移动 n 个位置（对于随机访问迭代器）。
  • it - n：将迭代器向后移动 n 个位置（对于随机访问迭代器）。
  • it[n]：访问迭代器指向的第 n 个元素（对于随机访问迭代器）。

迭代器的注意事项

1. 迭代器失效：
   • 当容器的大小发生变化时（如插入、删除元素），某些迭代器可能会失效。例如，std::vector 在插入或删除元素时，所有迭代器都会失效，但 std::list 和 std::deque 只有受影响的迭代器会失效。
2. 反向迭代器：
   • 反向迭代器用于反向遍历容器。rbegin() 和 rend() 分别返回指向容器最后一个元素和第一个元素之前的反向迭代器。
3. 常量迭代器：
   • 常量迭代器（如 const_iterator）用于只读访问容器中的元素，不能修改元素。

总结

迭代器是C++标准库中的重要组件，提供了一种统一的接口，可以遍历、访问和修改容器中的元素。通过合理使用迭代器，可以编写更通用、更灵活的代码，提高程序的可维护性和性能。希望这些内容能帮助你更好地理解和使用C++中的迭代器。

六、命名空间（Namespace）

在C++中，命名空间（Namespace）是一种用于组织代码的机制，它可以帮助你避免命名冲突，将相关的类、函数、变量等封装在一起。命名空间提供了一种逻辑上的分组方式，使得代码更加模块化和易于管理。

命名空间的基本概念

1. 定义命名空间：

   • 使用 namespace 关键字定义一个命名空间。
   • 命名空间可以包含类、函数、变量、枚举等。

   namespace MyNamespace {
       int globalVar = 10;
   
       void myFunction() {
           std::cout << "MyFunction called" << std::endl;
       }
   
       class MyClass {
       public:
           void display() {
               std::cout << "MyClass::display called" << std::endl;
           }
       };
   }
   

2. 使用命名空间：

   • 作用域运算符（::）：使用作用域运算符来访问命名空间中的成员。
   • using 声明：使用 using 声明来引入命名空间中的特定成员。
   • using 指令：使用 using 指令来引入整个命名空间（不推荐在头文件中使用）。

   // 使用作用域运算符
   MyNamespace::myFunction();
   MyNamespace::MyClass obj;
   obj.display();
   
   // 使用 using 声明
   using MyNamespace::myFunction;
   using MyNamespace::MyClass;
   
   myFunction();
   MyClass obj;
   obj.display();
   
   // 使用 using 指令
   using namespace MyNamespace;
   
   myFunction();
   MyClass obj;
   obj.display();
   

命名空间的用途

1. 避免命名冲突：

   • 命名空间可以防止不同库或模块中的同名函数、类、变量等发生冲突。

   namespace LibraryA {
       void print() {
           std::cout << "LibraryA::print" << std::endl;
       }
   }
   
   namespace LibraryB {
       void print() {
           std::cout << "LibraryB::print" << std::endl;
       }
   }
   
   int main() {
       LibraryA::print(); // 调用 LibraryA 中的 print
       LibraryB::print(); // 调用 LibraryB 中的 print
       return 0;
   }
   

2. 组织代码：

   • 命名空间可以将相关的类、函数、变量等封装在一起，提高代码的可读性和可维护性。

   namespace Math {
       double add(double a, double b) {
           return a + b;
       }
   
       double subtract(double a, double b) {
           return a - b;
       }
   }
   
   int main() {
       double result = Math::add(5.0, 3.0);
       std::cout << "Result: " << result << std::endl;
       return 0;
   }
   

3. 模块化：

   • 命名空间可以用于模块化设计，将不同的功能模块封装在不同的命名空间中。

   namespace Network {
       void connect() {
           std::cout << "Network::connect" << std::endl;
       }
   }
   
   namespace Database {
       void connect() {
           std::cout << "Database::connect" << std::endl;
       }
   }
   
   int main() {
       Network::connect(); // 调用 Network 模块的 connect
       Database::connect(); // 调用 Database 模块的 connect
       return 0;
   }
   

命名空间的注意事项

1. 避免使用 using 指令：

   • 在头文件中使用 using 指令可能会导致命名冲突，因此不推荐在头文件中使用 using 指令。
   • 在源文件中使用 using 指令时要小心，确保不会引入命名冲突。

2. 嵌套命名空间：

   • 命名空间可以嵌套，但嵌套层次不宜过深，以免影响代码的可读性。

   namespace Outer {
       namespace Inner {
           void myFunction() {
               std::cout << "Outer::Inner::myFunction" << std::endl;
           }
       }
   }
   
   int main() {
       Outer::Inner::myFunction();
       return 0;
   }
   

3. 匿名命名空间：

   • 匿名命名空间用于限制变量、函数等的作用域，使其仅在当前文件中可见。

   namespace {
       int globalVar = 10;
   }
   
   void myFunction() {
       std::cout << "GlobalVar: " << globalVar << std::endl;
   }
   
   int main() {
       myFunction();
       // globalVar 在其他文件中不可见
       return 0;
   }
   

总结

命名空间是C++中用于组织代码、避免命名冲突的重要机制。通过合理使用命名空间，可以提高代码的可读性和可维护性，避免不同模块之间的命名冲突。希望这些内容能帮助你更好地理解和使用C++中的命名空间。