C语言 数组，指针，结构体，文件的训练内容
时间：2024-04-29 18:20:30 来源：网络cs 作者：欧阳逸 栏目：选品工具 阅读：
《计算思维（二）》实验报告
基础实践二
班级：
学号：
姓名：
实验时间： 2023 年 第01~12周
成绩
哈尔滨工程大学计算机基础课程教学中心
实验五：数组
实验题目1：数组元素遍历
【适用题型】编程题
【题目标题】数组元素遍历。
【问题描述】
输入一个整型数组a[10]，并计算其中的前9个元素的平均值，然后将这个值替换a[9]中的内容，最后输出该数组的所有元素。
【源文件名】ex501.c
【输入形式】从键盘先后输入数组元素值，每两个值之间用空格分隔
【输出形式】在一行内输出数组的所有元素值，每两个值之间用逗号分隔
【样例输入】0 1 2 3 4 5 6 7 8 9
【样例输出】0,1,2,3,4,5,6,7,8,4
【样例说明】无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】2
【知识点】数组；一维数组；循环结构
【章节】第6章 数组；实验五：数组
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
验证与结论：
#include <stdio.h>
int main(){
int a[10],i,sum;
int average;
for(i=0;i<10;i++){
scanf("%d",&a[i]);//输入数组的值
}
sum=0;
for(i=0;i<9;i++){//求和
sum=sum+a[i];
}
average=sum/9;//替换
a[9]=average;
for(i=0;i<9;i++){
printf("%d,",a[i]);
}
printf("%d",average);
return 0;
}
总结与心得体会：
实验题目2：数组合并与排序
【适用题型】编程题
【题目标题】数组合并与排序。
【问题描述】
输入两个整数数组，每个数组有5个整数，将二者进行合并，然后按照数值从小到大排序输出。
【源文件名】ex502.c
【输入形式】有两行输入，分别为第一个数组和第二个数组的元素赋值。每行输入中的每两个数值之间用空格分隔
【输出形式】有两行输出，第一行输出为合并之后的数组元素值，第二行输出为排序后的数组元素值。每行输出中的每两个数值之间用逗号分隔
【样例输入】
9 1 5 3 7
8 0 6 4 2
【样例输出】
9,1,5,3,7,8,0,6,4,2
0,1,2,3,4,5,6,7,8,9
【样例说明】
无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】数组；一维数组；函数；循环结构；排序算法
【章节】第6章 数组；实验五：数组
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
#include <stdio.h>
int main(){
int a[5],b[5],c[10];
int i,j,t;
char ch;
for(i=0;i<5;i++){
scanf("%d",&a[i]);
}
//scanf("\n");
for(i=0;i<5;i++){
scanf("%d",&b[i]);
}
for(i=0;i<5;i++){
c[i]=a[i];
}
for(i=0;i<5;i++){
c[i+5]=b[i];
}
for(i=0;i<9;i++){
printf("%d,",c[i]);
}
printf("%d\n",c[9]);
for(i=0;i<9;i++){ //冒泡排序
for(j=0;j<9;j++){
if(c[j]>c[j+1]){
t=c[j];
c[j]=c[j+1];
c[j+1]=t;
}
}
}
for(i=0;i<9;i++){
printf("%d,",c[i]);
}
printf("%d",c[9]);
return 0;
}
验证与结论：
总结与心得体会：
实验题目3：填充矩阵
【适用题型】编程题
【题目标题】填充矩阵。
【问题描述】
编程实现自动填充n×n矩阵元素数值，填充规则为：从第一行最后一列矩阵元素开始按逆时针方向螺旋式填充数值1，2，…，n×n，其中：n从键盘输入且3≤n≤20。最后向显示器输出该矩阵所有元素。
【源文件名】ex503.c
【输入形式】输入一个正整数，为矩阵的行数和列数
【输出形式】按行列顺序输出n×n矩阵的所有元素。
（1）每行n列矩阵元素均需在一行内输出显示
（2）输出每行矩阵元素后均需换行输出下一行，共输出n行
（3）每个矩阵元素数值的域宽均为4位且右对齐
【样例输入】
11
【样例输出】
11 10 9 8 7 6 5 4 3 2 1
12 49 48 47 46 45 44 43 42 41 40
13 50 79 78 77 76 75 74 73 72 39
14 51 80 101 100 99 98 97 96 71 38
15 52 81 102 115 114 113 112 95 70 37
16 53 82 103 116 121 120 111 94 69 36
17 54 83 104 117 118 119 110 93 68 35
18 55 84 105 106 107 108 109 92 67 34
19 56 85 86 87 88 89 90 91 66 33
20 57 58 59 60 61 62 63 64 65 32
21 22 23 24 25 26 27 28 29 30 31
【样例说明】在样例输出中，对于数值域宽的控制，请参见《教材》P54表3-7。输入和输出的格式控制效果如下图所示，请以此图为标准设计程序的输入和输出格式。
【评分标准】正确性 + £ 性能（性能占比0%）
【解析】数组下标被赋予特定内涵及下标控制技巧。
这是一个简单的二维数组元素的遍历访问问题，但是你可以把这个矩阵看成一张地图、一个计算机网络、一个居民生活区、一块广阔的农业种植区域、一个工业工厂的流水线作业平台、一个自动化物流仓库，当然你也可以把它看成一个游戏界面、一个军事沙盘或作战区域……如果你倾心其他更为复杂的问题，那么请先耐心思考一下本问题吧，也请思考和体会如何自顶向下、逐步求精的将复杂问题进行分解？如何构造程序对象和程序算法？
由于题目要求采用逆时针螺旋式填充矩阵的所有元素，因此，解题思路之一是通过设计两层的嵌套循环来解决所有矩阵元素的遍历，其中：
（1）通过外层循环来定义矩阵元素遍历的总次数问题，即所有矩阵元素都将被遍历一次的次数总和，就是n×n次。
（2）通过外层循环所包含的4个内层循环解决如何遍历的问题，即解决如何控制上下左右或东南西北四个方向按序逐步移动遍历访问的问题。
【难度】3
【知识点】数组；二维数组；循环结构
【章节】第6章 数组；实验五：数组
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
#include <stdio.h>
int main(){
int n;
scanf("%d",&n);
int i=0,p=n-1,q;
int j,k;
int a[20][20];
int count=0;
while(count<n*n)
{
for(q=p;q>=i;q--)
{
a[i][q]=count+1;
count++;
}
for(q=i+1;q<=p;q++)
{
a[q][i]=count+1;
count++;
}
for(q=i+1;q<=p;q++)
{
a[p][q]=count+1;
count++;
}
for(q=p-1;q>=i+1;q--)
{
a[q][p]=count+1;
count++;
}
p--;
i++;
}
for( j=0;j<n;j++)
{
for( k=0;k<n;k++)
{
printf("%4d",a[j][k]);
}
printf("\n");
}
}
验证与结论：
总结与心得体会：
实验题目4：字串处理
【适用题型】编程题
【题目标题】字串处理。
【问题描述】
现有两个字符串s1和s2，它们最多都只能包含255个字符。编写程序，将字符串s1中所有出现在字符串s2中的字符删去，然后输出s1。
【源文件名】ex504.c
【输入形式】有两行输入。第一行输入为字符串s1，第二行输入为字符串s2
【输出形式】输出被处理过的字符串s1
【样例输入】
I love you!8767%$#&*Yeah
o7W$hB*
【样例输出（测试数据）】
I lve yu!86%#&Yea
【样例说明】无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】数组；一维数组；字符数组；循环结构；函数；字串处理函数
【章节】第6章 数组；实验五：数组
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
#include <stdio.h>
#include <string.h>
int main(){
char s1[255],s2[255];
gets(s1);
gets(s2);
int i,j;
for(i = 0;i < strlen(s1);i++)
{
int flag = 0;
for(j = 0;j < strlen(s2);j++){
if(s1[i] == s2[j]){
flag = 1;
break;
}
}
if(flag == 0)
printf("%c",s1[i]);
}
}
验证与结论：
总结与心得体会：
实验六：指针
提示：程序片段编程题这类题型有助于认识和培养结构化（函数模块）编程方法和能力；有利于将难度较大的复杂问题分解为若干个难度较小的问题，进而有助于学习相关知识；也有助于通过代码的阅读，逐步理解和学习程序设计和算法设计思想。因此，希望大家能够耐心阅读代码，认真完成题目。
实验题目1：函数指针应用
【适用题型】程序片段编程题
【题目标题】指针形参及函数指针应用。
【问题描述】
任意输入两个整数，编写三个函数分别实现：（1）计算两个数的加法和；（2）计算两个整数的减法差；（3）交换这两个整数的数值。要求用“函数指针”调用这三个函数，结果在主函数中输出。目前已编写完成main函数，请编程实现sum函数、minus函数和swap函数，函数功能和要求如下所示。
/*
@Filename: ex601.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Simple Application of Pointer
*/
#include <stdio.h>
/*主函数*/
int main(void){
int sum(int *a, int *b);
int minus(int *a, int *b);
void swap(int *a, int *b);
int a, b;
int *pa = &a, *pb = &b;
scanf("%d,%d", &a, &b);
int (*p)(int *, int *);
p = sum;
printf("%d", (*p)(pa, pb));
p = minus;
printf("\n%d", (*p)(pa, pb));
void (*q)(int *,int *);
q = swap;
(*q)(pa, pb);
printf("\n%d,%d", a, b);
return 1;
}
/*
* 函数名称：sum
* 函数功能：对两个整数进行加法计算
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：int型，为两个整数的加法和
*/
int sum(int *a, int *b){
//请编程实现本函数
}
/*
* 函数名称：minus
* 函数功能：对两个整数进行减法计算
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：int型，为两个整数的减法差
*/
int minus(int *a, int *b){
//请编程实现本函数
}
/*
* 函数名称：swap
* 函数功能：交换两个整数数值
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：无
*/
void swap(int *a, int *b){
//请编程实现本函数
}
注：不得使用全局变量。
【源文件名】ex601.c
【输入形式】输入两个整数，用逗号分隔
【输出形式】有三行输出，分别为：
第1行：输出两个整数的加法和
第2行：输出两个整数的减法差
第3行：输出两个整数交换数值后的结果，用逗号分隔
【样例输入】10,20
【样例输出】
30
-10
20,10
【样例说明】无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】指针；指针变量；指针运算；指向函数的指针；
【章节】第7章 指针；实验六：指针
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex601.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Simple Application of Pointer
*/
#include <stdio.h>
/*主函数*/
int main(void) {
int sum(int* a, int* b);
int minus(int* a, int* b);
void swap(int* a, int* b);
int a, b;
int *pa = &a, *pb = &b;
scanf("%d,%d", &a, &b);
int (*p)(int*, int*);
p = sum;
printf("%d", (*p)(pa, pb));
p = minus;
printf("\n%d", (*p)(pa, pb));
void (*q)(int*, int*);
q = swap;
(*q)(pa, pb);
printf("\n%d,%d", a, b);
return 1;
}
/*
* 函数名称：sum
* 函数功能：对两个整数进行加法计算
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：int型，为两个整数的加法和
*/
int sum(int* a, int* b) {
//请编程实现本函数
return *a + *b;
}
/*
* 函数名称：minus
* 函数功能：对两个整数进行减法计算
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：int型，为两个整数的减法差
*/
int minus(int* a, int* b) {
//请编程实现本函数
return *a - *b;
}
/*
* 函数名称：swap
* 函数功能：交换两个整数数值
* 形式参数：a，整型指针
* 形式参数：b，整型指针
* 返 回 值：无
*/
void swap(int* a, int* b) {
//请编程实现本函数
int t = *a;
*a = *b;
*b = t;
}
验证与结论：
总结与心得体会：
实验题目2：指针作为函数参数
【适用题型】程序片段编程题
【题目标题】指针作为函数参数。
【问题描述】
一维整型数组a有5个元素，请编写assign函数和max函数分别实现为数组元素赋值和求解数组元素最大值。目前，除了assign和max这两个函数以外，其他代码已编写完成，如下所示。请编码实现上述两个函数。
#include <stdio.h>
/*
@Filename: ex602.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Pointer As Function Parameter
*/
int main(void){
void assign(int *array, int length);
int max(int *array, int length);
int a[5];
assign(a, 5); /* 为数组a元素赋值 */
printf("max=%d",max(a, 5)); /* 求数组元素最大值并输出 */
return 0;
}
/*
* 函数名称：assign
* 函数功能：通过键盘输入为一维数组元素赋值
* 形式参数：array为int型指针；length为int型，可用于表示一维数组长度
* 返 回 值：无
*/
void assign(int *array,int length){
// 请编码实现assign函数
}
/*
* 函数名称：max
* 函数功能：求解一维数组元素最大值
* 形式参数：array为int型指针；length为int型，可用于表示一维数组长度
* 返 回 值：int型，为数组元素最大值
*/
int max(int *array,int length){
// 请编码实现max函数
}
注：在程序中不得使用全局变量。
【源文件名】ex602.c
【输入形式】在assign函数中，从键盘输入整型数据为数组元素赋值，用逗号分隔
【输出形式】在main函数中，输出数组元素最大值，为整型数据
【样例输入】-9 28 76 45 34
【样例输出】max=76
【样例说明】样例输入和输出的效果如下图所示。
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】指针；指针变量；指针运算；指针与一维数组；
【章节】第7章 指针；实验六：指针
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
#include <stdio.h>
/*
@Filename: ex602.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Pointer As Function Parameter
*/
int main(void) {
void assign(int* array, int length);
int max(int* array, int length);
int a[5];
assign(a, 5); /* 为数组a元素赋值 */
printf("max=%d", max(a, 5)); /* 求数组元素最大值并输出 */
return 0;
}
/*
* 函数名称：assign
* 函数功能：通过键盘输入为一维数组元素赋值
* 形式参数：array为int型指针；length为int型，可用于表示一维数组长度
* 返 回 值：无
*/
void assign(int* array, int length) {
// 请编码实现assign函数
int i;
for (i = 0; i < length; i++)
scanf("%d", array + i);
}
/*
* 函数名称：max
* 函数功能：求解一维数组元素最大值
* 形式参数：array为int型指针；length为int型，可用于表示一维数组长度
* 返 回 值：int型，为数组元素最大值
*/
int max(int* array, int length) {
// 请编码实现max函数
int i, *max = &array[0];
for (i = 1; i < length; i++) {
if (*max < array[i]) {
max = array + i;
}
}
return *max;
}
验证与结论：
总结与心得体会：
实验题目3：数字与月份
【适用题型】程序片段编程题
【题目标题】数字与月份。
【问题描述】
输入一个三位数，计算该数各位上的数字之和，如果在[1, 12]之内，则输出与数字之和相对应的月份的英文单词，否则输出***。要求：用指针数组记录各月份英文单词的首地址，且不得使用全局变量。目前仅完成了main函数和bizProcess函数，请编程实现hundredsDigit函数、tensDigit函数、unitsDigit函数、searchMonth函数和getNumber函数。
#include <stdio.h>
/*
@Filename: ex604.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Number to Month
*/
/*
* 函数名称：hundredsDigit
* 函数功能：获取形参整数位于百位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于百位上的数字
*/
static int hundredsDigit(int num){
// 请编程实现本函数
}
/*
* 函数名称：tensDigit
* 函数功能：获取形参整数位于十位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于十位上的数字
*/
static int tensDigit(int num){
// 请编程实现本函数
}
/*
* 函数名称：unitsDigit
* 函数功能：获取形参整数位于个位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于个位上的数字
*/
static int unitsDigit(int num){
// 请编程实现本函数
}
/*
* 函数名称：searchMonth
* 函数功能：对num进行判断，若1≤num≤12，返回month[num]；否则返回month[0]
* 形式参数：month，为表示月份单词的字符指针数组
* num，为一个整数
* 返 回 值：字符指针，为月份单词的首地址
*/
static char *searchMonth(char *month[], int num){
// 请编程实现本函数
}
/*
* 函数名称：getNumber
* 函数功能：从键盘输入一个三位正整数，若不符合要求，则重新输入
* 形式参数：无
* 返 回 值：返回所输入的三位正整数
*/
int getNumber(){
// 请编程实现本函数
}
/*
* 函数名称：bizProcess
* 函数功能：业务处理函数，功能定义如下。
* （1）调用hundredsDigit等函数，对一个三位数的各位进行拆分并计算数字和
* （2）调用searchMonth函数，对上述数字和进行检索返回其月份单词
* （3）按题目要求的格式，打印输出上述结果
* 形式参数：month，为一个指针数组，指向月份单词的字串数组
* num，一个整数
* 返 回 值：无
*/
void bizProcess(char *month[], int num){
int unitsD, tensD, hundredsD, sum;
unitsD = unitsDigit(num);
tensD = tensDigit(num);
hundredsD = hundredsDigit(num);
sum = unitsD + tensD+hundredsD;
printf("%s",searchMonth(month, sum));
}
int main(void){
/*定义数据结构*/
char *month[]=
{
"***",
"January", "February", "March",
"April", "May", "June",
"July", "August", "September",
"October", "November", "December"
};
/*获取一个三位正整数*/
int number = getNumber();
/*业务逻辑判断处理*/
bizProcess(month, number);
return 1;
}
注：应耐心研读各函数模块功能及其逻辑关系。
【源文件名】ex604.c
【输入形式】输入一个三位正整数
【输出形式】月份英文单词或***
【样例输入】520
【样例输出】July
【样例说明】无
【样例输入】999
【样例输出】***
【样例说明】无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】指针；指针变量；指针运算；指针与字符串；数组指针（行指针）；指针数组；
【章节】第7章 指针；实验六：指针
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
#include <stdio.h>
/*
@Filename: ex604.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Number to Month
*/
/*
* 函数名称：hundredsDigit
* 函数功能：获取形参整数位于百位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于百位上的数字
*/
static int hundredsDigit(int num) {
// 请编程实现本函数
int t = num / 100;
return t;
}
/*
* 函数名称：tensDigit
* 函数功能：获取形参整数位于十位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于十位上的数字
*/
static int tensDigit(int num) {
// 请编程实现本函数
int t = num / 10 % 10;
return t;
}
/*
* 函数名称：unitsDigit
* 函数功能：获取形参整数位于个位上的数字
* 形式参数：num，一个整型数
* 返 回 值：返回形参整数位于个位上的数字
*/
static int unitsDigit(int num) {
// 请编程实现本函数
int t = num % 10;
return t;
}
/*
* 函数名称：searchMonth
* 函数功能：对num进行判断，若1≤num≤12，返回month[num]；否则返回month[0]
* 形式参数：month，为表示月份单词的字符指针数组
* num，为一个整数
* 返 回 值：字符指针，为月份单词的首地址
*/
static char* searchMonth(char* month[], int num) {
// 请编程实现本函数
int index = 0;
if (num >= 1 && num <= 12)
index = num;
return month[index];
}
/*
* 函数名称：getNumber
* 函数功能：从键盘输入一个三位正整数，若不符合要求，则重新输入
* 形式参数：无
* 返 回 值：返回所输入的三位正整数
*/
int getNumber() {
// 请编程实现本函数
int num = 0;
int t = 0;
while (t != 1 || num < 100 || num > 1000) {
t = scanf("%d", &num);
}
return num;
}
/*
* 函数名称：bizProcess
* 函数功能：业务处理函数，功能定义如下。
* （1）调用hundredsDigit等函数，对一个三位数的各位进行拆分并计算数字和
* （2）调用searchMonth函数，对上述数字和进行检索返回其月份单词
* （3）按题目要求的格式，打印输出上述结果
* 形式参数：month，为一个指针数组，指向月份单词的字串数组
* num，一个整数
* 返 回 值：无
*/
void bizProcess(char* month[], int num) {
int unitsD, tensD, hundredsD, sum;
unitsD = unitsDigit(num);
tensD = tensDigit(num);
hundredsD = hundredsDigit(num);
sum = unitsD + tensD + hundredsD;
printf("%s", searchMonth(month, sum));
}
int main(void) {
/*定义数据结构*/
char* month[] = {"***", "January", "February", "March", "April",
"May", "June", "July", "August", "September",
"October", "November", "December"};
/*获取一个三位正整数*/
int number = getNumber();
/*业务逻辑判断处理*/
bizProcess(month, number);
return 1;
}
验证与结论：
总结与心得体会：
实验题目4：循环移动数组元素
【适用题型】程序片段编程题
【题目标题】循环移动数组元素。
【问题描述】
定义一个长度为10的一维整型数组，并编写三个函数分别实现如下功能：
（1）函数input：对数组的各元素实现从键盘输入赋值。
（2）函数output：将数组的所有元素向屏幕打印输出。
（3）函数moveToRight：向右循环移动数组元素
（4）函数moveToLeft：向左循环移动数组元素
（5）函数move：将数组元素向左或向右循环移动m个位置。移动规则为：
● 若m>0，调用moveToRight函数，执行向右循环移动；
● 若m=0，不做任何移动；
● 若m<0，调用moveToLeft函数，执行向左循环移动。
目前已编写完成main函数和move函数，请编程实现input函数、output函数、moveToRight函数和moveToLeft函数。
/*
@Filename: ex605.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Loopy Moving of Array Element
*/
#include <stdio.h>
#include <stdlib.h>
#define LENGTH 10
/*主函数*/
int main(void){
/*声明函数*/
void input(int *p, int n);
void output(int *p, int n);
void move(int *p, int length, int m);
/*定义数据结构*/
int a[LENGTH], m;//m表示数组元素循环移动的位置个数
int *p = a;
/*调用input函数，通过键盘输入为数组a赋值*/
input(p, LENGTH);
/*从键盘输入为循环移动位置个数m赋值*/
scanf("%d", &m);
/*调用move函数，完成数组元素的循环移动*/
move(p, LENGTH, m);
/*调用output函数，输出移动后的数组元素*/
output(p, LENGTH);
return 0;
}
/*
* 函数名称：input
* 函数功能：通过键盘输入为一维数组元素赋值
* 输入格式：各输入数据之间以空格分隔
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：n，int型，一维数组长度
* 返回值：无
*/
void input(int *p, int n){
// 请编程实现本函数
}
/*
* 函数名称：output
* 函数功能：向屏幕打印输出一维数组元素值
* 输出格式：各输出数据之间以空格分隔
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：n，int型，一维数组长度
* 返回值：无
*/
void output(int *p, int n){
// 请编程实现本函数
}
/*
* 函数名称：moveToRight
* 函数功能：使一维数组各元素向右循环移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，循环移动的位置数
* 返 回 值：无
*/
void moveToRight(int *p, int length, int m){
// 请编程实现本函数
}
/*
* 函数名称：moveToLeft
* 函数功能：使一维数组各元素向左循环移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，循环移动的位置数
* 返 回 值：无
*/
void moveToLeft(int *p, int length, int m){
// 请编程实现本函数
}
/*
* 函数名称：move
* 函数功能：使一维数组元素循环向左或向右移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，表示循环移动的方向和移动的位置个数
* 当m>0时，执行向右循环移动（水平方向从左向右循环移动）
* 当m=0时，不做任何移动
* 当m<0时，执行向左循环移动（水平方向从右向左循环移动）
* 返 回 值：无
*/
void move(int *p, int length, int m){
if(m > 0){
/*向右循环移动*/
moveToRight(p, length, m);
}else if(m == 0){
/*不移动*/
; //空语句，什么都不做
}else{
/*向左循环移动*/
moveToLeft(p, length, m);
}
}
注：不得使用全局变量。
【源文件名】ex605.c
【输入形式】有两行输入，第1行输入为数组元素赋值，第2行输入为m赋值
【输出形式】有一行输出，输出循环移动后的数组各元素值
【样例输入】
1 2 3 4 5 6 7 8 9 10
3
【样例输出】
8 9 10 1 2 3 4 5 6 7
【样例说明】无
【样例输入】
1 2 3 4 5 6 7 8 9 10
-3
【样例输出】
4 5 6 7 8 9 10 1 2 3
【样例说明】无
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】4
【知识点】指针；指针变量；指针运算；指针与一维数组；函数；循环结构
【章节】第7章 指针；实验六：指针
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex605.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Loopy Moving of Array Element
*/
#include <stdio.h>
#include <stdlib.h>
#define LENGTH 10
/*主函数*/
int main(void) {
/*声明函数*/
void input(int* p, int n);
void output(int* p, int n);
void move(int* p, int length, int m);
/*定义数据结构*/
int a[LENGTH], m; // m表示数组元素循环移动的位置个数
int* p = a;
/*调用input函数，通过键盘输入为数组a赋值*/
input(p, LENGTH);
/*从键盘输入为循环移动位置个数m赋值*/
scanf("%d", &m);
/*调用move函数，完成数组元素的循环移动*/
move(p, LENGTH, m);
/*调用output函数，输出移动后的数组元素*/
output(p, LENGTH);
return 0;
}
/*
* 函数名称：input
* 函数功能：通过键盘输入为一维数组元素赋值
* 输入格式：各输入数据之间以空格分隔
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：n，int型，一维数组长度
* 返回值：无
*/
void input(int* p, int n) {
// 请编程实现本函数
int i;
for (i = 0; i < n; i++)
scanf("%d", p + i);
}
/*
* 函数名称：output
* 函数功能：向屏幕打印输出一维数组元素值
* 输出格式：各输出数据之间以空格分隔
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：n，int型，一维数组长度
* 返回值：无
*/
void output(int* p, int n) {
// 请编程实现本函数
int i;
for (i = 0; i < n; i++) {
if (i == 0)
printf("%d", *p);
else
printf(" %d", *(p + i));
}
}
/*
* 函数名称：moveToRight
* 函数功能：使一维数组各元素向右循环移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，循环移动的位置数
* 返 回 值：无
*/
void moveToRight(int* p, int length, int m) {
// 请编程实现本函数
int i, j, t;
m %= length; //减少不必要的动作
//外循环移m次
//内循环完成一次的移动
for (i = 0; i < m; i++) {
t = p[length - 1]; //保存最后一个的值
for (j = length - 1; j > 0; j--)
p[j] = p[j - 1];
p[0] = t; //最后值放在第一个位置
}
}
/*
* 函数名称：moveToLeft
* 函数功能：使一维数组各元素向左循环移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，循环移动的位置数
* 返 回 值：无
*/
void moveToLeft(int* p, int length, int m) {
// 请编程实现本函数
int i, j, t;
m = -m;//注意这里要处理
m %= length; //减少不必要的动作
//外循环移m次
//内循环完成一次的移动
for (i = 0; i < m; i++) {
t = p[0]; //保存第一个的值
for (j = 0; j < length - 1; j++)
p[j] = p[j + 1];
p[length - 1] = t; //第一个的值放在最后
}
}
/*
* 函数名称：move
* 函数功能：使一维数组元素循环向左或向右移动m个位置
* 形式参数：p，int型指针变量，一维整型数组首地址
* 形式参数：length，int型，一维数组长度
* 形式参数：m，int型，表示循环移动的方向和移动的位置个数
* 当m>0时，执行向右循环移动（水平方向从左向右循环移动）
* 当m=0时，不做任何移动
* 当m<0时，执行向左循环移动（水平方向从右向左循环移动）
* 返 回 值：无
*/
void move(int* p, int length, int m) {
if (m > 0) {
/*向右循环移动*/
moveToRight(p, length, m);
} else if (m == 0) {
/*不移动*/
; //空语句，什么都不做
} else {
/*向左循环移动*/
moveToLeft(p, length, m);
}
}
验证与结论：
总结与心得体会：
实验七：结构体
实验题目1：教师信息管理
【适用题型】程序片段编程题
【题目标题】教师信息管理
【问题描述】
定义一个包含5个教师成员的结构体数组，教师信息包括职工号、姓名和工资。要求从键盘输入所有教师的信息，并设计一个sort函数实现结构体数组按教师工资由少到多排序。目前，已编辑完成main函数，请编程实现input函数、output函数和sort函数，分别实现教师信息的录入、输出与排序。
/*
@Filename: ex701.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Salary Management System
*/
#include <stdio.h>
#include <string.h>
typedef struct teacher{
int id; // 职工号
char name[100]; // 姓名
int salary; // 工资
}teacher;
const int NUM = 5;
int main(){
void input(teacher *t, int n);
void output(teacher *t, int n);
void sort(teacher *t, int n);
teacher t[NUM]; //教师数组
teacher *pt = t;
input(pt, NUM); //为教师数组元素赋值
printf("Before sorting:\n");
output(pt, NUM); //排序前输出
sort(pt, NUM); //按工资排序
printf("After sorting:\n");
output(pt, NUM); //排序后输出
return 0;
}
/*
* 函数名称：input
* 函数功能：实现教师信息的键盘输入
* 输入格式：每行输入一个教师的信息，一个教师的各个数据之间用空格分隔；
* 教师姓名不能包含空格
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void input(teacher *t, int n){
// 请编程实现本函数
}
/*
* 函数名称：output
* 函数功能：输出教师信息
* 输出格式：每行只输出一个教师的信息，各信息数据以逗号分隔
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void output(teacher *t, int n){
// 请编程实现本函数
}
/*
* 函数名称：sort
* 函数功能：对教师数组元素按工资由小到大进行排序
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void sort(teacher *t, int n){
// 请编程实现本函数
}
其他说明：无
【源文件名】ex701.c
【输入形式】共有5行输入，每行输入一名教师信息，每个教师的各个数据之间用空格分隔，教师姓名不能包含空格
【输出形式】共有12行输出。
第1行：输出“Before sorting:”
第2~6行：输出排序前教师信息；每行输出一个教师信息；每个教师数据用逗号分隔
第7行：输出“After sorting:”
第8~12行：输出排序后教师信息；每行输出一个教师信息；每个教师数据用逗号分隔
【样例输入】
1 LiuBeibei 26000
2 GuanYuyu 24890
3 ZhangFeifei 22000
4 WangWu 3610
5 LiSi 1860
【样例输出】
Before sorting:
1,LiuBeibei,26000
2,GuanYuyu,24890
3,ZhangFeifei,22000
4,WangWu,3610
5,LiSi,1860
After sorting:
5,LiSi,1860
4,WangWu,3610
3,ZhangFeifei,22000
2,GuanYuyu,24890
1,LiuBeibei,26000
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
101 ZhangSan 9800
102 ZhangSi 5100
103 ZhangWu 48000
104 ZhangLiu 3200
105 ZhangQi 6800
【样例输出】
Before sorting:
101,ZhangSan,9800
102,ZhangSi,5100
103,ZhangWu,48000
104,ZhangLiu,3200
105,ZhangQi,6800
After sorting:
104,ZhangLiu,3200
102,ZhangSi,5100
105,ZhangQi,6800
101,ZhangSan,9800
103,ZhangWu,48000
【样例说明】
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】结构体；结构体类型变量；结构体类型指针；结构体类型数组
【章节】第8章 结构体；实验七：结构体
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex701.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Salary Management System
*/
#include <stdio.h>
#include <string.h>
typedef struct teacher {
int id; // 职工号
char name[100]; // 姓名
int salary; // 工资
} teacher;
const int NUM = 5;
int main() {
void input(teacher * t, int n);
void output(teacher * t, int n);
void sort(teacher * t, int n);
teacher t[NUM]; //教师数组
teacher* pt = t;
input(pt, NUM); //为教师数组元素赋值
printf("Before sorting:\n");
output(pt, NUM); //排序前输出
sort(pt, NUM); //按工资排序
printf("After sorting:\n");
output(pt, NUM); //排序后输出
return 0;
}
/*
* 函数名称：input
* 函数功能：实现教师信息的键盘输入
* 输入格式：每行输入一个教师的信息，一个教师的各个数据之间用空格分隔；
* 教师姓名不能包含空格
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void input(teacher* t, int n) {
// 请编程实现本函数
int i;
for (i = 0; i < n; i++) {
scanf("%d %s %d", &t[i].id, t[i].name, &t[i].salary);
}
}
/*
* 函数名称：output
* 函数功能：输出教师信息
* 输出格式：每行只输出一个教师的信息，各信息数据以逗号分隔
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void output(teacher* t, int n) {
// 请编程实现本函数
int i;
for (i = 0; i < n; i++) {
printf("%d,%s,%d\n", t[i].id, t[i].name, t[i].salary);
}
}
/*
* 函数名称：sort
* 函数功能：对教师数组元素按工资由小到大进行排序
* 形式参数：t, struct teacher型指针，教师数组首地址
* 形式参数：n, int型，教师数组元素个数
* 返 回 值：无
*/
void sort(teacher* t, int n) {
// 请编程实现本函数
int i, j;
teacher tmp;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (t[j].salary > t[j + 1].salary) {
tmp = t[j];
t[j] = t[j + 1];
t[j + 1] = tmp;
}
}
}
}
验证与结论：
总结与心得体会：
实验题目2：复数加减法运算器
【适用题型】程序片段编程题
【题目标题】复数加减法运算器
【问题描述】
定义一个结构体类型，用于描述复数结构数据。分别编写函数实现复数的加法和减法运算，在主函数中调用这些函数进行计算并输出计算结果。目前已完成main函数的编写，请编程实现add函数和minus函数。具体要求如下所示。
/*
@Filename: ex702.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Complex Addition and Subtraction
*/
#include <stdio.h>
struct complex{
int re; // real part（实部）
int im; // imaginary part（虚部）
};
int main(){
struct complex add(struct complex a, struct complex b);
struct complex minus(struct complex a, struct complex b);
struct complex x, y, z;
// 输入实数x的实部和虚部
scanf("%d,%d", &x.re, &x.im);
// 输入实数y的实部和虚部
scanf("%d,%d", &y.re, &y.im);
// 计算并输出复数加法和
z = add(x, y);
printf("%d+%di\n",z.re, z.im);
// 计算并输出复数减法差
z = minus(x, y);
printf("%d+%di",z.re, z.im);
return 0;
}
/*
* 函数名称：add
* 函数功能：实现复数加法运算
* 形式参数：struct complex a，操作数
* 形式参数：struct complex b，操作数
* 返 回 值：struct complex型，返回形参a和形参b的加法结果
*/
struct complex add(struct complex a, struct complex b){
// 请编程实现本函数
}
/*
* 函数名称：minus
* 函数功能：实现复数减法运算
* 形式参数：struct complex a，操作数
* 形式参数：struct complex b，操作数
* 返 回 值：struct complex型，返回形参a和形参b的减法结果
*/
struct complex minus(struct complex a, struct complex b){
// 请编程实现本函数
}
其它说明：无。
【源文件名】ex702.c
【输入形式】输入有两行。
第1行输入两个整数，用逗号分隔，分别表示复数x的实部和虚部
第2行输入两个整数，用逗号分隔，分别表示复数y的实部和虚部
【输出形式】输出有两行。
第1行输出复数x和复数y的加法和
第2行输出复数x和复数y的减法差
【样例输入】
3,6
4,5
【样例输出】
7+11i
-1+1i
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
-18,-27
-34,15
【样例输出】
-52+-12i
16+-42i
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
8,3
-2,3
【样例输出】
6+6i
10+0i
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
9,5
9,18
【样例输出】
18+23i
0+-13i
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
138,-236
138,-236
【样例输出】
276+-472i
0+0i
【样例说明】输入和输出格式效果如下图所示。
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】结构体；结构体类型变量；
【章节】第8章 结构体；实验七：结构体
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex702.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Complex Addition and Subtraction
*/
#include <stdio.h>
struct complex {
int re; // real part（实部）
int im; // imaginary part（虚部）
};
int main() {
struct complex add(struct complex a, struct complex b);
struct complex minus(struct complex a, struct complex b);
struct complex x, y, z;
// 输入实数x的实部和虚部
scanf("%d,%d", &x.re, &x.im);
// 输入实数y的实部和虚部
scanf("%d,%d", &y.re, &y.im);
// 计算并输出复数加法和
z = add(x, y);
printf("%d+%di\n", z.re, z.im);
// 计算并输出复数减法差
z = minus(x, y);
printf("%d+%di", z.re, z.im);
return 0;
}
/*
* 函数名称：add
* 函数功能：实现复数加法运算
* 形式参数：struct complex a，操作数
* 形式参数：struct complex b，操作数
* 返 回 值：struct complex型，返回形参a和形参b的加法结果
*/
struct complex add(struct complex a, struct complex b) {
// 请编程实现本函数
struct complex res;
res.im = a.im + b.im;
res.re = a.re + b.re;
return res;
}
/*
* 函数名称：minus
* 函数功能：实现复数减法运算
* 形式参数：struct complex a，操作数
* 形式参数：struct complex b，操作数
* 返 回 值：struct complex型，返回形参a和形参b的减法结果
*/
struct complex minus(struct complex a, struct complex b) {
// 请编程实现本函数
struct complex res;
res.im = a.im - b.im;
res.re = a.re - b.re;
return res;
}
验证与结论：
总结与心得体会：
实验题目3：简单的图书管理程序
【适用题型】程序片段编程题
【题目标题】简单的图书管理程序
【问题描述】
现有3本图书，每本图书的信息包括：书号、书名、作者、价格。
（1）编写input函数，实现从键盘输入若干本图书信息，存放在结构体数组中。
（2）编写output函数，遍历结构体数组，输出所有图书信息。
（3）编写findBookByID函数，实现按书号检索图书。
（4）编写findBookByName函数，实现按书名检索图书。
目前，已编写完成main函数、input函数和findBookByName函数，请编程实现output函数和findBookByID函数。程序结构及具体要求如下。
/*
@Filename: ex703.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Simple Library Management Program
*/
#include <stdio.h>
#include <string.h>
typedef struct book{
int id; // 书号
char name[30]; // 书名
char author[30]; //作者
float price; //价格
}BOOK;
int main(){
/* 声明函数 */
void input(struct book *p, int num);
void output(struct book *p, int num);
struct book * findBookByID(struct book *p, int num, int id);
struct book * findBookByName(struct book *p, int num, char name[]);
/* 声明变量 */
const int NUM = 3;
struct book myBooks[NUM];
struct book *pBook = myBooks;
BOOK *theBook;
/* 为myBooks数组的所有元素赋值 */
input(pBook, NUM);
/* 按ID检索图书 */
int bookID;
scanf("%d", &bookID);
fflush(stdin); /*清空输入缓冲区*/
theBook = findBookByID(pBook, NUM, bookID); /*按书号检索*/
output(theBook, 1); /*输出检索结果*/
/* 输出myBooks数组的所有元素值 */
output(pBook, NUM);
return 0;
}
/*
* 函数名称：input
* 函数功能：从键盘输入为book型结构体数组元素赋值
* 输入格式：（1）共输入num本图书信息
* （2）对每本图书，在一行内分别输入书号、书名、作者、价格，各数据之间以空格分隔
* （3）书名和作者不能包含空格
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 返 回 值：无
*/
void input(struct book *p, int num){
int i;
for(i = 0; i < num; i++){
scanf("%d %s %s %f", &(p+i)->id, (p+i)->name, (p+i)->author, &(p+i)->price);
}
}
/*
* 函数名称：output
* 函数功能：输出显示book型结构体数组元素值
* 输出格式：（1）一行输出一本图书信息，共输出num行
* （2）每行先后输出书号、书名、作者、价格（保留小数点后2位），用逗号分隔图书信息
* （3）若形参p为空指针，则输出字串NULL
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 返 回 值：无
*/
void output(struct book *p, int num){
// 请编程实现本函数
}
/*
* 函数名称：findBookByID
* 函数功能：按书号检索图书
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 形式参数：id，int型，书号
* 返 回 值：返回book型指针。若没有找到图书，则返回空指针NULL；否则，仅返回第1本符合检索条件的图书
*/
struct book * findBookByID(struct book *p, int num, int id){
// 请编程实现本函数
}
/*
* 函数名称：findBookByName
* 函数功能：按书名检索图书
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 形式参数：name，字符数组，书名
* 返 回 值：返回book型指针。若没有找到图书，则返回空指针NULL；否则，仅返回第1本符合检索条件的图书
*/
struct book * findBookByName(struct book *p, int num, char name[]){
struct book *theBook = NULL;
if(p == NULL){
return theBook;
}
int i;
for(i = 0; i < num; i++){
if(strcmp((p + i) -> name, name) == 0){
theBook = p + i;
break; //检索到第一个符合条件的图书后就强制退出
}
}
return theBook;
}
其他说明：无
【源文件名】ex703.c
【输入形式】共4行输入。
（1）第1行~第 3行分别输入为第1本~第3本图书信息；对每本图书，在一行内分别输入书号、书名、作者、价格，各数据之间以空格分隔；书名和作者不能包含空格。
（2）第4行输入需进行检索的图书书号（ID）
【输出形式】共4行输出。
（1）第1行输出为按书号检索的结果。若没有图书，则输出字串NULL；若找到图书，则在一行内先后输出书号、书名、作者、价格（保留小数点后两位），用逗号分隔。
（2）第2行~第4行分别为所有图书信息，每行输出一本图书信息，输出格式同上。
【样例输入】
1001 CLanguage ZhangSan 29.99
1002 English LiSi 36.1823
1003 Math WangWu 65.739
1002
【样例输出】
1002,English,LiSi,36.18
1001,CLanguage,ZhangSan,29.99
1002,English,LiSi,36.18
1003,Math,WangWu,65.74
【样例说明】输入和输出格式效果如下图所示。
【样例输入】
1 JavaScript LiuBeibei 78.23567
2 OperatingSystem GuanYuyu 62.398
3 C++ ZhangFeifei 18.9834
110
【样例输出】
NULL
1,JavaScript,LiuBeibei,78.24
2,OperatingSystem,GuanYuyu,62.40
3,C++,ZhangFeifei,18.98
【样例说明】输入和输出格式效果如下图所示。
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】结构体；结构体类型变量；结构体类型指针；指针型函数
【章节】第8章 结构体；实验七：结构体
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex703.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Simple Library Management Program
*/
#include <stdio.h>
#include <string.h>
typedef struct book {
int id; // 书号
char name[30]; // 书名
char author[30]; //作者
float price; //价格
} BOOK;
int main() {
/* 声明函数 */
void input(struct book * p, int num);
void output(struct book * p, int num);
struct book* findBookByID(struct book * p, int num, int id);
struct book* findBookByName(struct book * p, int num, char name[]);
/* 声明变量 */
const int NUM = 3;
struct book myBooks[NUM];
struct book* pBook = myBooks;
BOOK* theBook;
/* 为myBooks数组的所有元素赋值 */
input(pBook, NUM);
/* 按ID检索图书 */
int bookID;
scanf("%d", &bookID);
fflush(stdin); /*清空输入缓冲区*/
theBook = findBookByID(pBook, NUM, bookID); /*按书号检索*/
output(theBook, 1); /*输出检索结果*/
/* 输出myBooks数组的所有元素值 */
output(pBook, NUM);
return 0;
}
/*
* 函数名称：input
* 函数功能：从键盘输入为book型结构体数组元素赋值
* 输入格式：（1）共输入num本图书信息
* （2）对每本图书，在一行内分别输入书号、书名、作者、价格，各数据之间以空格分隔
* （3）书名和作者不能包含空格
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 返 回 值：无
*/
void input(struct book* p, int num) {
int i;
for (i = 0; i < num; i++) {
scanf("%d %s %s %f", &(p + i)->id, (p + i)->name, (p + i)->author,
&(p + i)->price);
}
}
/*
* 函数名称：output
* 函数功能：输出显示book型结构体数组元素值
* 输出格式：（1）一行输出一本图书信息，共输出num行
* （2）每行先后输出书号、书名、作者、价格（保留小数点后2位），用逗号分隔图书信息
* （3）若形参p为空指针，则输出字串NULL
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 返 回 值：无
*/
void output(struct book* p, int num) {
// 请编程实现本函数
int i;
if(p==NULL)
{
puts("NULL");
return ;
}
for (i = 0; i < num; i++) {
printf("%d %s %s %.2f\n", (p + i)->id, (p + i)->name, (p + i)->author,
(p + i)->price);
}
}
/*
* 函数名称：findBookByID
* 函数功能：按书号检索图书
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 形式参数：id，int型，书号
* 返 回
* 值：返回book型指针。若没有找到图书，则返回空指针NULL；否则，仅返回第1本符合检索条件的图书
*/
struct book* findBookByID(struct book* p, int num, int id) {
// 请编程实现本函数
int i;
for (i = 0; i < num; i++) {
if ((p + i)->id == id) {
return p + i;
}
}
return NULL;
}
/*
* 函数名称：findBookByName
* 函数功能：按书名检索图书
* 形式参数：p，book型指针，book型一维数组首地址
* 形式参数：num，int型，图书数量
* 形式参数：name，字符数组，书名
* 返 回
* 值：返回book型指针。若没有找到图书，则返回空指针NULL；否则，仅返回第1本符合检索条件的图书
*/
struct book* findBookByName(struct book* p, int num, char name[]) {
struct book* theBook = NULL;
if (p == NULL) {
return theBook;
}
int i;
for (i = 0; i < num; i++) {
if (strcmp((p + i)->name, name) == 0) {
theBook = p + i;
break; //检索到第一个符合条件的图书后就强制退出
}
}
return theBook;
}
验证与结论：
总结与心得体会：
实验八：文件
实验题目1：写入文本文件
【适用题型】程序片段编程题
【题目标题】写入文本文件。
【问题描述】
从键盘输入一个长度不超过100个字符的字符串，然后做如下操作：
（1）将字串中的小写字母转为大写，大写字母转为小写，而其它字符不作处理。
（2）将字串输出保存到一个名为“ex801.txt”的文本文件中。注：文本文件ex801.txt应与源码文件ex801.c保存在同一个文件夹中。
目前，已编写完成main函数，请编程实现writeToFile函数，具体功能和要求如下所示。
/*
@Filename: ex801.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: File Character Reading and Writing
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc,char *argv[]){
/*（1）声明函数及变量*/
int writeToFile(char *str, char *fileName, char *mode);
char str[100];
char fileName[] = "ex801.txt";
/*（2）获取键盘输入字串*/
fgets(str, 100, stdin);
//gets(str); //将回车看作字串输入结束标志，字串中可以有空格
//scanf("%s", str); //将空格看作字串输入结束标志，字串中不能有空格
/*（3）将字串写入文件*/
int charNum = writeToFile(str, fileName, "w");
if(charNum < 0){
//printf("write error");//用于调试
return -1;
}
return 0;
}
/*
* 函数名称：writeToFile
* 函数功能：将字串写入文件
* 形式参数：char *str，一维字符数组（字符串）首地址
* 形式参数：char *fileName，待写入的文件路径及名称
* 形式参数：char *mode，文件使用方式
* 返 回 值：int型，若文件打开异常，返回 -1；否则返回写入到文件的字符数
*/
int writeToFile(char *str, char *fileName, char *mode){
// 请编程实现本函数
}
其他说明：无
【源文件名】ex801.c
【输入形式】标准输入：从键盘任意输入不超过100个字符的字串
【输出形式】文件输出：将字串转换后输出到文件
【样例输入】
I Love You!78$%2kjhaEWF
【样例输出】
i lOVE yOU!78$%2KJHAewf
【样例说明】
图1 标准输入内容样例
图2 文件输出内容样例
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】文件系统；
【章节】第9章 文件；实验八：文件
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】£ 标准输出 R 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex801.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: File Character Reading and Writing
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]) {
/*（1）声明函数及变量*/
int writeToFile(char* str, char* fileName, char* mode);
char str[100];
char fileName[] = "ex801.txt";
/*（2）获取键盘输入字串*/
fgets(str, 100, stdin);
// gets(str); //将回车看作字串输入结束标志，字串中可以有空格
// scanf("%s", str); //将空格看作字串输入结束标志，字串中不能有空格
/*（3）将字串写入文件*/
int charNum = writeToFile(str, fileName, "w");
if (charNum < 0) {
// printf("write error");//用于调试
return -1;
}
return 0;
}
/*
* 函数名称：writeToFile
* 函数功能：将字串写入文件
* 形式参数：char *str，一维字符数组（字符串）首地址
* 形式参数：char *fileName，待写入的文件路径及名称
* 形式参数：char *mode，文件使用方式
* 返 回 值：int型，若文件打开异常，返回 -1；否则返回写入到文件的字符数
*/
int writeToFile(char* str, char* fileName, char* mode) {
// 请编程实现本函数
FILE* fp;
char c;
int i;
fp = fopen(fileName, mode);
if (!fp) {
return -1;
}
i = 0;
while (str[i]) {
c = str[i];
if (c >= 'a' && c <= 'z') {
c -= 32;
} else if (c >= 'A' && c <= 'Z') {
c += 32;
}
fputc(c, fp);
i += 1;
}
fclose(fp);
return i;
}
验证与结论：
总结与心得体会：
实验题目2：统计文本文件
【适用题型】程序片段编程题
【题目标题】统计文本文件。
【问题描述】
请编程实现读取并统计文本文件“ex802.txt”中字母、数字和其它字符的个数，然后将统计结果输出到屏幕。注：该文本文件与源码文件保存在同一个文件夹中。
目前已完成main函数的编写，请编程实现statisticsFromFile函数，函数的功能和要求如下所示。
/*
@Filename: ex802.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: File Character Statistics
*/
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void){
int statisticsFromFile(int *num, char *fileName, char *mode);
/*
* 定义数组num，包含三个元素：
* 第1个元素表示字母个数；
* 第2个元素表示数字个数；
* 第3个元素表示其他字符个数
*/
int num[3]={0,0,0};
char fileName[] = "ex802.txt";
/*读取文件并分类统计字符个数*/
statisticsFromFile(num, fileName, "r");
/*输出显示各类字符个数*/
printf("letter:%d\n",num[0]);
printf("number:%d\n",num[1]);
printf("other:%d",num[2]);
return 0;
}
/*
* 函数名称：statisticsFromFile
* 函数功能：读取文件并分类统计字符个数，统计结果保存在形参数组num中
* 形式参数：int *，一维整型数组首地址
* 形式参数：char *fileName，文件路径及名称
* 形式参数：char *mode，文件使用方式
* 返 回 值：int型，若文件打开异常，返回 -1；否则返回读取文件的字符数
*/
int statisticsFromFile(int *num, char *fileName, char *mode){
// 请编程实现本函数
}
其他说明：无
【源文件名】ex802.c
【输入形式】文件输入：事先创建“ex802.txt”文件并录入任意字串作为文件输入内容
【输出形式】标准输出：在显示器中有3行输出。
第1行：字母个数
第2行：数字个数
第3行：其他字符个数
【样例输入】
ksiwkslapUWJ827301*&!@&&^%*!
【样例输出】
letter:12
number:6
other:10
【样例说明】
图1 文件输入内容样例
图2 标准输出内容样例
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】文件系统；
【章节】第9章 文件；实验八：文件
【输入类型】£ 标准输入 R 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex802.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: File Character Statistics
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
int statisticsFromFile(int* num, char* fileName, char* mode);
/*
* 定义数组num，包含三个元素：
* 第1个元素表示字母个数；
* 第2个元素表示数字个数；
* 第3个元素表示其他字符个数
*/
int num[3] = {0, 0, 0};
char fileName[] = "ex802.txt";
/*读取文件并分类统计字符个数*/
statisticsFromFile(num, fileName, "r");
/*输出显示各类字符个数*/
printf("letter:%d\n", num[0]);
printf("number:%d\n", num[1]);
printf("other:%d", num[2]);
return 0;
}
/*
* 函数名称：statisticsFromFile
* 函数功能：读取文件并分类统计字符个数，统计结果保存在形参数组num中
* 形式参数：int *，一维整型数组首地址
* 形式参数：char *fileName，文件路径及名称
* 形式参数：char *mode，文件使用方式
* 返 回 值：int型，若文件打开异常，返回 -1；否则返回读取文件的字符数
*/
int statisticsFromFile(int* num, char* fileName, char* mode) {
// 请编程实现本函数
FILE* fp;
char c;
int i;
int letter, number, other;
letter = 0;
number = 0;
other = 0;
fp = fopen(fileName, mode);
if (!fp) {
return -1;
}
i = 0;
while ((c = fgetc(fp)) != EOF) {
i += 1;
if (c >= 'a' && c <= 'z')
letter += 1;
else if (c >= 'A' && c <= 'Z')
letter += 1;
else if (c >= '0' && c <= '9')
number += 1;
else
other += 1;
}
fclose(fp);
num[0] = letter;
num[1] = number;
num[2] = other;
return i;
}
验证与结论：
总结与心得体会：
实验题目3：格式化写文件
【适用题型】程序片段编程题
【题目标题】格式化写文件
【问题描述】
创建一个学生结构体，如下所示。
struct stu{
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
然后从键盘录入两名学生的信息，最后将上述信息格式化写入到文件。写入格式要求：将每个同学的信息写入到文件中的一行，每行中的各个数据之间以空格分隔。目前，已经完成了main函数的编写，请编程实现“stdinForStu”函数和“writeFileForStu”函数。
注：需写入的文本文件“ex803.txt”应与源文件“ex803.c”保存在同一个文件夹中。
/*
@Filename: ex803.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Format Input and Output
*/
#include <stdio.h>
struct stu{
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
int main(){
/*声明函数及变量*/
void stdinForStu(struct stu *p, int num);
void writeFileForStu(struct stu *p, int num, char filename[],char mode[]);
const int NUM = 2; //学生数量
struct stu students[NUM]; //stu型数组
struct stu *p = students; //stu型指针
char filename[] = "ex803.txt"; //待写入文件路径及名称
/*从键盘获取输入*/
stdinForStu(p, NUM);
/*向文件写入数据*/
writeFileForStu(p, NUM, filename, "w");
return 0;
}
/*
* 函数名称：stdinForStu
* 函数功能：从键盘输入数据，保存到指针 p 所指向的数组中
* 输入格式：共输入 num 行；每行输入一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址
* 形式参数：int num，一维数组元素个数
* 返 回 值：无
*/
void stdinForStu(struct stu *p, int num){
// 请编程实现本函数
}
/*
* 函数名称：writeFileForStu
* 函数功能：向文件格式化写入数据
* 写入格式：共写入 num 行；每行写入一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址。该数组数据将被写入文件
* 形式参数：int num，一维数组元素个数，也即写入到文件的行数
* 形式参数：char filename[]，待写入的文件路径及名称
* 形式参数：char mode[]，文件使用方式
* 返 回 值：无
*/
void writeFileForStu(struct stu *p, int num, char filename[],char mode[]){
// 请编程实现本函数
}
其他说明：无
【源文件名】ex803.c
【输入形式】标准输入：有2行。每行输入一个同学信息；每行中数据之间以空格分隔
【输出形式】文件输出：有2行。每行写入一个同学信息；每行中数据之间以空格分隔
【样例输入】
1001 zhangfeifei 18 100
1002 liubeibei 19 80
【样例输出】
1001 zhangfeifei 18 100
1002 liubeibei 19 80
【样例说明】
图1 标准输入内容样例
图2 文件输出内容样例
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】文件系统；
【章节】第9章 文件；实验八：文件
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】£ 标准输出 R 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex803.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Format Input and Output
*/
#include <stdio.h>
struct stu {
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
int main() {
/*声明函数及变量*/
void stdinForStu(struct stu * p, int num);
void writeFileForStu(struct stu * p, int num, char filename[], char mode[]);
const int NUM = 2; //学生数量
struct stu students[NUM]; // stu型数组
struct stu* p = students; // stu型指针
char filename[] = "ex803.txt"; //待写入文件路径及名称
/*从键盘获取输入*/
stdinForStu(p, NUM);
/*向文件写入数据*/
writeFileForStu(p, NUM, filename, "w");
return 0;
}
/*
* 函数名称：stdinForStu
* 函数功能：从键盘输入数据，保存到指针 p 所指向的数组中
* 输入格式：共输入 num 行；每行输入一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址
* 形式参数：int num，一维数组元素个数
* 返 回 值：无
*/
void stdinForStu(struct stu* p, int num) {
// 请编程实现本函数
int i;
for (i = 0; i < num; i++) {
scanf("%d %s %d %d", &p[i].id, p[i].name, &p[i].age, &p[i].score);
}
}
/*
* 函数名称：writeFileForStu
* 函数功能：向文件格式化写入数据
* 写入格式：共写入 num 行；每行写入一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址。该数组数据将被写入文件
* 形式参数：int num，一维数组元素个数，也即写入到文件的行数
* 形式参数：char filename[]，待写入的文件路径及名称
* 形式参数：char mode[]，文件使用方式
* 返 回 值：无
*/
void writeFileForStu(struct stu* p, int num, char filename[], char mode[]) {
// 请编程实现本函数
FILE* fp;
char c;
int i;
fp = fopen(filename, mode);
if (!fp) {
return;
}
for (i = 0; i < num; i++) {
fprintf(fp, "%d %s %d %d\n", p[i].id, p[i].name, p[i].age, p[i].score);
}
fclose(fp);
}
验证与结论：
总结与心得体会：
实验题目4：格式化读文件
【适用题型】程序片段编程题
【题目标题】格式化读文件
【问题描述】
从文本文件“ex804.txt”格式化读取学生信息，然后将学生信息封装到结构体数组中，最后在标准输出设备中输出显示。
（1）“ex804.txt”的存储组织格式为：每行只保存一个同学信息；每行（每个同学）共有4个数据，分别为学号、姓名、年龄、成绩，每个数据之间以空格分隔。注：文本文件“ex804.txt”应与源文件“ex804.c”保存在同一个文件夹中。
（2）学生结构体定义如下：
struct stu{
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
目前，已完成main函数的编写，请编程实现“readFileForStu”函数和“stdoutForStu”函数。
/*
@Filename: ex804.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Format Input and Output
*/
#include <stdio.h>
struct stu{
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
int main(){
/*声明函数及变量*/
void readFileForStu(struct stu *p, int num, char filename[],char mode[]);
void stdoutForStu(struct stu *p, int num);
const int NUM = 2; //学生数量
struct stu students[NUM]; //stu型数组
struct stu *p = students; //stu型指针
char filename[] = "ex804.txt"; //待读取的文件路径及名称
/*从文件获取输入*/
readFileForStu(p, NUM, filename, "r");
/*向屏幕输出显示*/
stdoutForStu(p, NUM);
return 0;
}
/*
* 函数名称：readFileForStu
* 函数功能：从文件格式化读取数据
* 写入格式：共读取 num 行；每行读出一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址。该数组用于保存文件读取数据
* 形式参数：int num，一维数组元素个数，也即读取文件的行数
* 形式参数：char filename[]，待读取的文件路径及名称
* 形式参数：char mode[]，文件使用方式
* 返 回 值：无
*/
void readFileForStu(struct stu *p, int num, char filename[],char mode[]){
// 请编程实现本函数
}
/*
* 函数名称：stdoutForStu
* 函数功能：向显示器输出显示数据
* 输出格式：共输出 num 行；每行输出一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址
* 形式参数：int num，一维数组元素个数
* 返 回 值：无
*/
void stdoutForStu(struct stu *p, int num){
// 请编程实现本函数
}
其他说明：无
【源文件名】ex804.c
【输入形式】文件输入：在文件中每行只保存一个同学信息，共有2行；每行（每个同学）共有4个数据，分别为学号、姓名、年龄、成绩，每个数据之间以空格分隔
【输出形式】标准输出：每行输出一个同学信息，每行中数据之间以空格分隔
【样例输入】
1 libai 100 100
2 lihei 200 200
【样例输出】
1 libai 100 100
2 lihei 200 200
【样例说明】
图1 文件输入内容样例
图2 标准输出内容样例
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】文件系统；
【章节】第9章 文件；实验八：文件
【输入类型】£ 标准输入 R 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex804.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Format Input and Output
*/
#include <stdio.h>
struct stu {
int id; //学号
char name[20]; //姓名
int age; //年龄
int score; //成绩
};
int main() {
/*声明函数及变量*/
void readFileForStu(struct stu * p, int num, char filename[], char mode[]);
void stdoutForStu(struct stu * p, int num);
const int NUM = 2; //学生数量
struct stu students[NUM]; // stu型数组
struct stu* p = students; // stu型指针
char filename[] = "ex804.txt"; //待读取的文件路径及名称
/*从文件获取输入*/
readFileForStu(p, NUM, filename, "r");
/*向屏幕输出显示*/
stdoutForStu(p, NUM);
return 0;
}
/*
* 函数名称：readFileForStu
* 函数功能：从文件格式化读取数据
* 写入格式：共读取 num 行；每行读出一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu
* 型一维数组首地址。该数组用于保存文件读取数据 形式参数：int
* num，一维数组元素个数，也即读取文件的行数 形式参数：char
* filename[]，待读取的文件路径及名称 形式参数：char mode[]，文件使用方式 返 回
* 值：无
*/
void readFileForStu(struct stu* p, int num, char filename[], char mode[]) {
// 请编程实现本函数
FILE* fp;
char c;
int i;
fp = fopen(filename, mode);
if (!fp) {
return;
}
for (i = 0; i < num; i++) {
fscanf(fp, "%d %s %d %d", &p[i].id, p[i].name, &p[i].age, &p[i].score);
}
fclose(fp);
}
/*
* 函数名称：stdoutForStu
* 函数功能：向显示器输出显示数据
* 输出格式：共输出 num 行；每行输出一个 stu 型数据，每个成员变量之间用空格分隔
* 形式参数：struct stu * p，指向 stu 型一维数组首地址
* 形式参数：int num，一维数组元素个数
* 返 回 值：无
*/
void stdoutForStu(struct stu* p, int num) {
// 请编程实现本函数
int i;
for (i = 0; i < num; i++) {
printf("%d %s %d %d\n", p[i].id, p[i].name, p[i].age, p[i].score);
}
}
验证与结论：
总结与心得体会：
实验题目5：读写二进制文件
【适用题型】程序片段编程题
【题目标题】读写二进制文件
【问题描述】
现有一个结构体用来描述学生信息，结构体数据成员包括：学号、姓名、三门课程成绩和平均成绩。
typedef struct student{
char sno[SNO_LENGTH]; //学号
char name[NAME_LENGTH]; //姓名
int score[COURSE_NUMBER]; //课程成绩数组
float average; //所有课程的平均成绩
}STU;
（1）从键盘输入3个学生的学号、姓名和三门课成绩，然后计算每个学生的平均成绩。之后，将每个学生的结构体数据存放在二进制磁盘文件“ex805.dat”（与源文件“ex805.c”存放于同一个文件夹）中。
（2）读取二进制磁盘文件“ex805.dat”，然后输出到显示器。
目前，已编辑完成main函数、input函数和output函数。请编程实现writeFile函数和readFile函数。具体函数功能及要求如下所示。
/*
@Filename: ex805.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Data File Processing
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SNO_LENGTH 10
#define NAME_LENGTH 20
#define COURSE_NUMBER 3
#define STU_NUMBER 3
/*
* 定义结构体类型student
*/
typedef struct student{
char sno[SNO_LENGTH]; //学号
char name[NAME_LENGTH]; //姓名
int score[COURSE_NUMBER]; //课程成绩数组
float average; //所有课程的平均成绩
}STU;
int main(){
/*声明函数*/
void input(struct student *p, int rows);
void output(STU *p, int rows);
int writeFile(STU *p, int rows, char filename[], char mode[]);
int readFile(STU *p, int rows, char filename[], char mode[]);
/*定义student型结构体数组*/
STU stu[STU_NUMBER], stu2[STU_NUMBER];
/*从标准输入为stu数组元素赋值*/
input(stu,STU_NUMBER);
/*将stu数组元素值写入二进制文件，并输出成功写入的数据块个数*/
printf("%d\n", writeFile(stu, STU_NUMBER, "ex805.dat", "wb"));
//writeFile(stu, STU_NUMBER, "ex805.dat", "wb");
/*读取二进制文件并填充stu2数组中，并输出成功读取的数据块个数*/
printf("%d\n", readFile(stu2, STU_NUMBER, "ex805.dat", "rb"));
/*输出显示stu2数组元素*/
output(stu2, STU_NUMBER);
return 0;
}
/*
* 函数名称：input
* 函数功能：为形参 p 所指向的结构体数组元素以键盘输入方式进行赋值
* 输入格式：所有学生的所有数据均需分行输入，即：
* 每个学生均有 5 行输入，自上而下分别为学号、姓名、三门课程成绩，
* 其中，学号和姓名不能包含空格
* 形式参数：struct student型指针，p 指向结构体数组首地址
* 形式参数：int型，rows 为结构体数组元素个数
* 返 回 值：无
*/
void input(struct student *p, int rows){
int i, j;
for(i = 0; i < rows; i++){
//printf("\nInput the information of student %d:\n", (i + 1));
//输入学号
//printf("sno:\t");
scanf("%s", (p + i) -> sno);
//gets((p + i) -> sno);
//fgets((p + i) -> sno, SNO_LENGTH, stdin);
fflush(stdin);
//输入姓名
//printf("name:\t");
scanf("%s", (p + i) -> name);
//gets((p + i) -> name);
//fgets((p + i) -> name, NAME_LENGTH, stdin);
fflush(stdin);
//输入三门课程成绩，并求和
float sum = 0;
for(j = 0; j < COURSE_NUMBER; j++){
//printf("score%d:\t", j + 1);
scanf("%d", &((p + i) -> score[j]));
fflush(stdin);
sum += (p + i) -> score[j];
}
//计算平均成绩
(p + i) -> average = sum / COURSE_NUMBER;
}
}
/*
* 函数名称：output
* 函数功能：将形参 p 所指向的结构体数组输出到屏幕
* 输出格式：所有同学的信息均需分行输出，即：每行只输出一个同学的所有数据，
* 从左至右分别为学号、姓名、三门课程成绩和平均成绩，
* 其中，平均成绩保留小数点后两位
* 形式参数：struct student型指针，p 指向结构体数组首地址
* 形式参数：int型，rows 为结构体数组元素个数
* 返 回 值：无
*/
void output(STU *p, int rows){
int i,j;
//printf("\nThe students'information is as follows:");
for(i = 0; i < rows; i++){
printf("%s,", (p + i) -> sno);
//puts((p + i) -> sno);
fflush(stdout);
printf("%s,", (p + i) -> name);
//puts((p + i) -> name);
fflush(stdout);
for(j = 0; j < COURSE_NUMBER; j++){
printf("%d,", (p + i) -> score[j]);
fflush(stdout);
}
printf("%.2f\n", (p + i) -> average);
}
}
/*
* 函数名称：writeFile
* 函数功能：将指针 p 所指向的数组的所有元素值写入到二进制文件中
* 形式参数：struct student型指针，p 指向结构体数组的首地址
* 形式参数：int型，rows 为结构体数组长度
* 形式参数：一维字符数组，filename 为二进制文件路径及名称
* 形式参数：一维字符数组，mode 为文件打开模式
* 返 回 值：int型，若打开文件失败，返回 -1；否则，返回成功写入到文件的数据块个数
*/
int writeFile(STU *p, int rows, char filename[], char mode[]){
// 请编程实现本函数
}
/*
* 函数名称：readFile
* 函数功能：读取二进制文件并存储到指针p所指向的数组
* 形式参数：struct student型指针，p 指向结构体数组的首地址
* 形式参数：int型，rows 为结构体数组长度
* 形式参数：一维字符数组，filename 为二进制文件路径及名称
* 形式参数：一维字符数组，mode 为文件打开模式
* 返 回 值：int型，若打开文件失败，返回 -1；否则，返回从文件成功读取的数据块个数
*/
int readFile(STU *p, int rows, char filename[], char mode[]){
// 请编程实现本函数
}
其他说明：不得使用全局变量。
【源文件名】ex805.c
【输入形式】从键盘输入3个学生信息，且每个学生的每个数据均分行输入。共有15行输入。
第1~5行：第1个学生的学号、姓名、成绩1、成绩2、成绩3
第6~10行：第2个学生的学号、姓名、成绩1、成绩2、成绩3
第11~15行：第3个学生的学号、姓名、成绩1、成绩2、成绩3
其中，学生的学号和姓名不能包含空格。
【输出形式】标准输出。共有5行输出。
第1行：成功写入二进制文件的数据块个数
第2行：成功读取二进制文件的数据块个数
第3行：第1个学生的学号、姓名、成绩1、成绩2、成绩3、平均成绩，以逗号分隔
第4行：第2个学生的学号、姓名、成绩1、成绩2、成绩3、平均成绩，以逗号分隔
第5行：第3个学生的学号、姓名、成绩1、成绩2、成绩3、平均成绩，以逗号分隔
【样例输入】
1001
LiuBeibei
100
100
71
1002
GuanYuyu
90
90
80
1003
ZhangFeifei
80
80
90
【样例输出】
3
3
1001,LiuBeibei,100,100,71,90.33
1002,GuanYuyu,90,90,80,86.67
1003,ZhangFeifei,80,80,90,83.33
【样例说明】
图1 标准输入与输出样例
【评分标准】正确性 + £ 性能（性能占比0%）
【难度】3
【知识点】文件系统；
【章节】第9章 文件；实验八：文件
【输入类型】R 标准输入 £ 文件 £ 命令行参数
【输出类型】R 标准输出 £ 文件
【计算机语言】C
【运行时限制】最长运行时间：（ ）秒；最大内存（一般不用设置）：（ ）KB
【代码提交方式】R 源文件提交 £ 在线编辑
设计思想：
实验代码及注释：
/*
@Filename: ex805.c
@Author: Ju Chengdong
@Version: 1.0
@Date: 2021-03-18
@Description: Data File Processing
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SNO_LENGTH 10
#define NAME_LENGTH 20
#define COURSE_NUMBER 3
#define STU_NUMBER 3
/*
* 定义结构体类型student
*/
typedef struct student {
char sno[SNO_LENGTH]; //学号
char name[NAME_LENGTH]; //姓名
int score[COURSE_NUMBER]; //课程成绩数组
float average; //所有课程的平均成绩
} STU;
int main() {
/*声明函数*/
void input(struct student * p, int rows);
void output(STU * p, int rows);
int writeFile(STU * p, int rows, char filename[], char mode[]);
int readFile(STU * p, int rows, char filename[], char mode[]);
/*定义student型结构体数组*/
STU stu[STU_NUMBER], stu2[STU_NUMBER];
/*从标准输入为stu数组元素赋值*/
input(stu, STU_NUMBER);
/*将stu数组元素值写入二进制文件，并输出成功写入的数据块个数*/
printf("%d\n", writeFile(stu, STU_NUMBER, "ex805.dat", "wb"));
// writeFile(stu, STU_NUMBER, "ex805.dat", "wb");
/*读取二进制文件并填充stu2数组中，并输出成功读取的数据块个数*/
printf("%d\n", readFile(stu2, STU_NUMBER, "ex805.dat", "rb"));
/*输出显示stu2数组元素*/
output(stu2, STU_NUMBER);
return 0;
}
/*
* 函数名称：input
* 函数功能：为形参 p 所指向的结构体数组元素以键盘输入方式进行赋值
* 输入格式：所有学生的所有数据均需分行输入，即：
* 每个学生均有 5 行输入，自上而下分别为学号、姓名、三门课程成绩，
* 其中，学号和姓名不能包含空格
* 形式参数：struct student型指针，p 指向结构体数组首地址
* 形式参数：int型，rows 为结构体数组元素个数
* 返 回 值：无
*/
void input(struct student* p, int rows) {
int i, j;
for (i = 0; i < rows; i++) {
// printf("\nInput the information of student %d:\n", (i + 1));
//输入学号
// printf("sno:\t");
scanf("%s", (p + i)->sno);
// gets((p + i) -> sno);
// fgets((p + i) -> sno, SNO_LENGTH, stdin);
fflush(stdin);
//输入姓名
// printf("name:\t");
scanf("%s", (p + i)->name);
// gets((p + i) -> name);
// fgets((p + i) -> name, NAME_LENGTH, stdin);
fflush(stdin);
//输入三门课程成绩，并求和
float sum = 0;
for (j = 0; j < COURSE_NUMBER; j++) {
// printf("score%d:\t", j + 1);
scanf("%d", &((p + i)->score[j]));
fflush(stdin);
sum += (p + i)->score[j];
}
//计算平均成绩
(p + i)->average = sum / COURSE_NUMBER;
}
}
/*
* 函数名称：output
* 函数功能：将形参 p 所指向的结构体数组输出到屏幕
* 输出格式：所有同学的信息均需分行输出，即：每行只输出一个同学的所有数据，
* 从左至右分别为学号、姓名、三门课程成绩和平均成绩，
* 其中，平均成绩保留小数点后两位
* 形式参数：struct student型指针，p 指向结构体数组首地址
* 形式参数：int型，rows 为结构体数组元素个数
* 返 回 值：无
*/
void output(STU* p, int rows) {
int i, j;
// printf("\nThe students'information is as follows:");
for (i = 0; i < rows; i++) {
printf("%s,", (p + i)->sno);
// puts((p + i) -> sno);
fflush(stdout);
printf("%s,", (p + i)->name);
// puts((p + i) -> name);
fflush(stdout);
for (j = 0; j < COURSE_NUMBER; j++) {
printf("%d,", (p + i)->score[j]);
fflush(stdout);
}
printf("%.2f\n", (p + i)->average);
}
}
/*
* 函数名称：writeFile
* 函数功能：将指针 p 所指向的数组的所有元素值写入到二进制文件中
* 形式参数：struct student型指针，p 指向结构体数组的首地址
* 形式参数：int型，rows 为结构体数组长度
* 形式参数：一维字符数组，filename 为二进制文件路径及名称
* 形式参数：一维字符数组，mode 为文件打开模式
* 返 回 值：int型，若打开文件失败，返回
* -1；否则，返回成功写入到文件的数据块个数
*/
int writeFile(STU* p, int rows, char filename[], char mode[]) {
// 请编程实现本函数
FILE* fp;
fp = fopen(filename, mode);
if (!fp) {
return -1;
}
fwrite(p, sizeof(STU), rows, fp);
fclose(fp);
return rows;
}
/*
* 函数名称：readFile
* 函数功能：读取二进制文件并存储到指针p所指向的数组
* 形式参数：struct student型指针，p 指向结构体数组的首地址
* 形式参数：int型，rows 为结构体数组长度
* 形式参数：一维字符数组，filename 为二进制文件路径及名称
* 形式参数：一维字符数组，mode 为文件打开模式
* 返 回 值：int型，若打开文件失败，返回
* -1；否则，返回从文件成功读取的数据块个数
*/
int readFile(STU* p, int rows, char filename[], char mode[]) {
// 请编程实现本函数
FILE* fp;
fp = fopen(filename, mode);
if (!fp) {
return -1;
}
fread(p, sizeof(STU), rows, fp);
fclose(fp);
return rows;
}
验证与结论：
总结与心得体会：
本文链接：https://www.kjpai.cn/news/2024-04-29/163559.html，文章来源：网络cs，作者：欧阳逸，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！
下一篇：返回列表