厢副漠空嚏赦袍了锑朗犀惰礁
第1周——初识C语言从认识变量和常量开始
codeblocks介绍——从Hello World开始
1、单选题：
#include <stdio.h>是
A: 编译预处理指令
B: 语句
C: 函数
D: 程序入口
答案: 编译预处理指令
debug
1、单选题：
codeblocks中运行到下一步(next line)的快捷键是
A: F7
B: F5
C: F8
D: F11
答案: F7
变量在内存中所占的字节数
1、单选题：
Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）
A: 函数
B: 运算符
C: 标识符
D: 语句
答案: 运算符
宏常量与const常量
1、单选题：
宏定义是（）
A: 一条语句
B: 一种编译预处理指令
C: 一个标识符
D: 一个变量
答案: 一种编译预处理指令
2、判断题：
const常量有数据类型。
A: 正确
B: 错误
答案: 正确
第1周——海陆空齐上阵又来了一堆数据
共用体类型
1、单选题：
下列说法错误的是（）。
A: 编译器只为共用体中最大的成员分配足够的内存空间。共用体的成员在这个空间内是彼此覆盖的，都从同一起始地址开始存储。
B: 与结构体不同的是，共用体在内存中所占空间的字节数取决于占空间最多的那个成员变量。
C: 共用体变量在每一瞬时只能保存一个成员，起作用的成员是最后一次赋值的成员。
D: 共用体和结构体的成员访问方式以及成员的初始化方式都是一样的，都使用成员选择运算符访问成员变量，都可以在定义的时候对所有成员进行初始化。
答案: 共用体和结构体的成员访问方式以及成员的初始化方式都是一样的，都使用成员选择运算符访问成员变量，都可以在定义的时候对所有成员进行初始化。
关键字typedef
1、判断题：
关键字typedef主要用于定义一种新的数据类型。
A: 正确
B: 错误
答案: 错误
向函数传递结构体
1、单选题：
下列说法错误的是（）。
A: 用结构体变量做函数参数，是将整个结构体的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
B: 用结构体数组/结构体指针作函数参数的参数传递效率比用结构体变量做函数参数的参数传递效率要高。
C: 用结构体数组/结构体指针作函数参数，是复制结构体的首地址给被调函数，因此在被调函数中可以修改结构体指针所指向的结构体的内容。
D: 数组和结构体变量都不可以用做函数返回值的类型。
答案: 数组和结构体变量都不可以用做函数返回值的类型。
对结构体的操作
1、单选题：
下列说法错误的是（）。
A: 对结构体变量的成员的访问是通过名字并使用成员选择运算符来访问的。
B: 只能在相同类型的结构体变量之间进行赋值。
C: 可以使用==和!=来判定两个结构体相等或不等。
D: 对嵌套的结构体成员，必须以级联的方式来访问。
答案: 可以使用==和!=来判定两个结构体相等或不等。
枚举类型
1、单选题：
下列对枚举类型的使用的代码中错误的是（）。
A: enum {no, yes, none}answer;
if (answer == yes)
{
printf(“Yesn”);
}
B: enum response{no = -1, yes = 1, none = 0};
enum response answer;
C: answer = yes;
printf(“%d”, answer);
D: answer = “yes”;
printf(“%s”, answer);
答案: answer = “yes”;
printf(“%s”, answer);
2、判断题：
和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
A: 正确
B: 错误
答案: 正确
第1周测验
1、单选题：
设有以下说明语句,则下面的叙述中错误的是struct ex
{
int x ;
float y;
char z ;
} example;
A: example是结构体类型名
B: struct是结构体类型的关键字
C: x,y,z都是结构体成员名
D: ex为结构体标签。
答案: example是结构体类型名
2、单选题：
若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。struct
{
short a;
float b;
} v1;union
{
short a;
float b;
} v2;
A: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
B: 执行sizeof(v1)获得的结果是6个字节，只能对结构体变量v1中的第一个成员进行初始化。
C: 执行sizeof(v2)获得的结果是6个字节，只能对共用体变量v2中的第一个成员进行初始化。
D: 执行sizeof(v2)获得的结果是4个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
E: 执行sizeof(v2)获得的结果是8个字节，只能对共用体变量v2中的第一个成员进行初始化
F: 执行sizeof(v1)获得的结果是8个字节，只能对结构体变量v1中的第一个成员进行初始化。
G: 执行sizeof(v1)获得的结果是4个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
H: 执行sizeof(v2)获得的结果是6个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
答案: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
3、单选题：
以下正确的描述是
A: 结构体和共用体变量都不能进行比较操作。
B: 两个结构体变量可以比较，但不能将结构体类型作为函数返回值类型。
C: 既可以对两个共用体变量进行比较操作，也可以将共用体变量作为函数参数。
D: 关键字typedef用于定义一种新的数据类型。
E: 结构体和共用体变量都能进行比较操作。
F: 枚举类型和结构体、共用体一样，也是一种构造数据类型。
G: 不同结构体类型的成员名不能相同。
H: 和数组一样，即使是相同类型的结构体变量也不能整体赋值，只能逐个成员进行赋值。
答案: 结构体和共用体变量都不能进行比较操作。
4、单选题：
以下选项中不能正确把cl定义成结构体变量的是
A: struct color cl
{
int red;
int green;
int blue;
}
B: typedef struct
{
int red;
int green;
int blue;
} COLOR;
COLOR cl;
C: struct color
{
int red;
int green;
int blue;
} cl;
D: struct
{
int red;
int green;
int blue;
} cl;
答案: struct color cl
{
int red;
int green;
int blue;
}
5、单选题：
以下程序执行后的输出结果是#include <stdio.h>
struct STU
{
char name[10];
int num;
};
void Fun1(struct STU c)
{
struct STU b={“LiGuo”,2042};
c=b;
};
void Fun2(struct STU *c)
{
struct STU b={“SunDan”,2044};
*c=b;
};
int main()
{
struct STU a={“YangHan”,2041},b={“WangYi”,2043};
Fun1(a);
Fun2(&b);
printf(“%d %dn”,a.num,b.num);
return 0;
}
A: 2041 2044
B: 2041 2043
C: 2042 2044
D: 2042 2043
答案: 2041 2044
6、单选题：
下面说法错误的是
A: 在一个结构体内不能包含另一个不同类型的结构体作为其成员。
B: 用结构体变量做函数参数，是将结构体变量的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
C: 结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
D: 和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
E: 用指向结构体变量的指针做函数参数，是将结构体变量的地址传给被调函数，因此在被调函数中对结构体内容的修改会影响原结构体变量。
答案: 在一个结构体内不能包含另一个不同类型的结构体作为其成员。
7、单选题：
若能使程序运行后的输出结果如下：201501201502201503则空白处填写的表达式或语句应该是#include <stdio.h>
struct student
{
int age;
char num[8];
};
int main()
{
struct student stu[3]={{20,”201501″},{21,”201502″},{19,”201503″}};
struct student *p=stu;
____________________
return 0;
}
A: printf(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);
B: printf(“%sn”,(p++).num); printf(“%sn”,(p++).num); printf(“%sn”,(p++).num);
C: printf(“%sn”,(++p)->num); printf(“%sn”,(++p)->num); printf(“%sn”,(*p).num);
D: printf(“%sn”,stu[0]->num); printf(“%sn”,stu[1]->num); printf(“%sn”,stu[2]->num);
答案: printf(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);
8、单选题：
以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
typedef struct clock
{
int hour;
int minute;
int second;
}CLOCK;
/* 函数功能：时、分、秒时间的更新 */
void Update(________)
{
static long m = 1;
t->hour = m / 3600;
t->minute = __________________;
t->second = ___________;
m++;
if (t->hour == 24) m = 1;
}
/* 函数功能：时、分、秒时间的显示 */
void Display(CLOCK *t)
{
printf(“%2d:%2d:%2dr”, t->hour, t->minute, t->second);
}
/* 函数功能：模拟延迟1秒的时间 */
void Delay(void)
{
long t;
for (t=0; t<50000000; t++)
{
/* 循环体为空语句的循环，起延时作用 */
}
}
int main()
{
long i;
CLOCK myclock;
myclock.hour = myclock.minute = myclock.second = 0;
for (i=0; i<100000; i++) /* 利用循环，控制时钟运行的时间 */
{
Update(&myclock); /* 时钟值更新 */
Display(__________); /* 时间显示 */
Delay(); /* 模拟延时1秒 */
}
return 0;
}
A: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock
B: 第10行： CLOCK *t第14行： (m – 3600 * hour) / 60第15行： m / 60第44行： &myclock
C: 第10行： CLOCK t第14行： (m – 3600 * t->hour) / 60第15行： m / 60第44行： myclock
D: 第10行： CLOCK t第14行： (m – 3600 * hour) / 60第15行： m % 60第44行： myclock
答案: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock
9、单选题：
有以下说明和定义语句，下面各输入语句中错误的是#include <stdio.h>
int main()
{
struct student
{
int age;
char sex;
char name[8];
};
struct student std;
struct student *p=&std;
…….
return 0;
}
A: scanf(“%c”,&std[0].sex);
B: scanf(“%d”,&(*p).age);
C: scanf(“%s”,std.name);
D: scanf(“%c”,&(p->sex));
答案: scanf(“%c”,&std[0].sex);
10、单选题：
以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
struct stu
{
char num[10];
float score[3];
};
int main()
{
struct stu s[3]={{“20021”,90,95,85},{“20022”,95,80,75},{“20023”,100,95,90}},*p=s;
int i,j;
float sum;
__________
return 0;
}
A: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
p++;
}
B: sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
C: sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
p++;
}
printf(“%6.2fn”,sum);
D: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
p++;
}
printf(“%6.2fn”,sum);
}
答案: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
p++;
}
11、单选题：
某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是
A: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
B: struct student
{
int number;
char name[20];
char sex;
int year;
int month;
int day;
} s;
year = 1984;
month = 11;
day = 11;
C: struct student
{
int number;
char name[20];
char sex;
} s;
struct
{
int year;
int month;
int day;
} birth;
birth.year = 1984;
birth.month = 11;
birth.day = 11;
D: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.year = 1984;
s.month = 11;
s.day = 11;
答案: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
12、单选题：
下面程序的输出结果是#include <stdio.h>
int main()
{
union
{
int i[2];
int k;
int c;
}t,*s = &t;
s->i[0] = 10;
s->i[1] = 20;
s->k=30;
printf(“%dn”, s->k);
printf(“%dn”, s->i[0]);
printf(“%dn”, s->c);
return 0;
}
A: 303030
B: 102030
C: 3010随机数
D: 301020
答案: 303030
13、单选题：
设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。
A: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
B: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
……
return 0;
}
C: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
……
return 0;
}
D: #include <stdio.h>
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
…..
return 0;
}
E: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
union professionalState /* 定义职业共用体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
union professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
答案: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
14、单选题：
下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <string.h>
#define NUM_ELECTORATE 10
#define NUM_CANDIDATE 3
struct candidate
{
char name[20];
int count;
}candidate[3] = {“li”,0, “zhang”,0, “wang”,0};
int main()
{
int i, j, flag = 1, wrong = 0;
char name[20];
for (i=1; i<=NUM_ELECTORATE; i++)
{
printf(“Input vote %d:”, i);
scanf(“%s”, name);
strlwr(name); /* C语言的标准库函数，功能是将name中的字符全部变成小写字母 */
flag = 1;
for (j=0; j<NUM_CANDIDATE; j++)
{
if (_________________)
{
_____________;
flag = 0;
}
}
if (flag)
{
wrong++; /* 废票计数 */
________;
}
}
printf(“Election results:n”);
for (i=0; i<NUM_CANDIDATE; i++)
{
printf(“%s:%dn”, ____________________);
}
printf(“Wrong election:%dn”, wrong);
return 0;
}
A: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count
B: 第24行： name == candidate[j].name第26行： count++第34行： flag = 0第41行： name, count
C: 第24行： name = candidate[j].name第26行： count++第34行： flag = 1第41行： candidate[i].name[i], candidate[i].count
D: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 1第41行： name, count
答案: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count
练兵区——单选题——不计入总分
1、单选题：
设有以下说明语句，则下面的叙述中错误的是struct ex
{
int x ;
float y;
char z ;
} example;
A: example是结构体类型名
B: struct是结构体类型的关键字
C: x,y,z都是结构体成员名
D: ex为结构体标签。
答案: example是结构体类型名
2、单选题：
以下正确的描述是
A: 结构体和共用体变量都不能进行比较操作。
B: 两个结构体变量可以比较，但不能将结构体类型作为函数返回值类型。
C: 既可以对两个共用体变量进行比较操作，也可以将共用体变量作为函数参数。
D: 关键字typedef用于定义一种新的数据类型。
E: 结构体和共用体变量都能进行比较操作。
F: 枚举类型和结构体、共用体一样，也是一种构造数据类型。
G: 不同结构体类型的成员名不能相同。
H: 和数组一样，即使是相同类型的结构体变量也不能整体赋值，只能逐个成员进行赋值。
答案: 结构体和共用体变量都不能进行比较操作。
3、单选题：
以下程序执行后的输出结果是#include <stdio.h>
struct STU
{
char name[10];
int num;
};
void Fun1(struct STU c)
{
struct STU b={“LiGuo”,2042};
c=b;
};
void Fun2(struct STU *c)
{
struct STU b={“SunDan”,2044};
*c=b;
};
int main()
{
struct STU a={“YangHan”,2041},b={“WangYi”,2043};
Fun1(a);
Fun2(&b);
printf(“%d %dn”,a.num,b.num);
return 0;
}
A: 2041 2044
B: 2041 2043
C: 2042 2044
D: 2042 2043
答案: 2041 2044
4、单选题：
以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
struct stu
{
char num[10];
float score[3];
};
int main()
{
struct stu s[3]={{“20021”,90,95,85},{“20022”,95,80,75},{“20023”,100,95,90}},*p=s;
int i,j;
float sum;
__________
return 0;
}
A: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
p++;
}
B: sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
C: sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
p++;
}
printf(“%6.2fn”,sum)
D: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
p++;
}
printf(“%6.2fn”,sum);
}
答案: for (j=0;j<3;j++)
{
sum=0;
for(i=0;i<3;i++)
{
sum=sum+p->score[i];
}
printf(“%6.2fn”,sum);
p++;
}
5、单选题：
某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是
A: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
B: struct student
{
int number;
char name[20];
char sex;
int year;
int month;
int day;
} s;
year = 1984;
month = 11;
day = 11;
C: struct student
{
int number;
char name[20];
char sex;
} s;
struct
{
int year;
int month;
int day;
} birth;
birth.year = 1984;
birth.month = 11;
birth.day = 11;
D: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.year = 1984;
s.month = 11;
s.day = 11;
答案: struct student
{
int number;
char name[20];
char sex;
struct
{
int year;
int month;
int day;
} birth;
} s;
s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
6、单选题：
若能使程序运行后的输出结果如下：201501201502201503则空白处填写的表达式或语句应该是#include <stdio.h>
struct student
{
int age;
char num[8];
};
int main()
{
struct student stu[3]={{20,”201501″},{21,”201502″},{19,”201503″}};
struct student *p=stu;
____________________
return 0;
}
A: printf(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);
B: printf(“%sn”,(p++).num); printf(“%sn”,(p++).num); printf(“%sn”,(p++).num);
C: printf(“%sn”,(++p)->num); printf(“%sn”,(++p)->num); printf(“%sn”,(*p).num);
D: printf(“%sn”,stu[0]->num); printf(“%sn”,stu[1]->num); printf(“%sn”,stu[2]->num);
答案: printf(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);
7、单选题：
以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
typedef struct clock
{
int hour;
int minute;
int second;
}CLOCK;
/* 函数功能：时、分、秒时间的更新 */
void Update(________)
{
static long m = 1;
t->hour = m / 3600;
t->minute = __________________;
t->second = ___________;
m++;
if (t->hour == 24) m = 1;
}
/* 函数功能：时、分、秒时间的显示 */
void Display(CLOCK *t)
{
printf(“%2d:%2d:%2dr”, t->hour, t->minute, t->second);
}
/* 函数功能：模拟延迟1秒的时间 */
void Delay(void)
{
long t;
for (t=0; t<50000000; t++)
{
/* 循环体为空语句的循环，起延时作用 */
}
}
int main()
{
long i;
CLOCK myclock;
myclock.hour = myclock.minute = myclock.second = 0;
for (i=0; i<100000; i++) /* 利用循环，控制时钟运行的时间 */
{
Update(&myclock); /* 时钟值更新 */
Display(__________); /* 时间显示 */
Delay(); /* 模拟延时1秒 */
}
return 0;
}
A: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock
B: 第10行： CLOCK *t第14行： (m – 3600 * hour) / 60第15行： m / 60第44行： &myclock
C: 第10行： CLOCK t第14行： (m – 3600 * t->hour) / 60第15行： m / 60第44行： myclock
D: 第10行： CLOCK t第14行： (m – 3600 * hour) / 60第15行： m % 60第44行： myclock
答案: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock
8、单选题：
下面程序的输出结果是#include <stdio.h>
int main()
{
union
{
int i[2];
int k;
int c;
}t,*s = &t;
s->i[0] = 10;
s->i[1] = 20;
s->k=30;
printf(“%dn”, s->k);
printf(“%dn”, s->i[0]);
printf(“%dn”, s->c);
return 0;
}
A: 303030
B: 102030
C: 3010随机数
D: 301020
答案: 303030
9、单选题：
设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。
A: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
B: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
……
return 0;
}
C: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
……
return 0;
}
D: #include <stdio.h>
int main()
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
…..
return 0;
}
E: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
union professionalState /* 定义职业共用体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
union professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
答案: #include <stdio.h>
struct date /* 定义日期结构体类型 */
{
int year; /* 年 */
int month; /* 月 */
int day; /* 日 */
};
struct professionalState /* 定义职业结构体类型 */
{
char college[80]; /* 所在学院*/
char professionalTitle[20]; /* 职称 */
char duty[20]; /* 职务 */
};
struct person /* 定义职工个人信息结构体类型 */
{
char name[20]; /* 姓名 */
char sex; /* 性别 */
struct date birthday; /* 出生日期 */
struct professionalState occupation; /* 职业状况 */
};
int main()
{
……
return 0;
}
10、单选题：
下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <string.h>
#define NUM_ELECTORATE 10
#define NUM_CANDIDATE 3
struct candidate
{
char name[20];
int count;
}candidate[3] = {“li”,0, “zhang”,0, “wang”,0};
int main()
{
int i, j, flag = 1, wrong = 0;
char name[20];
for (i=1; i<=NUM_ELECTORATE; i++)
{
printf(“Input vote %d:”, i);
scanf(“%s”, name);
strlwr(name); /* C语言的标准库函数，功能是将name中的字符全部变成小写字母 */
flag = 1;
for (j=0; j<NUM_CANDIDATE; j++)
{
if (_________________)
{
_____________;
flag = 0;
}
}
if (flag)
{
wrong++; /* 废票计数 */
________;
}
}
printf(“Election results:n”);
for (i=0; i<NUM_CANDIDATE; i++)
{
printf(“%s:%dn”, ____________________);
}
printf(“Wrong election:%dn”, wrong);
return 0;
}
A: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count
B: 第24行： name == candidate[j].name第26行： count++第34行： flag = 0第41行： name, count
C: 第24行： name = candidate[j].name第26行： count++第34行： flag = 1第41行： candidate[i].name[i], candidate[i].count
D: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 1第41行： name, count
答案: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count
11、单选题：
下面说法错误的是
A: 在一个结构体内不能包含另一个不同类型的结构体作为其成员。
B: 用结构体变量做函数参数，是将结构体变量的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
C: 结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
D: 和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
E: 用指向结构体变量的指针做函数参数，是将结构体变量的地址传给被调函数，因此在被调函数中对结构体内容的修改会影响原结构体变量。
答案: 在一个结构体内不能包含另一个不同类型的结构体作为其成员。
12、单选题：
有以下说明和定义语句，下面各输入语句中错误的是#include <stdio.h>
int main()
{
struct student
{
int age;
char sex;
char name[8];
};
struct student std;
struct student *p=&std;
…….
return 0;
}
A: scanf(“%c”,&std[0].sex);
B: scanf(“%d”,&(*p).age);
C: scanf(“%s”,std.name);
D: scanf(“%c”,&(p->sex));
答案: scanf(“%c”,&std[0].sex);
13、单选题：
若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。struct
{
short a;
float b;
} v1;union
{
short a;
float b;
} v2;
A: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
B: 执行sizeof(v1)获得的结果是6个字节，只能对结构体变量v1中的第一个成员进行初始化。
C: 执行sizeof(v2)获得的结果是6个字节，只能对共用体变量v2中的第一个成员进行初始化。
D: 执行sizeof(v2)获得的结果是4个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
E: 执行sizeof(v2)获得的结果是8个字节，只能对共用体变量v2中的第一个成员进行初始化
F: 执行sizeof(v1)获得的结果是8个字节，只能对结构体变量v1中的第一个成员进行初始化。
G: 执行sizeof(v1)获得的结果是4个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
H: 执行sizeof(v2)获得的结果是6个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
答案: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
14、单选题：
以下选项中不能正确把cl定义成结构体变量的是
A: struct color cl
{
int red;
int green;
int blue;
}
B: typedef struct
{
int red;
int green;
int blue;
} COLOR;
COLOR cl;
C: struct color
{
int red;
int green;
int blue;
} cl;
D: struct
{
int red;
int green;
int blue;
} cl;
答案: struct color cl
{
int red;
int green;
int blue;
}
结构体变量的定义
1、单选题：
下面哪条语句是正确的。
A: typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
B: typedef struct STUDENT
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
};
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
C: struct
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
};
struct stu1;
D: struct student{ long studentID; char studentName[10]; char studentSex; int yearOfBirth; int score[4]; }STUDENT;STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
答案: typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
结构体变量的访问
1、单选题：
已知：typedef struct date
{
int year;
int month;
int day;
}DATE;
typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
DATE birthday;
int score[4];
}STUDENT;
STUDENT stu1;
STUDENT *pt = &stu1;则下列访问结构体变量的方法中，哪个是错误的。
A: stu1. birthday. year = 1999;
B: (*pt). birthday. year = 1999;
C: pt -> birthday -> year = 1999;
D: pt -> birthday. year = 1999;
答案: pt -> birthday -> year = 1999;
结构体的嵌套
1、判断题：
在一个结构体内可以包含另一个不同类型的结构体作为其成员。
A: 正确
B: 错误
答案: 正确
结构体类型所占内存的字节数
1、单选题：
下列说法错误的是（）。
A: 结构体类型所占内存的字节数就是结构体的每个成员类型所占内存字节数的总和。
B: 结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
C: 计算结构体所占内存的字节数时，一定要使用sizeof运算符。
D: 内存对齐的主要目的就是为了提高内存的寻址效率。不同的系统和编译器，内存对齐方式可能会不同，是机器相关的。
答案: 结构体类型所占内存的字节数就是结构体的每个成员类型所占内存字节数的总和。
第2周——原来内存也可以这么玩，我是指针我怕谁
指针和内存
1、判断题：
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
A: 正确
B: 错误
答案: 错误
2、判断题：
用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
A: 正确
B: 错误
答案: 错误
第2周测验
1、单选题：
下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p,n,i;
printf(“Enter array size:”);
scanf(“%d”,&n);
__________________;
for(i=0;i<n;i++)
{
____________;
}
for(i=0;i<n;i++)
{
_______________;
}
free(p);
return 0;
}
A: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
B: 第8行： p=(int *)(n*malloc(sizeof(int*)))第12行： *p+i=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
C: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *p+i=i*10第16行： printf(“array[i]=%dn”,i,*p+i)
D: 第8行： p=(int)malloc(n*sizeof(int *));第12行： *(p+i)=i*10第16行： printf(“array[i]=%dn”,i,*(p+i))
答案: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
2、单选题：
下列说法正确的是
A: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
B: 函数free()的参数是指向被释放的动态内存的指针变量。
C: 对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
D: 函数free的函数原型是void* free(void* p);表示函数没有返回值。
E: 程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
F: 执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
G: 用动态内存分配函数来申请的内存都是从栈上分配的。
H: 栈的特点是先进先出。
I: 用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
答案: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。;
函数free()的参数是指向被释放的动态内存的指针变量。;
对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
3、单选题：
申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(n * sizeof(int));
B: p = (int *)calloc(n, sizeof(int));
C: p = (int *) malloc(n, sizeof(int));
D: p = (int *)calloc(n * sizeof(int));
E: int p[n];
F: p = (int *) realloc(n * sizeof(int));
答案: p = (int *) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int));
4、单选题：
假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。p = (int *) malloc(m*n*sizeof(int));或者p = (int *) calloc(m*n, sizeof(int));
A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）
5、单选题：
下列说法错误的是
A: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
B: 用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
C: 在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
D: 对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
E: 对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
F: 用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
G: 计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
H: 为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。
答案: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。;
用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。;
在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
6、单选题：
下列说法错误的是
A: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B: 函数realloc()用于改变原来分配的存储空间的大小。
C: 对于函数void * calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D: 向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E: 函数void * calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F: void*型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type*)为其他类型。
G: 用calloc动态申请的内存会自动初始化为0.
答案: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
7、单选题：
下面关于内存泄漏问题的描述错误的是（）
A: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
B: 内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
C: 指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
D: 出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
E: 内存泄漏问题通常需要运行相当一段时间后才能发现。
F: C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
G: 需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。
答案: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。;
内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。;
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
8、单选题：
关于下面程序中的变量和常量分布的内存区域说法错误的是#include <stdio.h>
#include <stdlib.h >
static char array2[] = {“dddd”};
char array3[100];
int main()
{
short b;
char array1[]=”aaaa”;
char *p;
p = (char *)malloc(10*sizeof(int));
strcpy(p,”bbbb”);
free(p);
return 0;
}
A: 指针变量p存放在堆中
B: “bbbb”存放在栈中
C: array3数组存放在静态存储区
D: 本题中指针变量p指向的内存空间在堆中
E: “bbbb”存放在常量区
F: array2存放在静态存储区
答案: 指针变量p存放在堆中;
“bbbb”存放在栈中
9、单选题：
对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
A: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B: void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C: void *的含义是指该函数没有返回值
D: 以上说法都不对
答案: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
10、单选题：
下面说法错误的是
A: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
B: 如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
C: 动态内存分配是指在程序运行时为变量分配内存的一种方法。
D: 栈和堆都属于动态存储区。
答案: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
11、单选题：
下面程序希望得到的运行结果如下：Total string numbers = 3How are you目前程序存在错误，请找出错误所在并加以改正。#include <stdio.h>
void Print(char *arr[], int len);
int main()
{
char *pArray[] = {“How”,”are”,”you”};
int num = sizeof(pArray) / sizeof(char);
printf(“Total string numbers = %dn”, num);
Print(pArray, num);
return 0;
}
void Print(char *arr[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf(“%s “, arr[i]);
}
printf(“n”);
}
A: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
B: 第6行错误改正为：int num = sizeof(char*) / sizeof(pArray);
C: 第12行错误改正为：char arr[]
D: 第5行错误改正为：char *pArray = {“How”,”are”,”you”}
答案: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
12、单选题：
申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(m*n*sizeof(int));
B: p = (int *)calloc(m*n, sizeof(int));
C: p = (int *) malloc(m*n, sizeof(int));
D: p = (int *)calloc(m * n * sizeof(int));
E: int p[m][n];
F: p = (int *) realloc(m * n * sizeof(int));
答案: p = (int *) malloc(m*n*sizeof(int)); ;
p = (int *)calloc(m*n, sizeof(int));
练兵区——单选题——不计入总分
1、单选题：
假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。p = (int *) malloc(m*n*sizeof(int));或者p = (int *) calloc(m*n, sizeof(int));
A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）
2、单选题：
下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p,n,i;
printf(“Enter array size:”);
scanf(“%d”,&n);
__________________;
for(i=0;i<n;i++)
{
____________;
}
for(i=0;i<n;i++)
{
_______________;
}
free(p);
return 0;
}
A: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
B: 第8行： p=(int *)(n*malloc(sizeof(int*)))第12行： *p+i=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
C: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *p+i=i*10第16行： printf(“array[i]=%dn”,i,*p+i)
D: 第8行： p=(int)malloc(n*sizeof(int *));第12行： *(p+i)=i*10第16行： printf(“array[i]=%dn”,i,*(p+i))
答案: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
3、单选题：
下列说法正确的是
A: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
B: 函数free()的参数是指向被释放的动态内存的指针变量。
C: 对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
D: 函数free的函数原型是void* free(void* p);表示函数没有返回值。
E: 程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
F: 执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
G: 用动态内存分配函数来申请的内存都是从栈上分配的。
H: 栈的特点是先进先出。
I: 用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
答案: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。;
函数free()的参数是指向被释放的动态内存的指针变量。;
对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
4、单选题：
对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
A: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B: void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C: void *的含义是指该函数没有返回值
D: 以上说法都不对
答案: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
5、单选题：
下列说法错误的是
A: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
B: 用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
C: 在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
D: 对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
E: 对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
F: 用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
G: 计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
H: 为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。
答案: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。;
用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。;
在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
6、单选题：
下列说法错误的是
A: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B: 函数realloc()用于改变原来分配的存储空间的大小。
C: 对于函数void * calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D: 向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E: 函数void * calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F: void*型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type*)为其他类型。
G: 用calloc动态申请的内存会自动初始化为0.
答案: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
7、单选题：
下面关于内存泄漏问题的描述错误的是（）
A: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
B: 内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
C: 指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
D: 出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
E: 内存泄漏问题通常需要运行相当一段时间后才能发现。
F: C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
G: 需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。
答案: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。;
内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。;
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
8、单选题：
下面程序希望得到的运行结果如下：Total string numbers = 3How are you目前程序存在错误，请找出错误所在并加以改正。#include <stdio.h>
void Print(char *arr[], int len);
int main()
{
char *pArray[] = {“How”,”are”,”you”};
int num = sizeof(pArray) / sizeof(char);
printf(“Total string numbers = %dn”, num);
Print(pArray, num);
return 0;
}
void Print(char *arr[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf(“%s “, arr[i]);
}
printf(“n”);
}
A: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
B: 第6行错误改正为：int num = sizeof(char*) / sizeof(pArray);
C: 第12行错误改正为：char arr[]
D: 第5行错误改正为：char *pArray = {“How”,”are”,”you”}
答案: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
9、单选题：
申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(n * sizeof(int));
B: p = (int *)calloc(n, sizeof(int));
C: p = (int *) malloc(n, sizeof(int));
D: p = (int *)calloc(n * sizeof(int));
E: int p[n];
F: p = (int *) realloc(n * sizeof(int));
答案: p = (int *) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int));
10、单选题：
关于下面程序中的变量和常量分布的内存区域说法错误的是#include <stdio.h>
#include <stdlib.h >
static char array2[] = {“dddd”};
char array3[100];
int main()
{
short b;
char array1[]=”aaaa”;
char *p;
p = (char *)malloc(10*sizeof(int));
strcpy(p,”bbbb”);
free(p);
return 0;
}
A: 指针变量p存放在堆中
B: “bbbb”存放在栈中
C: array3数组存放在静态存储区
D: 本题中指针变量p指向的内存空间在堆中
E: “bbbb”存放在常量区
F: array2存放在静态存储区
答案: 指针变量p存放在堆中;
“bbbb”存放在栈中
11、单选题：
下面说法错误的是
A: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
B: 如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
C: 动态内存分配是指在程序运行时为变量分配内存的一种方法。
D: 栈和堆都属于动态存储区。
答案: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
12、单选题：
申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(m*n*sizeof(int));
B: p = (int *)calloc(m*n, sizeof(int));
C: p = (int *) malloc(m*n, sizeof(int));
D: p = (int *)calloc(m * n * sizeof(int));
E: int p[m][n];
F: p = (int *) realloc(m * n * sizeof(int));
答案: p = (int *) malloc(m*n*sizeof(int)); ;
p = (int *)calloc(m*n, sizeof(int));
第3周——结构设计的艺术
第3周测验
1、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p, *pr, *head;
若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是
A: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
B: p = head;
pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
C: pr = head;
while(pr!=p)
{
pr = pr->next;
}
D: p = head;
while(p->next!=pr)
{
p = p->next;
}
答案: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
2、单选题：
若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是
A: p = p->next; q->next = p; p->next = q;
B: q->next = NULL; p = p->next; p->next = q;
C: p = p->next; q->next = p->next; p->next = q;
D: p = (*p).next; (*q).next = (*p).next; (*p).next = q;
答案: p = p->next; q->next = p; p->next = q;
3、单选题：
下列叙述中正确的是
A: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
B: 对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
C: 线性链表的长度是固定的，在访问之前就已经确定下来。
D: 构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
E: 线性链表的数据域一般只包含一个成员数据，如data。
F: 作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。
答案: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。;
对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
4、单选题：
下面属于动态数据结构的是
A: 链表
B: 栈
C: 结构体数组
D: 指针数组
E: 字符数组
答案: 链表;
栈
5、单选题：
以下程序执行后的输出结果是#include <stdio.h>
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};
int main( )
{
struct NODE *p,*q,*r;
int sum=0;
p=(struct NODE *)malloc(sizeof(struct NODE));
q=(struct NODE *)malloc(sizeof(struct NODE));
r=(struct NODE *)malloc(sizeof(struct NODE));
p->num=1;
q->num=2;
r->num=3;
p->next=q;
q->next=r;
r->next=NULL;
sum+=q->next->num;
sum+=p->num;
printf(“%dn”,sum);
return 0;
}
A: 4
B: 3
C: 5
D: 6
答案: 4
6、单选题：
向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：struct node{ int data; struct node *next;}*p, *pr, *head;则操作正确的是
A: p->next = pr->next;pr->next = p;
B: struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
C: pr->next = p;
D: p->next = pr->next;pr = p;
E: pr->next = p;p->next = pr->next;
答案: p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
7、单选题：
关于单向链表说法错误的是
A: 单向链表在内存中是连续存储的
B: 结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
C: 存储空间可以动态的获取和释放
D: 与数据相比，单向链表适合反复进行删除、插入操作
答案: 单向链表在内存中是连续存储的
8、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p，*q;
则下面语句序列的功能是
while(p->next->next != NULL)
{
p = p->next;
}
free(p->next);
p->next = NULL;
A: 删除链表的尾结点
B: 删除p结点
C: 删除结点q
D: 删除p的前驱结点
答案: 删除链表的尾结点
9、单选题：
有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是
struct node
{
int data;
struct node *next;
}*p, *q, *r;
A: r->next=q; q->next=r->next; p->next=r;
B: q->next=r->next; p->next=r; r->next=q;
C: p->next=r; q->next=r->next; r->next=q;
D: q->next=r->next; r->next=q; p->next=r;
答案: r->next=q; q->next=r->next; p->next=r;
10、单选题：
已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p;
若要删除头结点，则下面正确的语句序列是
A: p = head;head = p->next;free(p);
B: head = head->next;free(head);
C: p = head->next;free(p);
D: head = head->next;p = head;free(p);
答案: p = head;head = p->next;free(p);
练兵区——单选题
1、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p，*q;
则下面语句序列的功能是
while(p->next->next != NULL)
{
p = p->next;
}
free(p->next);
p->next = NULL;
A: 删除链表的尾结点
B: 删除p结点
C: 删除结点q
D: 删除p的前驱结点
答案: 删除链表的尾结点
2、单选题：
已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p;
若要删除头结点，则下面正确的语句序列是
A: p = head;head = p->next;free(p);
B: head = head->next;free(head);
C: p = head->next;free(p);
D: head = head->next;p = head;free(p);
答案: p = head;head = p->next;free(p);
3、单选题：
若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是
A: p = p->next; q->next = p; p->next = q;
B: q->next = NULL; p = p->next; p->next = q;
C: p = p->next; q->next = p->next; p->next = q;
D: p = (*p).next; (*q).next = (*p).next; (*p).next = q;
答案: p = p->next; q->next = p; p->next = q;
4、单选题：
以下程序执行后的输出结果是#include <stdio.h>
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};
int main( )
{
struct NODE *p,*q,*r;
int sum=0;
p=(struct NODE *)malloc(sizeof(struct NODE));
q=(struct NODE *)malloc(sizeof(struct NODE));
r=(struct NODE *)malloc(sizeof(struct NODE));
p->num=1;
q->num=2;
r->num=3;
p->next=q;
q->next=r;
r->next=NULL;
sum+=q->next->num;
sum+=p->num;
printf(“%dn”,sum);
return 0;
}
A: 4
B: 3
C: 5
D: 6
答案: 4
5、单选题：
有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是
struct node
{
int data;
struct node *next;
}*p, *q, *r;
A: r->next=q; q->next=r->next; p->next=r;
B: q->next=r->next; p->next=r; r->next=q;
C: p->next=r; q->next=r->next; r->next=q;
D: q->next=r->next; r->next=q; p->next=r;
答案: r->next=q; q->next=r->next; p->next=r;
6、单选题：
下面属于动态数据结构的是
A: 链表
B: 栈
C: 结构体数组
D: 指针数组
E: 字符数组
答案: 链表;
栈
7、单选题：
向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：struct node{ int data; struct node *next;}*p, *pr, *head;则操作正确的是
A: p->next = pr->next;pr->next = p;
B: struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
C: pr->next = p;
D: p->next = pr->next;pr = p;
E: pr->next = p;p->next = pr->next;
答案: p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
8、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p, *pr, *head;
若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是
A: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
B: p = head;
pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
C: pr = head;
while(pr!=p)
{
pr = pr->next;
}
D: p = head;
while(p->next!=pr)
{
p = p->next;
}
答案: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
9、单选题：
下列叙述中正确的是
A: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
B: 对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
C: 线性链表的长度是固定的，在访问之前就已经确定下来。
D: 构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
E: 线性链表的数据域一般只包含一个成员数据，如data。
F: 作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。
答案: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。;
对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
10、单选题：
关于单向链表说法错误的是
A: 单向链表在内存中是连续存储的
B: 结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
C: 存储空间可以动态的获取和释放
D: 与数据相比，单向链表适合反复进行删除、插入操作
答案: 单向链表在内存中是连续存储的
第4周——学会保存你的数据
fgets()与fputs()
1、判断题：
fgets()与gets()的不同点是，gets()从指定的流读字符串，读到换行符时将换行符替换为”，读入的字符串中不会保留’n’，而fgets()从指定的流读字符串，读到换行符时不替换为”，读入的字符串中会保留’n’，在’n’的后面会再添加一个”。
A: 正确
B: 错误
答案: 正确
2、判断题：
fputs()是向任意流写数据，puts()是向标准输出流写数据，二者在写数据时的不同之处是，puts()会在写入的字符串末尾自动添加换行符，而fputs()不会在写入的字符串末尾自动添加换行符，除非字符串本身含有换行符。
A: 正确
B: 错误
答案: 正确
函数fgetc()和feof()
1、判断题：
函数fgetc()的功能是从fp所指的文件中读取一个字符，并将位置指针指向下一个字符。若读取成功，则返回该字符，若读到文件末尾或者读取出错，则返回EOF。EOF是一个符号常量，通常在stdio.h中定义为-1。
A: 正确
B: 错误
答案: 正确
2、判断题：
函数feof()的功能是检查是否到达文件尾，只要读完最后一个字符、文件位置指针指向文件尾时（EOF）时，就会返回非0值，否则返回0值。
A: 正确
B: 错误
答案: 错误
第4周测验
1、单选题：
若要以“a+”方式打开一个已存在的文件，则以下叙述正确的是
A: 文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
B: 文件打开时，原有文件内容不被删除，位置指针移动到文件开头，可做重写和读操作。
C: 文件打开时，原有文件内容被删除，只可做写操作。
D: 以上各种说法都不正确。
答案: 文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
2、单选题：
在C语言中，从计算机内存中将数据写入文件中，称为
A: 输出
B: 输入
C: 修改
D: 删除
答案: 输出
3、单选题：
下面的程序执行后，文件test中的内容是#include <stdio.h>
#include <string.h>
void Fun(char *fname,char *st)
{
FILE *myf; int i;
myf=fopen(fname,”w” );
if (myf == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
for(i=0;i<strlen(st); i++)
{
fputc(st[i],myf);
}
fclose(myf);
}
int main()
{
Fun(“test”,”new world”);
Fun(“test”,”hello”);
return 0;
}
A: hello
B: new worldhello
C: new world
D: hello rld
答案: hello
4、单选题：
阅读以下程序,对程序功能的描述中正确的是#icnlude <stdio.h>
int main()
{
FILE *in, *out;
char ch, infile[10], outfile[10];
printf(“Enter the infile name:n”);
scanf(“%s”, infile);
printf(“Enter the outfile name:n”);
scanf(“%s”, outfile);
if ((in = fopen(infile, “r”)) == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
if ((out = fopen(outfile, “w”)) == NULL)
{
printf(“cannot open outfile.n”);
exit(0);
}
while (!feof(in))
{
fputc(fgetc(in), out);
}
fclose(in);
fclose(out);
return 0;
}
A: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
B: 程序完成将磁盘文件的信息在屏幕上显示的功能。
C: 程序完成将两个磁盘文件合二为一的功能。
D: 程序完成将两个磁盘文件合并并在屏幕上输出的功能。
答案: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
5、单选题：
C语言中标准输入文件stdin是指
A: 键盘
B: 显示器
C: 鼠标
D: 硬盘
E: U盘
答案: 键盘
6、单选题：
设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是struct st
{
char name[8];
int num;
float s[4];
} student[50];
A: fwrite(student, 25 * sizeof(struct st), 1, fp);
B: fwrite(student, sizeof(struct st), 50, fp);
C: fwrite(student, 50 * sizeof(struct st), 1, fp);
D: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
答案: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
7、单选题：
若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
A: “wb+”
B: “ab+”
C: “rb+”
D: “ab”
答案: “wb+”
8、单选题：
以下叙述中错误的是
A: Ｃ语言中顺序读写方式不适用于二进制文件
B: Ｃ语言中的文本文件以ASCⅡ码形式存储数据
C: Ｃ语言中对二进制文件的访问速度比文本文件快
D: Ｃ语言中随机读写方式不适用于文本文件
答案: Ｃ语言中顺序读写方式不适用于二进制文件
9、单选题：
有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为#include <stdio.h>
int main()
{
FILE *fp1;
fp1=fopen(“f1.txt”,”w”);
if (fp1 == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
fprintf(fp1,”abc”);
fclose(fp1);
return 0;
}
A: abc
B: goodabc
C: good
D: abcgood
答案: abc
10、单选题：
以下程序执行后输出结果是#include <stdio.h>
int main()
{
FILE *fp;
int i,k=0,n=0;
fp=fopen(“d1.dat”,”w”);
if (fp == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
for(i=1;i<4;i++)
{
fprintf(fp,”%d”,i);
}
fclose(fp);
fp=fopen(“d1.dat”,”r”);
if (fp == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
fscanf(fp,”%d%d”,&k,&n);
printf(“%d %dn”,k,n);
fclose(fp);
return 0;
}
A: 123 0
B: 1 2
C: 1 23
D: 0 0
答案: 123 0
11、单选题：
关于文件读写，正确的叙述是
A: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。
B: 使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。
C: 使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。
D: 使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。
E: 以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。
F: 以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。
G: 文件打开后一定要检查是否打开成功。
H: 文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。
I: 以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。
J: 以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
K: 文件一旦按文本方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是文本，对应的内容都是字符‘1’。
L: 文件一旦按二进制方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是二进制文件，对应的内容都是数值1。
M: 用FILE只能定义指向文本文件的文件指针。
N: 用FILE只能定义指向二进制文件的文件指针。
O: C语言中的文件都是流式文件，只能按顺序读写，不能进行随机读写。
P: 文件的读写方式中w+和r+都是可读可写方式，二者是完全一样的。
答案: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。;
使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。;
使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。;
使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。;
以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。;
以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。;
文件打开后一定要检查是否打开成功。;
文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。;
以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。;
以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
12、单选题：
以下叙述中错误的是
A: 不可以用FILE定义指向二进制文件的文件指针。
B: 二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
C: 在程序结束时，应当用fclose()函数关闭已打开的文件。
D: 在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。
答案: 不可以用FILE定义指向二进制文件的文件指针。
13、单选题：
下列关于C语言数据文件的叙述中正确的是
A: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
B: 文件由ASCII码字符序列组成，C语言只能读写文本文件
C: 文件由二进制数据序列组成，C语言只能读写二进制文件
D: 文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
答案: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
14、单选题：
若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
A: 0
B: 1
C: -1
D: 一个非0值
答案: 0
15、单选题：
在进行文件操作时，写文件的一般含义是
A: 将计算机内存中的信息存入磁盘。
B: 将磁盘中的信息存入计算机内存。
C: 将计算机CPU中的信息存入磁盘。
D: 将磁盘中的信息存入计算机CPU。
答案: 将计算机内存中的信息存入磁盘。
16、单选题：
以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是#include <stdio.h>
int main()
{
FILE *fout; char ch;
fout=fopen(‘abc.txt’,’w’);
if (fout == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
ch=fgetc(stdin);
while(ch!=’#’)
{
fputc(ch,fout);
ch=fgetc(stdin);
}
fclose(fout);
return 0;
}
A: 函数fopen()调用形式错误
B: 输入文件没有关闭
C: 函数fgetc()调用形式错误
D: 文件指针stdin没有定义
答案: 函数fopen()调用形式错误
练兵区——单选题
1、单选题：
下面的程序执行后，文件test中的内容是#include <stdio.h>
#include <string.h>
void Fun(char *fname,char *st)
{
FILE *myf; int i;
myf=fopen(fname,”w” );
if (myf == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
for(i=0;i<strlen(st); i++)
{
fputc(st[i],myf);
}
fclose(myf);
}
int main()
{
Fun(“test”,”new world”);
Fun(“test”,”hello”);
return 0;
}
A: hello
B: new worldhello
C: new world
D: hello rld
答案: hello
2、单选题：
有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为#include <stdio.h>
int main()
{
FILE *fp1;
fp1=fopen(“f1.txt”,”w”);
if (fp1 == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
fprintf(fp1,”abc”);
fclose(fp1);
return 0;
}
A: abc
B: goodabc
C: good
D: abcgood
答案: abc
3、单选题：
下列关于C语言数据文件的叙述中正确的是
A: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
B: 文件由ASCII码字符序列组成，C语言只能读写文本文件
C: 文件由二进制数据序列组成，C语言只能读写二进制文件
D: 文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
答案: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
4、单选题：
以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是#include <stdio.h>
int main()
{
FILE *fout; char ch;
fout=fopen(‘abc.txt’,’w’);
if (fout == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
ch=fgetc(stdin);
while(ch!=’#’)
{
fputc(ch,fout);
ch=fgetc(stdin);
}
fclose(fout);
return 0;
}
A: 函数fopen()调用形式错误
B: 输入文件没有关闭
C: 函数fgetc()调用形式错误
D: 文件指针stdin没有定义
答案: 函数fopen()调用形式错误
5、单选题：
阅读以下程序,对程序功能的描述中正确的是#icnlude <stdio.h>
int main()
{
FILE *in, *out;
char ch, infile[10], outfile[10];
printf(“Enter the infile name:n”);
scanf(“%s”, infile);
printf(“Enter the outfile name:n”);
scanf(“%s”, outfile);
if ((in = fopen(infile, “r”)) == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
if ((out = fopen(outfile, “w”)) == NULL)
{
printf(“cannot open outfile.n”);
exit(0);
}
while (!feof(in))
{
fputc(fgetc(in), out);
}
fclose(in);
fclose(out);
return 0;
}
A: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
B: 程序完成将磁盘文件的信息在屏幕上显示的功能。
C: 程序完成将两个磁盘文件合二为一的功能。
D: 程序完成将两个磁盘文件合并并在屏幕上输出的功能。
答案: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
6、单选题：
设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是struct st
{
char name[8];
int num;
float s[4];
} student[50];
A: fwrite(student, 25 * sizeof(struct st), 2, fp);
B: fwrite(student, sizeof(struct st), 50, fp);
C: fwrite(student, 50 * sizeof(struct st), 1, fp);
D: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
答案: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
7、单选题：
C语言中标准输入文件stdin是指
A: 键盘
B: 显示器
C: 鼠标
D: 硬盘
E: U盘
答案: 键盘
8、单选题：
若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
A: “wb+”
B: “ab+”
C: “rb+”
D: “ab”
答案: “wb+”
9、单选题：
在进行文件操作时，写文件的一般含义是
A: 将计算机内存中的信息存入磁盘。
B: 将磁盘中的信息存入计算机内存。
C: 将计算机CPU中的信息存入磁盘。
D: 将磁盘中的信息存入计算机CPU。
答案: 将计算机内存中的信息存入磁盘。
10、单选题：
关于文件读写，正确的叙述是
A: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。
B: 使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。
C: 使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。
D: 使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。
E: 以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。
F: 以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。
G: 文件打开后一定要检查是否打开成功。
H: 文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。
I: 以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。
J: 以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
K: 文件一旦按文本方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是文本，对应的内容都是字符‘1’。
L: 文件一旦按二进制方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是二进制文件，对应的内容都是数值1。
M: 用FILE只能定义指向文本文件的文件指针。
N: 用FILE只能定义指向二进制文件的文件指针。
O: C语言中的文件都是流式文件，只能按顺序读写，不能进行随机读写。
P: 文件的读写方式中w+和r+都是可读可写方式，二者是完全一样的。
答案: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。;
使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。;
使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。;
使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。;
以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。;
以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。;
文件打开后一定要检查是否打开成功。;
文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。;
以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。;
以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
11、单选题：
若要以“a+”方式打开一个已存在的文件，则以下叙述正确的是
A: 文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
B: 文件打开时，原有文件内容不被删除，位置指针移动到文件开头，可做重写和读操作。
C: 文件打开时，原有文件内容被删除，只可做写操作。
D: 以上各种说法都不正确。
答案: 文件打开时，原有文件内容不被删除，位置指针移动到文件末尾，可做添加和读操作。
12、单选题：
在C语言中，从计算机内存中将数据写入文件中，称为
A: 输出
B: 输入
C: 修改
D: 删除
答案: 输出
13、单选题：
以下叙述中错误的是
A: Ｃ语言中顺序读写方式不适用于二进制文件
B: Ｃ语言中的文本文件以ASCⅡ码形式存储数据
C: Ｃ语言中对二进制文件的访问速度比文本文件快
D: Ｃ语言中随机读写方式不适用于文本文件
答案: Ｃ语言中顺序读写方式不适用于二进制文件
14、单选题：
以下程序执行后输出结果是#include <stdio.h>
int main()
{
FILE *fp;
int i,k=0,n=0;
fp=fopen(“d1.dat”,”w”);
if (fp == NULL)
{
printf(“cannot open the file.n”);
exit(0);
}
for(i=1;i<4;i++)
{
fprintf(fp,”%d”,i);
}
fclose(fp);
fp=fopen(“d1.dat”,”r”);
if (fp == NULL)
{
printf(“cannot open infile.n”);
exit(0);
}
fscanf(fp,”%d%d”,&k,&n);
printf(“%d %dn”,k,n);
fclose(fp);
return 0;
}
A: 123 0
B: 1 2
C: 1 23
D: 0 0
答案: 123 0
15、单选题：
以下叙述中错误的是
A: 不可以用FILE定义指向二进制文件的文件指针。
B: 二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
C: 在程序结束时，应当用fclose()函数关闭已打开的文件。
D: 在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。
答案: 不可以用FILE定义指向二进制文件的文件指针。
16、单选题：
若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
A: 0
B: 1
C: -1
D: 一个非0值
答案: 0
第5周——周而复始的循环之道
嵌套循环
1、单选题：
下列说法错误的是（ ）。
A: 执行嵌套循环时是先执行内层循环，后执行外层循环。
B: 嵌套循环的内层和外层循环的循环控制变量不能同名。
C: 嵌套循环的循环次数等于外层循环的循环次数与内层循环的循环次数之积。
D: 如果一个循环的循环体中又完整地包含了另一个循环，则称为嵌套循环。
答案: 执行嵌套循环时是先执行内层循环，后执行外层循环。
流程的转移控制
1、单选题：
下面程序段中的break语句是转移到哪里去执行（）。for(…)
{
for(…)
{
switch(…)
{
case 1: …
break;
case 2:…
…
}
A: //code
}
B: //code
}
C: //code
A: 转到标号A所在的语句行与执行
B: 转到标号B所在的语句行与执行
C: 转到标号C所在的语句行与执行
D: 不进行流程转移，而是继续执行break后面的语句
答案: 转到标号A所在的语句行与执行
程序调试
1、单选题：
下列说法错误的是（）。
A: 程序测试的目的就是验证程序的正确性。
B: 程序中常见的错误有三种：编译错误，链接错误，以及运行时错误。
C: 编译错误通常是由语法错误造成的。
D: 运行时错误是指在程序运行时发生的错误，运行时错误有两种：一种是导致程序的运行结果与预期的不一致，另一种是导致程序无法正常运行。
答案: 程序测试的目的就是验证程序的正确性。
第5周测验
1、单选题：
程序运行后的输出结果是#include <stdio.h>
int main()
{
int i;
for(i=0;i<3;i++)
switch(i)
{
case 0: printf(“%d”,i);
case 2: printf(“%d”,i);
default: printf(“%d”,i);
}
return 0;
}
A: 000122
B: 022111
C: 021021
D: 012
答案: 000122
2、单选题：
若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是
A: for( i=1; i<=5; i++ )
{
p=1;
p*=i;
}
B: for(i=1,p=1;i<=5;i++) p*=i;
C: i=1;
p=1;
while ( i<=5 )
{
p*=i;
i++;
}
D: i=1;
p=1;
do {
p*=i;
i++;
} while ( i<=5 );
答案: for( i=1; i<=5; i++ )
{
p=1;
p*=i;
}
3、单选题：
以下程序执行后的输出结果是#include <stdio.h>
int main( )
{
int x=0,y=5,z=3;
while(z–>0 && ++x<5)
{
y=y-1;
}
printf(“%d,%d,%dn”,x,y,z);
return 0;
}
A: 3,2,-1
B: 3,2,0
C: 4,3,-1
D: 5,-2,-5
答案: 3,2,-1
4、单选题：
下面程序的输出是#include <stdio.h>
int main()
{
int y=9;
for( ; y>0; y–)
{
if(y%3==0)
{
printf(“%d”, –y);
continue;
}
}
return 0;
}
A: 852
B: 741
C: 963
D: 875421
答案: 852
5、单选题：
爱因斯坦数学题。爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶，最后才正好1阶不剩。请问，这条阶梯共有多少阶？代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
int main()
{
int x = 1, find = 0;
while (__________)
{
if (______________________)
{
printf(“x = %dn”, x);
find = 1;
&nbs
上方为免费预览版答案，如需购买完整答案，请点击下方红字：
为了方便下次阅读，建议在浏览器添加书签收藏本网页
添加书签方法：
1.电脑按键盘的Ctrl键+D键即可收藏本网页
2.手机浏览器可以添加书签收藏本网页
点击浏览器底部菜单-【添加书签】-收藏本网页
点击浏览器底部菜单-【书签/历史】-可查看本网页
获取更多慕课答案，欢迎在浏览器访问我们的网站：
http://mooc.mengmianren.com
注：请切换至英文输入法输入域名，如果没有成功进入网站，请输入完整域名：http://mooc.mengmianren.com/
我们的公众号
打开手机微信，扫一扫下方二维码，关注微信公众号：萌面人APP
本公众号可查看各种网课答案，还可免费查看大学教材答案
点击这里，可查看公众号功能介绍
APP下载
APP功能说明
1.可查看各种网课答案
点击【萌面人官网】，可查看知到智慧树，超星尔雅学习通，学堂在线等网课答案
点击【中国大学慕课答案】，可查看mooc慕课答案
2.可一键领取淘宝/天猫/京东/拼多多无门槛优惠券
如图所示，点击对应图标即可领取淘宝/天猫/京东/拼多多无门槛优惠券
褐荣粮虹孪悸蚕杰久玻许办燃