C 数组
预计时间： 13分钟
数组(array)是若干同类变量的聚合，允许通过统一的名字引用其中的变量。数组的特定元素通过下标(index)访问。
数组是一种数据结构，可以存储相同类型元素的固定大小的顺序集合。数组用于存储数据的集合，但将数组视为相同类型变量的集合通常更有用。
不用声明单独的变量，例如 number0、number1、...和 number99，而是声明一个数组变量，例如 numbers，并使用 numbers[0]、numbers[1] 和 ...、numbers[99] 来表示个体变量。数组中的特定元素由索引访问。
所有数组都由连续的内存位置组成。最低地址对应于第一个元素，最高地址对应于最后一个元素。
声明数组
要在 C 中声明一个数组，程序员指定元素的类型和数组所需的元素数量，如下所示 -
type arrayName [ arraySize ];
这称为一维数组。arraySize必须是一个大于零的整数常量，并且type可以是任何有效的 C 数据类型。例如，要声明一个名为balance的 double 类型的 10 元素数组，请使用以下语句 -
double balance[10];
这里的balance是一个变量数组，足以容纳最多 10 个双精度数。
初始化数组
您可以一个一个地初始化 C 中的数组，也可以使用单个语句初始化一个数组，如下所示 -
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
大括号 { } 之间的值的数量不能大于我们为方括号 [ ] 之间的数组声明的元素数量。
如果省略数组的大小，则会创建一个大到足以容纳初始化的数组。因此，如果你写 -
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
您将创建与前面示例中完全相同的数组。以下是分配数组的单个元素的示例 -
balance[4] = 50.0;
上面的语句将数组中的第 5个元素赋值为 50.0。所有数组都有 0 作为它们的第一个元素的索引，也称为基本索引，数组的最后一个索引将是数组的总大小减 1。下面显示的是我们上面讨论的数组的图形表示 -
访问数组元素
通过索引数组名称来访问元素。这是通过将元素的索引放在数组名称之后的方括号内来完成的。例如 -
double salary = balance[9];
上面的语句将从数组中获取第 10个元素并将值分配给薪水变量。以下示例展示了如何使用上述所有三个概念，即。声明、赋值和访问数组 -
#include <stdio.h>
int main () {
int n[ 10 ]; /* n is an array of 10 integers */
int i,j;
/* initialize elements of array n to 0 */
for ( i = 0; i < 10; i++ ) {
n[ i ] = i + 100; /* set element at location i to i + 100 */
}
/* output each array element's value */
for (j = 0; j < 10; j++ ) {
printf("Element[%d] = %d\n", j, n[j] );
}
return 0;
}
编译并执行上述代码时，会产生以下结果 -
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
多维数组
C 编程语言允许多维数组。这是多维数组声明的一般形式 -
type name[size1][size2]...[sizeN];
例如，以下声明创建一个三维整数数组 -
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 <stdio.h>
int main () {
/* an array with 5 rows and 2 columns*/
int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
int i, j;
/* output each array element's value */
for ( i = 0; i < 5; i++ ) {
for ( j = 0; j < 2; j++ ) {
printf("a[%d][%d] = %d\n", i,j, a[i][j] );
}
}
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 中将数组作为函数参数传递
如果要将一维数组作为参数传递给函数，则必须以以下三种方式之一声明形式参数，并且所有三种声明方法都会产生相似的结果，因为每种方法都告诉编译器一个整数指针正在运行被接收。同样，您可以将多维数组作为形式参数传递。
方式一
形式参数作为指针 -
void myFunction(int *param) {
.
.
.
}
方式二
形式参数作为一个大小的数组 -
void myFunction(int param[10]) {
.
.
.
}
方式 3
形式参数作为未调整大小的数组 -
void myFunction(int param[]) {
.
.
.
}
例子
现在，考虑以下函数，它将一个数组作为一个参数以及另一个参数，并基于传递的参数，它返回通过数组传递的数字的平均值，如下所示 -
double getAverage(int arr[], int size) {
int i;
double avg;
double sum = 0;
for (i = 0; i < size; ++i) {
sum += arr[i];
}
avg = sum / size;
return avg;
}
现在，让我们按如下方式调用上述函数 -
#include <stdio.h>
/* function declaration */
double getAverage(int arr[], int size);
int main () {
/* an int array with 5 elements */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
/* pass pointer to the array as an argument */
avg = getAverage( balance, 5 ) ;
/* output the returned value */
printf( "Average value is: %f ", avg );
return 0;
}
当上面的代码一起编译并执行时，它会产生以下结果 -
Average value is: 214.400000
如您所见，就函数而言，数组的长度并不重要，因为 C 不执行形式参数的边界检查。
从函数返回数组
C 允许函数返回一个数组。
C 编程不允许将整个数组作为参数返回给函数。但是，您可以通过指定不带索引的数组名称来返回指向数组的指针。
如果要从函数返回一维数组，则必须声明一个返回指针的函数，如下例所示 -
int * myFunction() {
.
.
.
}
要记住的第二点是C不提倡将局部变量的地址返回到函数外部，因此您必须将局部变量定义为静态变量。
现在，考虑以下函数，它将生成 10 个随机数并使用数组返回它们，并按如下方式调用此函数 -
#include <stdio.h>
/* function to generate and return random numbers */
int * getRandom( ) {
static int r[10];
int i;
/* set the seed */
srand( (unsigned)time( NULL ) );
for ( i = 0; i < 10; ++i) {
r[i] = rand();
printf( "r[%d] = %d\n", i, r[i]);
}
return r;
}
/* main function to call above defined function */
int main () {
/* a pointer to an int */
int *p;
int i;
p = getRandom();
for ( i = 0; i < 10; i++ ) {
printf( "*(p + %d) : %d\n", i, *(p + i));
}
return 0;
}
当上面的代码一起编译并执行时，它会产生以下结果 -
r[0] = 313959809
r[1] = 1759055877
r[2] = 1113101911
r[3] = 2133832223
r[4] = 2073354073
r[5] = 167288147
r[6] = 1827471542
r[7] = 834791014
r[8] = 1901409888
r[9] = 1990469526
*(p + 0) : 313959809
*(p + 1) : 1759055877
*(p + 2) : 1113101911
*(p + 3) : 2133832223
*(p + 4) : 2073354073
*(p + 5) : 167288147
*(p + 6) : 1827471542
*(p + 7) : 834791014
*(p + 8) : 1901409888
*(p + 9) : 1990469526
指向数组的指针
您可以通过简单地指定数组名称来生成指向数组第一个元素的指针，而无需任何索引。
在你读完“指针”一章之前，你很可能不会理解这一节。
假设您对 C 语言中的指针有所了解，让我们开始：数组名是指向数组第一个元素的常量指针。因此，在声明中 -
double balance[50];
balance是一个指向 &balance[0] 的指针，它是数组 balance 的第一个元素的地址。因此，以下程序片段将p分配为balance第一个元素的地址-
double *p;
double balance[10];
p = balance;
使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是访问 balance[4] 处数据的合法方式。
一旦将第一个元素的地址存储在 'p' 中，就可以使用 *p、*(p+1)、*(p+2) 等访问数组元素。下面给出的示例显示了上面讨论的所有概念 -
#include <stdio.h>
int main () {
/* an array with 5 elements */
double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
double *p;
int i;
p = balance;
/* output each array element's value */
printf( "Array values using pointer\n");
for ( i = 0; i < 5; i++ ) {
printf("*(p + %d) : %f\n", i, *(p + i) );
}
printf( "Array values using balance as address\n");
for ( i = 0; i < 5; i++ ) {
printf("*(balance + %d) : %f\n", i, *(balance + i) );
}
return 0;
}
编译并执行上述代码时，会产生以下结果 -
Array values using pointer
*(p + 0) : 1000.000000
*(p + 1) : 2.000000
*(p + 2) : 3.400000
*(p + 3) : 17.000000
*(p + 4) : 50.000000
Array values using balance as address
*(balance + 0) : 1000.000000
*(balance + 1) : 2.000000
*(balance + 2) : 3.400000
*(balance + 3) : 17.000000
*(balance + 4) : 50.000000
在上面的例子中，p 是一个指向 double 的指针，这意味着它可以存储一个 double 类型的变量的地址。一旦我们获得了 p 中的地址，*p将为我们提供存储在 p 中的地址的可用值，如上例所示。
更新于2022年04月13日