• 《C++ Primer》导学系列：第 3 章 - 字符串、向量和数组

    3.1 命名空间的使用

    概述

    命名空间是C++中的一种机制，用于组织代码并避免名字冲突。通过使用命名空间，可以将全局作用域中的标识符组织到逻辑分组中，从而提高代码的可读性和可维护性。命名空间在大型项目中尤为重要，因为它们可以防止不同模块之间的名字冲突。

    3.1.1 定义命名空间

    命名空间使用关键字namespace来定义，后跟命名空间的名字和一对花括号。在花括号内定义的所有标识符都属于这个命名空间。

    • 语法：
    1. namespace 命名空间名 {
    2.     // 命名空间内的内容
    3. }

    • 示例：
    1. namespace myNamespace {
    2.     int myVariable = 42;
    3.  
    4.     void myFunction() {
    5.         std::cout << "Hello from myNamespace!" << std::endl;
    6.     }
    7. }

    3.1.2 使用命名空间

    为了访问命名空间中的成员，可以使用作用域解析运算符::，或者使用using声明将命名空间引入作用域。

    直接访问

    通过作用域解析运算符::来访问命名空间中的成员。

    • 示例：
    1. int main() {
    2.     std::cout << myNamespace::myVariable << std::endl;
    3.     myNamespace::myFunction();
    4.     return 0;
    5. }

    using声明

    使用using声明可以将命名空间中的某个成员引入当前作用域。

    • 语法：
    using 命名空间名::成员名;

    • 示例：
    1. int main() {
    2.     using myNamespace::myVariable;
    3.     using myNamespace::myFunction;
    4.     std::cout << myVariable << std::endl;
    5.     myFunction();
    6.     return 0;
    7. }

    using指示

    使用using指示可以将整个命名空间引入当前作用域。

    • 语法：
    using namespace 命名空间名;

    • 示例：
    1. int main() {
    2.     using namespace myNamespace;
    3.     std::cout << myVariable << std::endl;
    4.     myFunction();
    5.     return 0;
    6. }

    3.1.3 命名空间嵌套

    命名空间可以嵌套定义，以创建分层次的逻辑组织结构。嵌套的命名空间可以通过嵌套的::来访问。

    • 示例：
    1. namespace outer {
    2.     namespace inner {
    3.         int value = 100;
    4.     }
    5. }
    6.  
    7. int main() {
    8.     std::cout << outer::inner::value << std::endl;
    9.     return 0;
    10. }

    3.1.4 匿名命名空间

    匿名命名空间没有名字，定义在匿名命名空间中的成员只能在定义它们的文件中访问。这是一种实现文件内私有的机制。

    • 示例：
    1. namespace {
    2.     int secret = 42;
    3.  
    4.     void secretFunction() {
    5.         std::cout << "This is a secret function." << std::endl;
    6.     }
    7. }
    8.  
    9. int main() {
    10.     std::cout << secret << std::endl;
    11.     secretFunction();
    12.     return 0;
    13. }

    重点与难点分析

    重点：

    1. 命名空间的定义和使用：掌握命名空间的基本概念和定义方法，理解如何使用作用域解析运算符和using声明/指示。
    2. 命名空间嵌套：理解嵌套命名空间的用法，能够通过嵌套的::访问嵌套命名空间中的成员。
    3. 匿名命名空间：了解匿名命名空间的作用及其在实现文件内私有机制中的应用。

    难点：

    1. 命名空间冲突的解决：初学者需要通过实践理解如何使用命名空间解决名字冲突的问题。
    2. 合理使用using声明和指示：在实际编程中，合理使用using声明和指示，避免污染全局命名空间。

    练习题解析
    1. 练习3.1：定义一个命名空间，包含一个变量和一个函数，并在主函数中访问它们。
      • 示例代码：
    1. #include 
    2.  
    3. namespace myNamespace {
    4.     int myVariable = 42;
    5.  
    6.     void myFunction() {
    7.         std::cout << "Hello from myNamespace!" << std::endl;
    8.     }
    9. }
    10.  
    11. int main() {
    12.     std::cout << myNamespace::myVariable << std::endl;
    13.     myNamespace::myFunction();
    14.     return 0;
    15. }

    1. 练习3.2：使用using声明和指示分别引入命名空间的成员和整个命名空间。
      • 示例代码：
    1. #include 
    2.  
    3. namespace myNamespace {
    4.     int myVariable = 42;
    5.  
    6.     void myFunction() {
    7.         std::cout << "Hello from myNamespace!" << std::endl;
    8.     }
    9. }
    10.  
    11. int main() {
    12.     using myNamespace::myVariable;
    13.     using myNamespace::myFunction;
    14.  
    15.     std::cout << myVariable << std::endl;
    16.     myFunction();
    17.  
    18.     using namespace myNamespace;
    19.     std::cout << myVariable << std::endl;
    20.     myFunction();
    21.  
    22.     return 0;
    23. }

    1. 练习3.3：定义嵌套命名空间，并访问嵌套命名空间中的成员。
      • 示例代码：
    1. #include 
    2.  
    3. namespace outer {
    4.     namespace inner {
    5.         int value = 100;
    6.     }
    7. }
    8.  
    9. int main() {
    10.     std::cout << outer::inner::value << std::endl;
    11.     return 0;
    12. }

    1. 练习3.4：定义匿名命名空间，并在主函数中访问匿名命名空间中的成员。
      • 示例代码：
    1. #include 
    2.  
    3. namespace {
    4.     int secret = 42;
    5.  
    6.     void secretFunction() {
    7.         std::cout << "This is a secret function." << std::endl;
    8.     }
    9. }
    10.  
    11. int main() {
    12.     std::cout << secret << std::endl;
    13.     secretFunction();
    14.     return 0;
    15. }

    总结与提高

    本节总结：

    1. 学习了命名空间的基本概念和定义方法，理解了如何通过作用域解析运算符和using声明/指示来使用命名空间。
    2. 掌握了嵌套命名空间和匿名命名空间的定义和使用方法，理解了它们在组织代码和实现文件内私有机制中的作用。
    3. 通过实际编程练习，初步掌握了命名空间的应用，提高了代码的可读性和可维护性。

    提高建议：

    1. 多练习命名空间的使用：通过编写各种使用命名空间的小程序，熟悉命名空间的定义和使用方法。
    2. 理解命名空间冲突的解决：在实际编程中，理解并解决命名空间冲突的问题，提高代码的可读性和可维护性。
    3. 合理使用using声明和指示：在编写代码时，合理使用using声明和指示，避免污染全局命名空间，保持代码的清晰和结构化。
    4. 在头文件中不应该包含using声明：如果头文件里有某个using声明，那么每个使用了该头文件的文件都会有这个声明，有可能会引起始料未及的名字冲突。

    3.2 标准库类型string

    概述

    C++标准库中的string类型是一个用于表示和操作字符串的类。string类型提供了一系列强大而灵活的功能，使得处理文本变得更加简单和高效。在本小节中，我们将深入探讨string类型的基本用法和操作。

    3.2.1 定义和初始化string对象
    定义string对象

    string对象可以用多种方式定义和初始化。

    • 示例：
    1. std::string s1;  // 默认初始化，s1是一个空字符串
    2. std::string s2 = "Hello, World!";  // 使用字符串字面值初始化
    3. std::string s3("C++ Primer");  // 直接初始化
    4. std::string s4(s2);  // 拷贝初始化
    5. std::string s5(10, 'a');  // 初始化为10个'a'字符组成的字符串

    字符串的拼接

    可以使用+运算符将两个字符串拼接在一起，或者使用+=运算符将一个字符串添加到另一个字符串的末尾。

    • 示例：
    1. std::string s1 = "Hello";
    2. std::string s2 = "World";
    3. std::string s3 = s1 + ", " + s2 + "!";  // 拼接字符串
    4. std::cout << s3 << std::endl;  // 输出 "Hello, World!"
    5.  
    6. s1 += ", ";
    7. s1 += s2;
    8. std::cout << s1 << std::endl;  // 输出 "Hello, World"

    3.2.2 基本操作
    获取string对象的长度

    使用size()或length()成员函数可以获取字符串的长度。

    • 示例：
    1. std::string s = "Hello";
    2. std::cout << "Length: " << s.size() << std::endl;  // 输出长度

    访问和修改字符

    使用下标运算符[]或at()成员函数可以访问和修改字符串中的字符。

    • 示例：
    1. std::string s = "Hello";
    2. char c1 = s[1];  // 获取第二个字符 'e'
    3. char c2 = s.at(1);  // 获取第二个字符 'e'
    4.  
    5. s[0] = 'h';  // 修改第一个字符为 'h'
    6. s.at(1) = 'a';  // 修改第二个字符为 'a'
    7. std::cout << s << std::endl;  // 输出 "hallo"

    输入和输出

    使用标准输入输出流可以读取和输出字符串。

    • 示例：
    1. std::string s;
    2. std::cout << "Enter a string: ";
    3. std::cin >> s;  // 读取一个单词
    4. std::cout << "You entered: " << s << std::endl;
    5.  
    6. std::cin.ignore();  // 忽略换行符
    7. std::cout << "Enter a line: ";
    8. std::getline(std::cin, s);  // 读取一整行
    9. std::cout << "You entered: " << s << std::endl;

    3.2.3 string对象的操作函数
    比较字符串

    使用关系运算符可以比较字符串。

    • 示例：
    1. std::string s1 = "abc";
    2. std::string s2 = "def";
    3. if (s1 < s2) {
    4.     std::cout << s1 << " is less than " << s2 << std::endl;
    5. }

    查找和替换

    string类提供了多种查找和替换的成员函数，如find()、replace()等。

    • 示例：
    1. std::string s = "Hello, World!";
    2. auto pos = s.find("World");
    3. if (pos != std::string::npos) {
    4.     s.replace(pos, 5, "C++");
    5. }
    6. std::cout << s << std::endl;  // 输出 "Hello, C++!"

    插入和删除

    string类还提供了插入和删除的成员函数，如insert()、erase()等。

    • 示例：
    1. std::string s = "Hello!";
    2. s.insert(5, ", World");  // 在第5个位置插入 ", World"
    3. std::cout << s << std::endl;  // 输出 "Hello, World!"
    4.  
    5. s.erase(5, 7);  // 删除从第5个位置开始的7个字符
    6. std::cout << s << std::endl;  // 输出 "Hello!"

    重点与难点分析

    重点：

    1. string对象的定义和初始化：掌握多种方式定义和初始化string对象。
    2. 基本操作：了解如何获取字符串长度、连接字符串、访问和修改字符。
    3. string对象的操作函数：掌握字符串的比较、查找、替换、插入和删除操作。

    难点：

    1. 字符串查找和替换：初学者需要通过实践理解如何使用find()和replace()函数。
    2. 字符串的输入和输出：理解标准输入输出流的使用，特别是std::getline()读取整行输入的方法。

    练习题解析
    1. 练习3.1：定义一个string对象，输出其长度，并连接另一个字符串。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::string s1 = "Hello";
    6.     std::cout << "Length: " << s1.size() << std::endl;
    7.  
    8.     std::string s2 = " World";
    9.     s1 += s2;
    10.     std::cout << "Concatenated string: " << s1 << std::endl;
    11.  
    12.     return 0;
    13. }

    1. 练习3.2：定义一个string对象，使用下标运算符访问和修改其字符。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::string s = "Hello";
    6.     std::cout << "Original string: " << s << std::endl;
    7.  
    8.     s[0] = 'h';
    9.     s.at(1) = 'a';
    10.     std::cout << "Modified string: " << s << std::endl;
    11.  
    12.     return 0;
    13. }

    1. 练习3.3：使用std::getline()读取一行输入，并输出该行内容。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::string s;
    6.     std::cout << "Enter a line: ";
    7.     std::getline(std::cin, s);
    8.     std::cout << "You entered: " << s << std::endl;
    9.  
    10.     return 0;
    11. }

    1. 练习3.4：定义一个string对象，使用find()和replace()函数查找并替换字符串中的子串。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::string s = "Hello, World!";
    6.     auto pos = s.find("World");
    7.     if (pos != std::string::npos) {
    8.         s.replace(pos, 5, "C++");
    9.     }
    10.     std::cout << "Replaced string: " << s << std::endl;
    11.  
    12.     return 0;
    13. }

    总结与提高

    本节总结：

    1. 学习了string类型的基本用法，包括定义和初始化、基本操作以及常用的成员函数。
    2. 掌握了字符串的长度获取、连接、字符访问和修改、输入输出等操作。
    3. 理解了字符串的比较、查找、替换、插入和删除操作方法。

    提高建议：

    1. 多练习string类型的基本操作：通过编写各种字符串操作的小程序，熟悉string类型的定义和使用方法。
    2. 深入理解字符串操作函数：通过实际编程练习，掌握find()、replace()、insert()、erase()等字符串操作函数的用法。
    3. 应用string提高代码的灵活性和可读性：在实际编程中，充分利用string类型的强大功能，提高代码的灵活性和可读性。

    3.3 标准库类型vector

    概述

    C++标准库中的vector类型是一个动态数组，可以存储相同类型的对象，并能根据需要自动调整大小。vector提供了一系列灵活而强大的功能，使得动态数组的操作变得简单高效。在本小节中，我们将深入探讨vector类型的基本用法和操作。

    3.3.1 定义和初始化vector对象
    定义vector对象

    vector对象可以用多种方式定义和初始化。

    • 示例：
    1. std::vector<int> v1;  // 默认初始化，v1是一个空的vector
    2. std::vector<int> v2 = {1, 2, 3, 4, 5};  // 使用列表初始化
    3. std::vector<int> v3(10, 42);  // 初始化为10个值为42的元素
    4. std::vector<int> v4(v2);  // 拷贝初始化

    初始化vector对象

    vector类型支持多种初始化方式，包括列表初始化、拷贝构造、直接初始化等。

    • 示例：
    1. std::vector v1 = {"hello", "world"};
    2. std::vector<int> v2(10, -1);
    3. std::vector<int> v3 = v2;
    4. std::vector<double> v4(5);  // 初始化为5个默认值（0.0）

    3.3.2 基本操作
    获取vector对象的大小

    使用size()成员函数可以获取vector的大小，即元素的个数。

    • 示例：
    1. std::vector<int> v = {1, 2, 3, 4, 5};
    2. std::cout << "Size: " << v.size() << std::endl;  // 输出大小

    访问和修改元素

    使用下标运算符[]或at()成员函数可以访问和修改vector中的元素。

    • 示例：
    1. std::vector<int> v = {1, 2, 3, 4, 5};
    2. int value1 = v[2];  // 获取第三个元素
    3. int value2 = v.at(2);  // 获取第三个元素
    4.  
    5. v[0] = 10;  // 修改第一个元素为10
    6. v.at(1) = 20;  // 修改第二个元素为20
    7. std::cout << v[0] << " " << v[1] << std::endl;  // 输出 "10 20"

    添加和删除元素

    使用push_back()成员函数可以在vector末尾添加元素，使用pop_back()可以删除末尾元素，使用insert()和erase()可以在指定位置插入和删除元素。

    • 示例：
    1. std::vector<int> v = {1, 2, 3};
    2. v.push_back(4);  // 在末尾添加元素4
    3. std::cout << "After push_back: ";
    4. for (int i : v) std::cout << i << " ";  // 输出 "1 2 3 4"
    5. std::cout << std::endl;
    6.  
    7. v.pop_back();  // 删除末尾元素
    8. std::cout << "After pop_back: ";
    9. for (int i : v) std::cout << i << " ";  // 输出 "1 2 3"
    10. std::cout << std::endl;
    11.  
    12. v.insert(v.begin() + 1, 10);  // 在第二个位置插入元素10
    13. std::cout << "After insert: ";
    14. for (int i : v) std::cout << i << " ";  // 输出 "1 10 2 3"
    15. std::cout << std::endl;
    16.  
    17. v.erase(v.begin() + 1);  // 删除第二个位置的元素
    18. std::cout << "After erase: ";
    19. for (int i : v) std::cout << i << " ";  // 输出 "1 2 3"
    20. std::cout << std::endl;

    清空vector

    使用clear()成员函数可以清空vector中的所有元素。

    • 示例：
    1. std::vector<int> v = {1, 2, 3};
    2. v.clear();  // 清空vector
    3. std::cout << "Size after clear: " << v.size() << std::endl;  // 输出0

    3.3.3 vector的其他操作
    访问第一个和最后一个元素

    使用front()和back()成员函数可以访问vector的第一个和最后一个元素。

    • 示例：
    1. std::vector<int> v = {1, 2, 3, 4, 5};
    2. int first = v.front();  // 获取第一个元素
    3. int last = v.back();  // 获取最后一个元素
    4. std::cout << "First: " << first << ", Last: " << last << std::endl;  // 输出 "First: 1, Last: 5"

    检查vector是否为空

    使用empty()成员函数可以检查vector是否为空。

    • 示例：
    1. std::vector<int> v;
    2. if (v.empty()) {
    3.     std::cout << "Vector is empty" << std::endl;
    4. } else {
    5.     std::cout << "Vector is not empty" << std::endl;
    6. }

    预留空间

    使用reserve()成员函数可以预留vector的存储空间，以避免多次分配内存。

    • 示例：
    1. std::vector<int> v;
    2. v.reserve(100);  // 预留100个元素的存储空间
    3. for (int i = 0; i < 100; ++i) {
    4.     v.push_back(i);
    5. }
    6. std::cout << "Size: " << v.size() << ", Capacity: " << v.capacity() << std::endl;  // 输出 "Size: 100, Capacity: 100"

    重点与难点分析

    重点：

    1. vector对象的定义和初始化：掌握多种方式定义和初始化vector对象。
    2. 基本操作：了解如何获取vector的大小，访问和修改元素，以及添加和删除元素。

    难点：

    1. 迭代器的操作：初学者需要通过实践理解如何使用迭代器访问和修改vector中的元素。
    2. 动态调整vector大小：理解vector如何在添加和删除元素时动态调整大小，并掌握相关操作。

    课后练习题解析
    1. 练习3.9：定义一个vector对象，输出其大小，并添加和删除元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> v = {1, 2, 3};
    6.     std::cout << "Size: " << v.size() << std::endl;
    7.  
    8.     v.push_back(4);
    9.     std::cout << "After push_back: ";
    10.     for (int i : v) std::cout << i << " ";
    11.     std::cout << std::endl;
    12.  
    13.     v.pop_back();
    14.     std::cout << "After pop_back: ";
    15.     for (int i : v) std::cout << i << " ";
    16.     std::cout << std::endl;
    17.  
    18.     return 0;
    19. }

    1. 练习3.10：使用vector的迭代器遍历一个vector对象，并输出其元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> v = {1, 2, 3, 4, 5};
    6.     for (auto it = v.begin(); it != v.end(); ++it) {
    7.         std::cout << *it << " ";
    8.     }
    9.     std::cout << std::endl;
    10.  
    11.     return 0;
    12. }

    1. 练习3.11：使用insert()和erase()函数在vector中插入和删除元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> v = {1, 2, 3};
    6.     v.insert(v.begin() + 1, 10);  // 在第二个位置插入元素10
    7.     std::cout << "After insert: ";
    8.     for (int i : v) std::cout << i << " ";
    9.     std::cout << std::endl;
    10.  
    11.     v.erase(v.begin() + 1);  // 删除第二个位置的元素
    12.     std::cout << "After erase: ";
    13.     for (int i : v) std::cout << i << " ";
    14.     std::cout << std::endl;
    15.  
    16.     return 0;
    17. }

    1. 练习3.12：使用vector的反向迭代器遍历一个vector对象，并输出其元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> v = {1, 2, 3, 4, 5};
    6.     for (auto it = v.rbegin(); it != v.rend(); ++it) {
    7.         std::cout << *it << " ";
    8.     }
    9.     std::cout << std::endl;
    10.  
    11.     return 0;
    12. }

    总结与提高

    本节总结：

    1. 学习了vector类型的基本用法，包括定义和初始化、基本操作以及常用的成员函数。
    2. 掌握了vector的大小获取、元素访问和修改、添加和删除元素等操作。
    3. 理解了vector的迭代器使用方法，包括正向迭代器和反向迭代器的应用。

    提高建议：

    1. 多练习vector类型的基本操作：通过编写各种vector操作的小程序，熟悉vector类型的定义和使用方法。
    2. 深入理解迭代器操作：通过实际编程练习，掌握迭代器的使用方法，特别是正向和反向迭代器的应用。
    3. 优化vector性能：在实际编程中，合理使用reserve()预留存储空间，优化vector的性能。

    3.4 迭代器介绍

    概述

    迭代器是C++标准库中用于遍历和访问容器（如vector、string等）元素的工具。迭代器提供了类似于指针的操作接口，使得在容器中移动和访问元素变得简单和高效。理解迭代器的基本用法和操作是掌握C++标准库容器的关键。

    3.4.1 定义和使用迭代器
    定义迭代器

    迭代器是容器类中的一种类型，可以通过容器的成员函数来获取。例如，begin()和end()函数返回容器的迭代器。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. std::vector<int>::iterator it = vec.begin();  // 定义一个迭代器

    使用迭代器遍历容器

    使用迭代器可以遍历容器中的元素，类似于使用指针。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    3.     std::cout << *it << " ";  // 输出容器中的每个元素
    4. }
    5. std::cout << std::endl;

    auto关键字与迭代器

    可以使用auto关键字自动推导迭代器的类型，简化代码。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. for (auto it = vec.begin(); it != vec.end(); ++it) {
    3.     std::cout << *it << " ";  // 输出容器中的每个元素
    4. }
    5. std::cout << std::endl;

    3.4.2 常用迭代器操作
    访问元素

    通过解引用运算符*可以访问迭代器所指向的元素。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. auto it = vec.begin();
    3. std::cout << *it << std::endl;  // 输出第一个元素

    修改元素

    通过解引用运算符*可以修改迭代器所指向的元素。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. auto it = vec.begin();
    3. *it = 10;  // 修改第一个元素的值
    4. std::cout << vec[0] << std::endl;  // 输出10

    迭代器的算术运算

    迭代器支持算术运算，如递增、递减、加减整数等。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. auto it = vec.begin();
    3. ++it;  // 移动到下一个元素
    4. std::cout << *it << std::endl;  // 输出第二个元素

    3.4.3 反向迭代器

    反向迭代器用于从后向前遍历容器，可以通过容器的rbegin()和rend()函数获取反向迭代器。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. for (auto rit = vec.rbegin(); rit != vec.rend(); ++rit) {
    3.     std::cout << *rit << " ";  // 输出 "5 4 3 2 1"
    4. }
    5. std::cout << std::endl;

    3.4.4 const迭代器

    const迭代器用于遍历容器中的常量元素，不能通过const迭代器修改元素的值。可以通过容器的cbegin()和cend()函数获取const迭代器。

    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. for (auto cit = vec.cbegin(); cit != vec.cend(); ++cit) {
    3.     std::cout << *cit << " ";  // 输出容器中的每个元素
    4. }
    5. std::cout << std::endl;

    3.4.5 迭代器类别

    C++标准库中有五种迭代器类别，每种类别的迭代器支持不同的操作：

    1. 输入迭代器：只能读取序列中的元素，支持==、!=、*、++等操作。
    2. 输出迭代器：只能写入序列中的元素，支持*、++等操作。
    3. 前向迭代器：能在序列中读取和写入元素，支持输入和输出迭代器的所有操作。
    4. 双向迭代器：能在序列中前后移动，支持前向迭代器的所有操作，并增加--运算符。
    5. 随机访问迭代器：能以常数时间访问序列中的任意元素，支持双向迭代器的所有操作，并增加+、-、[]运算符。
    • 示例：
    1. std::vector<int> vec = {1, 2, 3, 4, 5};
    2. auto it = vec.begin();
    3. it += 3;  // 使用随机访问迭代器移动到第四个元素
    4. std::cout << *it << std::endl;  // 输出4

    重点与难点分析

    重点：

    1. 迭代器的定义和使用：掌握如何定义和使用迭代器遍历和访问容器中的元素。
    2. 常用迭代器操作：了解迭代器的基本操作，包括访问和修改元素，迭代器的算术运算等。
    3. 反向迭代器和const迭代器：理解反向迭代器和const迭代器的用法，掌握如何遍历容器中的元素。

    难点：

    1. 迭代器的算术运算：初学者需要通过实践理解如何使用迭代器进行算术运算，如递增、递减、加减整数等。
    2. 迭代器类别的区分：理解五种迭代器类别的特点和用法，掌握它们在不同容器中的应用。

    练习题解析
    1. 练习3.13：定义一个vector对象，使用迭代器遍历并输出其元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> vec = {1, 2, 3, 4, 5};
    6.     for (auto it = vec.begin(); it != vec.end(); ++it) {
    7.         std::cout << *it << " ";
    8.     }
    9.     std::cout << std::endl;
    10.  
    11.     return 0;
    12. }

    1. 练习3.14：定义一个vector对象，使用反向迭代器遍历并输出其元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> vec = {1, 2, 3, 4, 5};
    6.     for (auto rit = vec.rbegin(); rit != vec.rend(); ++rit) {
    7.         std::cout << *rit << " ";
    8.     }
    9.     std::cout << std::endl;
    10.  
    11.     return 0;
    12. }

    1. 练习3.15：定义一个vector对象，使用const迭代器遍历并输出其元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> vec = {1, 2, 3, 4, 5};
    6.     for (auto cit = vec.cbegin(); cit != vec.cend(); ++cit) {
    7.         std::cout << *cit << " ";
    8.     }
    9.     std::cout << std::endl;
    10.  
    11.     return 0;
    12. }

    1. 练习3.16：定义一个vector对象，使用随机访问迭代器访问并输出某个元素。
      • 示例代码：
    1. #include 
    2. #include 
    3.  
    4. int main() {
    5.     std::vector<int> vec = {1, 2, 3, 4, 5};
    6.     auto it = vec.begin();
    7.     it += 2;  // 移动到第三个元素
    8.     std::cout << *it << std::endl;  // 输出3
    9.  
    10.     return 0;
    11. }

    总结与提高

    本节总结：

    1. 学习了迭代器的基本概念和用法，掌握了如何定义和使用迭代器遍历和访问容器中的元素。
    2. 了解了常用的迭代器操作，包括访问和修改元素、迭代器的算术运算等。
    3. 理解了反向迭代器和const迭代器的用法，掌握了如何遍历容器中的元素。

    提高建议：

    1. 多练习迭代器的基本操作：通过编写各种迭代器操作的小程序，熟悉迭代器的定义和使用方法。
    2. 深入理解迭代器的算术运算：通过实际编程练习，掌握迭代器的算术运算，特别是递增、递减、加减整数等操作。
    3. 区分并掌握不同类别的迭代器：在实际编程中，理解并应用五种迭代器类别，掌握它们在不同容器中的应用。

    3.5 数组

    概述

    数组是一种固定大小的顺序容器，用于存储相同类型的元素。与vector相比，数组的大小在声明时必须确定，且在整个程序执行过程中保持不变。数组是C++中最基本的容器类型之一，了解数组的定义、初始化和基本操作是编写高效C++代码的基础。

    3.5.1 定义和初始化数组
    定义数组

    数组的定义需要指定元素类型和数组的大小。

    • 语法：
    类型 数组名[大小];

    • 示例：
    1. int arr[10];  // 定义一个包含10个整数的数组
    2. double values[5];  // 定义一个包含5个双精度浮点数的数组

    初始化数组

    数组可以在定义时进行初始化，初始化方式有多种，包括列表初始化和默认初始化。

    • 列表初始化：
    1. int arr1[5] = {1, 2, 3, 4, 5};  // 使用列表初始化
    2. int arr2[] = {1, 2, 3};  // 自动推断大小，定义一个包含3个整数的数组

    • 默认初始化：
    int arr3[10] = {};  // 初始化为全0

    3.5.2 访问和修改数组元素
    访问数组元素

    通过下标运算符[]可以访问和修改数组中的元素，下标从0开始。

    • 示例：
    1. int arr[5] = {1, 2, 3, 4, 5};
    2. int first = arr[0];  // 访问第一个元素
    3. int last = arr[4];  // 访问最后一个元素

    修改数组元素
    • 示例：
    1. int arr[5] = {1, 2, 3, 4, 5};
    2. arr[0] = 10;  // 修改第一个元素的值
    3. arr[4] = 50;  // 修改最后一个元素的值

    使用循环访问数组

    使用循环结构可以遍历数组中的所有元素。

    • 示例：
    1. int arr[5] = {1, 2, 3, 4, 5};
    2. for (int i = 0; i < 5; ++i) {
    3.     std::cout << arr[i] << " ";  // 输出数组中的每个元素
    4. }
    5. std::cout << std::endl;

    3.5.3 多维数组

    多维数组用于存储矩阵或更高维度的数据，可以使用嵌套的下标运算符访问其中的元素。

    定义多维数组
    • 语法：
    类型 数组名[大小1][大小2]...[大小N];

    • 示例：
    int matrix[3][4];  // 定义一个3行4列的二维数组

    初始化多维数组

    多维数组的初始化可以使用嵌套的列表初始化。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };

    访问和修改多维数组元素

    通过嵌套的下标运算符可以访问和修改多维数组中的元素。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };
    5. int val = matrix[1][2];  // 访问第二行第三列的元素
    6. matrix[0][1] = 10;  // 修改第一行第二列的元素

    3.5.4 指针和数组

    数组名表示数组的首地址，可以使用指针操作数组。

    使用指针遍历数组

    通过指针可以遍历和操作数组中的元素。

    • 示例：
    1. int arr[5] = {1, 2, 3, 4, 5};
    2. for (int* p = arr; p != arr + 5; ++p) {
    3.     std::cout << *p << " ";  // 输出数组中的每个元素
    4. }
    5. std::cout << std::endl;

    数组与指针的关系

    数组名表示数组的首地址，可以将数组名赋值给指针。

    • 示例：
    1. int arr[5] = {1, 2, 3, 4, 5};
    2. int* p = arr;  // 将数组名赋值给指针p

    重点与难点分析

    重点：

    1. 数组的定义和初始化：掌握数组的多种定义和初始化方式，了解列表初始化和默认初始化。
    2. 访问和修改数组元素：了解如何使用下标运算符访问和修改数组中的元素，掌握使用循环遍历数组的方法。
    3. 多维数组的使用：理解多维数组的定义、初始化和访问方法，掌握如何操作多维数组中的元素。

    难点：

    1. 多维数组的操作：初学者需要通过实践理解如何定义、初始化和访问多维数组中的元素。
    2. 指针和数组的关系：理解数组名和指针的关系，掌握使用指针遍历和操作数组的方法。

    练习题解析
    1. 练习3.17：定义一个包含10个整数的数组，初始化为1到10，并输出数组中的每个元素。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    5.     for (int i = 0; i < 10; ++i) {
    6.         std::cout << arr[i] << " ";
    7.     }
    8.     std::cout << std::endl;
    9.  
    10.     return 0;
    11. }

    1. 练习3.18：定义一个包含3行4列的二维数组，初始化为任意值，并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int matrix[3][4] = {
    5.         {1, 2, 3, 4},
    6.         {5, 6, 7, 8},
    7.         {9, 10, 11, 12}
    8.     };
    9.  
    10.     for (int i = 0; i < 3; ++i) {
    11.         for (int j = 0; j < 4; ++j) {
    12.             std::cout << matrix[i][j] << " ";
    13.         }
    14.         std::cout << std::endl;
    15.     }
    16.  
    17.     return 0;
    18. }

    1. 练习3.19：使用指针遍历一个包含5个整数的数组，并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int arr[5] = {1, 2, 3, 4, 5};
    5.     for (int* p = arr; p != arr + 5; ++p) {
    6.         std::cout << *p << " ";
    7.     }
    8.     std::cout << std::endl;
    9.  
    10.     return 0;
    11. }

    1. 练习3.20：定义一个包含3行4列的二维数组，使用嵌套循环和指针访问并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int matrix[3][4] = {
    5.         {1, 2, 3, 4},
    6.         {5, 6, 7, 8},
    7.         {9, 10, 11, 12}
    8.     };
    9.  
    10.     for (int (*p)[4] = matrix; p != matrix + 3; ++p) {
    11.         for (int* q = *p; q != *p + 4; ++q) {
    12.             std::cout << *q << " ";
    13.         }
    14.         std::cout << std::endl;
    15.     }
    16.  
    17.     return 0;
    18. }

    总结与提高

    本节总结：

    1. 学习了数组的定义和初始化方法，掌握了列表初始化和默认初始化的用法。
    2. 了解了如何使用下标运算符访问和修改数组中的元素，掌握了使用循环遍历数组的方法。
    3. 理解了多维数组的定义、初始化和访问方法，掌握了如何操作多维数组中的元素。
    4. 理解了数组与指针的关系，掌握了使用指针遍历和操作数组的方法。

    提高建议：

    1. 多练习数组的基本操作：通过编写各种数组操作的小程序，熟悉数组的定义和使用方法。
    2. 深入理解多维数组的操作：通过实际编程练习，掌握多维数组的定义、初始化和访问方法。
    3. 掌握指针与数组的关系：在实际编程中，理解并应用数组名和指针的关系，掌握使用指针遍历和操作数组的方法。

    3.6 多维数组

    概述

    多维数组是一种可以存储矩阵或更高维度数据的数组。多维数组的每个维度都有固定的大小，可以通过嵌套的下标访问其中的元素。理解多维数组的定义、初始化和操作方法是处理复杂数据结构的基础。

    3.6.1 定义和初始化多维数组
    定义多维数组

    多维数组的定义需要指定每个维度的大小。

    • 语法：
    类型 数组名[维度1大小][维度2大小]...[维度N大小];

    • 示例：
    int matrix[3][4];  // 定义一个3行4列的二维数组

    初始化多维数组

    多维数组的初始化可以使用嵌套的列表初始化。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };

    3.6.2 访问和修改多维数组元素

    通过嵌套的下标运算符可以访问和修改多维数组中的元素。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };
    5. int val = matrix[1][2];  // 访问第二行第三列的元素
    6. matrix[0][1] = 10;  // 修改第一行第二列的元素

    使用循环访问多维数组

    使用嵌套循环可以遍历多维数组中的所有元素。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };
    5.  
    6. for (int i = 0; i < 2; ++i) {
    7.     for (int j = 0; j < 3; ++j) {
    8.         std::cout << matrix[i][j] << " ";
    9.     }
    10.     std::cout << std::endl;
    11. }

    3.6.3 多维数组与指针

    多维数组的首地址可以通过数组名获取，并使用指针操作多维数组。

    使用指针遍历多维数组

    通过指针可以遍历和操作多维数组中的元素。

    • 示例：
    1. int matrix[2][3] = {
    2.     {1, 2, 3},
    3.     {4, 5, 6}
    4. };
    5.  
    6. for (int (*p)[3] = matrix; p != matrix + 2; ++p) {
    7.     for (int* q = *p; q != *p + 3; ++q) {
    8.         std::cout << *q << " ";
    9.     }
    10.     std::cout << std::endl;
    11. }

    重点与难点分析

    重点：

    1. 多维数组的定义和初始化：掌握多维数组的定义方法和初始化方式，了解嵌套列表初始化的用法。
    2. 访问和修改多维数组元素：了解如何使用嵌套的下标运算符访问和修改多维数组中的元素，掌握使用循环遍历多维数组的方法。
    3. 多维数组与指针的关系：理解多维数组名和指针的关系，掌握使用指针遍历和操作多维数组的方法。

    难点：

    1. 多维数组的操作：初学者需要通过实践理解如何定义、初始化和访问多维数组中的元素。
    2. 指针与多维数组的关系：理解多维数组名和指针的关系，掌握使用指针遍历和操作多维数组的方法。

    练习题解析
    1. 练习3.21：定义一个包含3行4列的二维数组，初始化为任意值，并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int matrix[3][4] = {
    5.         {1, 2, 3, 4},
    6.         {5, 6, 7, 8},
    7.         {9, 10, 11, 12}
    8.     };
    9.  
    10.     for (int i = 0; i < 3; ++i) {
    11.         for (int j = 0; j < 4; ++j) {
    12.             std::cout << matrix[i][j] << " ";
    13.         }
    14.         std::cout << std::endl;
    15.     }
    16.  
    17.     return 0;
    18. }

    1. 练习3.22：使用指针遍历一个包含2行3列的二维数组，并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int matrix[2][3] = {
    5.         {1, 2, 3},
    6.         {4, 5, 6}
    7.     };
    8.  
    9.     for (int (*p)[3] = matrix; p != matrix + 2; ++p) {
    10.         for (int* q = *p; q != *p + 3; ++q) {
    11.             std::cout << *q << " ";
    12.         }
    13.         std::cout << std::endl;
    14.     }
    15.  
    16.     return 0;
    17. }

    1. 练习3.23：定义一个包含3层4行5列的三维数组，初始化为任意值，并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int tensor[3][4][5] = {
    5.         {
    6.             {1, 2, 3, 4, 5},
    7.             {6, 7, 8, 9, 10},
    8.             {11, 12, 13, 14, 15},
    9.             {16, 17, 18, 19, 20}
    10.         },
    11.         {
    12.             {21, 22, 23, 24, 25},
    13.             {26, 27, 28, 29, 30},
    14.             {31, 32, 33, 34, 35},
    15.             {36, 37, 38, 39, 40}
    16.         },
    17.         {
    18.             {41, 42, 43, 44, 45},
    19.             {46, 47, 48, 49, 50},
    20.             {51, 52, 53, 54, 55},
    21.             {56, 57, 58, 59, 60}
    22.         }
    23.     };
    24.  
    25.     for (int i = 0; i < 3; ++i) {
    26.         for (int j = 0; j < 4; ++j) {
    27.             for (int k = 0; k < 5; ++k) {
    28.                 std::cout << tensor[i][j][k] << " ";
    29.             }
    30.             std::cout << std::endl;
    31.         }
    32.         std::cout << std::endl;
    33.     }
    34.  
    35.     return 0;
    36. }

    1. 练习3.24：定义一个包含2层3行2列的三维数组，使用指针遍历并输出每个元素的值。
      • 示例代码：
    1. #include 
    2.  
    3. int main() {
    4.     int tensor[2][3][2] = {
    5.         {
    6.             {1, 2},
    7.             {3, 4},
    8.             {5, 6}
    9.         },
    10.         {
    11.             {7, 8},
    12.             {9, 10},
    13.             {11, 12}
    14.         }
    15.     };
    16.  
    17.     for (int (*p)[3][2] = tensor; p != tensor + 2; ++p) {
    18.         for (int (*q)[2] = *p; q != *p + 3; ++q) {
    19.             for (int* r = *q; r != *q + 2; ++r) {
    20.                 std::cout << *r << " ";
    21.             }
    22.             std::cout << std::endl;
    23.         }
    24.         std::cout << std::endl;
    25.     }
    26.  
    27.     return 0;
    28. }

    总结与提高

    本节总结：

    1. 学习了多维数组的定义和初始化方法，掌握了嵌套列表初始化的用法。
    2. 了解了如何使用嵌套的下标运算符访问和修改多维数组中的元素，掌握了使用循环遍历多维数组的方法。
    3. 理解了多维数组名和指针的关系，掌握了使用指针遍历和操作多维数组的方法。

    提高建议：

    1. 多练习多维数组的基本操作：通过编写各种多维数组操作的小程序，熟悉多维数组的定义和使用方法。
    2. 深入理解指针与多维数组的关系：通过实际编程练习，掌握多维数组名和指针的关系，理解如何使用指针遍历和操作多维数组的方法。
    3. 处理更高维度的数据：在实际编程中，尝试使用多维数组处理更高维度的数据，掌握其操作方法。

    本主页会定期更新，为了能够及时获得更新，敬请关注我：点击左下角的关注。也可以关注公众号：请在微信上搜索公众号“iShare爱分享”并关注，或者扫描以下公众号二维码关注，以便在内容更新时直接向您推送。 

  • 相关阅读:
    Java设计模式基本介绍、基本要素、23种设计模式介绍
    修改和完成SpringSecurity的登录功能
    npm install如何知道使用nodejs太低
    数组 [3]｜二维数组（C语言）
    uni——判断option传参
    leetcode.494. 目标和
    【博客486】prometheus-----rate，irate，increase的原理
    JS Ajax 封装
    OPC UA 与IEC61499 深度融合（1）
    docker部署（使用docker-compose）手把手教程
  • 原文地址：https://blog.csdn.net/iShare_Carlos/article/details/139718017