介绍
在本实验中，你将学习如何在 C 语言中操作数组元素。实验涵盖了声明和初始化数组、访问和修改数组元素、遍历数组、执行数组计算以及动态分配数组内存的基本技能。你将探索各种处理数组的技术，包括使用特定值声明和初始化数组、部分初始化数组以及动态为数组元素赋值。通过本实验，你将深入了解如何有效地管理和操作 C 语言中的数组数据结构。
声明和初始化数组
在这一步中，你将学习如何在 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
让我们分解数组初始化的方法：
int numbers[5] = {10, 20, 30, 40, 50};- 声明一个包含 5 个元素的整数数组
- 使用特定值初始化所有元素
- 数组大小由初始化列表中的元素数量决定
int scores[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
让我们分解关键概念：
数组索引
- 数组使用从 0 开始的索引进行访问
temperatures[0]表示第一个元素temperatures[4]表示一个 5 元素数组中的最后一个元素
修改数组元素
- 可以直接使用索引修改单个元素
temperatures[1] = 70;将第二个元素替换为 70- 你可以在任何有效的索引位置修改元素
数组元素计算
- 可以使用单个数组元素进行计算
- 在示例中，我们计算了平均温度
- 在数学运算中直接通过索引访问元素
需要避免的常见陷阱：
- 永远不要访问超出数组边界的索引
- 数组索引从 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
关键遍历技术：
标准 for 循环
- 最常见的数组遍历方法
- 允许精确控制索引
- 适合正向处理
反向遍历
- 从最后一个元素遍历到第一个元素
- 适用于特定的处理需求
- 使用递减的循环计数器
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
关键数组计算技术：
总和计算
- 使用循环累加所有数组元素
- 将值累加到一个单独的变量中
- 适用于查找总和
平均值计算
- 将总和除以元素数量
- 使用类型转换以确保浮点精度
- 提供数组元素的平均值
查找最大值/最小值
- 从第一个数组元素开始初始化
- 比较每个后续元素
- 当发现新的极值时更新最大值/最小值
逐元素变换
- 对每个元素应用数学运算
- 可以根据特定规则修改数组值
- 适用于缩放、调整或转换数据
重要的计算原则：
- 始终考虑数组边界
- 使用适当的数据类型
- 注意整数除法
- 在计算前初始化累加变量
动态分配数组内存
在这一步中，你将学习如何在 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
关键动态内存分配概念：
malloc()函数- 分配请求的内存并返回指针
- 语法：
pointer = (type *)malloc(size * sizeof(type)) - 始终检查是否为 NULL 以确保分配成功
realloc()函数- 调整先前分配的内存块大小
- 可以增加或减少数组大小
- 扩展时保留现有数据
free()函数- 释放动态分配的内存
- 防止内存泄漏
- 必须为每个
malloc()/realloc()分配调用
重要的内存分配原则：
- 始终检查分配是否成功
- 当不再需要时释放动态分配的内存
- 调整数组大小时要小心
- 优雅处理潜在的分配失败
总结
在本实验中，你学习了如何在 C 语言中声明和初始化数组、访问和修改数组元素、遍历数组、执行数组计算以及动态分配数组内存。你探索了声明和初始化数组的不同方法，包括直接指定值、稍后赋值以及部分初始化数组。你还学习了如何打印数组内容以验证其初始化。这些基本的数组操作对于在 C 语言中处理数据结构至关重要，并为更复杂的数组操作奠定了基础。
