C 语言中的数组元素操作

CCBeginner
立即练习

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

介绍

在本实验中,你将学习如何在 C 语言中操作数组元素。实验涵盖了声明和初始化数组、访问和修改数组元素、遍历数组、执行数组计算以及动态分配数组内存的基本技能。你将探索各种处理数组的技术,包括使用特定值声明和初始化数组、部分初始化数组以及动态为数组元素赋值。通过本实验,你将深入了解如何有效地管理和操作 C 语言中的数组数据结构。


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("`C`")) -.-> c/BasicsGroup(["`Basics`"]) c(("`C`")) -.-> c/ControlFlowGroup(["`Control Flow`"]) c(("`C`")) -.-> c/CompoundTypesGroup(["`Compound Types`"]) c(("`C`")) -.-> c/PointersandMemoryGroup(["`Pointers and Memory`"]) c(("`C`")) -.-> c/FunctionsGroup(["`Functions`"]) c/BasicsGroup -.-> c/variables("`Variables`") c/BasicsGroup -.-> c/data_types("`Data Types`") c/BasicsGroup -.-> c/operators("`Operators`") c/ControlFlowGroup -.-> c/for_loop("`For Loop`") c/ControlFlowGroup -.-> c/while_loop("`While Loop`") c/CompoundTypesGroup -.-> c/arrays("`Arrays`") c/PointersandMemoryGroup -.-> c/memory_address("`Memory Address`") c/FunctionsGroup -.-> c/math_functions("`Math Functions`") subgraph Lab Skills c/variables -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/data_types -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/operators -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/for_loop -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/while_loop -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/arrays -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/memory_address -.-> lab-438261{{"`C 语言中的数组元素操作`"}} c/math_functions -.-> lab-438261{{"`C 语言中的数组元素操作`"}} end

声明和初始化数组

在这一步中,你将学习如何在 C 语言中声明和初始化数组。数组是一种基本的数据结构,允许你在连续的内存位置中存储多个相同类型的元素。

让我们从创建一个新的 C 文件开始,来探索数组的声明和初始化:

cd ~/project
touch array_basics.c

接下来,编写一个程序来演示不同的数组声明和初始化方法:

#include <stdio.h>

int main() {
    // 方法 1:声明并初始化一个包含特定值的数组
    int numbers[5] = {10, 20, 30, 40, 50};

    // 方法 2:先声明数组,稍后初始化
    int scores[3];
    scores[0] = 85;
    scores[1] = 92;
    scores[2] = 78;

    // 方法 3:部分初始化数组(未指定的元素自动设置为 0)
    int grades[4] = {100, 95};

    // 打印数组以验证初始化
    printf("Numbers array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    printf("Scores array: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", scores[i]);
    }
    printf("\n");

    printf("Grades array: ");
    for (int i = 0; i < 4; i++) {
        printf("%d ", grades[i]);
    }
    printf("\n");

    return 0;
}

编译并运行程序:

gcc array_basics.c -o array_basics
./array_basics

示例输出:

Numbers array: 10 20 30 40 50
Scores array: 85 92 78
Grades array: 100 95 0 0

让我们分解数组初始化的方法:

  1. int numbers[5] = {10, 20, 30, 40, 50};

    • 声明一个包含 5 个元素的整数数组
    • 使用特定值初始化所有元素
    • 数组大小由初始化列表中的元素数量决定
  2. int scores[3]; 后跟单独的元素赋值

    • 先声明数组
    • 稍后为各个元素赋值
    • 适用于需要动态设置值的情况
  3. int grades[4] = {100, 95};

    • 部分初始化数组
    • 未指定的元素自动设置为 0
    • 当你只想设置一些初始值时,可以节省时间

需要记住的关键点:

  • 数组索引从 0 开始
  • 必须指定数组存储的元素类型
  • 数组一旦声明,大小固定
  • 始终确保不要访问超出声明大小的数组元素

访问和修改数组元素

在这一步中,你将学习如何在 C 语言中访问和修改数组的单个元素。基于上一步的内容,我们将探索如何使用索引与数组元素进行交互,并演示多种操作数组内容的方法。

让我们创建一个新的 C 文件来练习访问和修改数组元素:

cd ~/project
touch array_access.c

接下来,编写一个程序来演示数组元素的访问和修改:

#include <stdio.h>

int main() {
    // 声明并初始化一个数组
    int temperatures[5] = {72, 68, 75, 80, 65};

    // 访问单个数组元素
    printf("First temperature: %d\n", temperatures[0]);
    printf("Third temperature: %d\n", temperatures[2]);

    // 修改数组元素
    temperatures[1] = 70;  // 修改第二个元素
    temperatures[4] = 73;  // 修改最后一个元素

    // 打印修改后的数组
    printf("Modified temperatures: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", temperatures[i]);
    }
    printf("\n");

    // 演示数组元素的计算
    int average = (temperatures[0] + temperatures[1] + temperatures[2] +
                   temperatures[3] + temperatures[4]) / 5;
    printf("Average temperature: %d\n", average);

    return 0;
}

编译并运行程序:

gcc array_access.c -o array_access
./array_access

示例输出:

First temperature: 72
Third temperature: 75
Modified temperatures: 72 70 75 80 73
Average temperature: 74

让我们分解关键概念:

  1. 数组索引

    • 数组使用从 0 开始的索引进行访问
    • temperatures[0] 表示第一个元素
    • temperatures[4] 表示一个 5 元素数组中的最后一个元素
  2. 修改数组元素

    • 可以直接使用索引修改单个元素
    • temperatures[1] = 70; 将第二个元素替换为 70
    • 你可以在任何有效的索引位置修改元素
  3. 数组元素计算

    • 可以使用单个数组元素进行计算
    • 在示例中,我们计算了平均温度
    • 在数学运算中直接通过索引访问元素

需要避免的常见陷阱:

  • 永远不要访问超出数组边界的索引
  • 数组索引从 0 开始,而不是 1
  • 注意不要超出数组的声明大小

遍历数组

在这一步中,你将学习在 C 语言中遍历数组的不同方法。遍历对于高效处理数组元素以及对数组内容执行各种操作至关重要。

让我们创建一个新的 C 文件来探索数组遍历技术:

cd ~/project
touch array_iteration.c

接下来,编写一个程序来演示多种遍历数组的方式:

#include <stdio.h>

int main() {
    // 声明并初始化一个学生成绩数组
    int scores[6] = {85, 92, 78, 90, 88, 95};
    int total = 0;

    // 方法 1:使用标准的 for 循环
    printf("Method 1 - Standard For Loop:\n");
    for (int i = 0; i < 6; i++) {
        printf("Score %d: %d\n", i + 1, scores[i]);
        total += scores[i];
    }

    // 计算并打印平均值
    float average = (float)total / 6;
    printf("\nTotal Score: %d\n", total);
    printf("Average Score: %.2f\n", average);

    // 方法 2:反向遍历
    printf("\nMethod 2 - Reverse Iteration:\n");
    printf("Scores in reverse order:\n");
    for (int i = 5; i >= 0; i--) {
        printf("Score %d: %d\n", i + 1, scores[i]);
    }

    // 方法 3:使用 while 循环遍历
    printf("\nMethod 3 - While Loop Iteration:\n");
    int j = 0;
    while (j < 6) {
        if (scores[j] >= 90) {
            printf("High score detected: %d\n", scores[j]);
        }
        j++;
    }

    return 0;
}

编译并运行程序:

gcc array_iteration.c -o array_iteration
./array_iteration

示例输出:

Method 1 - Standard For Loop:
Score 1: 85
Score 2: 92
Score 3: 78
Score 4: 90
Score 5: 88
Score 6: 95

Total Score: 528
Average Score: 88.00

Method 2 - Reverse Iteration:
Scores in reverse order:
Score 6: 95
Score 5: 88
Score 4: 90
Score 3: 78
Score 2: 92
Score 1: 85

Method 3 - While Loop Iteration:
High score detected: 92
High score detected: 90
High score detected: 95

关键遍历技术:

  1. 标准 for 循环

    • 最常见的数组遍历方法
    • 允许精确控制索引
    • 适合正向处理
  2. 反向遍历

    • 从最后一个元素遍历到第一个元素
    • 适用于特定的处理需求
    • 使用递减的循环计数器
  3. while 循环遍历

    • 提供灵活的遍历控制
    • 可以包含条件处理
    • 适用于复杂的遍历逻辑

重要的遍历原则:

  • 始终定义清晰的循环边界
  • 使用数组长度防止越界访问
  • 根据具体任务选择最合适的遍历方法

执行数组计算

在这一步中,你将学习如何在 C 语言中对数组执行各种计算。我们将探索查找最大值和最小值、计算总和、平均值以及对数组元素应用数学变换的技术。

让我们创建一个新的 C 文件来练习数组计算:

cd ~/project
touch array_calculations.c

接下来,编写一个程序来演示不同的数组计算技术:

#include <stdio.h>
#include <limits.h>

int main() {
    // 声明并初始化一个销售数据数组
    int sales[7] = {1200, 1500, 980, 1750, 1100, 1300, 1600};

    // 计算总销售额
    int total_sales = 0;
    for (int i = 0; i < 7; i++) {
        total_sales += sales[i];
    }
    printf("Total Weekly Sales: $%d\n", total_sales);

    // 计算平均销售额
    float average_sales = (float)total_sales / 7;
    printf("Average Daily Sales: $%.2f\n", average_sales);

    // 查找最大销售额
    int max_sales = sales[0];  // 从第一个元素开始
    for (int i = 1; i < 7; i++) {
        if (sales[i] > max_sales) {
            max_sales = sales[i];
        }
    }
    printf("Highest Daily Sales: $%d\n", max_sales);

    // 查找最小销售额
    int min_sales = sales[0];  // 从第一个元素开始
    for (int i = 1; i < 7; i++) {
        if (sales[i] < min_sales) {
            min_sales = sales[i];
        }
    }
    printf("Lowest Daily Sales: $%d\n", min_sales);

    // 应用百分比增长
    float increase_percentage = 1.1;  // 10% 增长
    printf("\nSales After 10%% Increase:\n");
    for (int i = 0; i < 7; i++) {
        float increased_sale = sales[i] * increase_percentage;
        printf("Day %d: $%.2f\n", i + 1, increased_sale);
    }

    return 0;
}

编译并运行程序:

gcc array_calculations.c -o array_calculations
./array_calculations

示例输出:

Total Weekly Sales: $9430
Average Daily Sales: $1347.14
Highest Daily Sales: $1750
Lowest Daily Sales: $980

Sales After 10% Increase:
Day 1: $1320.00
Day 2: $1650.00
Day 3: $1078.00
Day 4: $1925.00
Day 5: $1210.00
Day 6: $1430.00
Day 7: $1760.00

关键数组计算技术:

  1. 总和计算

    • 使用循环累加所有数组元素
    • 将值累加到一个单独的变量中
    • 适用于查找总和
  2. 平均值计算

    • 将总和除以元素数量
    • 使用类型转换以确保浮点精度
    • 提供数组元素的平均值
  3. 查找最大值/最小值

    • 从第一个数组元素开始初始化
    • 比较每个后续元素
    • 当发现新的极值时更新最大值/最小值
  4. 逐元素变换

    • 对每个元素应用数学运算
    • 可以根据特定规则修改数组值
    • 适用于缩放、调整或转换数据

重要的计算原则:

  • 始终考虑数组边界
  • 使用适当的数据类型
  • 注意整数除法
  • 在计算前初始化累加变量

动态分配数组内存

在这一步中,你将学习如何在 C 语言中使用 malloc()realloc()free() 函数为数组动态分配内存。动态内存分配允许你在运行时确定数组的大小。

让我们创建一个新的 C 文件来探索动态内存分配:

cd ~/project
touch dynamic_array.c

接下来,编写一个程序来演示动态数组内存分配:

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

int main() {
    // 为整数数组动态分配内存
    int array_size;
    printf("Enter the number of elements: ");
    scanf("%d", &array_size);

    // 动态分配内存
    int *dynamic_array = (int *)malloc(array_size * sizeof(int));

    // 检查内存分配是否成功
    if (dynamic_array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // 输入数组元素
    printf("Enter %d integers:\n", array_size);
    for (int i = 0; i < array_size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &dynamic_array[i]);
    }

    // 打印数组元素
    printf("\nArray elements:\n");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // 动态调整数组大小
    int new_size;
    printf("\nEnter new array size: ");
    scanf("%d", &new_size);

    // 重新分配内存
    int *resized_array = (int *)realloc(dynamic_array, new_size * sizeof(int));

    // 检查重新分配是否成功
    if (resized_array == NULL) {
        printf("Memory reallocation failed!\n");
        free(dynamic_array);
        return 1;
    }

    dynamic_array = resized_array;

    // 如果新大小更大,初始化新元素
    if (new_size > array_size) {
        for (int i = array_size; i < new_size; i++) {
            dynamic_array[i] = 0;
        }
    }

    // 打印调整大小后的数组
    printf("Resized array:\n");
    for (int i = 0; i < new_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // 释放动态分配的内存
    free(dynamic_array);

    return 0;
}

编译并运行程序:

gcc dynamic_array.c -o dynamic_array
./dynamic_array

示例交互:

Enter the number of elements: 3
Enter 3 integers:
Element 1: 10
Element 2: 20
Element 3: 30

Array elements:
10 20 30

Enter new array size: 5
Resized array:
10 20 30 0 0

关键动态内存分配概念:

  1. malloc() 函数

    • 分配请求的内存并返回指针
    • 语法:pointer = (type *)malloc(size * sizeof(type))
    • 始终检查是否为 NULL 以确保分配成功
  2. realloc() 函数

    • 调整先前分配的内存块大小
    • 可以增加或减少数组大小
    • 扩展时保留现有数据
  3. free() 函数

    • 释放动态分配的内存
    • 防止内存泄漏
    • 必须为每个 malloc()/realloc() 分配调用

重要的内存分配原则:

  • 始终检查分配是否成功
  • 当不再需要时释放动态分配的内存
  • 调整数组大小时要小心
  • 优雅处理潜在的分配失败

总结

在本实验中,你学习了如何在 C 语言中声明和初始化数组、访问和修改数组元素、遍历数组、执行数组计算以及动态分配数组内存。你探索了声明和初始化数组的不同方法,包括直接指定值、稍后赋值以及部分初始化数组。你还学习了如何打印数组内容以验证其初始化。这些基本的数组操作对于在 C 语言中处理数据结构至关重要,并为更复杂的数组操作奠定了基础。

您可能感兴趣的其他 C 教程