C语言中的数组

---

---

C语言中的数组是一种数据结构，可以存储相同数据类型的固定大小的顺序元素集合。数组用于存储数据集合，但通常将数组视为相同类型变量的集合更有用。

什么是 C 语言中的数组？

C语言中的数组是相同数据类型的数据项的集合。数组可以存储一个或多个相同数据类型的值，这些值可以是基本数据类型（int、float、char），也可以是用户定义类型，例如结构体或指针。在 C 语言中，数组中元素的类型应与数组本身的数据类型匹配。

数组的大小，也称为数组的长度，必须在声明中指定。一旦声明，C 语言数组的大小就不能更改。当声明数组时，编译器会分配存储声明的元素数量所需的连续内存块。

为什么我们在 C 语言中使用数组？

数组用于存储和操作相同类型的数据。

假设我们要存储 10 名学生的成绩并求平均值。我们声明 10 个不同的变量来存储 10 个不同的值，如下所示：

int a = 50, b = 55, c = 67, . . . ;
float avg = (float)(a + b + c +. . . ) / 10;

这些变量将在内存中分散开来，它们之间没有任何关系。重要的是，如果我们想扩展求 100（或更多）名学生平均值的问题，那么声明如此多的单个变量变得不切实际。

数组提供了一种紧凑且内存高效的解决方案。由于数组中的元素存储在相邻的位置，因此我们可以轻松地访问相对于当前元素的任何元素。由于每个元素都有一个索引，因此可以对其进行直接操作。

示例：在 C 语言中使用数组

回到存储 10 名学生的成绩并求平均值的问题，使用数组的解决方案将是：

#include <stdio.h>

int main(){
   int marks[10] = {50, 55, 67, 73, 45, 21, 39, 70, 49, 51};
   int i, sum = 0;
   float avg;

   for (i = 0; i <= 9; i++){
      sum += marks[i];
   }

   avg = (float)sum / 10;
   printf("Average: %f", avg);
   return 0;    
}

输出

运行代码并检查其输出：

Average: 52.000000

数组元素存储在连续的内存位置。每个元素都由从“0”开始的索引标识。最低地址对应于第一个元素，最高地址对应于最后一个元素。

在 C 语言中声明数组

要在 C 语言中声明数组，您需要指定元素的类型以及要存储的元素数量。

声明数组的语法

type arrayName[size];

“size”必须是一个大于零的整数常量，其“type”可以是任何有效的 C 语言数据类型。在 C 语言中声明数组的方法有很多种。

示例：在 C 语言中声明数组

在下面的示例中，我们声明了一个包含 5 个整数的数组，并打印所有数组元素的索引和值：

#include <stdio.h>

int main(){
   int arr[5];
   int i;

   for (i = 0; i <= 4; i++){
      printf("a[%d]: %d\n", i, arr[i]);
   }
   return 0;
}

输出

运行代码并检查其输出：

a[0]: -133071639
a[1]: 32767
a[2]: 100
a[3]: 0
a[4]: 4096

在 C 语言中初始化数组

在声明数组时，您可以通过提供用花括号 {} 括起来的逗号分隔的值集来初始化它。

初始化数组的语法

data_type array_name [size] = {value1, value2, value3, ...};

初始化数组的示例

以下示例演示了整数数组的初始化

// Initialization of an integer array
#include <stdio.h>

int main() 
{
  int numbers[5] = {10, 20, 30, 40, 50};

  int i;  // loop counter

  // Printing array elements
  printf("The array elements are : ");
  for (i = 0; i < 5; i++) {
    printf("%d ", numbers[i]);
  }

  return 0;
}

输出

The array elements are : 10 20 30 40 50

将所有数组元素初始化为 0 的示例

要将所有元素初始化为 0，请将其放在花括号内

#include <stdio.h>

int main(){
   int arr[5] = {0};
   int i;

   for(i = 0; i <= 4; i++){
      printf("a[%d]: %d\n", i, arr[i]);
   }
   return 0;
}

输出

运行此代码时，将产生以下输出：

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

部分初始化数组的示例

如果值的列表小于数组的大小，则其余元素将初始化为“0”。

#include <stdio.h>

int main(){
   int arr[5] = {1,2};
   int i;

   for(i = 0; i <= 4; i++){
      printf("a[%d]: %d\n", i, arr[i]);
   }
   return 0;
}

输出

运行此代码时，将产生以下输出：

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

部分和特定元素初始化的示例

如果数组被部分初始化，则可以在方括号中指定元素。

#include <stdio.h>

int main(){
   int a[5] = {1,2, [4] = 4};
   int i;
   
   for(i = 0; i <= 4; i++){
      printf("a[%d]: %d\n", i, a[i]);
   }
   return 0;
}

输出

执行后，将产生以下输出：

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

获取 C 语言中数组的大小

编译器分配一个连续的内存块。分配的内存大小取决于数组的数据类型。

示例 1：整数数组的大小

如果声明了一个包含 5 个元素的整数数组，则数组以字节为单位的大小将为“sizeof(int) x 5”

#include <stdio.h>

int main(){
   int arr[5] = {1, 2, 3, 4, 5};
   printf("Size of array: %ld", sizeof(arr));
   return 0;
}

输出

执行后，您将获得以下输出：

Size of array: 20

sizeof 运算符返回变量占用的字节数。

示例 2：数组元素的相邻地址

每个int的大小为 4 个字节。编译器为每个元素分配相邻的位置。

#include <stdio.h>

int main(){
   int a[] = {1, 2, 3, 4, 5};
   int i;

   for(i = 0; i < 4; i++){
      printf("a[%d]: %d \t Address: %d\n", i, a[i], &a[i]);
   }
   return 0;
}

输出

运行代码并检查其输出：

a[0]: 1 	 Address: 2102703872
a[1]: 2 	 Address: 2102703876
a[2]: 3 	 Address: 2102703880
a[3]: 4 	 Address: 2102703884

在此数组中，每个元素都是int类型。因此，第 0 个元素占用前 4 个字节 642016 到 19。下一个下标处的元素占用接下来的 4 个字节，依此类推。

示例 3：双精度类型数组

如果我们有double类型的数组，则每个下标处的元素占用 8 个字节

#include <stdio.h>

int main(){
   double a[] = {1.1, 2.2, 3.3, 4.4, 5.5};
   int i;

   for(i = 0; i < 4; i++){
      printf("a[%d]: %f \t Address: %ld\n", i, a[i], &a[i]);
   }
   return 0;
}

输出

运行代码并检查其输出：

a[0]: 1.100000 	 Address: 140720746288624
a[1]: 2.200000 	 Address: 140720746288632
a[2]: 3.300000 	 Address: 140720746288640
a[3]: 4.400000 	 Address: 140720746288648

示例 4：字符数组的大小

“char”变量的长度为 1 个字节。因此，char 数组的长度将等于数组的大小。

#include <stdio.h>

int  main(){
   char a[] = "Hello";
   int i;

   for (i=0; i<5; i++){
      printf("a[%d]: %c address: %ld\n", i, a[i], &a[i]);
   }
   return 0;
}

输出

运行代码并检查其输出：

a[0]: H address: 6422038
a[1]: e address: 6422039
a[2]: l address: 6422040
a[3]: l address: 6422041
a[4]: o address: 6422042

在 C 语言中访问数组元素

数组中的每个元素都由一个唯一的递增索引标识，从“0”开始。要按索引访问元素，可以通过在数组名称后方方括号内放置元素的索引来实现。

通过在数组名称后方的方括号内指定所需元素的索引（偏移量）来访问数组的元素。例如：

double salary = balance[9];

上述语句将从数组中获取第 10 个元素并将该值赋给“salary”。

访问 C 语言中数组元素的示例

以下示例显示了如何使用上述所有三个概念，即声明、赋值和访问数组。

#include <stdio.h>
 
int main(){

   int n[5];  /* n is an array of 5 integers */ 
   int i, j;
 
   /* initialize elements of array n to 0 */         
   for(i = 0; i < 5; i++){
      n[i] = i + 100;
   }
   
   /* output each array element's value */
   for(j = 0; j < 5; j++){
      printf("n[%d] = %d\n", j, n[j]);
   }
   return 0;
}

输出

运行此代码后，您将获得以下输出：

n[0] = 100
n[1] = 101
n[2] = 102
n[3] = 103
n[4] = 104

索引允许随机访问数组元素。数组可以包含结构体变量、指针甚至其他数组作为其元素。

更多关于 C 语言数组的内容

数组作为 C 语言中的一个重要概念，需要更多关注。以下与数组相关的重要的概念对于 C 语言程序员来说应该清楚：