数组中 C++ | 声明 | 初始化 | 指向数组的指针示例
本杰明·沃克
什么是数组？
数组是一种按顺序存储相同数据类型元素的数据结构。 C++ 数组具有固定大小。
您可以将数组视为具有相似数据类型的变量的集合。您不必声明每个变量并单独为其赋值，而是可以声明一个变量（数组）并将各个变量的值添加到其中。添加到数组的每个值都由索引标识。
为什么我们需要数组？
阵列 在任何编程语言中都非常重要。它们提供了一种更方便的方式来将变量或类似数据类型的数据集合存储在一起，而不是将它们分开存储。数组的每个值将被单独访问。
在中声明一个数组 C++
数组声明在 C++ 涉及声明数组要存储的元素类型和数量。语法：
type array-Name [ array-Size ];
声明一维数组的规则 C++.
- 类型： 类型是要存储在数组中的元素的类型，它必须是有效的 C++ 数据类型。
- 数组名称： array-Name 是要分配给数组的名称。
- 数组大小： array-Size 是数组中要存储的元素数。它必须是大于 0 的整数。
例如，可以创建一个名为 age 的数组并存储 5 名学生的年龄，如下所示：
int age[5];
数组age将存储5个整数，代表不同学生的年龄。
数组初始化
数组初始化是将元素分配/存储到数组的过程。初始化可以在单个语句中完成，也可以逐个完成。请注意，数组中的第一个元素存储在索引 0 处，而最后一个元素存储在索引 n-1 处，其中 n 是数组中元素的总数。
对于年龄数组，第一个元素将存储在索引 0 处，而最后一个元素将存储在索引 4 处。
让我们使用年龄数组来演示如何进行数组初始化：
int age[5] = {19, 18, 21, 20, 17};
{ } 中的元素总数不能超过 [ ] 中指定的值。元素 19 位于索引 0，18 位于索引 1，21 位于索引 2，20 位于索引 3，17 位于索引 4。如果您未在 [ ] 中指定要存储在数组中的元素数量，则数组仅足以容纳 { } 中添加的元素。例如：
int age[] = {19, 18, 21, 20, 17};
上述语句将创建与前一个完全相同的数组。您还可以使用索引将一个元素分配给数组。例如：
age[3] = 20;
上述语句将把值 20 存储在名为 age 的数组的索引 3 处。这意味着 20 将是第 4 个th 数组的元素。
数组类型
有两种类型 C++ 数组：
- 一维数组
- 多维数组
- 指向数组的指针
一维数组
这是一个数组，其中的数据项仅在一个维度上线性排列。它通常被称为一维数组。语法：
datatype array-name[size];
- array-name 是数组的名称。
- 大小是数组中要存储的项目数。
例如：
#include <iostream>
using namespace std;
int main()
{
int age[5] = { 19, 18, 21, 20, 17 };
for (int x = 0; x < 5; x++)
{
cout <<age[x]<<"\n";
}
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用main（）函数，在其中添加程序的逻辑。
- main() 函数主体的开始。
- 声明一个名为 age 的数组，用于存储 5 个整数。这 5 个整数也已初始化。
- 使用 for 循环创建一个整数变量 x。
- for 循环体的开头。
- 使用循环变量 x 迭代数组 age 的值并将其打印在控制台上。“\n”是换行符，每次迭代后都会打印在新行中。
- 主体的结尾 for循环.
- main() 函数体结束。
多维数组
这是一个数组，其中的数据项按顺序排列，形成数组的数组。多维数组可以有任意数量的维度，但二维和三维数组很常见。语法：
datatype array-name[d1][d2][d3]...[dn];
数组名称是具有 n 个维度的数组的名称。例如：
二维数组
二维数组将数据存储在具有一维数组的列表中。它是一个具有行和列的矩阵。要声明二维数组，请使用以下语法：
type array-Name [ x ][ y ];
类型必须是有效的 C++ 数据类型。将二维数组视为一个表，其中 x 表示行数，y 表示列数。这意味着您使用 a[x][y] 形式标识二维数组中的每个元素，其中 x 是元素所属的行数，y 是元素所属的列数。
以下是如何初始化二维数组的示例：
int a[2][3] = {
{0, 2, 1} , /* row at index 0 */
{4, 3, 7} , /* row at index 1 */
};
在上面的例子中，我们有一个二维数组，可以看作是一个 2×2 矩阵。它有 3 行和 2 列。元素 3 可以作为 a[0][0] 访问，因为它位于行索引 1 和列索引 0 的交点处。元素 1 可以作为 a[3][1] 访问，因为它位于行索引 2 和列索引 1 的交点处。
请注意，我们只是添加了花括号来区分元素的不同行。初始化也可以按如下方式完成：
int a[2][3] = {0, 2, 1, 4, 3, 7};
};
下列 C++ 示例演示如何初始化和遍历二维数组：
#include <iostream>
using namespace std;
int main()
{
// a 2x3 array
int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };
// traverse array elements
for (int i=0; i<3; i++)
for (int j=0; j<2; j++)
{
cout << "a[" <<i<< "][" <<j<< "]: ";
cout << a[i][j] << endl;
}
return 0;
}
输出：
以下是上述代码的截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用 main() 函数，其中应添加代码。
- main() 函数主体的开始。
- 一条评论。 C++ 编译器将跳过这一步。
- 声明一个 2 行 3 列的二维数组。项目也已添加到数组中。
- 一条评论。 C++ 编译器将跳过这一步。
- 使用 for 循环创建变量 i。此变量将遍历数组的行索引。
- 使用 for 循环创建变量 j。此变量将遍历数组的列索引。
- 循环主体的开始。
- 在控制台上的方括号内打印变量 i 和 j 的值。
- 打印出数组 a 的索引 [i][j] 处存储的值。
- 环体的末端。
- 如果程序运行正常，main() 函数应该返回一个整数值。
- main() 函数体结束。
三维阵列
三维数组是数组的数组。三维数组中的每个元素由一组 3 个索引标识。要访问三维数组的元素，我们使用三个 for 循环。例如：
#include<iostream>
using namespace std;
void main()
{
int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};
cout << "a[0][1][0] = " << a[0][1][0] << "\n";
cout << "a[0][1][1] = " << a[0][1][1] << "\n";
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用main（）函数，在其中添加程序的逻辑。
- main() 函数主体的开始。
- 声明一个名为 an 的 3D 数组，大小为 2x3x2。数组的值也已初始化。
- 访问数组索引 [0][1][0] 处存储的项目并将其打印在控制台上。
- 访问数组索引 [0][1][1] 处存储的项目并将其打印在控制台上。
- main() 函数体结束。
指向数组的指针
A 指针 是一个保存地址的变量。除了使用指针存储变量的地址外，我们还可以使用它来存储数组单元的地址。数组的名称始终指向其第一个元素。考虑下面给出的声明：
int age[5];
age 是指向 $age[0] 的指针，即名为 age 的数组的第一个元素的地址。请考虑以下示例：
#include <iostream>
using namespace std;
int main()
{
int *john;
int age[5] = { 19, 18, 21, 20, 17 };
john = age;
cout << john << "\n";
cout << *john;
}
输出：
请注意，上述输出的第一个值可能会返回不同的值，具体取决于计算机内存中分配给数组第一个元素的地址。
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用main（）函数，在其中添加程序的逻辑。
- main() 函数主体的开始。
- 声明一个名为*john的指针变量。
- 声明一个名为 age 的整数数组，用于存储 5 个整数。整数的值也已初始化。
- 将数组 age 的第一个索引中存储的项目的地址值分配给变量 john。
- 打印变量 john 的值，即存储在数组 age 第一个索引中的项目的地址。
- 打印数组 age 中存储的第一个值。
- main() 函数体结束。
数组名称可以用作常量指针，反之亦然。这意味着您可以使用 *(age + 3) 访问存储在数组 age 索引 3 处的值。例如：
#include <iostream>
using namespace std;
int main() {
// an array of 5 elements.
int age[5] = { 19, 18, 21, 20, 17 };
int *p;
p = age;
// output array values
cout << "Using pointer: " << endl;
for (int x=0; x<5; x++) {
cout << "*(p + " << x << ") : ";
cout << *(p + x) << endl;
}
cout << "Using age as address: " << endl;
for (int x = 0; x < 5; x++) {
cout << "*(age + " << x << ") : ";
cout << *(age + x) << endl;
}
return 0;
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用 main() 函数并启动 main() 函数体。
- 一条评论。 C++ 编译器将跳过这一步。
- 声明一个名为age的数组来存储5个整数。
- 创建一个整数指针 p。
- 将数组 age 第一个元素的地址的值赋给 p。
- 一条评论。 C++ 编译器将跳过这一步。
- 在控制台上打印一些文本。
- 使用 for a 循环创建一个整数 x。{ 标记 for a 循环主体的开始。
- 在控制台上打印出 x 的值以及其他一些文本。
- 在控制台上打印出*(p + x) 的值。
- 循环主体的结束。
- 在控制台上打印一些文本。
- 使用 for 循环创建变量 x。{ 标记 for 循环主体的开始。
- 将 x 的值从 0 到 4 与其他一些文本一起打印出来。
- 打印出*(age + x) 的值。
- for 循环主体的结束。
- 如果程序运行成功则返回值。
- main() 函数体结束。
访问数组的值
数组元素使用其各自的索引进行访问。要访问的元素的索引添加在数组名称后的方括号 [ ] 内。例如：
int john = age[2];
在上面的例子中，我们只是说明约翰的年龄存储在名为 age 的数组的索引 2 处。这意味着约翰的年龄是第 3rd 数组 age 中的值。下面是完整的 C++ 示例显示如何访问和打印出该值：
#include<iostream>
using namespace std;
int main()
{
int age[5] = { 19, 18, 21, 20, 17 };
int john = age[2];
cout << "The age of John is:"<<john;
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件。它将允许我们从控制台读取和写入。
- 包括 std 命名空间，以便使用其类和函数而无需调用它。
- 调用 main() 函数，其中应添加代码。
- main() 函数主体的开始。
- 声明一个名为age的数组来存储5个整数元素。
- 访问数组 age 索引 2 处存储的值并将其值存储在名为 john 的变量中。
- 将变量 john 的值与其他文本一起打印在控制台上。
数组的优点 C++
以下是使用数组的优点/好处 C++:
- 数组元素可以轻松遍历。
- 易于操作数组数据。
- 数组元素可以被随机访问。
- 数组有助于代码优化；因此，我们可以用更少的代码完成更多的工作。
- 轻松对数组数据进行排序。
数组的缺点 C++
- 数组具有固定的大小；因此，初始化后我们不能向其中添加新元素。
- 分配超过要求的内存会导致内存空间浪费，而分配较少的内存又会产生问题。
- 必须事先知道数组中要存储的元素数量。
总结
- 数组是一种存储相同数据类型元素的数据结构。
- 数组元素按顺序存储。
- 数组元素使用其各自的索引表示。第一个元素位于索引 0，最后一个元素位于索引 n-1，其中是数组元素的总数。
- 数组的声明涉及定义数组元素的数据类型以及数组中要存储的元素数量。
- 一维数组按顺序存储元素。
- 二维数组按行和列存储元素。
- 三维数组是数组的数组。
- 可以使用索引将元素添加到数组中。
- 使用索引来访问数组元素。
- 多维数组具有多个维度。
- 数组名称指向其第一个元素。
- 数组具有固定的大小，这意味着在初始化数组之后不能向其中添加新元素。
