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

本文主要是介绍《C++ Primer》导学系列：第 3 章 - 字符串、向量和数组，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

3.1 命名空间的使用

概述

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

3.1.1 定义命名空间

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

• 语法：

namespace 命名空间名 {// 命名空间内的内容
}

• 示例：

namespace myNamespace {int myVariable = 42;void myFunction() {std::cout << "Hello from myNamespace!" << std::endl;}
}

3.1.2 使用命名空间

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

直接访问

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

• 示例：

int main() {std::cout << myNamespace::myVariable << std::endl;myNamespace::myFunction();return 0;
}

using声明

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

• 语法：

using 命名空间名::成员名;

• 示例：

int main() {using myNamespace::myVariable;using myNamespace::myFunction;std::cout << myVariable << std::endl;myFunction();return 0;
}

using指示

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

• 语法：

using namespace 命名空间名;

• 示例：

int main() {using namespace myNamespace;std::cout << myVariable << std::endl;myFunction();return 0;
}

3.1.3 命名空间嵌套

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

• 示例：

namespace outer {namespace inner {int value = 100;}
}int main() {std::cout << outer::inner::value << std::endl;return 0;
}

3.1.4 匿名命名空间

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

• 示例：

namespace {int secret = 42;void secretFunction() {std::cout << "This is a secret function." << std::endl;}
}int main() {std::cout << secret << std::endl;secretFunction();return 0;
}

重点与难点分析

重点：

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

难点：

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

练习题解析

1. 练习3.1：定义一个命名空间，包含一个变量和一个函数，并在主函数中访问它们。

• • 示例代码：

#include <iostream>namespace myNamespace {int myVariable = 42;void myFunction() {std::cout << "Hello from myNamespace!" << std::endl;}
}int main() {std::cout << myNamespace::myVariable << std::endl;myNamespace::myFunction();return 0;
}

1. 练习3.2：使用using声明和指示分别引入命名空间的成员和整个命名空间。

• • 示例代码：

#include <iostream>namespace myNamespace {int myVariable = 42;void myFunction() {std::cout << "Hello from myNamespace!" << std::endl;}
}int main() {using myNamespace::myVariable;using myNamespace::myFunction;std::cout << myVariable << std::endl;myFunction();using namespace myNamespace;std::cout << myVariable << std::endl;myFunction();return 0;
}

1. 练习3.3：定义嵌套命名空间，并访问嵌套命名空间中的成员。

• • 示例代码：

#include <iostream>namespace outer {namespace inner {int value = 100;}
}int main() {std::cout << outer::inner::value << std::endl;return 0;
}

1. 练习3.4：定义匿名命名空间，并在主函数中访问匿名命名空间中的成员。

• • 示例代码：

#include <iostream>namespace {int secret = 42;void secretFunction() {std::cout << "This is a secret function." << std::endl;}
}int main() {std::cout << secret << std::endl;secretFunction();return 0;
}

总结与提高

本节总结：

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对象可以用多种方式定义和初始化。

• 示例：

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

字符串的拼接

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

• 示例：

std::string s1 = "Hello";
std::string s2 = "World";
std::string s3 = s1 + ", " + s2 + "!";  // 拼接字符串
std::cout << s3 << std::endl;  // 输出 "Hello, World!"s1 += ", ";
s1 += s2;
std::cout << s1 << std::endl;  // 输出 "Hello, World"

3.2.2 基本操作

获取string对象的长度

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

• 示例：

std::string s = "Hello";
std::cout << "Length: " << s.size() << std::endl;  // 输出长度

访问和修改字符

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

• 示例：

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

输入和输出

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

• 示例：

std::string s;
std::cout << "Enter a string: ";
std::cin >> s;  // 读取一个单词
std::cout << "You entered: " << s << std::endl;std::cin.ignore();  // 忽略换行符
std::cout << "Enter a line: ";
std::getline(std::cin, s);  // 读取一整行
std::cout << "You entered: " << s << std::endl;

3.2.3 string对象的操作函数

比较字符串

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

• 示例：

std::string s1 = "abc";
std::string s2 = "def";
if (s1 < s2) {std::cout << s1 << " is less than " << s2 << std::endl;
}

查找和替换

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

• 示例：

std::string s = "Hello, World!";
auto pos = s.find("World");
if (pos != std::string::npos) {s.replace(pos, 5, "C++");
}
std::cout << s << std::endl;  // 输出 "Hello, C++!"

插入和删除

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

• 示例：

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

重点与难点分析

重点：

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

难点：

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

练习题解析

1. 练习3.1：定义一个string对象，输出其长度，并连接另一个字符串。

• • 示例代码：

#include <iostream>
#include <string>int main() {std::string s1 = "Hello";std::cout << "Length: " << s1.size() << std::endl;std::string s2 = " World";s1 += s2;std::cout << "Concatenated string: " << s1 << std::endl;return 0;
}

1. 练习3.2：定义一个string对象，使用下标运算符访问和修改其字符。

• • 示例代码：

#include <iostream>
#include <string>int main() {std::string s = "Hello";std::cout << "Original string: " << s << std::endl;s[0] = 'h';s.at(1) = 'a';std::cout << "Modified string: " << s << std::endl;return 0;
}

1. 练习3.3：使用std::getline()读取一行输入，并输出该行内容。

• • 示例代码：

#include <iostream>
#include <string>int main() {std::string s;std::cout << "Enter a line: ";std::getline(std::cin, s);std::cout << "You entered: " << s << std::endl;return 0;
}

1. 练习3.4：定义一个string对象，使用find()和replace()函数查找并替换字符串中的子串。

• • 示例代码：

#include <iostream>
#include <string>int main() {std::string s = "Hello, World!";auto pos = s.find("World");if (pos != std::string::npos) {s.replace(pos, 5, "C++");}std::cout << "Replaced string: " << s << std::endl;return 0;
}

总结与提高

本节总结：

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对象可以用多种方式定义和初始化。

• 示例：

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

初始化vector对象

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

• 示例：

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

3.3.2 基本操作

获取vector对象的大小

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

• 示例：

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

访问和修改元素

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

• 示例：

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

添加和删除元素

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

• 示例：

std::vector<int> v = {1, 2, 3};
v.push_back(4);  // 在末尾添加元素4
std::cout << "After push_back: ";
for (int i : v) std::cout << i << " ";  // 输出 "1 2 3 4"
std::cout << std::endl;v.pop_back();  // 删除末尾元素
std::cout << "After pop_back: ";
for (int i : v) std::cout << i << " ";  // 输出 "1 2 3"
std::cout << std::endl;v.insert(v.begin() + 1, 10);  // 在第二个位置插入元素10
std::cout << "After insert: ";
for (int i : v) std::cout << i << " ";  // 输出 "1 10 2 3"
std::cout << std::endl;v.erase(v.begin() + 1);  // 删除第二个位置的元素
std::cout << "After erase: ";
for (int i : v) std::cout << i << " ";  // 输出 "1 2 3"
std::cout << std::endl;

清空vector

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

• 示例：

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

3.3.3 vector的其他操作

访问第一个和最后一个元素

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

• 示例：

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

检查vector是否为空

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

• 示例：

std::vector<int> v;
if (v.empty()) {std::cout << "Vector is empty" << std::endl;
} else {std::cout << "Vector is not empty" << std::endl;
}

预留空间

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

• 示例：

std::vector<int> v;
v.reserve(100);  // 预留100个元素的存储空间
for (int i = 0; i < 100; ++i) {v.push_back(i);
}
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对象，输出其大小，并添加和删除元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3};std::cout << "Size: " << v.size() << std::endl;v.push_back(4);std::cout << "After push_back: ";for (int i : v) std::cout << i << " ";std::cout << std::endl;v.pop_back();std::cout << "After pop_back: ";for (int i : v) std::cout << i << " ";std::cout << std::endl;return 0;
}

1. 练习3.10：使用vector的迭代器遍历一个vector对象，并输出其元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 5};for (auto it = v.begin(); it != v.end(); ++it) {std::cout << *it << " ";}std::cout << std::endl;return 0;
}

1. 练习3.11：使用insert()和erase()函数在vector中插入和删除元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3};v.insert(v.begin() + 1, 10);  // 在第二个位置插入元素10std::cout << "After insert: ";for (int i : v) std::cout << i << " ";std::cout << std::endl;v.erase(v.begin() + 1);  // 删除第二个位置的元素std::cout << "After erase: ";for (int i : v) std::cout << i << " ";std::cout << std::endl;return 0;
}

1. 练习3.12：使用vector的反向迭代器遍历一个vector对象，并输出其元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 5};for (auto it = v.rbegin(); it != v.rend(); ++it) {std::cout << *it << " ";}std::cout << std::endl;return 0;
}

总结与提高

本节总结：

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()函数返回容器的迭代器。

• 示例：

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

使用迭代器遍历容器

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

• 示例：

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

auto关键字与迭代器

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

• 示例：

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.4.2 常用迭代器操作

访问元素

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

• 示例：

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

修改元素

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

• 示例：

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

迭代器的算术运算

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

• 示例：

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

3.4.3 反向迭代器

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

• 示例：

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

3.4.4 const迭代器

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

• 示例：

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

3.4.5 迭代器类别

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

1. 输入迭代器：只能读取序列中的元素，支持==、!=、*、++等操作。
2. 输出迭代器：只能写入序列中的元素，支持*、++等操作。
3. 前向迭代器：能在序列中读取和写入元素，支持输入和输出迭代器的所有操作。
4. 双向迭代器：能在序列中前后移动，支持前向迭代器的所有操作，并增加--运算符。
5. 随机访问迭代器：能以常数时间访问序列中的任意元素，支持双向迭代器的所有操作，并增加+、-、[]运算符。

• 示例：

std::vector<int> vec = {1, 2, 3, 4, 5};
auto it = vec.begin();
it += 3;  // 使用随机访问迭代器移动到第四个元素
std::cout << *it << std::endl;  // 输出4

重点与难点分析

重点：

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

难点：

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

练习题解析

1. 练习3.13：定义一个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;return 0;
}

1. 练习3.14：定义一个vector对象，使用反向迭代器遍历并输出其元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};for (auto rit = vec.rbegin(); rit != vec.rend(); ++rit) {std::cout << *rit << " ";}std::cout << std::endl;return 0;
}

1. 练习3.15：定义一个vector对象，使用const迭代器遍历并输出其元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};for (auto cit = vec.cbegin(); cit != vec.cend(); ++cit) {std::cout << *cit << " ";}std::cout << std::endl;return 0;
}

1. 练习3.16：定义一个vector对象，使用随机访问迭代器访问并输出某个元素。

• • 示例代码：

#include <iostream>
#include <vector>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};auto it = vec.begin();it += 2;  // 移动到第三个元素std::cout << *it << std::endl;  // 输出3return 0;
}

总结与提高

本节总结：

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

提高建议：

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

3.5 数组

概述

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

3.5.1 定义和初始化数组

定义数组

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

• 语法：

类型 数组名[大小];

• 示例：

int arr[10];  // 定义一个包含10个整数的数组
double values[5];  // 定义一个包含5个双精度浮点数的数组

初始化数组

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

• 列表初始化：

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

• 默认初始化：

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

3.5.2 访问和修改数组元素

访问数组元素

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

• 示例：

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

修改数组元素

• 示例：

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

使用循环访问数组

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

• 示例：

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

3.5.3 多维数组

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

定义多维数组

• 语法：

类型 数组名[大小1][大小2]...[大小N];

• 示例：

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

初始化多维数组

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

• 示例：

int matrix[2][3] = {{1, 2, 3},{4, 5, 6}
};

访问和修改多维数组元素

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

• 示例：

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

3.5.4 指针和数组

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

使用指针遍历数组

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

• 示例：

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

数组与指针的关系

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

• 示例：

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

重点与难点分析

重点：

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

难点：

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

练习题解析

1. 练习3.17：定义一个包含10个整数的数组，初始化为1到10，并输出数组中的每个元素。

• • 示例代码：

#include <iostream>int main() {int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};for (int i = 0; i < 10; ++i) {std::cout << arr[i] << " ";}std::cout << std::endl;return 0;
}

1. 练习3.18：定义一个包含3行4列的二维数组，初始化为任意值，并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int matrix[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};for (int i = 0; i < 3; ++i) {for (int j = 0; j < 4; ++j) {std::cout << matrix[i][j] << " ";}std::cout << std::endl;}return 0;
}

1. 练习3.19：使用指针遍历一个包含5个整数的数组，并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int arr[5] = {1, 2, 3, 4, 5};for (int* p = arr; p != arr + 5; ++p) {std::cout << *p << " ";}std::cout << std::endl;return 0;
}

1. 练习3.20：定义一个包含3行4列的二维数组，使用嵌套循环和指针访问并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int matrix[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};for (int (*p)[4] = matrix; p != matrix + 3; ++p) {for (int* q = *p; q != *p + 4; ++q) {std::cout << *q << " ";}std::cout << std::endl;}return 0;
}

总结与提高

本节总结：

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

提高建议：

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

3.6 多维数组

概述

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

3.6.1 定义和初始化多维数组

定义多维数组

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

• 语法：

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

• 示例：

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

初始化多维数组

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

• 示例：

int matrix[2][3] = {{1, 2, 3},{4, 5, 6}
};

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

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

• 示例：

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

使用循环访问多维数组

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

• 示例：

int matrix[2][3] = {{1, 2, 3},{4, 5, 6}
};for (int i = 0; i < 2; ++i) {for (int j = 0; j < 3; ++j) {std::cout << matrix[i][j] << " ";}std::cout << std::endl;
}

3.6.3 多维数组与指针

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

使用指针遍历多维数组

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

• 示例：

int matrix[2][3] = {{1, 2, 3},{4, 5, 6}
};for (int (*p)[3] = matrix; p != matrix + 2; ++p) {for (int* q = *p; q != *p + 3; ++q) {std::cout << *q << " ";}std::cout << std::endl;
}

重点与难点分析

重点：

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

难点：

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

练习题解析

1. 练习3.21：定义一个包含3行4列的二维数组，初始化为任意值，并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int matrix[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};for (int i = 0; i < 3; ++i) {for (int j = 0; j < 4; ++j) {std::cout << matrix[i][j] << " ";}std::cout << std::endl;}return 0;
}

1. 练习3.22：使用指针遍历一个包含2行3列的二维数组，并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int matrix[2][3] = {{1, 2, 3},{4, 5, 6}};for (int (*p)[3] = matrix; p != matrix + 2; ++p) {for (int* q = *p; q != *p + 3; ++q) {std::cout << *q << " ";}std::cout << std::endl;}return 0;
}

1. 练习3.23：定义一个包含3层4行5列的三维数组，初始化为任意值，并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int tensor[3][4][5] = {{{1, 2, 3, 4, 5},{6, 7, 8, 9, 10},{11, 12, 13, 14, 15},{16, 17, 18, 19, 20}},{{21, 22, 23, 24, 25},{26, 27, 28, 29, 30},{31, 32, 33, 34, 35},{36, 37, 38, 39, 40}},{{41, 42, 43, 44, 45},{46, 47, 48, 49, 50},{51, 52, 53, 54, 55},{56, 57, 58, 59, 60}}};for (int i = 0; i < 3; ++i) {for (int j = 0; j < 4; ++j) {for (int k = 0; k < 5; ++k) {std::cout << tensor[i][j][k] << " ";}std::cout << std::endl;}std::cout << std::endl;}return 0;
}

1. 练习3.24：定义一个包含2层3行2列的三维数组，使用指针遍历并输出每个元素的值。

• • 示例代码：

#include <iostream>int main() {int tensor[2][3][2] = {{{1, 2},{3, 4},{5, 6}},{{7, 8},{9, 10},{11, 12}}};for (int (*p)[3][2] = tensor; p != tensor + 2; ++p) {for (int (*q)[2] = *p; q != *p + 3; ++q) {for (int* r = *q; r != *q + 2; ++r) {std::cout << *r << " ";}std::cout << std::endl;}std::cout << std::endl;}return 0;
}

总结与提高

本节总结：

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

提高建议：

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

---

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

这篇关于《C++ Primer》导学系列：第 3 章 - 字符串、向量和数组的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---