四、 数组

 

目录

1. 数组的概念

2. 数组的创建与初始化

3. 数组的使用

4. 一维数组在内存中的存储

5. sizeof计算数组元素个数

6. 二维数组的创建

7. 二维数组的初始化

8. 二维数组的使用

9. 二维数组在内存中的存储

10. C99中的变长数组

---

1. 数组的概念

在编程中，数组（Array）是一种用于存储多个相同类型数据元素的数据结构。数组可以存储在内存中连续的一段空间中，每个元素都有一个唯一的索引，通过索引可以访问数组中的元素。

数组通常具有以下特点：

1. 相同类型元素： 数组中的所有元素必须是相同的数据类型，例如整数、浮点数、字符等。
2. 固定大小： 一旦数组被创建，它的大小通常是固定的，无法在运行时改变。
3. 连续存储： 数组中的元素在内存中是连续存储的，这意味着通过索引可以快速访问任何元素。
4. 零基索引： 大多数编程语言中，数组的索引从0开始，即第一个元素的索引是0，第二个元素的索引是1，依此类推。

在许多编程语言中，声明一个数组通常需要指定数组的类型和大小。例如，在C语言中，你可以声明一个包含5个整数的数组如下：

int numbers[5];

这样就创建了一个包含5个整数的数组，名为**numbers。**数组中的每个元素可以通过索引访问，例如numbers[0]表示第一个元素，numbers[1]表示第二个元素，以此类推。

数组在编程中非常常见，它们可以用于存储和处理大量的数据，例如存储学生成绩、保存图像像素、处理文本数据等。

2. 数组的创建与初始化

好的，以下是不使用加粗字体的一维数组创建与初始化的示例：

好的，以下是不使用加粗字体的一维数组创建与初始化的示例：

1. 声明数组并初始化：

   • 在声明数组的同时，可以直接为数组的每个元素指定初始值。

   int numbers[5] = {1, 2, 3, 4, 5};
   

   这样就创建了一个包含5个整数的数组，并为每个元素赋予了初始值。

2. 动态初始化：

   • 在声明数组后，逐个为数组元素赋值。

   int numbers[5];
   numbers[0] = 1;
   numbers[1] = 2;
   numbers[2] = 3;
   numbers[3] = 4;
   numbers[4] = 5;
   

   这种方式适用于在程序运行过程中根据需要为数组赋值的情况。

3. 部分初始化：

   • 可以只初始化数组的一部分元素，未初始化的元素会被默认赋予默认值（例如0）。

   int numbers[5] = {1, 2}; // 初始化前两个元素为1和2，后面的元素默认为0
   

4. 使用循环初始化：

   • 可以使用循环结构来为数组赋值，特别适用于需要按照一定规律初始化数组的情况。

   int numbers[5];
   for (int i = 0; i < 5; i++) {
       numbers[i] = i + 1;
   }
   

   这种方式可以灵活地根据索引值设置数组的元素值。

无论使用哪种方式，创建和初始化一维数组都是在程序中常见的操作，它们为存储和处理数据提供了便利。

3. 数组的使用

一维数组在编程中被广泛使用，它们可以用于存储和操作一系列相同类型的数据。以下是一些常见的一维数组的使用方式：

1. 存储数据： 一维数组可以用来存储一系列数据，例如整数、浮点数、字符等。这些数据可以表示成员工工资、学生成绩、一段文本等。

   int scores[5] = {90, 85, 70, 95, 80};
   

2. 遍历数组： 使用循环结构可以遍历一维数组中的所有元素，对每个元素进行操作或输出。

   for (int i = 0; i < 5; i++) {
       printf("第 %d 个元素的值是：%d\\\\n", i + 1, scores[i]);
   }
   

3. 处理数据： 一维数组可以用于执行各种数据处理操作，例如排序、搜索、求和等。

   int sum = 0;
   for (int i = 0; i < 5; i++) {
       sum += scores[i];
   }
   printf("总分是：%d\\\\n", sum);
   

4. 传递参数： 函数可以接受一维数组作为参数，从而实现对数组的操作或处理。

   void printArray(int arr[], int size) {
       for (int i = 0; i < size; i++) {
           printf("%d ", arr[i]);
       }
       printf("\\\\n");
   }
   
   int main() {
       int numbers[5] = {1, 2, 3, 4, 5};
       printArray(numbers, 5);
       return 0;
   }
   

5. 多维数组的模拟： 使用一维数组可以模拟实现多维数组，例如使用一维数组表示二维矩阵。

   int matrix[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
   

通过合理地使用一维数组，可以在程序中存储和处理大量的数据，从而实现各种复杂的功能和算法。

4. 一维数组在内存中的存储

一维数组在内存中是按照连续的方式存储的，也就是说，数组中的各个元素在内存中是依次排列的，每个元素占据相同大小的存储空间。

在内存中，数组的存储可以用一个简单的图示来表示。假设我们有一个包含5个整数的一维数组，那么它在内存中的存储结构如下：

    |    0    |    1    |    2    |    3    |    4    |
    +---------+---------+---------+---------+---------+
    |  int    |  int    |  int    |  int    |  int    |
    +---------+---------+---------+---------+---------+

在这个示意图中，每个int表示一个整数的存储空间。数组中的第一个元素存储在索引为0的位置，第二个元素存储在索引为1的位置，以此类推。

当程序访问数组的某个元素时，编译器会根据数组的起始地址和元素的索引来计算出元素在内存中的确切位置。由于数组的元素是连续存储的，因此可以通过索引的偏移量来快速定位任何一个元素。

对于数组中的每个元素，都可以使用索引来访问，例如array[0]表示数组的第一个元素，array[1]表示数组的第二个元素，以此类推。

由于数组的内存存储是连续的，因此在访问数组元素时具有良好的性能。但是，需要注意的是，数组的大小一经确定，通常无法在运行时改变，因为数组在内存中分配的空间是固定的。

5. sizeof计算数组元素个数

在C语言中，可以使用 sizeof 操作符来计算数组中元素的个数。但是需要注意的是，sizeof 返回的是数组在内存中占用的总字节数，而不是数组中元素的个数。为了得到数组中元素的个数，通常需要用 sizeof 返回的总字节数除以单个元素的字节数。

以下是一个示例，展示了如何使用 sizeof 来计算数组中元素的个数：

#include <stdio.h>

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int array_size = sizeof(array) / sizeof(array[0]);

    printf("数组中元素的个数为：%d\\\\n", array_size);

    return 0;
}

在这个示例中，sizeof(array) 返回的是数组 array 在内存中占用的总字节数，而 sizeof(array[0]) 返回的是数组中第一个元素 array[0] 的字节数。通过将总字节数除以单个元素的字节数，就可以得到数组中元素的个数。

6. 二维数组的创建

在C语言中，创建二维数组与创建一维数组类似，只是需要指定数组的行数和列数。以下是几种常见的方式来创建二维数组：

1. 指定行数和列数同时初始化：

   • 可以在声明数组时指定行数和列数，并同时初始化数组的元素。

   int matrix[3][3] = {
       {1, 2, 3},
       {4, 5, 6},
       {7, 8, 9}
   };
   

2. 指定行数和列数动态初始化：

   • 可以先声明数组，然后逐行为数组的每一行指定元素值。

   int matrix[3][3];
   matrix[0][0] = 1;
   matrix[0][1] = 2;
   matrix[0][2] = 3;
   // 依此类推，为每行的元素赋值
   

3. 只指定行数，不指定列数：

   • 可以只指定数组的行数，而不指定列数。在这种情况下，数组的列数需要在后续赋值时指定。

   int matrix[3][];
   matrix[0] = (int[]){1, 2, 3}; // 第一行
   matrix[1] = (int[]){4, 5, 6}; // 第二行
   matrix[2] = (int[]){7, 8, 9}; // 第三行
   

   这种方式通常在需要动态分配列数的情况下使用。

无论哪种方式，创建二维数组都需要明确指定数组的行数和列数，以便在内存中分配相应大小的空间。

7. 二维数组的初始化

二维数组的初始化可以通过在声明数组时直接指定初始值，或者在声明后逐个为数组的每个元素赋值来实现。以下是几种常见的二维数组初始化方法：

1. 静态初始化：

   • 在声明数组的同时，直接为数组的每个元素指定初始值。

   int matrix[3][3] = {
       {1, 2, 3},
       {4, 5, 6},
       {7, 8, 9}
   };
   

   这样就创建了一个3行3列的二维数组，并初始化了每个元素的值。

2. 动态初始化：

   • 在声明数组后，逐行为数组的每一行指定元素值。

   int matrix[3][3];
   matrix[0][0] = 1;
   matrix[0][1] = 2;
   matrix[0][2] = 3;
   matrix[1][0] = 4;
   matrix[1][1] = 5;
   matrix[1][2] = 6;
   matrix[2][0] = 7;
   matrix[2][1] = 8;
   matrix[2][2] = 9;
   

   这种方式适用于在程序运行时动态确定数组的元素值。

3. 使用循环初始化：

   • 可以使用嵌套循环结构来为数组赋值，特别适用于数组较大或需要按照一定规律初始化的情况。

   int matrix[3][3];
   int count = 1;
   for (int i = 0; i < 3; i++) {
       for (int j = 0; j < 3; j++) {
           matrix[i][j] = count;
           count++;
       }
   }
   

   这种方式可以根据循环的控制变量为数组的每个元素赋予不同的值。

以上是常见的二维数组初始化方法，根据实际情况选择最合适的初始化方式。

8. 二维数组的使用

二维数组在编程中常用于表示矩阵、表格或二维数据结构，它们可以存储和操作多行多列的数据。以下是二维数组的一些常见使用方式：

1. 访问元素： 可以使用行索引和列索引来访问二维数组中的特定元素。

   int matrix[3][3] = {
       {1, 2, 3},
       {4, 5, 6},
       {7, 8, 9}
   };
   
   int element = matrix[1][2]; // 访问第二行第三列的元素，值为6
   

2. 遍历数组： 可以使用嵌套的循环结构遍历整个二维数组中的所有元素。

   for (int i = 0; i < 3; i++) {
       for (int j = 0; j < 3; j++) {
           printf("%d ", matrix[i][j]); // 输出每个元素的值
       }
       printf("\\\\n"); // 换行到下一行
   }
   

3. 处理数据： 可以对二维数组中的数据执行各种处理操作，例如求和、求平均值、搜索特定值等。

   int sum = 0;
   for (int i = 0; i < 3; i++) {
       for (int j = 0; j < 3; j++) {
           sum += matrix[i][j]; // 计算所有元素的总和
       }
   }
   

4. 传递参数： 函数可以接受二维数组作为参数，从而实现对数组的操作或处理。

   void printMatrix(int arr[][3], int rows) {
       for (int i = 0; i < rows; i++) {
           for (int j = 0; j < 3; j++) {
               printf("%d ", arr[i][j]); // 输出每个元素的值
           }
           printf("\\\\n"); // 换行到下一行
       }
   }
   
   int main() {
       int matrix[3][3] = {
           {1, 2, 3},
           {4, 5, 6},
           {7, 8, 9}
       };
       printMatrix(matrix, 3);
       return 0;
   }
   

通过合理地使用二维数组，可以在程序中存储和处理多行多列的数据，从而实现各种复杂的功能和算法。

9. 二维数组在内存中的存储

二维数组在内存中的存储是连续的，它们以行为主存储，也就是说，每一行的元素都是连续存储的，而行与行之间也是连续存储的。

当创建一个二维数组时，内存中会分配足够的空间来存储所有的元素，这些元素按照数组的行优先顺序依次存放。

让我们来看一个简单的例子，假设有一个3行3列的二维数组：

int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

在内存中，这个二维数组的存储结构可以如下所示：

    | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
    +---+---+---+---+---+---+---+---+---+

在这个示意图中，每个数字代表数组中的一个元素，按照行优先顺序依次存储。也就是说，首先存储第一行的元素（1、2、3），然后是第二行的元素（4、5、6），最后是第三行的元素（7、8、9）。

通过行优先存储，可以使得在访问数组元素时具有更好的性能，因为在内存中的连续存储可以提高数据的访问效率。

需要注意的是，二维数组的行和列数在编译时必须是确定的，这意味着在程序运行时无法动态改变二维数组的大小。

10. C99中的变长数组

C99引入了变长数组（Variable Length Arrays，简称VLA），它允许在运行时动态指定数组的大小，而不必在编译时就确定数组的大小。这为处理某些需要在运行时确定大小的情况提供了便利。

使用变长数组，你可以在声明数组时使用变量来指定数组的大小，而不仅仅是常量。以下是变长数组的基本用法：

#include <stdio.h>

int main() {
    int size;
    printf("请输入数组的大小：");
    scanf("%d", &size);

    int array[size]; // 变长数组的声明

    // 初始化数组
    for (int i = 0; i < size; i++) {
        array[i] = i * 2;
    }

    // 输出数组元素
    printf("数组的元素为：\\\\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\\\\n");

    return 0;
}

在这个示例中，用户可以在运行时输入数组的大小，然后创建一个相应大小的变长数组。这样就可以根据用户的输入在运行时动态分配内存。

需要注意的是，变长数组的作用域只限于声明它的代码块，也就是说，它们只在声明的作用域内有效。另外，变长数组不能是静态的，也不能作为结构体的成员或函数的参数，因为在这些情况下数组的大小必须在编译时就确定。