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

iShare_爱分享

于 2024-06-16 12:12:22 发布

阅读量1.2k

点赞数 36

分类专栏： C++ primer C++ 文章标签： C++入门到精通 C++ string C++ vector C++ using C++多维数组 C++数组 C++命名空间

本文链接：https://blog.csdn.net/iShare_Carlos/article/details/139718017

版权

C++ 同时被 2 个专栏收录

48 篇文章 3 订阅

订阅专栏

C++ primer

20 篇文章 0 订阅

订阅专栏

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;
}

重点与难点分析

重点：

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

难点：

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

练习题解析

练习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;
}

练习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;
}

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

- 示例代码：

#include <iostream>

namespace outer {
    namespace inner {
        int value = 100;
    }
}

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

练习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;
}

总结与提高

本节总结：

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

提高建议：

多练习命名空间的使用：通过编写各种使用命名空间的小程序，熟悉命名空间的定义和使用方法。
理解命名空间冲突的解决：在实际编程中，理解并解决命名空间冲突的问题，提高代码的可读性和可维护性。
合理使用using声明和指示：在编写代码时，合理使用using声明和指示，避免污染全局命名空间，保持代码的清晰和结构化。
在头文件中不应该包含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!"

重点与难点分析

重点：

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

难点：

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

练习题解析

练习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;
}

练习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;
}

练习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;
}

练习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;
}

总结与提高

本节总结：

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

提高建议：

多练习string类型的基本操作：通过编写各种字符串操作的小程序，熟悉string类型的定义和使用方法。
深入理解字符串操作函数：通过实际编程练习，掌握find()、replace()、insert()、erase()等字符串操作函数的用法。
应用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"

重点与难点分析

重点：

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

难点：

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

课后练习题解析

练习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;
}

练习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;
}

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

- 示例代码：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3};
    v.insert(v.begin() + 1, 10);  // 在第二个位置插入元素10
    std::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;
}

练习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;
}

总结与提高

本节总结：

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

提高建议：

多练习vector类型的基本操作：通过编写各种vector操作的小程序，熟悉vector类型的定义和使用方法。
深入理解迭代器操作：通过实际编程练习，掌握迭代器的使用方法，特别是正向和反向迭代器的应用。
优化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++标准库中有五种迭代器类别，每种类别的迭代器支持不同的操作：

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

示例：

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

重点与难点分析

重点：

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

难点：

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

练习题解析

练习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;
}

练习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;
}

练习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;
}

练习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;  // 输出3

    return 0;
}

总结与提高

本节总结：

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

提高建议：

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

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

重点与难点分析

重点：

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

难点：

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

练习题解析

练习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;
}

练习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;
}

练习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;
}

练习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;
}

总结与提高

本节总结：

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

提高建议：

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

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;
}

重点与难点分析

重点：

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

难点：

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

练习题解析

练习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;
}

练习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;
}

练习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;
}

练习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;
}

总结与提高

本节总结：

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

提高建议：

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

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

iShare_爱分享

关注

36
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
《C++ Primer》导学系列：第 3 章 - 字符串、向量和数组

命名空间是C++中的一种机制，用于组织代码并避免名字冲突。通过使用命名空间，可以将全局作用域中的标识符组织到逻辑分组中，从而提高代码的可读性和可维护性。命名空间在大型项目中尤为重要，因为它们可以防止不同模块之间的名字冲突。命名空间使用关键字namespace来定义，后跟命名空间的名字和一对花括号。在花括号内定义的所有标识符都属于这个命名空间。语法namespace 命名空间名 {// 命名空间内的内容示例本节总结学习了命名空间的基本概念和定义方法，理解了如何通过作用域解析运算符和using。
复制链接

扫一扫