在 C 语言中创建二维数组

CCBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

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


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/PointersandMemoryGroup(["Pointers and Memory"]) c(("C")) -.-> c/FunctionsGroup(["Functions"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c(("C")) -.-> c/BasicsGroup(["Basics"]) c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c/BasicsGroup -.-> c/data_types("Data Types") c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/CompoundTypesGroup -.-> c/structures("Structures") c/PointersandMemoryGroup -.-> c/pointers("Pointers") c/PointersandMemoryGroup -.-> c/memory_address("Memory Address") c/FunctionsGroup -.-> c/math_functions("Math Functions") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/data_types -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/for_loop -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/arrays -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/structures -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/pointers -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/memory_address -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/math_functions -.-> lab-438259{{"在 C 语言中创建二维数组"}} c/output -.-> lab-438259{{"在 C 语言中创建二维数组"}} end

声明二维数组

在本步骤中,你将学习如何在 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 语言中初始化二维数组的各种方法,包括逐行赋值、逐列赋值或使用扁平化方法。你还探索了如何使用行和列索引访问二维数组中的单个元素。