在 C 语言中创建二维数组

介绍

在本实验中，你将学习如何在 C 语言中创建和操作二维数组。你将从声明二维数组开始，然后探索初始化它们的各种方法。接下来，你将学习如何访问和操作数组中的元素。最后，你将应用所学知识计算两门科目的平均分数，并增强二维数组的功能。本实验将帮助你全面理解如何在 C 编程语言中使用二维数组。

Skills Graph

声明二维数组

在本步骤中，你将学习如何在 C 语言中声明二维数组。二维数组本质上是数组的数组，允许你以行和列的网格结构存储数据。

让我们从创建一个新的 C 文件开始，以演示二维数组的声明：

touch ~/project/two_dimensional_arrays.c

现在，让我们编写第一个二维数组声明：

#include <stdio.h>

int main() {
    // 声明一个 3x4 的整数二维数组
    int grades[3][4];

    return 0;
}

在这个例子中，grades 是一个 3 行 4 列的二维数组。这意味着它可以存储总共 12 个整数值（3 × 4 = 12）。

让我们探索不同的二维数组声明方法，将以下代码追加到文件中：

// 方法 1：声明并初始化
int matrix[2][3] = {
    {1, 2, 3},   // 第一行
    {4, 5, 6}    // 第二行
};

// 方法 2：部分初始化
int scores[3][3] = {
    {10, 20, 30},
    {40, 50}     // 剩余元素将为零
};

// 方法 3：扁平化初始化
int simple_matrix[2][3] = {1, 2, 3, 4, 5, 6};

编译并运行程序以验证：

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

由于我们尚未添加任何打印语句，示例输出将是一个空程序执行。

关于二维数组声明的关键点：

• 第一个方括号表示行
• 第二个方括号表示列
• 你可以部分或完全初始化
• 未初始化的元素会自动设置为零
• 总元素数 = 行数 × 列数

初始化二维数组

在本步骤中，你将学习在 C 语言中初始化二维数组的各种方法，基于上一步的声明技能进行扩展。

让我们修改之前的文件，探索不同的初始化技术。

现在，将现有代码替换为以下初始化方法：

#include <stdio.h>

int main() {
    // 方法 1：完全初始化
    int scores[3][4] = {
        {85, 92, 78, 90},    // 第一行
        {76, 88, 95, 82},    // 第二行
        {63, 71, 89, 93}     // 第三行
    };

    // 方法 2：部分初始化
    int temperatures[2][3] = {
        {25, 30, 22},        // 第一行
        {28}                 // 部分第二行
    };

    // 方法 3：扁平化初始化
    int matrix[2][3] = {1, 2, 3, 4, 5, 6};

    // 方法 4：将所有元素初始化为零
    int zeros[3][3] = {0};

    // 打印第一种方法以演示
    printf("学生成绩:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", scores[i][j]);
        }
        printf("\n");
    }

    return 0;
}

编译并运行程序：

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

示例输出：

学生成绩:
85 92 78 90
76 88 95 82
63 71 89 93

关键初始化方法：

1. 完全初始化：为每一行指定值
2. 部分初始化：未指定的元素设置为零
3. 扁平化初始化：按行填充值
4. 零初始化：所有元素设置为零

重要点：

• 你可以部分初始化数组
• 未指定的元素会自动设置为零
• 初始化值的总数不能超过数组大小
• 嵌套大括号有助于明确按行初始化

访问二维数组元素

在本步骤中，你将学习如何在 C 语言中使用索引和嵌套循环访问二维数组中的单个元素。

让我们更新之前的文件以演示元素访问。

添加以下代码以探索访问数组元素的不同方法：

#include <stdio.h>

int main() {
    // 创建一个 3x4 的学生成绩数组
    int grades[3][4] = {
        {85, 92, 78, 90},    // 第一个学生的成绩
        {76, 88, 95, 82},    // 第二个学生的成绩
        {63, 71, 89, 93}     // 第三个学生的成绩
    };

    // 方法 1：直接访问元素
    printf("第一个学生的第一个成绩: %d\n", grades[0][0]);
    printf("第二个学生的第三个成绩: %d\n", grades[1][2]);

    // 方法 2：使用嵌套循环访问元素
    printf("\n使用嵌套循环访问所有成绩:\n");
    for (int student = 0; student < 3; student++) {
        for (int subject = 0; subject < 4; subject++) {
            printf("学生 %d, 科目 %d: %d\n",
                   student + 1, subject + 1, grades[student][subject]);
        }
    }

    // 方法 3：修改数组元素
    grades[2][3] = 95;  // 更新第三个学生的最后一个成绩
    printf("\n更新后的第三个学生的最后一个成绩: %d\n", grades[2][3]);

    return 0;
}

编译并运行程序：

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

示例输出：

第一个学生的第一个成绩: 85
第二个学生的第三个成绩: 95

使用嵌套循环访问所有成绩:
学生 1, 科目 1: 85
学生 1, 科目 2: 92
学生 1, 科目 3: 78
学生 1, 科目 4: 90
学生 2, 科目 1: 76
学生 2, 科目 2: 88
学生 2, 科目 3: 95
学生 2, 科目 4: 82
学生 3, 科目 1: 63
学生 3, 科目 2: 71
学生 3, 科目 3: 89
学生 3, 科目 4: 95

更新后的第三个学生的最后一个成绩: 95

关于访问二维数组元素的关键点：

• 使用两个索引：array[row][column]
• 第一个索引表示行（垂直方向）
• 第二个索引表示列（水平方向）
• 索引从 0 开始
• 嵌套循环对于遍历整个数组非常有用
• 你可以直接读取和修改单个元素

计算两门科目的平均分

在本步骤中，你将学习如何使用二维数组计算多个学生在不同科目中的平均分。

让我们更新之前的文件以计算科目平均分。

添加以下代码以计算并显示平均分：

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 3

int main() {
    // 创建一个二维数组存储学生成绩
    int marks[STUDENTS][SUBJECTS] = {
        {85, 92, 78},
        {76, 88, 95},
        {63, 71, 89},
        {90, 84, 77},
        {82, 79, 91}
    };

    // 用于存储科目平均分的数组
    float subject_averages[SUBJECTS];

    // 计算每个科目的平均分
    for (int subject = 0; subject < SUBJECTS; subject++) {
        int subject_total = 0;

        // 对当前科目的成绩求和
        for (int student = 0; student < STUDENTS; student++) {
            subject_total += marks[student][subject];
        }

        // 计算平均分
        subject_averages[subject] = (float)subject_total / STUDENTS;
    }

    // 显示科目平均分
    printf("科目平均分:\n");
    for (int subject = 0; subject < SUBJECTS; subject++) {
        printf("科目 %d: %.2f\n", subject + 1, subject_averages[subject]);
    }

    // 额外功能：找到最高和最低的科目平均分
    float highest_avg = subject_averages[0];
    float lowest_avg = subject_averages[0];
    int highest_subject = 0;
    int lowest_subject = 0;

    for (int subject = 1; subject < SUBJECTS; subject++) {
        if (subject_averages[subject] > highest_avg) {
            highest_avg = subject_averages[subject];
            highest_subject = subject;
        }
        if (subject_averages[subject] < lowest_avg) {
            lowest_avg = subject_averages[subject];
            lowest_subject = subject;
        }
    }

    printf("\n最高平均分: 科目 %d (%.2f)\n",
           highest_subject + 1, highest_avg);
    printf("最低平均分: 科目 %d (%.2f)\n",
           lowest_subject + 1, lowest_avg);

    return 0;
}

编译并运行程序：

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

示例输出：

科目平均分:
科目 1: 79.20
科目 2: 82.80
科目 3: 86.00

最高平均分: 科目 3 (86.00)
最低平均分: 科目 1 (79.20)

演示的关键概念：

• 使用嵌套循环处理二维数组
• 计算行和列的平均值
• 找到最高和最低的平均分
• 使用类型转换计算浮点平均分
• 定义数组维度的常量

增强二维数组功能

在最后一步中，你将学习增强二维数组功能的高级技术，包括将数组传递给函数、动态内存分配以及创建更复杂的数组操作。

让我们更新之前的文件以演示这些高级概念。

将之前的代码替换为以下综合示例：

#include <stdio.h>
#include <stdlib.h>

#define ROWS 3
#define COLS 4

// 打印二维数组的函数
void printArray(int arr[ROWS][COLS]) {
    printf("数组内容:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", arr[i][j]);
        }
        printf("\n");
    }
}

// 转置二维数组的函数
void transposeArray(int original[ROWS][COLS], int transposed[COLS][ROWS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            transposed[j][i] = original[i][j];
        }
    }
}

int main() {
    // 静态二维数组
    int matrix[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // 打印原始数组
    printf("原始数组:\n");
    printArray(matrix);

    // 转置数组
    int transposed[COLS][ROWS];
    transposeArray(matrix, transposed);

    // 打印转置后的数组
    printf("\n转置后的数组:\n");
    for (int i = 0; i < COLS; i++) {
        for (int j = 0; j < ROWS; j++) {
            printf("%4d ", transposed[i][j]);
        }
        printf("\n");
    }

    // 动态内存分配二维数组
    int **dynamicMatrix;
    dynamicMatrix = (int **)malloc(ROWS * sizeof(int *));
    for (int i = 0; i < ROWS; i++) {
        dynamicMatrix[i] = (int *)malloc(COLS * sizeof(int));
    }

    // 初始化动态矩阵
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            dynamicMatrix[i][j] = i * COLS + j + 1;
        }
    }

    // 打印动态矩阵
    printf("\n动态矩阵:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", dynamicMatrix[i][j]);
        }
        printf("\n");
    }

    // 释放动态分配的内存
    for (int i = 0; i < ROWS; i++) {
        free(dynamicMatrix[i]);
    }
    free(dynamicMatrix);

    return 0;
}

编译并运行程序：

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

示例输出：

原始数组:
   1   2   3   4
   5   6   7   8
   9  10  11  12

转置后的数组:
   1   5   9
   2   6  10
   3   7  11
   4   8  12

动态矩阵:
   1   2   3   4
   5   6   7   8
   9  10  11  12

演示的关键高级概念：

• 将二维数组传递给函数
• 数组转置
• 二维数组的动态内存分配
• 使用 malloc() 和 free() 进行内存管理
• 灵活的数组操作技术

总结

在本实验中，你学习了如何在 C 语言中声明二维数组，二维数组是数组的数组，允许你以行和列的网格结构存储数据。你探索了声明和初始化二维数组的不同方法，包括完全初始化、部分初始化和扁平化初始化。你还了解到，未初始化的元素会自动设置为零，二维数组中的元素总数由行数和列数的乘积决定。

在声明技能的基础上，你进一步学习了在 C 语言中初始化二维数组的各种方法，包括逐行赋值、逐列赋值或使用扁平化方法。你还探索了如何使用行和列索引访问二维数组中的单个元素。