跳到主要内容

C++ 多维数组

提示
  1. 多维数组的定义和初始化：C++ 中的多维数组可以看作是数组的数组，例如 int x[3][4]; 是一个二维数组。我们可以在声明时初始化多维数组，如 int test[2][3] = {{2, 4, 5}, {9, 0, 19}};。
  2. 访问多维数组元素：多维数组的元素可以通过嵌套循环访问。对于二维数组，通常需要两层循环，第一层循环访问行，第二层循环访问列。
  3. 多维数组示例：例如，一个三维数组 int test[2][3][2] 可以存储 2×3×2 = 12 个元素，可以通过三层嵌套循环访问它的每个元素。

在 C++ 中，我们可以创建数组的数组，称为多维数组。例如：

int x[3][4];

这里，x 是一个二维数组。它最多可以容纳 12 个元素。

我们可以将这个数组视为一个表格，有 3 行，每行有 4 列，如下图所示。

C++ 二维数组

三维数组也以类似的方式工作。例如：

float x[2][4][3];

这个数组 x 最多可以容纳 24 个元素。

我们可以通过简单地将其维度相乘来找出数组中的总元素数：

2 x 4 x 3 = 24

多维数组初始化​

像普通数组一样，我们可以用多种方式初始化多维数组。

1. 二维数组的初始化​

int test[2][3] = {2, 4, 5, 9, 0, 19};

以上方法不太推荐。用下面的方法初始化这个数组会更好：

int test[2][3] = { {2, 4, 5}, {9, 0, 19}};

这个数组有 2 行 3 列，所以我们有两行元素，每行有 3 个元素。

C++ 二维数组初始化

2. 三维数组的初始化​

int test[2][3][4] = {3, 4, 2, 3, 0, -3, 9, 11, 23, 12, 23,
 2, 13, 4, 56, 3, 5, 9, 3, 5, 5, 1, 4, 9};

这不是初始化三维数组的好方法。初始化这个数组的更好方法是：

int test[2][3][4] = {
 { {3, 4, 2, 3}, {0, -3, 9, 11}, {23, 12, 23, 2} },
 { {13, 4, 56, 3}, {5, 9, 3, 5}, {5, 1, 4, 9} }
 };

注意这个三维数组的维度。

第一个维度的值是 2。因此，构成第一个维度的两个元素是：

元素 1 = { {3, 4, 2, 3}, {0, -3, 9, 11}, {23, 12, 23, 2} }
元素 2 = { {13, 4, 56, 3}, {5, 9, 3, 5}, {5, 1, 4, 9} }

第二个维度的值是 3。注意，第一个维度的每个元素都各自有三个元素：

对于元素 1 有 {3, 4, 2, 3}, {0, -3, 9, 11} 和 {23, 12, 23, 2}。
对于元素 2 有 {13, 4, 56, 3}, {5, 9, 3, 5} 和 {5, 1, 4, 9}。

最后，第二个维度的每个元素都有四个 int 数字：

{3, 4, 2, 3}
{0, -3, 9, 11}
... .. ...
... .. ...

示例 1：二维数组​

// C++ 程序显示初始化的二维数组的所有元素

#include <iostream>
using namespace std;

int main() {
 int test[3][2] = {{2, -5},
 {4, 0},
 {9, 1}};

 // 使用嵌套 for 循环
 // 访问数组的行
 for (int i = 0; i < 3; ++i) {

 // 访问数组的列
 for (int j = 0; j < 2; ++j) {
 cout << "test[" << i << "][" << j << "] = " << test[i][j] << endl;
 }
 }

 return 0;
}

输出

test[0][0] = 2
test[0][1] = -5
test[1][0] = 4
test[1][1] = 0
test[2][0] = 9
test[2][1] = 1

在上面的示例中，我们初始化了一个名为 test 的二维 int 数组，它有 3 个“行”和 2 个“列”。

这里，我们使用了嵌套的 for 循环来显示数组元素。

  • 外部循环从 i == 0 到 i == 2 访问数组的行
  • 内部循环从 j == 0 到 j == 1 访问数组的列

最后，我们在每次迭代中打印数组元素。

示例 2：为二维数组输入数据​

#include <iostream>
using namespace std;

int main() {
 int numbers[2][3];

 cout << "输入 6 个数字: " << endl;

 // 将用户输入存储在数组中
 for (int i = 0; i < 2; ++i) {
 for (int j = 0; j < 3; ++j) {
 cin >> numbers[i][j];
 }
 }

 cout << "这些数字是: " << endl;

 // 打印数组元素
 for (int i = 0; i < 2; ++i) {
 for (int j = 0; j < 3; ++j) {
 cout << "numbers[" << i << "][" << j << "]: " << numbers[i][j] << endl;
 }
 }

 return 0;
}

输出

输入 6 个数字:
1
2
3
4
5
6
这些数字是:
numbers[0][0]: 1
numbers[0][1]: 2
numbers[0][2]: 3
numbers[1][0]: 4
numbers[1][1]: 5
numbers[1][2]: 6

在这里，我们使用了嵌套的 for 循环来为 2d 数组输入数据。输入所有数据后，我们使用了另一个嵌套的 for 循环来打印数组成员。

示例 3：三维数组​

// C++ 程序用于存储用户输入的值
// 在三维数组中并显示它。

#include <iostream>
using namespace std;

int main() {
 // 这个数组最多可以存储12个元素（2x3x2）
 int test[2][3][2] = {
 {
 {1, 2},
 {3, 4},
 {5, 6}
 },
 {
 {7, 8},
 {9, 10},
 {11, 12}
 }
 };

 // 以适当的索引显示值。
 for (int i = 0; i < 2; ++i) {
 for (int j = 0; j < 3; ++j) {
 for (int k = 0; k < 2; ++k) {
 cout << "test[" << i << "][" << j << "][" << k << "] = " << test[i][j][k] << endl;
 }
 }
 }

 return 0;
}

输出

test[0][0][0] = 1
test[0][0][1] = 2
test[0][1][0] = 3
test[0][1][1] = 4
test[0][2][0] = 5
test[0][2][1] = 6
test[1][0][0] = 7
test[1][0][1] = 8
test[1][1][0] = 9
test[1][1][1] = 10
test[1][2][0] = 11
test[1][2][1] = 12

打印三维数组元素的基本概念类似于二维数组。

然而，由于我们操作的是3个维度，所以我们使用了3个嵌套的for循环而不是只有2个：

  • 外循环从i == 0到i == 1访问数组的第一维
  • 中间循环从j == 0到j == 2访问数组的第二维
  • 最内层循环从k == 0到k == 1访问数组的第三维

我们可以看到，随着维度的增加，数组的复杂性呈指数级增长。

最后于 更新