C++多维数组

多维数组

C++多维数组是一个具有多个维度并允许您以网格状结构存储数据的数组。您可以创建具有多个维度的数组，但这里我们将讨论二维 (2D) 和三维 (3D) 数组。

C++允许多维数组。以下是多维数组声明的一般形式：

语法

以下是 C++ 中多维数组的语法：

type name[size1][size2]...[sizeN];

示例

例如，以下声明创建一个三维 5 x 10 x 4 的整数数组：

int threedim[5][10][4];

二维数组

多维数组最简单的形式是二维数组。二维数组本质上是一维数组的列表。要声明一个大小为 x 和 y 的二维整数数组，您可以这样写：

type arrayName [ x ][ y ];

其中type可以是任何有效的C++数据类型，而arrayName将是一个有效的C++标识符。

二维数组可以看作一个表格，它将有 x 行和 y 列。包含三行四列的二维数组a如下所示：

因此，数组 a 中的每个元素都由一个名为a[i][j]的元素名标识，其中 a 是数组的名称，i 和 j 是唯一标识 a 中每个元素的下标。

初始化二维数组

多维数组可以通过为每一行指定带括号的值来初始化。下面是一个有 3 行，每行有 4 列的数组。

int a[3][4] = {  
   {0, 1, 2, 3} ,   /*  initializers for row indexed by 0 */
   {4, 5, 6, 7} ,   /*  initializers for row indexed by 1 */
   {8, 9, 10, 11}   /*  initializers for row indexed by 2 */
};

指示目标行的嵌套大括号是可选的。以下初始化与前面的示例等效：

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

访问二维数组元素

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

int val = a[2][3];

上面的语句将获取数组第 3 行的第 4 个元素。您可以在上图中验证它。

#include <iostream>
using namespace std;
 
int main () {
   // an array with 5 rows and 2 columns.
   int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
 
   // output each array element's value                      
   for ( int i = 0; i < 5; i++ )
      for ( int j = 0; j < 2; j++ ) {
      
         cout << "a[" << i << "][" << j << "]: ";
         cout << a[i][j]<< endl;
      }
 
   return 0;
}

当编译并执行上述代码时，它会产生以下结果：

a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8

如上所述，您可以创建任意维度的数组，尽管您创建的大多数数组可能是一维或二维的。

三维数组

类似地，C++ 中的三维 (3D) 数组是二维数组概念的扩展，增加了另一个维度。这使您可以访问以三维空间存储数据。您可以将其可视化为一个立方体，其中每个元素都由三个索引标识，这些索引通常表示深度、行和列的维度。要声明一个大小为 x、y 和 z 的三维整数数组，您可以这样写：

type arrayName [ x ][ y ][z];

其中type可以是任何有效的C++数据类型，而arrayName将是一个有效的C++标识符。

三维数组可以被认为是相互堆叠的二维表格的集合，形成一个类似立方体的结构。

因此，数组 a 中的每个元素都由一个名为 b[i][j][k] 的元素名标识，其中 a 是数组的名称，i、j 和 k 是唯一标识 b 中每个元素的下标。

初始化三维数组

三维数组可以通过为每一层、行和列指定带括号的值来初始化。下面是一个具有 2 层、3 行和 4 列的 3D 数组示例。

int b[2][3][4] = {  
  {  
    {0, 1, 2, 3},   /* Initializers for layer 0, row 0 */
    {4, 5, 6, 7},   /* Initializers for layer 0, row 1 */
    {8, 9, 10, 11}  /* Initializers for layer 0, row 2 */
  },
  {  
    {12, 13, 14, 15}, /* Initializers for layer 1, row 0 */
    {16, 17, 18, 19}, /* Initializers for layer 1, row 1 */
    {20, 21, 22, 23}  /* Initializers for layer 1, row 2 */
  }
};

在此初始化中，嵌套大括号用于每一组值的预期层和行。

扁平初始化

或者，您还可以初始化一个不带嵌套大括号的三维数组。此方法将数组视为单个连续的值块。这是一个示例

int b[2][3][4] = {0, 1, 2, 3, 
  4, 5, 6, 7, 
  8, 9, 10, 11, 
  12, 13, 14, 15, 
  16, 17, 18, 19, 
  20, 21, 22, 23};

在这种情况下，值以扁平的格式列出。这两种初始化方法都是有效的，并产生相同的数组结构。

访问三维数组元素

三维数组中的元素是通过使用三个下标来访问的，即层索引、行索引和列索引。例如：

int val = b[1][2][3];

在上语句中，val将获取数组 b 的第 2 层中第 3 行的第 4 个元素。

以下是索引的工作方式：

第一个索引 (1) 指定数组的层 (或深度)。
第二个索引 (2) 指定该层内的行。
第三个索引 (3) 指定该行内的列。

因此，由 b[1][2][3] 访问的元素对应于位于数组第 1 层、第 2 行和第 3 列的值。您可以通过考虑数据如何在立方体格式中结构化来将其可视化，其中每个坐标都指向该 3D 空间内的特定元素。

示例

这是给出的代码：

#include <iostream>
using namespace std;

int main() {
  // An array with 2 layers, 3 rows, and 4 columns.
  int b[2][3][4] = {{
                        {0, 1, 2, 3},   // Layer 0, Row 0
                        {4, 5, 6, 7},   // Layer 0, Row 1
                        {8, 9, 10, 11}  // Layer 0, Row 2
                    },
                    {
                        {12, 13, 14, 15},  // Layer 1, Row 0
                        {16, 17, 18, 19},  // Layer 1, Row 1
                        {20, 21, 22, 23}   // Layer 1, Row 2
                    }};

  // Output each array element's value
  for (int i = 0; i < 2; i++) {      // Iterating through layers
    for (int j = 0; j < 3; j++) {    // Iterating through rows
      for (int k = 0; k < 4; k++) {  // Iterating through columns
        cout << "b[" << i << "][" << j << "][" << k << "]: ";
        cout << b[i][j][k] << endl;
      }
    }
  }

  return 0;
}

当编译并执行上述代码时，它会产生以下结果：

b[0][0][0]: 0
b[0][0][1]: 1
b[0][0][2]: 2
b[0][0][3]: 3
b[0][1][0]: 4
b[0][1][1]: 5
b[0][1][2]: 6
b[0][1][3]: 7
b[0][2][0]: 8
b[0][2][1]: 9
b[0][2][2]: 10
b[0][2][3]: 11
b[1][0][0]: 12
b[1][0][1]: 13
b[1][0][2]: 14
b[1][0][3]: 15
b[1][1][0]: 16
b[1][1][1]: 17
b[1][1][2]: 18
b[1][1][3]: 19
b[1][2][0]: 20
b[1][2][1]: 21
b[1][2][2]: 22
b[1][2][3]: 23

上述代码有效地演示了如何在 C++ 中使用三维数组。

打印页面