原文： https://www.programiz.com/cpp-programming/arrays

在本教程中，我们将学习如何使用数组。 我们将借助示例学习在 C++ 编程中声明，初始化和访问数组元素。

在 C++ 中，数组是一个变量，可以存储相同类型的多个值。 例如，

假设一班有 27 个学生，我们需要存储所有学生的成绩。 无需创建 27 个单独的变量，我们只需创建一个数组即可：

  1. double grade[27];

此处，grade是最多可容纳 27 个double类型元素的数组。

在 C++ 中，声明数组后不能更改数组的大小和类型。

C++ 数组声明

  1. dataType arrayName[arraySize];

例如，

  1. int x[6];

这里，

  • int - 要存储的元素类型
  • x - 数组名称
  • 6 - 数组的大小

C++ 数组中的访问元素

在 C++ 中，数组中的每个元素都与一个数字关联。 该数字称为数组索引。 我们可以使用这些索引访问数组的元素。

  1. // syntax to access array elements
  2. array[index];

考虑上面我们看到的数组x。

C 数组 - 图1

C++ 数组元素

几件事要记住：

  • 数组索引以0开头。 含义x [0]是存储在索引0的第一个元素。

  • 如果数组的大小为n，则最后一个元素存储在索引(n-1)处。 在此示例中，x [5]是最后一个元素。

  • 数组的元素具有连续的地址。 例如，假设x[0]的起始地址为2120d。 然后，下一个元素x[1]的地址将为2124d，x[2]的地址将为2128d，依此类推。
    这里，每个元素的大小增加 4。这是因为int的大小是 4 个字节。

C++ 数组初始化

在 C++ 中，可以在声明期间初始化数组。 例如，

  1. // declare and initialize and array
  2. int x[6] = {19, 10, 8, 17, 9, 15};

C 数组 - 图2

C++ 数组元素及其数据

声明期间初始化数组的另一种方法：

  1. // declare and initialize an array
  2. int x[] = {19, 10, 8, 17, 9, 15};

在这里，我们没有提到数组的大小。 在这种情况下，编译器会自动计算大小。

空成员的 C++ 数组

在 C++ 中，如果数组的大小为n，我们最多可以在数组中存储n个元素。 但是，如果我们存储的元质数少于n个，将会发生什么。

For example,

  1. // store only 3 elements in the array
  2. int x[6] = {19, 10, 8};

在此，数组×的大小为6。 但是，我们仅用 3 个元素对其进行了初始化。

在这种情况下，编译器会为其余位置分配随机值。 通常，此随机值就是0。

C 数组 - 图3

空数组成员将自动分配值 0

如何插入和打印数组元素？

  1. int mark[5] = {19, 10, 8, 17, 9}
  3. // change 4th element to 9
  4. mark[3] = 9;
  6. // take input from the user
  7. // store the value at third position
  8. cin >> mark[2];
  10. // take input from the user
  11. // insert at ith position
  12. cin >> mark[i-1];
  14. // print first element of the array
  15. cout << mark[0];
  17. // print ith element of the array
  18. cout >> mark[i-1];

示例 1：显示数组元素

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  5.     int numbers[5] = {7, 5, 6, 12, 35};
  7.     cout << "The numbers are: ";
  9.     //  Printing array elements
  10.     // using range based for loop
  11.     for (const int &n : numbers) {
  12.         cout << n << "  ";
  13.     }
  15.     cout << "\nThe numbers are: ";
  17.     //  Printing array elements
  18.     // using traditional for loop
  19.     for (int i = 0; i < 5; ++i) {
  20.         cout << numbers[i] << "  ";
  21.     }
  23.     return 0;
  24. }

输出

  1. The numbers are: 7  5  6  12  35
  2. The numbers are: 7  5  6  12  35

在这里，我们使用了for循环从i = 0迭代到i = 4。 在每次迭代中，我们都打印了numbers[i]。

我们再次使用基于范围的for循环来打印出数组的元素。 要了解有关此循环的更多信息，请检查基于 C++ 的循环范围。

注意：在基于范围的循环中，我们使用代码const int &n而不是int n作为范围声明。 但是，const int &n更可取，因为：

  1. 使用int n只需在每次迭代期间将数组元素复制到变量n。 这不是高效的内存。 但是，
    & n使用数组元素的内存地址来访问其数据，而无需将其复制到新变量中。 这样可以节省内存。

  2. 我们只是在打印数组元素，而不修改它们。 因此，我们使用const以免意外更改数组的值。

示例 2：从用户那里获取输入并将其存储在数组中

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  5.     int numbers[5];
  7.     cout << "Enter 5 numbers: " << endl;
  9.     //  store input from user to array
  10.     for (int i = 0; i < 5; ++i) {
  11.         cin >> numbers[i];
  12.     }
  14.     cout << "The numbers are: ";
  16.     //  print array elements
  17.     for (int n = 0; n < 5; ++n) {
  18.         cout << numbers[n] << "  ";
  19.     }
  21.     return 0;
  22. }

输出

  1. Enter 5 numbers: 
  2. 11
  3. 12
  4. 13
  5. 14
  6. 15
  7. The numbers are: 11  12  13  14  15

再次，我们使用了for循环从i = 0迭代到i = 4。 在每次迭代中，我们从用户那里获取输入并将其存储在numbers[i]中。

然后，我们使用了另一个for循环来打印所有数组元素。

示例 3：使用for循环显示数组元素的总和和平均值

  1. #include <iostream>
  2. using namespace std;
  4. int main() {
  6.     // initialize an array without specifying size
  7.     double numbers[] = {7, 5, 6, 12, 35, 27};
  9.     double sum = 0;
  10.     double count = 0;
  11.     double average;
  13.     cout << "The numbers are: ";
  15.     //  print array elements
  16.     // use of range-based for loop
  17.     for (const double &n : numbers) {
  18.         cout << n << "  ";
  20.         //  calculate the sum
  21.         sum += n;
  23.         // count the no. of array elements
  24.         ++count;
  25.     }
  27.     // print the sum
  28.     cout << "\nTheir Sum = " << sum << endl;
  30.     // find the average
  31.     average = sum / count;
  32.     cout << "Their Average = " << average << endl;
  34.     return 0;
  35. }

输出

  1. The numbers are: 7  5  6  12  35  27
  2. Their Sum = 92
  3. Their Average = 15.3333

在此程序中：

  1. 我们已初始化名为num的double数组，但未指定其大小。 我们还声明了三个双变量sum，count和average。
    这里是sum =0和count = 0。

  2. 然后，我们使用基于范围的for循环来打印数组元素。 在循环的每次迭代中，我们将当前数组元素添加到sum中。

  3. 在每次迭代中，我们还将count的值增加1，以便可以在for循环结束时获得数组的大小。

  4. 在打印所有元素之后，我们将打印所有数字的总和和平均值。 数字的平均值由average = sum / count;给出

注意：我们使用基于范围的for循环而不是常规的for循环，因为我们不知道数组的大小。

普通的for循环要求我们指定迭代次数，该次数由数组的大小指定。

但是基于范围的for循环不需要这样的规范。

C++ 数组越界

如果我们声明一个大小为 10 的数组，则该数组将包含索引从 0 到 9 的元素。

但是，如果尝试访问索引为 10 或大于 10 的元素，则将导致未定义的行为。