20春-C语言程序设计-钱龙华-1答案-中国大学慕课

第1周——初识C语言从认识变量和常量开始

1.2 C 语言集成开发环境简介（16分钟）随堂测验

1、#include <stdio.h>是
    A、编译预处理指令
    B、语句
    C、函数
    D、程序入口

1.2 C 语言集成开发环境简介（16分钟）随堂测验

1、codeblocks中运行到下一步(next line)的快捷键是
    A、F7
    B、F5
    C、F8
    D、F11

1.4 变量的表数范围和存储形式（29分钟）随堂测验

1、Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）
    A、函数
    B、运算符
    C、标识符
    D、语句

1.5 宏常量与const常量（13分钟）随堂测验

1、宏定义是（）
    A、一条语句
    B、一种编译预处理指令
    C、一个标识符
    D、一个变量

2、const常量有数据类型。

第1周测验

1、下列选项中，合法的C语言标识符是
    A、_a1
    B、width.x
    C、#abc123
    D、123abc
    E、o*k
    F、a?
    G、a+b
    H、%a
    I、b!

2、以下不适合定义为用户标识符的是
    A、int
    B、a2
    C、def2
    D、_3com_
    E、PI
    F、Source
    G、abc

3、#include <stdio.h>是
    A、编译预处理指令
    B、语句
    C、函数
    D、什么都不是
    E、有语法错误

4、在windows下,程序编译链接后形成的可执行文件是
    A、.obj文件
    B、.exe文件
    C、.o文件
    D、.c文件
    E、.h文件

5、程序编译链接后显示" 0 error,0 warning" 代表
    A、程序中没有语法错误
    B、程序是正确的
    C、程序是不正确的
    D、程序中可能存在语法错误
    E、程序中有语义错误

6、用8位无符号二进制数能表示的最大十进制数为
    A、255
    B、127
    C、128
    D、256

7、关于可执行文件说法正确的是
    A、可执行文件是编译链接后生成的文件
    B、可执行文件就是源代码文件
    C、可执行文件后缀为.obj
    D、可执行文件就是main.c文件

8、若变量a是int类型，并执行了语句：a='A'+1.6；，则正确的叙述是
    A、'A'+1.6的结果是浮点型
    B、a的值还是整型
    C、a的值是字符C
    D、a的值是浮点型
    E、不允许字符型和浮点型相加

9、Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）
    A、运算符
    B、一元运算符
    C、只需要一个操作数的运算符
    D、函数
    E、语句
    F、标识符
    G、变量

10、程序的开发步骤中不包括
    A、撰写文档
    B、运行程序
    C、编译链接
    D、程序测试
    E、编辑（编写代码）

11、下列说法中错误的是（）
    A、尾数决定了实数的表数范围，阶码决定了实数的表数精度。
    B、内存是按位编址的。
    C、有符号和无符号整数的表数范围是相同的。
    D、int型在所有的计算机上都占4个字节的存储单元。
    E、编译器按变量定义的类型对不同类型的变量分配不同大小的内存空间。
    F、内存是按字节编址的。
    G、对于同样的尾数，阶码的值越大，则浮点数所表示的数值的绝对值就越大。
    H、sizeof是编译时执行的运算符，不会导致额外的运行时间开销。

12、若有定义：int a=8，b=5，c; ，执行语句c=a/b+0.4;后，c的值为
    A、1
    B、1.4
    C、2.0
    D、2

13、在C语言中，字符型数据在内存中以字符的（ ）形式存放
    A、ASCII码
    B、国标码
    C、BCD码
    D、反码

14、以下符合C语言语法的实型常量是
    A、5e-3
    B、3.14.159e
    C、1.2e0.5
    D、e15

15、以下选项中可作为C语言合法整数的是
    A、0xffa
    B、10110B
    C、038x
    D、x2a2

16、下列说法正确的是
    A、在C语言中，变量必须先定义后使用。
    B、一条变量定义语句可定义多个同类型的变量。
    C、C89规定所有变量必须在第一条可执行语句前定义。
    D、const常量只能在定义时赋值。
    E、实型常量的默认类型是double类型。
    F、一条变量定义语句不可以同时定义多个变量。
    G、不同类型的变量分配的存储空间大小都是相同的。
    H、在C语言中，所有变量都必须在定义时进行初始化。
    I、变量在没有初始化的时候，其值都是0
    J、宏常量有数据类型，编译器在宏替换时可以进行类型检查。

17、下列变量定义中合法的是
    A、long ao=0xfdaL；
    B、short _a=1-.1e-1；
    C、double b=1+5e2.5；
    D、float 2_and=1-e-3；

练兵区——单选题——不计入总分

1、下列选项中，合法的C语言标识符是
    A、_a1
    B、width
    C、#abc123
    D、123abc
    E、o*k
    F、a?
    G、a+b
    H、%a
    I、b!

2、以下不适合定义为用户标识符的是
    A、float
    B、main
    C、define
    D、_3com_
    E、PI
    F、Source
    G、abc

3、#include <stdio.h>是
    A、编译预处理指令
    B、语句
    C、函数
    D、什么都不是
    E、有语法错误

4、在windows下,程序编译链接后形成的可执行文件是
    A、.obj文件
    B、.exe文件
    C、.o文件
    D、.c文件
    E、.h文件

5、程序编译链接后显示" 0 error,0 warning" 代表
    A、程序中没有语法错误
    B、程序是正确的
    C、程序是不正确的
    D、程序中可能存在语法错误
    E、程序中有语义错误

6、用8位无符号二进制数能表示的最大十进制数为
    A、255
    B、127
    C、128
    D、256

7、关于可执行文件说法正确的是
    A、可执行文件是编译链接后生成的文件
    B、可执行文件就是源代码文件
    C、可执行文件后缀为.obj
    D、可执行文件就是main.c文件

8、若变量a是int类型，并执行了语句：a='A'+1.6；，则正确的叙述是
    A、'A'+1.6的结果是浮点型
    B、a的值还是整型
    C、a的值是字符C
    D、a的值是浮点型
    E、不允许字符型和浮点型相加

9、Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）
    A、运算符
    B、一元运算符
    C、只需要一个操作数的运算符
    D、函数
    E、语句
    F、标识符
    G、变量

10、以下不属于Codeblocks中用于调试程序的工具是
    A、run
    B、build
    C、run to cursor
    D、next line
    E、stop debugger
    F、watches

11、程序的开发步骤中不包括
    A、撰写文档
    B、运行程序
    C、编译链接
    D、程序测试
    E、编辑（编写代码）

12、下列说法中错误的是（）
    A、尾数决定了实数的表数范围，阶码决定了实数的表数精度。
    B、内存是按位编址的。
    C、有符号和无符号整数的表数范围是相同的。
    D、int型在所有的计算机上都占4个字节的存储单元。
    E、编译器按变量定义的类型对不同类型的变量分配不同大小的内存空间。
    F、内存是按字节编址的。
    G、对于同样的尾数，阶码的值越大，则浮点数所表示的数值的绝对值就越大。
    H、sizeof是编译时执行的运算符，不会导致额外的运行时间开销。

13、若有定义：int a=8，b=5，c; ，执行语句c=a/b+0.4;后，c的值为
    A、1
    B、1.4
    C、2.0
    D、2

14、在C语言中，字符型数据在内存中以字符的（ ）形式存放
    A、ASCII码
    B、国标码
    C、BCD码
    D、反码

15、以下符合C语言语法的实型常量是
    A、5e-3
    B、3.14.159e
    C、1.2e0.5
    D、e15

16、以下选项中可作为C语言合法整数的是
    A、0xffa
    B、10110B
    C、038x
    D、x2a2

17、下列说法正确的是
    A、在C语言中，变量必须先定义后使用。
    B、一条变量定义语句可定义多个同类型的变量。
    C、C89规定所有变量必须在第一条可执行语句前定义。
    D、const常量只能在定义时赋值。
    E、实型常量的默认类型是double类型。
    F、一条变量定义语句不可以同时定义多个变量。
    G、不同类型的变量分配的存储空间大小都是相同的。
    H、在C语言中，所有变量都必须在定义时进行初始化。
    I、变量在没有初始化的时候，其值都是0
    J、宏常量有数据类型，编译器在宏替换时可以进行类型检查。

18、下列变量定义中合法的是
    A、long ao=0xfdaL；
    B、short _a=1-.1e-1；
    C、double b=1+5e2.5；
    D、float 2_and=1-e-3；

练兵区——编程题——不计入总分

1、hello world！

2、在屏幕上输出多行信息

3、计算半圆弧长及半圆的面积。

4、计算长方体体积

第2周——数字间的那些事儿，做点计算哈

2.1 算术运算（20分钟）随堂测验

1、二元的算术运算符的结合性都是左结合。

2.2 赋值运算（15分钟）随堂测验

1、下列语句中错误的是（）。
    A、int a, b, c; a=b=c=0;
    B、int a, b, c; a=0; b=0; c=0;
    C、int a=0; int b=0; int c=0;
    D、int a=b=c=0;

2.4 自动类型转换（5分钟）随堂测验

1、通常情况下，不同类型数据的运算结果的类型是取值范围较大的那种类型。

2.5 强制类型转换（7分半）随堂测验

1、强制类型转换运算符就是强制改变一个变量原有的数据类型。

第2周测验

1、下列程序的输出结果是 #include <stdio.h> int main() { int a=7,b=5; printf("%d\n",b/a); return 0; }
    A、0
    B、5
    C、1
    D、0.7

2、下列关于单目运算符++、--的叙述中正确的是
    A、a++的运算过程是：先使用变量a的值，然后再执行a=a+1。
    B、++a的运算过程是：先使用变量a的值，然后再执行a=a+1。
    C、a++的运算过程是：先执行a=a+1,然后再使用变量a的值。
    D、a++和++a都是最终使变量a执行a=a+1,因此对于包含a++或++a的表达式而言(如j=a++;或者j=++a;)，两种情况下表达式的最终运算结果一定是相同的。

3、以下程序的输出结果是： #include <stdio.h> int main() { int a=1, b=2; a=a+b; b=a-b; a=a-b; printf("%d,%d\n", a, b ); return 0; }
    A、2,1
    B、3,1
    C、3,2
    D、1,2

4、程序运行后的输出结果是#include <stdio.h> int main() { int m=3,n=4,x; x=m++; ++n; x=x+8/n; printf("%d,%d\n",x,m); return 0; }
    A、4,4
    B、4,3
    C、5,4
    D、5,3

5、下面程序的运行结果是 #include <stdio.h> int main() { int a = 2, b = 3 ; float x = 3.5, y = 2.5 ; printf("%f", (float)(a+b) / 2 + (int)x % (int)y) ; return 0; }
    A、3.500000
    B、3.000000
    C、3.5
    D、3

6、以下非法的赋值语句是
    A、++(i+1);
    B、x=(j--);
    C、n=++i;
    D、j++;

7、设a和b均为double型变量，且a=5.5、b=2.5，则表达式（int）a+b/b的值是
    A、6.000000
    B、6.500000
    C、6
    D、5.500000

8、以下程序的运行结果是 #include <stdio.h> int main() { int a = 12, b = 3; float x = 18.5, y = 4.5; printf("%f\n", (float)(a * b) / 2); printf("%d\n", (int)x %(int)y); return 0; }
    A、18.000000 2
    B、18 2
    C、18 2.000000
    D、18.000000 2.000000

9、设有语句“int a = 3;”，执行语句“a += a -= a * a;”后，变量a的值是
    A、-12
    B、3
    C、0
    D、9

10、在C语言中，要求操作数必须是整型的运算符是
    A、%
    B、/
    C、*
    D、+
    E、-

11、程序运行后的输出结果是#include <stdio.h> int main() { char a='a'; printf("%c,",++a); printf("%c\n",a++); return 0; }
    A、b,b
    B、b,c
    C、a,b
    D、a,c

12、下面哪条语句可以生成0-9之间的随机数
    A、magic=rand()%10;
    B、magic=rand()%10+1;
    C、magic=rand()/10;
    D、magic=rand()/10+1;

13、在下面的C语言语句中，存在错误的是
    A、int a=b=10;
    B、int a=10,b=10;
    C、int a,b; a=b=10;
    D、int a,b; a=10; b=10;

14、若以下选项中的变量已正确定义，则正确的赋值语句是
    A、x3=x2=x1=0；
    B、x1=26.8%3；
    C、1+2=x2；
    D、x4=1+2=3；

15、若有以下定义，则表达式“a * b + d – c”的值的类型为 #include <stdio.h> int main() { char a; int b; float c; double d; .... return 0; }
    A、double
    B、int
    C、float
    D、char

16、在C程序中如果要使用数学函数，如sin(x),log(x)等，需要在程序中加入的语句是
    A、#include <math.h>
    B、#include <stdio.h>
    C、#define <math.h>
    D、#define <stdio.h>

17、十进制3位数整数x,下面哪条语句能正确分离出它的十位上的数字d?
    A、d=(x-(x/100)*100)/10;
    B、d=(x%100)/10;
    C、d=(x/10)%10;
    D、d=x%10;
    E、d=(x-x%10)/10;
    F、d=x%100;

18、在C语言中对下面的语句而言，哪个说法是错误的？ int a, b;
    A、变量a和b中的值都是0
    B、变量a和b中都没有数值
    C、变量a和b中的值都是未知的随机数
    D、a和b都是整型变量
    E、变量a和b占用的内存空间的大小是相同的

19、已知int a,b;并且有a=5%3;以及b=5/3;，则a和b的值分别是（ ）。
    A、2和1
    B、0和1.67
    C、3和1
    D、5和1
    E、0和1
    F、3和1.67
    G、5和1.67

20、设有以下定义，则下面给出的语句中错误的是 int a=0; float b=1.25; char c='A'; #define d 2
    A、d++;
    B、(a+b)++;
    C、(-a)++;
    D、(a+1)++;
    E、a++;
    F、b++;
    G、c++;

练兵区——单选题——不计入总分

1、设有语句“int a = 3;”，执行语句“a += a -= a * a;”后，变量a的值是
    A、-12
    B、3
    C、0
    D、9

2、在C程序中如果要使用数学函数，如sin(x),log(x)等，需要在程序中加入的语句是
    A、#include <math.h>
    B、#include <stdio.h>
    C、#define <math.h>
    D、#define <stdio.h>

3、设有以下定义,则下面给出的语句中错误的是 int a=0; float b=1.25; char c='A'; #define d 2
    A、d++;
    B、(a+b)++;
    C、(-a)++;
    D、(a+1)++;
    E、a++;
    F、b++;
    G、c++;

4、下列关于单目运算符++、--的叙述中正确的是
    A、a++的运算过程是：先使用变量a的值，然后再执行a=a+1。
    B、++a的运算过程是：先使用变量a的值，然后再执行a=a+1。
    C、a++的运算过程是：先执行a=a+1,然后再使用变量a的值。
    D、a++和++a都是最终使变量a执行a=a+1,因此对于包含a++或++a的表达式而言(如j=a++;或者j=++a;)，两种情况下表达式的最终运算结果一定是相同的。

5、以下程序的输出结果是：#include <stdio.h> int main() { int a=1, b=2; a=a+b; b=a-b; a=a-b; printf("%d,%d\n", a, b ); return 0; }
    A、2,1
    B、3,1
    C、3,2
    D、1,2

6、下面哪条语句可以生成0-9之间的随机数
    A、magic=rand()%10;
    B、magic=rand()%10+1;
    C、magic=rand()/10;
    D、magic=rand()/10+1;

7、在下面的C语言语句中，存在错误的是
    A、int a=b=10;
    B、int a=10,b=10;
    C、int a,b; a=b=10;
    D、int a,b; a=10; b=10;

8、若有以下定义，则表达式“a * b + d – c”的值的类型为 #include <stdio.h> int main() { char a; int b; float c; double d; .... return 0; }
    A、double
    B、int
    C、float
    D、char

9、十进制3位数整数x,下面哪条语句能正确分离出它的十位上的数字d?
    A、d=(x-(x/100)*100)/10;
    B、d=(x%100)/10;
    C、d=(x/10)%10;
    D、d=x%10;
    E、d=(x-x%10)/10;
    F、d=x%100;

10、在C语言中对下面的语句而言，哪个说法是错误的？ int a, b;
    A、变量a和b中的值都是0
    B、变量a和b中都没有数值
    C、变量a和b中的值都是未知的随机数
    D、a和b都是整型变量
    E、变量a和b占用的内存空间的大小是相同的

11、下列程序的输出结果是#include <stdio.h> int main() { int a=7,b=5; printf("%d\n",b/a); return 0; }
    A、0
    B、5
    C、1
    D、0.7

12、程序运行后的输出结果是#include <stdio.h> int main() { int m=3,n=4,x; x=m++; ++n; x=x+8/n; printf("%d,%d\n",x,m); return 0; }
    A、4,4
    B、4,3
    C、5,4
    D、5,3

13、下面程序的运行结果是#include <stdio.h> int main() { int a = 2, b = 3 ; float x = 3.5, y = 2.5 ; printf("%f", (float)(a+b) / 2 + (int)x % (int)y) ; return 0; }
    A、3.500000
    B、3.000000
    C、3.5
    D、3

14、以下非法的赋值语句是
    A、++(i+1);
    B、x=(j--);
    C、n=++i;
    D、j++;

15、已知int a,b;并且有a=5%3;以及b=5/3;，则a和b的值分别是
    A、2和1
    B、0和1.67
    C、3和1
    D、5和1
    E、0和1
    F、3和1.67
    G、5和1.67

16、设a和b均为double型变量，且a=5.5、b=2.5，则表达式（int）a+b/b的值是
    A、6.000000
    B、6.500000
    C、6
    D、5.500000

17、以下程序的运行结果是#include <stdio.h> int main() { int a = 12, b = 3; float x = 18.5, y = 4.5; printf("%f\n", (float)(a * b) / 2); printf("%d\n", (int)x %(int)y); return 0; }
    A、18.000000 2
    B、18 2
    C、18 2.000000
    D、18.000000 2.000000

18、在C语言中，要求操作数必须是整型的运算符是
    A、%
    B、/
    C、*
    D、+
    E、-

19、程序运行后的输出结果是 #include <stdio.h> int main() { char a='a'; printf("%c,",++a); printf("%c\n",a++); return 0; }
    A、b,b
    B、b,c
    C、a,b
    D、a,c

20、若以下选项中的变量已正确定义，则正确的赋值语句是
    A、x3=x2=x1=0；
    B、x1=26.8%3；
    C、1+2=x2；
    D、x4=1+2=3；

练兵区——编程题——不计入总分

1、计算总分和平均分

2、数位拆分v1.0

3、求正/负余数

4、身高预测

5、求一元二次方程的根

第一次编程实验

1、输出逆序数

2、存款利率计算器V1.0

第3周——从键盘中来，到键盘中去，开始输入和输出啦

3.1 数据的格式化屏幕输出（15分钟）随堂测验

1、在调用printf函数输出数据时，当数据的实际位宽大于printf函数中的指定位宽时，将按照数据的实际位宽输出数据。

3.3 单个字符的输入输出（15分半）随堂测验

1、单个字符既可以以c格式符也可以以d格式符输出，前者是输出这个字符，后者是输出这个字符的ASCII码值。

3.5 进阶：用%c输入数据存在的问题（含错误案例分析）（10分）随堂测验

1、用c格式符输入字符型数据的时候，为了避免将输入缓冲区中的空白字符（空格、回车换行符、Tab键）作为有效字符读入，可以在%c前面加一个空格。

第3周测验

1、分析下列程序，写出程序运行结果 #include <stdio.h> int main() { char c1 = 'a', c2 = 'b', c3 = 'c'; printf("a%cb%cc%cabc\n", c1, c2, c3); return 0; }
    A、aabbccabc
    B、acbcabc
    C、aabcabc
    D、acbbcabc

2、有如下语句,为使变量a的值为1，b的值为2，从键盘输入数据的正确形式是 scanf("a=%d,b=%d",&a,&b);
    A、a=1,b=2
    B、1 2
    C、1,2
    D、a=1 b=2

3、#include <stdio.h> int main() { int a,b,c,d; scanf("%c%c%d,%d",&a,&b,&c,&d); printf("%c,%c,%c,%c\n",a,b,c,d); return 0; }若运行以上程序时从键盘上输入：6565,66<回车>。则输出结果是
    A、6,5,A,B
    B、6,5,65,66
    C、6,5,6,5
    D、6,5,6,6

4、给出程序的运行结果,程序运行时从键盘输入：54321<回车> #include <stdio.h> int main() { int a,b,s; scanf("%2d%2d",&a,&b); s=a/b; printf("%d",s); return 0; }
    A、1
    B、1.6875
    C、2
    D、0

5、以下程序的输出结果为 #include <stdio.h> int main() { float a = 1234.567,b = 55.32; printf("a = %4.2f, b = %5.1f\n", a,b); return 0; }
    A、a = 1234.57, b = 55.3
    B、a =1234, b =55
    C、a = 1234.6, b = 5.32
    D、a =1234.567, b = 55.32

6、以下程序的输出结果为 #include <stdio.h> int main() { int a=2, c=5; printf("a = %%d, b = %%d\n", a, c); return 0; }
    A、a = %d, b = %d
    B、a = %2, b = %5
    C、a = 2, b = 5
    D、a = %%d, b = %%d

7、有以下程序，运行时若输入为B，则输出是 #include <stdio.h> int main() { char ch; ch=getchar(); ch=ch+32; printf("%c",ch); return 0; }
    A、b
    B、98
    C、32
    D、66

8、在调用printf函数输出数据时，当数据的实际位宽小于printf函数中的指定位宽时，下面叙述正确的是
    A、如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。
    B、如果格式字符前面没有负号，那么输出的数据将会左对齐、右补空格；如果格式字符前面有负号，那么输出的数据将会右对齐、左补空格。
    C、如果格式字符前面没有负号，那么输出的数据将会右对齐、左补0；如果格式字符前面有负号，那么输出的数据将会左对齐、右补0。
    D、如果格式字符前面没有负号，那么输出的数据将会左对齐、右补0；如果格式字符前面有负号，那么输出的数据将会右对齐、左补0。

9、设有语句“char c='\72';”，则变量c
    A、包含1个字符
    B、包含2个字符
    C、包含3个字符
    D、不合法

10、在下列语句中存在错误的是
    A、int a,b; scanf("%d %f",&a,&b);
    B、int a,b; scanf("%d %d",a,b);
    C、int a,b; scanf("%d%d\n",&a,&b); printf("%d %d",a,b);
    D、float a,b; scanf("%3.2f %4.2f",&a,&b); printf("%f %f",a,b);
    E、float a,b; scanf("%f %f",&a,&b); printf("%f %f",a,b);
    F、float a,b; scanf("%f %f",&a,&b); printf("a=%4.3f,b=%4.3f",a,b);
    G、int a,b; scanf("%2d%2d",&a,&b); printf("a=%d,b=%d",a,b);
    H、int a,b; scanf("%d,%d",&a,&b); printf("a=%2d,b=%2d",a,b);
    I、int a,b; scanf("a=%d,b=%d",&a,&b); printf("a=%d,b=%d",a,b);

11、程序运行后的输出结果是#include <stdio.h> int main() { int a=666,b=888; printf("%d\n",a,b); return 0; }
    A、666
    B、错误信息
    C、888
    D、666,888

12、有以下语句段#include <stdio.h> int main() { int n1=10,n2=20; printf("_________",n1,n2); return 0; }要求按以下格式输出n1和n2的值，每个输出行都是从第一列开始，则空白处代码填写正确的是 运行结果示例如下： n1=10 n2=20
    A、n1=%d\nn2=%d
    B、n1=%dn2=%d\n
    C、n1=%d,n2=%d
    D、n1=%d n2=%d\n

13、以下选项中合法的字符常量是
    A、'\010'
    B、"B"
    C、68
    D、D

14、写出下面程序的输出结果#include<stdio.h> int main() { int x=6,y,z; x*=18+1; printf("%d,",x--); x+=y=z=11; printf("%d",x); return 0; }
    A、114,124
    B、113,124
    C、109,116
    D、110,116

15、给出程序的运行结果,程序运行时从键盘输入：45-12<回车> #include <stdio.h> int main() { int a,b,sum; scanf("%d%*c%d",&a,&b); sum=a+b; printf("sum=%d",sum); return 0; }
    A、57
    B、输出报错
    C、33
    D、输出一个随机数

16、给出程序的运行结果 #include <stdio.h> int main() { int a,b,s; char op; scanf("%d %c%d",&a,&op,&b); s=a%b; printf("s=%d",s); return 0; } 程序运行时从键盘输入： 15<回车> % 5<回车>
    A、0
    B、程序报错
    C、输出一个随机数
    D、3

17、给出程序的运行结果 #include <stdio.h> int main() { int a,b,c,d; char op1,op2,op3; int sum; printf("please input:a+b+c+d\n"); scanf("%d%c%d%c%d%c%d",&a,&op1,&b,&op2,&c,&op3,&d); sum=a+b+c+d; printf("sum=%d",sum); return 0; } 程序运行时从键盘输入: 1<回车>2+3+1<回车>
    A、7
    B、1
    C、3
    D、6

18、在C语言中，字符型数据在内存中以（ ）形式存放
    A、ASCII码
    B、国标码
    C、BCD码
    D、反码

19、以下程序的执行结果是 #include <stdio.h> int main() { int a = 5, b = 4, x, y; x = 2 * a++; y = --b * 2; printf("a=%d, x=%d\n", a, x); printf("b=%d, y=%d\n", b, y); return 0; }
    A、a=6, x=10 b=3, y=6
    B、a=6, x=10 b=3, y=8
    C、a=6, x=12 b=3, y=6
    D、以上均不对

20、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a; int c=10; float f=100.0; double x; a=f/=c*=(x=6.5); printf("%d,%d,%3.1f,%3.1f\n",a,c,f,x); return 0; }
    A、1,65,1.5,6.5
    B、1,65,1,6.5
    C、1,65,1.0,6.5
    D、2,65,1.5,6.5

21、给出程序的运行结果 #include <stdio.h> int main() { char a,b; int s; printf("please input a and b:\n"); a=getchar(); b=getchar(); s=a+b; printf("a=%c,b=%c",a,b); return 0; } 程序运行时从键盘输入: 1<空格>2<回车>
    A、a=1,b=
    B、a=1,b=2
    C、a= ,b=2
    D、输出乱码

22、以下程序的输出结果是 #include <stdio.h> int main() { int a=1234; printf("%2d\n",a); return 0; }
    A、1234
    B、12
    C、34
    D、提示出错、无结果

练兵区——单选题——不计入总分

1、以下程序的输出结果为 #include <stdio.h> int main() { float a = 1234.567,b = 55.32; printf("a = %4.2f, b = %5.1f\n", a,b); return 0; }
    A、a = 1234.57, b = 55.3
    B、a =1234, b =55
    C、a = 1234.6, b = 5.32
    D、a =1234.567, b = 55.32

2、以下选项中合法的字符常量是
    A、'\010'
    B、"B"
    C、68
    D、D

3、给出程序的运行结果 程序运行时从键盘输入: 1<空格>2<回车> #include <stdio.h> int main() { char a,b; int s; printf("please input a and b:\n"); a=getchar(); b=getchar(); s=a+b; printf("a=%c,b=%c",a,b); return 0; }
    A、a=1,b=
    B、a=1,b=2
    C、a= ,b=2
    D、输出乱码

4、有如下语句,为使变量a的值为1，b的值为2，从键盘输入数据的正确形式是 scanf("a=%d,b=%d",&a,&b)
    A、a=1,b=2
    B、1 2
    C、1,2
    D、a=1 b=2

5、#include <stdio.h> int main() { int a,b,c,d; scanf("%c%c%d,%d",&a,&b,&c,&d); printf("%c,%c,%c,%c\n",a,b,c,d); return 0; } 若运行以上程序时从键盘上输入：6565,66<回车>。则输出结果是
    A、6,5,A,B
    B、6,5,65,66
    C、6,5,6,5
    D、6,5,6,6

6、给出程序的运行结果,程序运行时从键盘输入：54321<回车> #include <stdio.h> int main() { int a,b,s; scanf("%2d%2d",&a,&b); s=a/b; printf("s=%d",s); return 0; }
    A、1
    B、1.6875
    C、2
    D、0

7、在调用printf函数输出数据时，当数据的实际位宽小于printf函数中的指定位宽时，下面叙述正确的是
    A、如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。
    B、如果格式字符前面没有负号，那么输出的数据将会左对齐、右补空格；如果格式字符前面有负号，那么输出的数据将会右对齐、左补空格。
    C、如果格式字符前面没有负号，那么输出的数据将会右对齐、左补0；如果格式字符前面有负号，那么输出的数据将会左对齐、右补0。
    D、如果格式字符前面没有负号，那么输出的数据将会左对齐、右补0；如果格式字符前面有负号，那么输出的数据将会右对齐、左补0。

8、程序运行后的输出结果是#include <stdio.h> int main() { int a=666,b=888; printf("%d\n",a,b); return 0; }
    A、666
    B、错误信息
    C、888
    D、666,888

9、在C语言中，字符型数据在内存中以（ ）形式存放
    A、ASCII码
    B、国标码
    C、BCD码
    D、反码

10、以下程序运行后的输出结果是#include <stdio.h> int main() { int a; int c=10; float f=100.0; double x; a=f/=c*=(x=6.5); printf("%d,%d,%3.1f,%3.1f\n",a,c,f,x); return 0; }
    A、1,65,1.5,6.5
    B、1,65,1,6.5
    C、1,65,1.0,6.5
    D、2,65,1.5,6.5

11、以下程序的输出结果是 #include <stdio.h> int main() { int a=1234; printf("%2d\n",a); return 0; }
    A、1234
    B、12
    C、34
    D、提示出错、无结果

12、设有语句“char c='\72';”，则变量c
    A、包含1个字符
    B、包含2个字符
    C、包含3个字符
    D、不合法

13、有以下语句段#include <stdio.h> int main() { int n1=10,n2=20; printf("_________",n1,n2); return 0; } 要求按以下格式输出n1和n2的值，每个输出行都是从第一列开始，则空白处代码填写正确的是 运行结果示例如下： n1=10 n2=20
    A、n1=%d\nn2=%d
    B、n1=%dn2=%d\n
    C、n1=%d,n2=%d
    D、n1=%d n2=%d\n

14、给出程序的运行结果,程序运行时从键盘输入：45-12<回车>#include <stdio.h> int main() { int a,b,sum; scanf("%d%*c%d",&a,&b); sum=a+b; printf("sum=%d",sum); return 0; }
    A、57
    B、输出报错
    C、33
    D、输出一个随机数

15、给出程序的运行结果#include <stdio.h> int main（） { int a,b,s; char op; scanf("%d %c%d",&a,&op,&b); s=a%b; printf("s=%d",s); return 0; } 程序运行时从键盘输入： 15<回车> % 5<回车>
    A、0
    B、程序报错
    C、输出一个随机数
    D、3

16、分析下列程序，写出程序运行结果#include <stdio.h> int main() { char c1 = 'a', c2 = 'b', c3 = 'c'; printf("a%cb%cc%cabc\n", c1, c2, c3); return 0; }
    A、aabbccabc
    B、acbcabc
    C、aabcabc
    D、acbbcabc

17、以下程序的输出结果为#include <stdio.h> int main() { int a=2, c=5; printf("a = %%d, b = %%d\n", a, c); return 0; }
    A、a = %d, b = %d
    B、a = %2, b = %5
    C、a = 2, b = 5
    D、a = %%d, b = %%d

18、有以下程序，运行时若输入为B，则输出是#include <stdio.h> int main() { char ch; ch=getchar(); ch=ch+32; printf("%c",ch); return 0; }
    A、b
    B、98
    C、32
    D、66

19、在下列语句中存在错误的是
    A、int a,b; scanf("%d %f",&a,&b);
    B、int a,b; scanf("%d %d",a,b);
    C、int a,b; scanf("%d%d\n",&a,&b); printf("%d %d",a,b);
    D、float a,b; scanf("%3.2f %4.2f",&a,&b); printf("%f %f",a,b);
    E、float a,b; scanf("%f %f",&a,&b); printf("%f %f",a,b);
    F、float a,b; scanf("%f %f",&a,&b); printf("a=%4.3f,b=%4.3f",a,b);
    G、int a,b; scanf("%2d%2d",&a,&b); printf("a=%d,b=%d",a,b);
    H、int a,b; scanf("%d,%d",&a,&b); printf("a=%2d,b=%2d",a,b);
    I、int a,b; scanf("a=%d,b=%d",&a,&b); printf("a=%d,b=%d",a,b);

20、写出下面程序的输出结果#include<stdio.h> int main() { int x=6,y,z; x*=18+1; printf("%d,",x--); x+=y=z=11; printf("%d",x); return 0; }
    A、114,124
    B、113,124
    C、109,116
    D、110,116

21、给出程序的运行结果#include <stdio.h> int main() { int a,b,c,d; char op1,op2,op3; int sum; printf("please input:a+b+c+d\n"); scanf("%d%c%d%c%d%c%d",&a,&op1,&b,&op2,&c,&op3,&d); sum=a+b+c+d; printf("sum=%d",sum); return 0; } 程序运行时从键盘输入: 1<回车>2+3+1<回车>
    A、7
    B、1
    C、3
    D、6

22、以下程序的执行结果是#include <stdio.h> int main() { int a = 5, b = 4, x, y; x = 2 * a++; y = --b * 2; printf("a=%d, x=%d\n", a, x); printf("b=%d, y=%d\n", b, y); return 0; }
    A、a=6, x=10 b=3, y=6
    B、a=6, x=10 b=3, y=8
    C、a=6, x=12 b=3, y=6
    D、以上均不对

第4周编程实验题

1、学分绩计算

2、一尺之捶，日取其半

3、网购打折商品V1.0

4、计算时间差V1.0

练兵区——编程题——不计入总分

1、日期显示

2、产品信息格式化

3、计算两个数的平方和

4、逆序数的拆分计算

5、拆分英文名

6、计算体指数

第4周——无处不在的抉择

4.1 关系运算符和逻辑运算符（23分钟）随堂测验

1、下面判断ch是大写或者小写英文字母的表达式是否正确？ ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z'

4.2 条件语句（14分钟）随堂测验

1、下列关于if-else语句的说法中哪个是正确的。
    A、else总是和离它最近的if配对
    B、else总是和前面离它最近的且还未和其他else匹配的在同一语句块内同一层次的if配对
    C、else总是和前面离它最近的且位于花括号内的if配对
    D、else可以和它前面的尚未与其他else匹配的任何一个if配对

2、条件运算符是C语言中唯一的一个三元运算符.

4.4 进阶：数值溢出和精度损失问题（34分半）随堂测验

1、在赋值操作中，当赋值表达式左侧的变量的类型与右侧的表达式的类型不一致的时候，下面说法正确的是（）。
    A、在赋值操作中，当赋值运算符左侧的变量的类型与右侧的表达式的类型不一致的时候，会发生自动类型转换，赋值表达式的结果类型是赋值运算符左侧变量的类型。
    B、在赋值操作中，当赋值运算符左侧的变量的类型与右侧的表达式的类型不一致的时候，赋值表达式的结果类型是赋值运算符右侧表达式的类型。
    C、在赋值操作中，只要赋值运算符左侧的变量的类型与右侧的表达式的类型不一致，就会发生数值溢出。
    D、在赋值操作中，当赋值运算符左侧的变量的类型与右侧的表达式的类型不一致的时候，要么发生数值溢出，要么发生数值精度的损失。

4.4 进阶：数值溢出和精度损失问题（34分半）随堂测验

1、下列说法错误的是（）。
    A、浮点数并非真正意义上的实数，只是其在某种范围内的近似。
    B、浮点数能精确表示的数字位数取决于这种类型的浮点数的有效数字位数。
    C、使用更多的位来存储阶码，将会扩大浮点数的表数精度。
    D、受浮点数表数精度的限制，因此对于浮点数不能直接比较其是否相等，应该比较其是否近似相等。

4.5 进阶：软件测试与错误实例分析（20分半）随堂测验

1、下列说法错误的是（）。
    A、软件测试的目的就是证明程序的正确性，即给定特定的输入，通过运行被测程序，检查程序的输出是否与预期结果一致，进而验证程序的正确性。
    B、白盒测试就是在完全了解程序的结构和处理过程的情况下，按照程序内部的逻辑测试程序，检验程序中的每条逻辑路径是否都能按预定要求正确工作。黑盒测试就是把系统看成一个黑盒子，不考虑程序内部的逻辑结构和处理过程，只根据需求规格说明书的要求，设计测试用例，检查程序的功能是否符合它的功能说明。
    C、在选择测试用例时，不仅要选取合理的输入数据，还要选取一些不合理的输入数据，以及某些极端的边界点或临界点等，对程序进行测试
    D、由于修复了旧的bug的同时，往往又会产生新的bug，因此往往还需要对所有出现过的bug重新测试一遍，看其是否会重新出现，并给确认代码修改后没有引入新的bug，即修改代码后需要进行回归测试。

第4周测验

1、程序代码如下：#include <stdio.h> int main() { int a,b; printf("please input a and b:\n"); scanf("%d%d",&a,&b); printf("the output data is %d\n",a<b?b:a); return 0; } 从键盘输入以下数据： 2<回车> 7<回车> 则程序输出为
    A、the output data is 7
    B、the output data is 2
    C、the output data is 1
    D、the output data is 0

2、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a,b,c; a=10; b=20; c=(a%b<1)||(a/b>1); printf("%d,%d,%d",a%b,a/b,c); return 0; }
    A、10,0,0
    B、10,1,0
    C、10,0,1
    D、10,1,1

3、从键盘输入三角形的三边长为a,b,c，按下面公式计算并输出三角形的面积。 程序代码如下，但程序运行后输出结果不正确，请找出有问题的语句。 #include <stdio.h> #include <math.h> int main() { float a, b, c; float s, area; printf("Input a,b,c:"); scanf("%f,%f,%f",&a,&b,&c); if (a+b>c && b+c>a && a+c>b) { s = 1/2 * (a + b + c); area = sqrt(s * (s - a) * (s - b) * (s - c)); printf("area=%.2f\n", area); } else { printf("It is not a triangle\n"); } return 0; }
    A、第11行： s = 1/2 * (a + b + c);
    B、第9行： if (a+b>c && b+c>a && a+c>b)
    C、第12行： area = sqrt(s * (s - a) * (s - b) * (s - c));
    D、第8行： scanf("%f,%f,%f",&a,&b,&c);

4、编程设计一个简单的计算器程序，要求用户从键盘输入如下形式的表达式： 操作数1 运算符op 操作数2 然后，计算并输出表达式的值 指定的运算符为: 加（+） 减（-） 乘（*） 除（/） 代码如下，所给程序是否存在错误，若有，找出错误所在并改正。 #include <stdio.h> int main() { float data1, data2; char op; printf("Please enter the expression:"); scanf("%f %c%f", &data1, &op, &data2); /* %c前有一个空格 */ switch (op) { case '+': printf("%f + %f = %f\n", data1, data2, data1 + data2); break; case '-': printf("%f - %f = %f\n", data1, data2, data1 - data2); break; case '*': printf("%f * %f = %f\n", data1, data2, data1 * data2); break; case '/': printf("%f/%f = %f\n", data1, data2,data1/data2); break; default: printf("Invalid operator!\n"); } return 0; }
    A、第20行语句有错误，改成： if (fabs(data2)<=EPS) printf("Division by zero!\n"); else printf("%f/%f = %f\n", data1, data2, data1/data2); 同时，第1行语句下方应加入 #include <math.h> #define EPS 1e-6
    B、default分支缺少break语句
    C、没有错误
    D、第20行语句有错误，改成： if (data2=0) printf("Division by zero!\n"); else printf("%f/%f = %f\n", data1, data2, data1/data2);

5、若x和y代表整型数，以下表达式中不能正确表示数学关系|x-y|<10的是
    A、(x-y)<-10||!(y-x)>10
    B、fabs(x-y)<10
    C、x-y>-10 && x-y<10
    D、(x-y)*(x-y)<100

6、下列复合语句中，不能实现两数交换的是
    A、{ a=b; b=a; }
    B、{ b = a * b; a = b / a; b = b / a; }
    C、{ t=a; a=b; b=t; }
    D、{ a = a + b; b = a – b; a = a – b; }

7、写出下面程序的输出结果 #include <stdio.h> int main() { int x=1, y=0, a=0, b=0; switch(x) { case 1: switch(y) { case 0: a++; case 1: b++; } case 2: a++; b++; } printf("a=%d, b=%d\n", a, b) ; return 0; }
    A、a=2, b=2
    B、a=2, b=1
    C、a=1, b=1
    D、a=1, b=0

8、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a=5,b=4,c=3,d; d=(a>b>c); printf("%d\n",d); return 0; }
    A、0
    B、1
    C、5
    D、4
    E、3

9、执行以下程序后的输出结果为 #include <stdio.h> int main() { int a=1,b=0; switch (a) { case 1: switch (b) { case 0: printf("**0**");break; case 1: printf("**1**");break; } case 2: printf("**2**");break; } return 0; }
    A、**0****2**
    B、**0**
    C、**0****1****2**
    D、有语法错误

10、下面程序运行后的输出结果是 #include <stdio.h> int main() { int a=3,b=4,c=5,d=2; if(a>b) { if(b>c) { printf("%d",d++ +1); } else { printf("%d",++d +1); } } printf("%d\n",d); return 0; }
    A、2
    B、3
    C、43
    D、44

11、下面程序代码的功能是判断输入整数的正负性和奇偶性，请将第19行和22行标号处缺少的代码填写完整。 #include <stdio.h> int main() { int m; printf("Input m: "); scanf("%d", &m); //输入一个整数 if (m > 0) //是否为正数 { if (m % 2 == 0) //是正数，且能被2整除，则是正偶数 { printf("%d is a positive even\n", m); } else //不能被2整除，则是正奇数 { printf("%d is a positive odd\n", m); } } _______________ //判断是否为负数 { _______________ { printf("%d is a negative even\n", m); //是负偶数 } else { printf("%d is a negative odd\n", m); //是负奇数 } } else { printf("%d is zero.It is an even\n", m); } return 0; }
    A、第19行代码： else if(m < 0) 第22行代码： if (m % 2 == 0)
    B、第19行代码： if(m < 0) 第22行代码： if (m % 2 == 0)
    C、第19行代码： else if(m < 0) 第22行代码： if (m % 2 != 0)
    D、第19行代码： if(m < 0) 第22行代码： if (m % 2 != 0)

12、程序功能：从键盘输入一个字符，判别它是否为大写字母。如果是，将它转换成小写字母，如果不是，不转换。在屏幕上输出最后得到的字符。程序代码如下，为实现上述功能，请将第8行标号处缺少的语句填写完整。 #include<stdio.h> int main() { char c; printf("Please input a character:"); scanf("%c",&c); if(c >='A'&&c <= 'Z') c =_______________; printf("%c\n",c); return 0; }
    A、c+32
    B、c+48
    C、C+65
    D、C+97

13、执行下列程序，k输入为1时的输出结果是 #include <stdio.h> int main() { int k; scanf("%d",&k); switch(k) { case 1: printf("%d",k++); case 2: printf("%d",k++); case 3: printf("%d",k++); break; default: printf("Full!"); } return 0; }
    A、123
    B、1
    C、2
    D、3

14、编程计算下面的分段函数，根据从键盘输入的x值，在屏幕上输出y值。 程序代码如下，为完成以上功能，请将第13行标号处缺少的代码填写完整。 #include <stdio.h> #include <math.h> int main() { int x; double y; printf("Input x: "); scanf("%d", &x); // 输入一个整数 if (x > 0) { y = exp(-x); //如果大于0，计算y=exp(-x)的值 } _____________ { y = 1; //x=0，则y=1 } else { y = -exp(x); //x<0，则y=-exp(x) } printf("y=%f\n", y); return 0; }
    A、else if (x == 0)
    B、else if (x = 0)
    C、if (x == 0)
    D、if (x = 0)

15、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a=1,b=2,m=0,n=0,k; k=(n=b>a)||(m=a<b); printf("%d,%d\n",k,m); return 0; }
    A、1,0
    B、0,0
    C、0,1
    D、1,1

16、以下程序的功能是计算一元二次方程的根。代码如下，请将第10行标号处缺少的语句填写完整。 #include <stdio.h> #include <stdlib.h> #include <math.h> #define EPS 1e-6 int main() { float a, b, c, disc, p, q; printf("Please enter the coefficients a,b,c:"); scanf("%f,%f,%f", &a, &b, &c); _________________________________ /* a=0时，输出"不是二次方程" */ { printf("It is not a quadratic equation!\n"); exit(0); /* C标准库函数，用于终止整个程序的执行，强制返回操作系统 */ } disc = b * b - 4 * a * c; /* 计算判别式 */ p = - b / (2 * a); q = sqrt(fabs(disc)) / (2 * a); if (fabs(disc) <= EPS) /* 判别式等于0时，输出两相等实根 */ { printf("x1 = x2 = %.2f\n", p); } else { if (disc > EPS) /* 判别式大于0时，输出两不等实根 */ { printf("x1 = %.2f, x2 = %.2f\n", p+q, p-q); } else /* 判别式小于0时，输出两共轭复根 */ { printf("x1 = %.2f+%.2fi, ", p, q); printf("x2 = %.2f-%.2fi\n", p, q); } } return 0; }
    A、if (fabs(a) <= EPS)
    B、if (a <= EPS)
    C、if (a=0)
    D、if (a<= EPS || a>=-EPS)

17、下列说法错误的是（）。
    A、case后的“常量表达式”的类型只能是整型。
    B、若case后面的语句省略不写，则表示它什么也不做。
    C、switch语句中的break和default可有可无。
    D、每个case后的“常量表达式”的类型应该与switch后括号内表达式的类型一致。
    E、程序执行到switch语句时，先计算表达式的值，然后自上而下寻找与该值匹配的case常量，找到后则按顺序执行此case后的所有语句，而不再进行判断，直到遇break语句或右花括号}为止。
    F、若所有的case常量都不能与表达式的值相匹配，那么就执行default后面的语句。通常用于处理不在合理区间内的非法数据。
    G、每个case后的常量只起语句标号的作用，所以case常量的值必须互不相同，而且在每个case的语句序列后都有break的情况下，改变case常量出现的次序，不影响程序的运行结果。
    H、case后面的表达式不能是含有变量的关系表达式和逻辑表达式，它不能像if语句那样起到判断表达式真假的作用。

练兵区——单选题——不计入总分

1、下面程序代码的功能是判断输入整数的正负性和奇偶性，请将第19行和22行标号处缺少的代码填写完整。 #include <stdio.h> int main() { int m; printf("Input m: "); scanf("%d", &m); //输入一个整数 if (m > 0) //是否为正数 { if (m % 2 == 0) //是正数，且能被2整除，则是正偶数 { printf("%d is a positive even\n", m); } else //不能被2整除，则是正奇数 { printf("%d is a positive odd\n", m); } } _______________ //判断是否为负数 { _______________ { printf("%d is a negative even\n", m); //是负偶数 } else { printf("%d is a negative odd\n", m); //是负奇数 } } else { printf("%d is zero.It is an even\n", m); } return 0; }
    A、第19行代码： else if(m < 0) 第22行代码： if (m % 2 == 0)
    B、第19行代码： if(m < 0) 第22行代码： if (m % 2 == 0)
    C、第19行代码： else if(m < 0) 第22行代码： if (m % 2 != 0)
    D、第19行代码： if(m < 0) 第22行代码： if (m % 2 != 0)

2、执行以下程序后的输出结果为#include <stdio.h> int main() { int a=1,b=0; switch (a) { case 1: switch (b) { case 0: printf("**0**");break; case 1: printf("**1**");break; } case 2: printf("**2**");break; } return 0; }
    A、**0****2**
    B、**0**
    C、**0****1****2**
    D、有语法错误

3、以下程序运行后的输出结果是#include <stdio.h> int main() { int a=1,b=2,m=0,n=0,k; k=(n=b>a)||(m=a<b); printf("%d,%d\n",k,m); return 0; }
    A、1,0
    B、0,0
    C、0,1
    D、1,1

4、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a,b,c; a=10; b=20; c=(a%b<1)||(a/b>1); printf("%d,%d,%d",a%b,a/b,c); return 0; }
    A、10,0,0
    B、10,1,0
    C、10,0,1
    D、10,1,1

5、编程设计一个简单的计算器程序，要求用户从键盘输入如下形式的表达式： 操作数1 运算符op 操作数2 然后，计算并输出表达式的值 指定的运算符为: 加（+） 减（-） 乘（*） 除（/） 代码如下，所给程序是否存在错误，若有，找出错误所在并改正。 #include <stdio.h> int main() { float data1, data2; char op; printf("Please enter the expression:"); scanf("%f %c%f", &data1, &op, &data2); /* %c前有一个空格 */ switch (op) { case '+': printf("%f + %f = %f\n", data1, data2, data1 + data2); break; case '-': printf("%f - %f = %f\n", data1, data2, data1 - data2); break; case '*': printf("%f * %f = %f\n", data1, data2, data1 * data2); break; case '/': printf("%f/%f = %f\n", data1, data2,data1/data2); break; default: printf("Invalid operator!\n"); } return 0; }
    A、第20行语句有错误，改成： if (fabs(data2)<=EPS) printf("Division by zero!\n"); else printf("%f/%f = %f\n", data1, data2, data1/data2); 同时，第1行语句下方应加入 #include <math.h> #define EPS 1e-6
    B、default分支缺少break语句
    C、没有错误
    D、第20行语句有错误，改成： if (data2=0) printf("Division by zero!\n"); else printf("%f/%f = %f\n", data1, data2, data1/data2);

6、下列复合语句中，不能实现两数交换的是
    A、{ a=b; b=a; }
    B、{ b = a * b; a = b / a; b = b / a; }
    C、{ t=a; a=b; b=t; }
    D、{ a = a + b; b = a – b; a = a – b; }

7、写出下面程序的输出结果#include <stdio.h> int main() { int x=1, y=0, a=0, b=0; switch(x) { case 1: switch(y) { case 0: a++; case 1: b++; } case 2: a++; b++; } printf("a=%d, b=%d\n", a, b) ; return 0; }
    A、a=2, b=2
    B、a=2, b=1
    C、a=1, b=1
    D、a=1, b=0

8、执行下列程序，k输入为1时的输出结果是#include <stdio.h> int main() { int k; scanf("%d",&k); switch(k) { case 1: printf("%d",k++); case 2: printf("%d",k++); case 3: printf("%d",k++); break; default: printf("Full!"); } return 0; }
    A、123
    B、1
    C、2
    D、3

9、编程计算下面的分段函数，根据从键盘输入的x值，在屏幕上输出y值。 程序代码如下，为完成以上功能，请将第13行标号处缺少的代码填写完整。#include <stdio.h> #include <math.h> int main() { int x; double y; printf("Input x: "); scanf("%d", &x); // 输入一个整数 if (x > 0) { y = exp(-x); //如果大于0，计算y=exp(-x)的值 } _____________ { y = 1; //x=0，则y=1 } else { y = -exp(x); //x<0，则y=-exp(x) } printf("y=%f\n", y); return 0; }
    A、else if (x == 0)
    B、else if (x = 0)
    C、if (x == 0)
    D、if (x = 0)

10、以下程序的功能是计算一元二次方程的根。代码如下，请将第10行标号处缺少的语句填写完整。 #include <stdio.h> #include <stdlib.h> #include <math.h> #define EPS 1e-6 int main() { float a, b, c, disc, p, q; printf("Please enter the coefficients a,b,c:"); scanf("%f,%f,%f", &a, &b, &c); _________________________________ /* a=0时，输出"不是二次方程" */ { printf("It is not a quadratic equation!\n"); exit(0); /* C标准库函数，用于终止整个程序的执行，强制返回操作系统 */ } disc = b * b - 4 * a * c; /* 计算判别式 */ p = - b / (2 * a); q = sqrt(fabs(disc)) / (2 * a); if (fabs(disc) <= EPS) /* 判别式等于0时，输出两相等实根 */ { printf("x1 = x2 = %.2f\n", p); } else { if (disc > EPS) /* 判别式大于0时，输出两不等实根 */ { printf("x1 = %.2f, x2 = %.2f\n", p+q, p-q); } else /* 判别式小于0时，输出两共轭复根 */ { printf("x1 = %.2f+%.2fi, ", p, q); printf("x2 = %.2f-%.2fi\n", p, q); } } return 0; }
    A、if (fabs(a) <= EPS)
    B、if (a <= EPS)
    C、if (a=0)
    D、if (a<= EPS || a>=-EPS)

11、从键盘输入三角形的三边长为a,b,c，按下面公式计算并输出三角形的面积。 程序代码如下，但程序运行后输出结果不正确，请找出有问题的语句。#include <stdio.h> #include <math.h> int main() { float a, b, c; float s, area; printf("Input a,b,c:"); scanf("%f,%f,%f",&a,&b,&c); if (a+b>c && b+c>a && a+c>b) { s = 1/2 * (a + b + c); area = sqrt(s * (s - a) * (s - b) * (s - c)); printf("area=%.2f\n", area); } else { printf("It is not a triangle\n"); } return 0; }
    A、第11行： s = 1/2 * (a + b + c);
    B、第9行： if (a+b>c && b+c>a && a+c>b)
    C、第12行： area = sqrt(s * (s - a) * (s - b) * (s - c));
    D、第8行： scanf("%f,%f,%f",&a,&b,&c);

12、若x和y代表整型数，以下表达式中不能正确表示数学关系|x-y|<10的是
    A、(x-y)<-10||!(y-x)>10
    B、fabs(x-y)<10
    C、x-y>-10 && x-y<10
    D、(x-y)*(x-y)<100

13、程序功能：从键盘输入一个字符，判别它是否为大写字母。如果是，将它转换成小写字母，如果不是，不转换。在屏幕上输出最后得到的字符。程序代码如下，为实现上述功能，请将第8行标号处缺少的语句填写完整。#include<stdio.h> int main() { char c; printf("Please input a character:"); scanf("%c",&c); if(c >='A'&&c <= 'Z') c =_______________; printf("%c\n",c); return 0; }
    A、c+32
    B、c+48
    C、c+65
    D、c+97

14、程序代码如下：#include <stdio.h> int main() { int a,b; printf("please input a and b:\n"); scanf("%d%d",&a,&b); printf("the output data is %d\n",a<b?b:a); return 0; } 从键盘输入以下数据： 2<回车> 7<回车> 则程序输出为
    A、the output data is 7
    B、the output data is 2
    C、the output data is 1
    D、the output data is 0

15、以下程序运行后的输出结果是#include <stdio.h> int main() { int a=5,b=4,c=3,d; d=(a>b>c); printf("%d\n",d); return 0; }
    A、0
    B、1
    C、5
    D、4
    E、3

16、下面程序运行后的输出结果是#include <stdio.h> int main() { int a=3,b=4,c=5,d=2; if(a>b) { if(b>c) { printf("%d",d++ +1); } else { printf("%d",++d +1); } } printf("%d\n",d); return 0; }
    A、2
    B、3
    C、43
    D、44

17、下列说法错误的是（）。
    A、case后的“常量表达式”的类型只能是整型。
    B、若case后面的语句省略不写，则表示它什么也不做。
    C、switch语句中的break和default可有可无。
    D、每个case后的“常量表达式”的类型应该与switch后括号内表达式的类型一致。
    E、程序执行到switch语句时，先计算表达式的值，然后自上而下寻找与该值匹配的case常量，找到后则按顺序执行此case后的所有语句，而不再进行判断，直到遇break语句或右花括号}为止。
    F、若所有的case常量都不能与表达式的值相匹配，那么就执行default后面的语句。通常用于处理不在合理区间内的非法数据。
    G、每个case后的常量只起语句标号的作用，所以case常量的值必须互不相同，而且在每个case的语句序列后都有break的情况下，改变case常量出现的次序，不影响程序的运行结果。
    H、case后面的表达式不能是含有变量的关系表达式和逻辑表达式，它不能像if语句那样起到判断表达式真假的作用。

练兵区——编程题——不计入总分

1、检测用户错误输入

2、闰年判断

3、程序改错v1.0

4、字符类型判断

5、快递费用计算

6、数位拆分v2.0

7、出租车计价

8、数据区间判断

9、计算一元二次方程的根v2.0

第5周——周而复始的循环之道

5.1 计数控制的循环（31分钟）随堂测验

1、下列说法错误的是（）。
    A、逗号运算符也称为顺序求值运算符，由逗号运算符构成的表达式称为逗号表达式。
    B、多数情况下，我们并不使用整个逗号表达式的值，主要用它来顺序求得到各个子表达式的值。
    C、逗号表达式主要用在循环语句中同时对多个变量赋初值等。
    D、在逗号表达式中，其第一个表达式的值就是整个逗号表达式的值。

5.3 条件控制的循环（32分钟）随堂测验

1、下列说法错误的是（）。
    A、函数rand()用于生成一个[0,RAND_MAX]间的随机数，RAND_MAX是不大于双字节整数的最大值32767的宏常量。使用函数rand()必须在程序开头加上这样一条编译预处理指令：#include <stdio.h>
    B、magic = rand()%100 + 1用于生成[1，100]之间的随机数。
    C、事实上，函数rand()产生的都是伪随机数。
    D、函数srand()用于为rand()设置随机数种子，使rand()产生的随机数“随机化”。

5.4 嵌套循环（17分钟）随堂测验

1、下列说法错误的是（ ）。
    A、执行嵌套循环时是先执行内层循环，后执行外层循环。
    B、嵌套循环的内层和外层循环的循环控制变量不能同名。
    C、嵌套循环的循环次数等于外层循环的循环次数与内层循环的循环次数之积。
    D、如果一个循环的循环体中又完整地包含了另一个循环，则称为嵌套循环。

5.5 穷举（39分钟）随堂测验

1、下面程序段中的break语句是转移到哪里去执行（）。for(...) { for(...) { switch(...) { case 1: ... break; case 2:... ... } A: //code } B: //code } C: //code
    A、转到标号A所在的语句行与执行
    B、转到标号B所在的语句行与执行
    C、转到标号C所在的语句行与执行
    D、不进行流程转移，而是继续执行break后面的语句

5.6 进阶：软件调试与错误实例分析（27分钟）随堂测验

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

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 );

3、以下程序执行后的输出结果是 #include <stdio.h> int main( ) { int x=0,y=5,z=3; while(z-->0 && ++x<5) { y=y-1; } printf("%d,%d,%d\n",x,y,z); return 0; }
    A、3,2,-1
    B、3,2,0
    C、4,3,-1
    D、5,-2,-5

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

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 = %d\n", x); find = 1; } x++; } return 0; }
    A、第5行： !find 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
    B、第5行： find==1 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
    C、第5行： find!=1 第7行： x/2==1 && x/3==2 && x/5==4 && x/6==5 && x/7==0
    D、第5行： find!=0 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0

6、鸡兔同笼，共有98个头，386只脚，编程求鸡、兔各多少只。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int x, y; for (x=1; _______; x++) { ____________; if (____________) { printf("x = %d, y = %d", x, y); } } return 0; }
    A、第5行： x<=97 第7行： y = 98 - x 第8行： 2*x+4*y == 386
    B、第5行： x<97 第7行： x = 98 - y 第8行： 2*x+4*y == 386
    C、第5行： x<97 第7行： y = 98 - x 第8行： 2x+4y == 386
    D、第5行： x<=97 第7行： x = 98 - y 第8行： 2*x+4*y <= 386

7、以下能正确计算1×2×3×4...×10的程序段是
    A、i=1; s=1; do { s=s*i; i++; } while(i<=10);
    B、do { i=1; s=1; s=s*i; i++; } while(i<=10);
    C、do { i=1; s=0; s=s*i; i++; } while(i<=10);
    D、i=1; s=0; do { s=s*i; i++; } while(i<=10);

8、以下程序执行后的输出结果是 #include <stdio.h> int main( ) { int i,n=0; for(i=2;i<5;i++) { do { if(i%3) continue; n++; }while(!i); n++; } printf("n=%d\n",n); return 0; }
    A、n=4
    B、n=5
    C、n=2
    D、n=3

9、以下正确的描述是
    A、只能在循环体内和switch语句体内使用break语句
    B、continue语句的作用是结束整个循环的执行
    C、在循环体内使用break语句或continue语句的作用相同
    D、continue语句可以写在循环体之外

10、计算 直到最后一项的绝对值小于 为止。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <math.h> int main() { int n = 1; float term = 1, sum = 0; ______________; while (fabs(term) >= 1e-4) //判末项大小 { term = sign / n; //求出累加项 sum = sum + term; //累加 ________________; //改变项的符号 n++; //分母加1 } printf("sum = %f\n", sum); return 0; }
    A、第7行代码： float sign=1 第13行代码： sign = -sign
    B、第7行代码： float sign= -1 第13行代码： sign = -sign
    C、第7行代码： float sign=1 第13行代码： term = -term
    D、第7行代码： float sign= -1 第13行代码： term = -term

11、设已定义i和k为int类型变量，则以下for循环语句 for(i=0,k=-1;k=1; i++,k++) printf( "* * * *\n");
    A、是无限循环
    B、判断循环结束的条件不合法
    C、循环一次也不执行
    D、循环只执行一次

12、有以下程序,若从键盘给n输入的值是-3,则程序的输出结果是 #include <stdio.h> int main() { int s=0,a=1,n; scanf("%d",&n); do { s+=1; a=a-2; } while(a!=n); printf("%d\n",s); return 0; }
    A、2
    B、-1
    C、3
    D、0

13、以下程序运行后的输出结果是 #include <stdio.h> int main() { int i=0,s=0; for (;;) { if(i==3||i==5) continue; if (i==6) break; i++; s+=i; } printf("%d\n",s); return 0; }
    A、程序进入死循环
    B、10
    C、13
    D、21

14、下面程序的功能是输出以下形式的图案,则在下划线处应填入的是 * *** ***** ******* #include <stdio.h> int main( ) { int i,j; for(i=1;i<=4;i++) { for(j=1;j<=__________;j++) { printf("*"); } printf("\n"); } return 0; }
    A、2*i-1
    B、2*i+1
    C、i+2
    D、i

15、程序执行后的输出结果是 #include <stdio.h> int main( ) { int i,s=0; for(i=1;i<10;i+=2) { s+=i+1; } printf("%d\n",s); return 0; }
    A、自然数1～10中的偶数之和
    B、自然数1～9的累加和
    C、自然数1～10的累加和
    D、自然数1～9中的奇数之和

16、以下程序的输出结果是 #include <stdio.h> int main() { int a, b; for(a=1, b=1; a<=100; a++) { if(b>=10) break; if (b%3==1) { b+=3; continue; } } printf("%d\n",a); return 0; }
    A、4
    B、101
    C、6
    D、5

17、三色球问题。若一个口袋中放有12个球，其中有3个红色的，3个白色的，6个黑色的，从中任取8个球，问共有多少种不同的颜色搭配？ 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int i, j, k; for (i=0; i<=3; i++) { for (j=0; j<=3; j++) { for (________________) { if (__________________) { printf("i=%d, j=%d, k=%d\n", i, j, k); } } } } return 0; }
    A、第9行： k=0; k<=6; k++ 第11行： i + j + k == 8
    B、第9行： k=0; k<=6; k++ 第11行： i + j + k = 8
    C、第9行： k=0; k<=6; k++ 第11行： i + j + k <= 8
    D、第9行： k=0; k<6; k++ 第11行： i + j + k == 8

18、我国古代的《张丘建算经》中有这样一道著名的百鸡问题：“鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。百钱买百鸡，问鸡翁、母、雏各几何？”其意为：公鸡每只5元，母鸡每只3元，小鸡3只1元。用100元买100只鸡，问公鸡、母鸡和小鸡各能买多少只？ 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int x, y, z; for (x=0; x<=20; x++) { for (y=0; _________; y++) { _______________; if (_______________) { printf("x=%d, y=%d, z=%d\n", x, y, z); } } } return 0; }
    A、第7行： y<=33 第9行： z = 100 – x - y 第10行： 5*x + 3*y + z/3.0 == 100
    B、第7行： y<=33 第9行： z + y + x = 100 第10行： 5*x + 3*y + z/3.0 = 100
    C、第7行： y<=33 第9行： z = 100 – x - y 第10行： 5x + 3y + z/3.0 == 100
    D、第7行： y<33 第9行： z = 100 – x - y 第10行： 5*x + 3*y + z/3.0 <= 100

19、以下不是死循环的程序段是
    A、int s=36; while (s) { --s; }
    B、int i=100; while(1) { i=i%100+1; if (i>100) break; }
    C、for( ; ;);
    D、unsigned int k=0; do{ ++k; } while (k>=0);

20、以下程序的功能是计算：s= 1+1/2+1/3+……+1/10,程序运行后输出结果错误，导致错误结果的程序行是 #include <stdio.h> int main() { int n; float s; s=1.0; for(n=10;n>1;n--) { s=s+1/n; } printf("%6.4f\n",s); return 0; }
    A、s=s+1/n;
    B、printf("%6.4f\n",s);
    C、for(n=10;n>1;n--)
    D、s=1.0;

21、以下程序运行时，从键盘输入：01<回车>，程序执行后的输出结果是 #include <stdio.h> int main( ) { char k; int i; for(i=1;i<3;i++) { scanf("%c",&k); switch(k) { case '0': printf("another\n"); case '1': printf("number\n"); } } return 0; }
    A、another number number
    B、number number
    C、another number
    D、another number another

22、华氏和摄氏温度的转换公式为C=5/9×（F-32）。式中，C表示摄氏温度，F表示华氏温度。要求：华氏0℉～300℉，每隔20℉输出一个华氏温度对应的摄氏温度值。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int upper = 300, step = 20; float fahr = 0, celsius; while (fahr < upper) { _________________; printf("%4.0f\t%6.1f\n", fahr, celsius); ________________ ; } return 0; }
    A、第8行代码： celsius = 5.0 / 9 * (fahr - 32) 第10行代码： fahr = fahr + step
    B、第8行代码： celsius = 5 / 9 * (fahr - 32) 第10行代码： fahr = fahr + step
    C、第8行代码： celsius = 5.0 / (9 * (fahr - 32)) 第10行代码： fahr = fahr + step
    D、第8行代码： celsius = 5.0 / 9 * (fahr - 32) 第10行代码： fahr = fahr - step

23、利用泰勒级数： 计算e的近似值，当最后一项的绝对值小于 时认为达到了精度要求，要求统计总共累加了多少项。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <math.h> #include <stdio.h> int main() { int n = 1, count = 1; ________________; double term = 1.0; while (fabs(term) >= 1e-5) //判末项大小 { ______________; //求出累加项 e = e + term; //累加 n++; // 计算下一项 _______________; //统计累加项数 } printf("e = %f, count = %d\n", e, count); return 0; }
    A、第6行代码： double e = 1.0 第10行代码： term = term / n 第13行代码： count++
    B、第6行代码： double e = 0 第10行代码： term = term / n 第13行代码： count++
    C、第6行代码： double e = 1.0 第10行代码： term = term *n 第13行代码： count++
    D、第6行代码： double e = 0 第10行代码： term = term *n 第13行代码： count++

24、打印所有的“水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如，153是“水仙花数”，因为 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int i, j, k, n; printf("result is:"); for (n=100; ________; n++) { i = n / 100; //分离出百位 j = ____________; //分离出十位 k = ____________; //分离出个位 if (_________________________) { printf("%d\t ",n); //输出结果 } } printf("\n"); return 0; }
    A、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n % 10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k
    B、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n % 10 第11行：i*100+j*10+k = i*i*i+j*j*j+k*k*k
    C、第6行： n<=1000 第9行： n % 100 第10行：n % 10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k
    D、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n /10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k

练兵区——单选题——不计入总分

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

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 );

3、下面程序的输出是#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

4、爱因斯坦数学题。爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶，最后才正好1阶不剩。请问，这条阶梯共有多少阶？ 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { int x = 1, find = 0; while (__________) { if (______________________) { printf("x = %d\n", x); find = 1; } x++; } return 0; }
    A、第5行： !find 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
    B、第5行： find==1 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0
    C、第5行： find!=1 第7行： x/2==1 && x/3==2 && x/5==4 && x/6==5 && x/7==0
    D、第5行： find!=0 第7行： x%2==1 && x%3==2 && x%5==4 && x%6==5 && x%7==0

5、鸡兔同笼，共有98个头，386只脚，编程求鸡、兔各多少只。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { int x, y; for (x=1; _______; x++) { ____________; if (____________) { printf("x = %d, y = %d", x, y); } } return 0; }
    A、第5行： x<=97 第7行： y = 98 - x 第8行： 2*x+4*y == 386
    B、第5行： x<97 第7行： x = 98 - y 第8行： 2*x+4*y == 386
    C、第5行： x<97 第7行： y = 98 - x 第8行： 2x+4y == 386
    D、第5行： x<=97 第7行： x = 98 - y 第8行： 2*x+4*y <= 386

6、以下正确的描述是
    A、只能在循环体内和switch语句体内使用break语句
    B、continue语句的作用是结束整个循环的执行
    C、在循环体内使用break语句或continue语句的作用相同
    D、continue语句可以写在循环体之外

7、华氏和摄氏温度的转换公式为C=5/9×（F-32）。式中，C表示摄氏温度，F表示华氏温度。要求：华氏0℉～300℉，每隔20℉输出一个华氏温度对应的摄氏温度值。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { int upper = 300, step = 20; float fahr = 0, celsius; while (fahr < upper) { _________________; printf("%4.0f\t%6.1f\n", fahr, celsius); ________________ ; } return 0; }
    A、第8行代码： celsius = 5.0 / 9 * (fahr - 32) 第10行代码： fahr = fahr + step
    B、第8行代码： celsius = 5 / 9 * (fahr - 32) 第10行代码： fahr = fahr + step
    C、第8行代码： celsius = 5.0 / (9 * (fahr - 32)) 第10行代码： fahr = fahr + step
    D、第8行代码： celsius = 5.0 / 9 * (fahr - 32) 第10行代码： fahr = fahr - step

8、利用泰勒级数： 计算e的近似值，当最后一项的绝对值小于 时认为达到了精度要求，要求统计总共累加了多少项。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <math.h> #include <stdio.h> int main() { int n = 1, count = 1; ________________; double term = 1.0; while (fabs(term) >= 1e-5) //判末项大小 { ______________; //求出累加项 e = e + term; //累加 n++; // 计算下一项 _______________; //统计累加项数 } printf("e = %f, count = %d\n", e, count); return 0; }
    A、第6行代码： double e = 1.0 第10行代码： term = term / n 第13行代码： count++
    B、第6行代码： double e = 0 第10行代码： term = term / n 第13行代码： count++
    C、第6行代码： double e = 1.0 第10行代码： term = term *n 第13行代码： count++
    D、第6行代码： double e = 0 第10行代码： term = term *n 第13行代码： count++

9、打印所有的“水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如，153是“水仙花数”，因为 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { int i, j, k, n; printf("result is:"); for (n=100; ________; n++) { i = n / 100; //分离出百位 j = ____________; //分离出十位 k = ____________; //分离出个位 if (_________________________) { printf("%d\t ",n); //输出结果 } } printf("\n"); return 0; }
    A、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n % 10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k
    B、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n % 10 第11行：i*100+j*10+k = i*i*i+j*j*j+k*k*k
    C、第6行： n<=1000 第9行： n % 100 第10行：n % 10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k
    D、第6行： n<1000 第9行： (n - i * 100) / 10 第10行：n /10 第11行：i*100+j*10+k == i*i*i+j*j*j+k*k*k

10、以下程序执行后的输出结果是#include <stdio.h> int main( ) { int i,n=0; for(i=2;i<5;i++) { do { if(i%3) continue; n++; }while(!i); n++; } printf("n=%d\n",n); return 0; }
    A、n=4
    B、n=5
    C、n=2
    D、n=3

11、以下程序运行后的输出结果是#include <stdio.h> int main() { int i=0,s=0; for (;;) { if(i==3||i==5) continue; if (i==6) break; i++; s+=i; } printf("%d\n",s); return 0; }
    A、程序进入死循环
    B、10
    C、13
    D、21

12、程序执行后的输出结果是 #include <stdio.h> int main( ) { int i,s=0; for(i=1;i<10;i+=2) { s+=i+1; } printf("%d\n",s); return 0; }
    A、自然数1～10中的偶数之和
    B、自然数1～9的累加和
    C、自然数1～10的累加和
    D、自然数1～9中的奇数之和

13、以下程序运行时，从键盘输入：01<回车>，程序执行后的输出结果是#include <stdio.h> int main( ) { char k; int i; for(i=1;i<3;i++) { scanf("%c",&k); switch(k) { case '0': printf("another\n"); case '1': printf("number\n"); } } return 0; }
    A、another number number
    B、number number
    C、another number
    D、another number another

14、以下程序执行后的输出结果是#include <stdio.h> int main( ) { int x=0,y=5,z=3; while(z-->0 && ++x<5) { y=y-1; } printf("%d,%d,%d\n",x,y,z); return 0; }
    A、3,2,-1
    B、3,2,0
    C、4,3,-1
    D、5,-2,-5

15、以下能正确计算1×2×3×4...×10的程序段是
    A、i=1; s=1; do { s=s*i; i++; } while(i<=10);
    B、do { i=1; s=1; s=s*i; i++; } while(i<=10);
    C、do { i=1; s=0; s=s*i; i++; } while(i<=10);
    D、i=1; s=0; do { s=s*i; i++; } while(i<=10);

16、下面程序的功能是输出以下形式的图案,则在下划线处应填入的是 * *** ***** *******#include <stdio.h> int main( ) { int i,j; for(i=1;i<=4;i++) { for(j=1;j<=__________;j++) { printf("*"); } printf("\n"); } return 0; }
    A、2*i-1
    B、2*i+1
    C、i+2
    D、i

17、以下程序的输出结果是#include <stdio.h> int main() { int a, b; for(a=1, b=1; a<=100; a++) { if(b>=10) break; if (b%3==1) { b+=3; continue; } } printf("%d\n",a); return 0; }
    A、4
    B、101
    C、6
    D、5

18、以下不是死循环的程序段是
    A、int s=36; while (s) { --s; }
    B、int i=100; while(1) { i=i%100+1; if (i>100) break; }
    C、for( ; ;);
    D、unsigned int k=0; do{ ++k; } while (k>=0);

19、计算 直到最后一项的绝对值小于 为止。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <math.h> int main() { int n = 1; float term = 1, sum = 0; ______________; while (fabs(term) >= 1e-4) //判末项大小 { term = sign / n; //求出累加项 sum = sum + term; //累加 ________________; //改变项的符号 n++; //分母加1 } printf("sum = %f\n", sum); return 0; }
    A、第7行代码： float sign=1 第13行代码： sign = -sign
    B、第7行代码： float sign= -1 第13行代码： sign = -sign
    C、第7行代码： float sign=1 第13行代码： term = -term
    D、第7行代码： float sign= -1 第13行代码： term = -term

20、设已定义i和k为int类型变量，则以下for循环语句for(i=0,k=-1;k=1; i++,k++) printf( "* * * *\n");
    A、是无限循环
    B、判断循环结束的条件不合法
    C、循环一次也不执行
    D、循环只执行一次

21、有以下程序,若从键盘给n输入的值是-3,则程序的输出结果是#include <stdio.h> int main() { int s=0,a=1,n; scanf("%d",&n); do { s+=1; a=a-2; } while(a!=n); printf("%d\n",s); return 0; }
    A、2
    B、-1
    C、3
    D、0

22、三色球问题。若一个口袋中放有12个球，其中有3个红色的，3个白色的，6个黑色的，从中任取8个球，问共有多少种不同的颜色搭配？ 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int i, j, k; for (i=0; i<=3; i++) { for (j=0; j<=3; j++) { for (________________) { if (__________________) { printf("i=%d, j=%d, k=%d\n", i, j, k); } } } } return 0; }
    A、第9行： k=0; k<=6; k++ 第11行： i + j + k == 8
    B、第9行： k=0; k<=6; k++ 第11行： i + j + k = 8
    C、第9行： k=0; k<=6; k++ 第11行： i + j + k <= 8
    D、第9行： k=0; k<6; k++ 第11行： i + j + k == 8

23、我国古代的《张丘建算经》中有这样一道著名的百鸡问题：“鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。百钱买百鸡，问鸡翁、母、雏各几何？”其意为：公鸡每只5元，母鸡每只3元，小鸡3只1元。用100元买100只鸡，问公鸡、母鸡和小鸡各能买多少只？ 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int x, y, z; for (x=0; x<=20; x++) { for (y=0; _________; y++) { _______________; if (_______________) { printf("x=%d, y=%d, z=%d\n", x, y, z); } } } return 0;
    A、第7行： y<=33 第9行： z = 100 – x - y 第10行： 5*x + 3*y + z/3.0 == 100
    B、第7行： y<=33 第9行： z + y + x = 100 第10行： 5*x + 3*y + z/3.0 = 100
    C、第7行： y<=33 第9行： z = 100 – x - y 第10行： 5x + 3y + z/3.0 == 100
    D、第7行： y<33 第9行： z = 100 – x - y 第10行： 5*x + 3*y + z/3.0 <= 100

24、以下程序的功能是计算：s= 1+1/2+1/3+……+1/10,程序运行后输出结果错误，导致错误结果的程序行是#include <stdio.h> int main() { int n; float s; s=1.0; for(n=10;n>1;n--) { s=s+1/n; } printf("%6.4f\n",s); return 0; }
    A、s=s+1/n;
    B、printf("%6.4f\n",s);
    C、for(n=10;n>1;n--)
    D、s=1.0;

第6周编程实验题

1、马克思手稿中的趣味数学题

2、猜神童年龄

3、闰年相关的问题v3.0——计算有多少闰年

4、闰年相关的问题v4.0——计算心跳数

练兵区——编程题——不计入总分

1、判断一个整型数据有几位v2.0

2、奖金计算

3、程序修改—1

4、程序修改—2

5、程序改错-1

6、程序改错-2

7、程序改错-3

8、猴子吃桃程序_扩展1

9、猴子吃桃程序_扩展2

10、6位密码输入检测

11、判断一个整型数据有几位v1.0

12、检测输入数据中奇数和偶数的个数

13、计算球的反弹高度

第6周——函数：分工与合作的艺术

6.1 函数定义、调用、参数传递和函数原型（35分半）随堂测验

1、下列说法中错误的是（）。
    A、函数中的return语句可以有多个，但是多个return语句并不表示函数可以用return返回多个值，用return返回的函数值只能有一个。
    B、在C语言中，只有当实参与其对应的形参同名时，才共占同一个存储单元，此时形参值的变化会影响到实参的值。
    C、形参也是局部变量，只能在函数体内访问。
    D、在C语言中，实参与其对应的形参各占独立的存储单元，函数调用时的参数传递就是把实参的值复制一份给形参，即由实参向形参进行单向传值，因此形参值的变化不影响实参的值。

6.1 函数定义、调用、参数传递和函数原型（35分半）随堂测验

1、下列说法错误的是（）。
    A、当函数原型与函数定义中的形参类型不一致时，编译器一般都会指出参数类型不匹配的编译错误。因此，写上函数原型有助于编译器对函数参数进行类型匹配检查。
    B、函数声明是一条语句，不包括函数体。
    C、无论何种情况，只要把用户自定义的所有函数都放在main函数的前面，就可以不用写函数原型了。
    D、函数调用时，要求实参与形参的数量相等，它们的类型也要匹配，匹配的原则与变量赋值的原则一致。当函数调用时的实参与函数定义中的形参的类型不匹配时，有的编译器会发出警告，提示有可能出现数据信息丢失，而有的编译器则不会发出警告。

6.2 函数封装与程序的健壮性（23分钟）随堂测验

1、下列说法错误的是（）。
    A、我们常将程序具有遇到不正确使用或非法数据输入时仍能保护自己避免出错的能力称为程序的健壮性。
    B、在函数的入口处增加对函数参数合法性的检查以及对函数调用是否成功的检查，是一种常用的增强程序健壮性的方法。
    C、对于一个封装好的函数，外界对函数的影响仅限于入口参数，函数对外界的影响仅限于函数的返回值和数组、指针形参 。
    D、编译器给出的警告信息无关紧要，因此可以忽略。

6.3 进阶：断言与防御式编程（14分钟）随堂测验

1、下列说发错误的是（）。
    A、assert()其实是一个在<assert.h>中定义的宏，用来验证“不应该”发生的情况是否的确不会发生。
    B、assert()的功能就是验证assert后括号内表达式值的真假，当该表达式的值为真时，它什么也不做。反之，则立即终止程序的执行，并报告错误，但是不会对错误采取其他处理措施。
    C、在使用assert()时，必须在源文件中用编译预处理指令包含头文件<assert.h>。
    D、断言不仅可以用于调试程序，还可以作为程序的功能，检查有可能发生的程序错误。

6.3 进阶：断言与防御式编程（14分钟）随堂测验

1、在下列哪些情况下适合使用断言？
    A、检查程序中的各种假设的正确性。
    B、证实或测试某种不可能发生的状况确实不会发生。
    C、捕捉不应该或者不可能发生的非法情况。
    D、捕捉程序中有可能出现的错误。

6.4 进阶：代码风格（22分钟）随堂测验

1、下面所列举的函数名正确且具有良好风格的是（）
    A、2_abcd()
    B、GetNumber()
    C、change_directory()
    D、chushihua@()

第6周测验

1、下列说法中正确的是
    A、函数原型是一条语句，不包括函数体。
    B、无论何种情况，只要把用户自定义的所有函数都放在main函数的前面，就可以不用写函数原型了。
    C、在C语言中，只有当实参与其对应的形参同名时，才共占同一个存储单元，此时形参值的变化会影响到实参的值。
    D、函数只有一个返回值，所以不能有多个return语句。

2、以下程序有语法错误，有关错误原因的正确说法是 #include <stdio.h> void prt_char(float x); int main() { int G=5,k; ...... k=prt_char(G); ...... return 0; } int prt_char(int x) { ...... }
    A、函数原型和函数定义不匹配
    B、变量名不能使用大写字母
    C、函数名不能使用下划线
    D、函数prt_char(int x)定义的位置不对，不能放在主函数main()的后面。

3、以下程序的功能是选出能被3整除且至少有一位是5的两位数的整数，输出所有满足条件的数及其个数。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int Sub(int k,int n) { int a1,a2; a2=k/10; a1=k-a2*10; if(________________) { printf("%4d",k); n++; return n; } else return -1; } int main() { int n=0,k,m; for(k=10;k<100;k++) { m=__________; if(________) n=m; } printf("\nn=%d\n",n); return 0; }
    A、第7行： (k%3==0&&a2==5)||(k%3==0&&a1==5) 第22行： Sub(k,n) 第24行： m!=-1
    B、第7行：(k%3==0 &&a2==5) && (k%3==0 &&a1==5) 第22行：Sub(n,k) 第24行：m==-1
    C、第7行：(k%3=0 && a2=5)||(k%3=0 && a1=5) 第22行：Sub(k,n) 第24行：m=-1
    D、第7行：(k%3=0 && a2=5) && (k%3=0 && a1=5) 第22行：Sub(n,k) 第24行：m!=-1

4、设计一个函数，用来判断一个整数是否为素数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <math.h> #include <stdio.h> int IsPrimeNumber(int number); int main() { int n, ret; printf("Input n:"); scanf("%d", &n); ret = IsPrimeNumber(n); if (___________) { printf("%d is a prime number\n", n); } else { printf("%d is not a prime number\n", n); } return 0; } //函数功能：判断number是否是素数,函数返回非0值,表示是素数，否则不是素数 int IsPrimeNumber(int number) { int i; if (number <= 1) return 0; // 负数、0和1都不是素数 for (i=2; ________________; i++) { if (_______________) // 被整除，不是素数 return 0; } return 1; }
    A、第11行： ret != 0 第29行： i<=sqrt(number) 第31行： number % i == 0
    B、第11行： ret == 0 第29行： i<=number 第31行： number % i == 0
    C、第11行： ret == 0 第29行： i<=sqrt(number) 第31行： number / i == 0
    D、第11行： ret != 0 第29行： i<=number 第31行： number / i == 0

5、以下程序执行后的输出结果是 void Fun(int v , int w) { int t; t=v; v=w; w=t; } int main( ) { int x=1,y=3,z=2; if(x>y) Fun(x,y); else if(y>z) Fun(y,z); else Fun(x,z); printf("%d,%d,%d\n",x,y,z); return 0; }
    A、1,3,2
    B、1,2,3
    C、3,1,2
    D、2,3,1

6、若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是
    A、函数调用可以作为一个函数的形参
    B、函数调用可以作为独立的语句存在
    C、函数调用可以作为一个函数的实参
    D、函数调用可以出现在表达式中

7、有以下函数定义： void Fun(int n, double x) { …… } 若以下选项中的变量都已正确定义并赋值如下: int a,k; double b; a=12; b=0.45; 则对函数Fun的正确调用语句是
    A、Fun(a,b);
    B、Fun(int y,double m);
    C、k=Fun(10,12.5);
    D、k=void Fun(a,b);

8、设计一个函数MinCommonMultiple()，计算两个正整数的最小公倍数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int MinCommonMultiple(int a, int b); int main() { int a, b, x; printf("Input a,b:"); scanf("%d,%d", &a, &b); x = _________________; if (__________) printf("MinCommonMultiple = %d\n", x); else printf("Input error!\n"); return 0; } //函数功能：计算两个正整数的最小公倍数，-1表示没有最小公倍数 int MinCommonMultiple(int a, int b) { int i; if (_________________) return -1; // 保证输入的参数为正整数 for (i=1; i<b; i++) { if (________________) return i * a; } return b * a; }
    A、第8行： MinCommonMultiple(a, b) 第10行： x != -1 第22行： a<=0 || b<=0 第26行： (i * a) % b == 0
    B、第8行： MinCommonMultiple 第10行： x == -1 第22行： a<=0 && b<=0 第26行： (i * a) % b == 0
    C、第8行： MinCommonMultiple(b, a) 第10行： x != -1 第22行： a<=0 || b<=0 第26行： (i * a) / b == 0
    D、第8行： MinCommonMultiple(int a, int b) 第10行： x = -1 第22行： a<=0 || b<=0 第26行： (i * a) % b == 0

9、设计一个函数MaxCommonFactor()，利用欧几里德算法（也称辗转相除法）计算两个正整数的最大公约数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int MaxCommonFactor(int a, int b); int main() { int a, b, x; printf("Input a,b:"); scanf("%d,%d", &a, &b); x =_______________ ; if (x != -1) { printf("MaxCommonFactor = %d\n", x); } else { printf("Input error!\n"); } return 0; } //函数功能： 计算两个正整数的最大公约数，-1表示没有最大公约数 int MaxCommonFactor(int a, int b) { int r; if (a<=0 || b<=0) return -1; // 保证输入的参数为正整数 do{ ____________; a = b; _____________; }while (__________); return a; }
    A、第8行： MaxCommonFactor(a, b) 第29行： r = a % b 第31行： b = r 第32行： r != 0
    B、第8行： MaxCommonFactor(a, b, x) 第29行： r = a % b 第31行： a = r 第32行： r == 0
    C、第8行： MaxCommonFactor(a, x) 第29行： r = b % a 第31行： b = r 第32行： r = 0
    D、第8行： MaxCommonFactor(x, b) 第29行： r = a / b 第31行： a = r 第32行： r != 0

10、C语言规定：在一个源程序中，main函数的位置
    A、可以任意
    B、必须在程序的最开始
    C、必须在系统调用的库函数的后面
    D、必须在程序的最后

11、编程计算下面组合数的值 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> _________________________; int main() { int m, k; _________; do{ printf("Please input m,k (m>=k>0):"); scanf("%d, %d", &m, &k); } while (______________); p = (double)Factorial(m) / (Factorial(k) * Factorial (m-k)); printf("p=%.0f\n", p); return 0; } //函数功能：计算无符号整型数number的阶乘 unsigned long Factorial(unsigned int number) { unsigned long i, result = 1; for (________________) { result *= i; } return result; }
    A、第2行： unsigned long Factorial(unsigned int number) 第6行： double p 第11行： m<k || m<0 || k<0 第23行： i=2; i<=number; i++
    B、第2行： long Factorial(unsigned int number) 第6行： double p 第11行： m<k || m<0 || k<0 第23行： i=1; i<number; i++
    C、第2行： unsigned long Factorial(int number) 第6行： int p 第11行： m<k && m<0 && k<0 第23行： i=2; i<=number; i++
    D、第2行： unsigned Factorial(unsigned number) 第6行： int p 第11行： m<k || m<0 || k<0 第23行： i=1; i<=number; i++

12、完全数，又称完美数或完数（Perfect Number），它是指这样的一些特殊的自然数，它所有的真因子（即除了自身以外的约数）的和，恰好等于它本身。例如，6就是一个完全数，是因为6 = 1 + 2 + 3。请编写一个判断完全数的函数IsPerfect()，然后判断从键盘输入的整数是否是完全数。注意：1没有真因子，所以不是完全数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <math.h> int IsPerfect(int x); int main() { int m; printf("Input m:"); scanf("%d", &m); if (_________________) /* 完全数判定 */ printf("%d is a perfect number\n", m); else printf("%d is not a perfect number\n", m); return 0; } /* 函数功能：判断完全数，若函数返回0，则代表不是完全数，若返回1，则代表是完全数 */ int IsPerfect(int x) { int i; int total = 0; /* 1没有真因子，不是完全数 */ for (__________________) { if (___________) total = total + i; } return total==x ? 1 : 0; }
    A、第10行： IsPerfect(m) 第24行： i=1; i<x; i++ 第26行： x % i == 0
    B、第10行： m 第24行： i=1; i<=x; i++ 第26行： x % i != 0
    C、第10行： IsPerfect(m)!=1 第24行： i=0; i<=x; i++ 第26行： x / i == 0
    D、第10行： IsPerfect(m)==0 第24行： i=0; i<x; i++ 第26行： x % i != 0

13、以下程序执行后输出结果是 #include <stdio.h> int MaxValue(int x, int y) { return x>y? x:y; } int MinValue(int x,int y) { return x>y? y:x; } int main() { int a=4,b=3,c=5,d,e,f; d=MaxValue(a,b); d=MaxValue(d,c); e=MinValue(a,b); e=MinValue(e,c); f=a+b+c-d-e; printf("%d,%d,%d\n",d,f,e); return 0; }
    A、5,4,3
    B、3,4,5
    C、5,3,4
    D、3,5,4

练兵区——单选题——不计入总分

1、设计一个函数MaxCommonFactor()，利用欧几里德算法（也称辗转相除法）计算两个正整数的最大公约数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int MaxCommonFactor(int a, int b); int main() { int a, b, x; printf("Input a,b:"); scanf("%d,%d", &a, &b); x =_______________ ; if (x != -1) { printf("MaxCommonFactor = %d\n", x); } else { printf("Input error!\n"); } return 0; } //函数功能： 计算两个正整数的最大公约数，-1表示没有最大公约数 int MaxCommonFactor(int a, int b) { int r; if (a<=0 || b<=0) return -1; // 保证输入的参数为正整数 do{ ____________; a = b; _____________; }while (__________); return a; }
    A、第8行： MaxCommonFactor(a, b) 第29行： r = a % b 第31行： b = r 第32行： r != 0
    B、第8行： MaxCommonFactor(a, b, x) 第29行： r = a % b 第31行： a = r 第32行： r == 0
    C、第8行： MaxCommonFactor(a, x) 第29行： r = b % a 第31行： b = r 第32行： r = 0
    D、第8行： MaxCommonFactor(x, b) 第29行： r = a / b 第31行： a = r 第32行： r != 0

2、C语言规定：在一个源程序中，main函数的位置
    A、可以任意
    B、必须在程序的最开始
    C、必须在系统调用的库函数的后面
    D、必须在程序的最后

3、以下程序执行后输出结果是#include <stdio.h> int MaxValue(int x, int y) { return x>y? x:y; } int MinValue(int x,int y) { return x>y? y:x; } int main() { int a=4,b=3,c=5,d,e,f; d=MaxValue(a,b); d=MaxValue(d,c); e=MinValue(a,b); e=MinValue(e,c); f=a+b+c-d-e; printf("%d,%d,%d\n",d,f,e); return 0; }
    A、5,4,3
    B、3,4,5
    C、5,3,4
    D、3,5,4

4、有以下函数定义： void Fun(int n, double x) { …… } 若以下选项中的变量都已正确定义并赋值如下: int a,k; double b; a=12; b=0.45; 则对函数Fun的正确调用语句是
    A、Fun(a,b);
    B、Fun(int y,double m);
    C、k=Fun(10,12.5);
    D、k=void Fun(a,b);

5、完全数，又称完美数或完数（Perfect Number），它是指这样的一些特殊的自然数，它所有的真因子（即除了自身以外的约数）的和，恰好等于它本身。例如，6就是一个完全数，是因为6 = 1 + 2 + 3。请编写一个判断完全数的函数IsPerfect()，然后判断从键盘输入的整数是否是完全数。注意：1没有真因子，所以不是完全数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <math.h> int IsPerfect(int x); int main() { int m; printf("Input m:"); scanf("%d", &m); if (_________________) /* 完全数判定 */ printf("%d is a perfect number\n", m); else printf("%d is not a perfect number\n", m); return 0; } /* 函数功能：判断完全数，若函数返回0，则代表不是完全数，若返回1，则代表是完全数 */ int IsPerfect(int x) { int i; int total = 0; /* 1没有真因子，不是完全数 */ for (__________________) { if (___________) total = total + i; } return total==x ? 1 : 0; }
    A、第10行： IsPerfect(m) 第24行： i=1; i<x; i++ 第26行： x % i == 0
    B、第10行： m 第24行： i=1; i<=x; i++ 第26行： x % i != 0
    C、第10行： IsPerfect(m)!=1 第24行： i=0; i<=x; i++ 第26行： x / i == 0
    D、第10行： IsPerfect(m)==0 第24行： i=0; i<x; i++ 第26行： x % i != 0

6、下列说法中正确的是
    A、函数原型是一条语句，不包括函数体。
    B、无论何种情况，只要把用户自定义的所有函数都放在main函数的前面，就可以不用写函数原型了。
    C、在C语言中，只有当实参与其对应的形参同名时，才共占同一个存储单元，此时形参值的变化会影响到实参的值。
    D、函数只有一个返回值，所以不能有多个return语句。

7、以下程序有语法错误，有关错误原因的正确说法是 #include <stdio.h> void prt_char(); int main() { int G=5,k; ...... k=prt_char(G); ...... return 0; } int prt_char(int x) { ...... }
    A、函数原型和函数定义不匹配
    B、变量名不能使用大写字母
    C、函数名不能使用下划线
    D、函数prt_char(int x)定义的位置不对，不能放在主函数main()的后面。

8、以下程序的功能是选出能被3整除且至少有一位是5的两位数的整数，输出所有满足条件的数及其个数。代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int Sub(int k,int n) { int a1,a2; a2=k/10; a1=k-a2*10; if(________________) { printf("%4d",k); n++; return n; } else return -1; } int main() { int n=0,k,m; for(k=10;k<100;k++) { m=__________; if(________) n=m; } printf("\nn=%d\n",n); return 0; }
    A、第7行： (k%3==0&&a2==5)||(k%3==0&&a1==5) 第22行： Sub(k,n) 第24行： m!=-1
    B、第7行：(k%3==0 &&a2==5) && (k%3==0 &&a1==5) 第22行：Sub(n,k) 第24行：m==-1
    C、第7行：(k%3=0 && a2=5)||(k%3=0 && a1=5) 第22行：Sub(k,n) 第24行：m=-1
    D、第7行：(k%3=0 && a2=5) && (k%3=0 && a1=5) 第22行：Sub(n,k) 第24行：m!=-1

9、设计一个函数，用来判断一个整数是否为素数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <math.h> #include <stdio.h> int IsPrimeNumber(int number); int main() { int n, ret; printf("Input n:"); scanf("%d", &n); ret = IsPrimeNumber(n); if (___________) { printf("%d is a prime number\n", n); } else { printf("%d is not a prime number\n", n); } return 0; } //函数功能：判断number是否是素数,函数返回非0值,表示是素数，否则不是素数 int IsPrimeNumber(int number) { int i; if (number <= 1) return 0; // 负数、0和1都不是素数 for (i=2; ________________; i++) { if (_______________) // 被整除，不是素数 return 0; } return 1; }
    A、第11行： ret != 0 第29行： i<=sqrt(number) 第31行： number % i == 0
    B、第11行： ret == 0 第29行： i<=number 第31行： number % i == 0
    C、第11行： ret == 0 第29行： i<=sqrt(number) 第31行： number / i == 0
    D、第11行： ret != 0 第29行： i<=number 第31行： number / i == 0

10、以下程序执行后的输出结果是void Fun(int v , int w) { int t; t=v; v=w; w=t; } int main( ) { int x=1,y=3,z=2; if(x>y) Fun(x,y); else if(y>z) Fun(y,z); else Fun(x,z); printf("%d,%d,%d\n",x,y,z); return 0; }
    A、1,3,2
    B、1,2,3
    C、3,1,2
    D、2,3,1

11、若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是
    A、函数调用可以作为一个函数的形参
    B、函数调用可以作为独立的语句存在
    C、函数调用可以作为一个函数的实参
    D、函数调用可以出现在表达式中

12、设计一个函数MinCommonMultiple()，计算两个正整数的最小公倍数。 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int MinCommonMultiple(int a, int b); int main() { int a, b, x; printf("Input a,b:"); scanf("%d,%d", &a, &b); x = _________________; if (__________) printf("MinCommonMultiple = %d\n", x); else printf("Input error!\n"); return 0; } //函数功能：计算两个正整数的最小公倍数，-1表示没有最小公倍数 int MinCommonMultiple(int a, int b) { int i; if (_________________) return -1; // 保证输入的参数为正整数 for (i=1; i<b; i++) { if (________________) return i * a; } return b * a; }
    A、第8行： MinCommonMultiple(a, b) 第10行： x != -1 第22行： a<=0 || b<=0 第26行： (i * a) % b == 0
    B、第8行： MinCommonMultiple 第10行： x == -1 第22行： a<=0 && b<=0 第26行： (i * a) % b == 0
    C、第8行： MinCommonMultiple(b, a) 第10行： x != -1 第22行： a<=0 || b<=0 第26行： (i * a) / b == 0
    D、第8行： MinCommonMultiple(int a, int b) 第10行： x = -1 第22行： a<=0 || b<=0 第26行： (i * a) % b == 0

13、编程计算下面组合数的值 代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> _________________________; int main() { int m, k; _________; do{ printf("Please input m,k (m>=k>0):"); scanf("%d, %d", &m, &k); } while (______________); p = (double)Factorial(m) / (Factorial(k) * Factorial (m-k)); printf("p=%.0f\n", p); return 0; } //函数功能：计算无符号整型数number的阶乘 unsigned long Factorial(unsigned int number) { unsigned long i, result = 1; for (________________) { result *= i; } return result; }
    A、第2行： unsigned long Factorial(unsigned int number) 第6行： double p 第11行： m<k || m<0 || k<0 第23行： i=2; i<=number; i++
    B、第2行： long Factorial(unsigned int number) 第6行： double p 第11行： m<k || m<0 || k<0 第23行： i=1; i<number; i++
    C、第2行： unsigned long Factorial(int number) 第6行： int p 第11行： m<k && m<0 && k<0 第23行： i=2; i<=number; i++
    D、第2行： unsigned Factorial(unsigned number) 第6行： int p 第11行： m<k || m<0 || k<0 第23行： i=1; i<=number; i++

第8周编程实验题

1、计算阶乘的和v2.0

2、计算最大的三位约数

3、孔融分梨

4、素数求和

练兵区——编程题——不计入总分

1、绘制金字塔

2、循环嵌套的应用

3、利用泰勒级数计算sinx的值

4、计算100~200之间的所有素数之和

5、编程实现一个输入指定范围内的整数的函数

6、程序改错v2.0

7、编程计算a+aa+aaa+…+aa…a（n个a）的值

8、搬砖问题

9、编程输出某年某月有多少天（考虑到闰年）

第7周——《盗梦空间》的逻辑：探寻递归的奥秘

7.1 从嵌套调用到递归调用（20分钟）随堂测验

1、下列说法错误的是（）
    A、函数既可以嵌套定义，也可以嵌套调用。
    B、函数直接或间接调用自己，称为递归调用。
    C、一个递归算法必须包含一般条件和基本条件两个基本要素。
    D、基本条件是一个能控制递归过程结束的条件，是递归的出口，它本身不再使用递归的方式来定义。一般条件定义了递归关系，控制递归调用向着基本条件的方向转化。

7.1 从嵌套调用到递归调用（20分钟）随堂测验

1、数学归纳法是递归的数学基础。

7.2 递归是如何执行的（16分钟）随堂测验

1、递归算法的执行过程可分为递推和回归两个阶段。在递推阶段，必须要有终止递归的情况。当满足递归终止条件时，即获得最简单情况的解以后，开始进入回归阶段，即递归返回阶段。

7.3 进阶：尾递归是什么鬼？（14分半）随堂测验

1、当递归调用是整个函数体中最后执行的语句且它的返回值不属于任何表达式的一部分（即在回归阶段不需要任何计算）时，这种递归调用就是尾递归。

7.4 变量的作用域（22分半）随堂测验

1、下列说法错误的是（）。
    A、变量的作用域是指变量的作用范围，即在程序中可以被读写访问的区域，它取决于变量被定义的位置。
    B、局部变量与全局变量同名时，全局变量隐藏局部变量，即全局变量起作用，局部变量不起作用。
    C、形参也是局部变量，形参变量和实参变量的作用域是不同的，因此形参变量和实参变量同名时，二者互不干扰。
    D、只要同名的变量出现在不同的作用域内，二者互不干扰，编译器有能力区分不同作用域中的同名变量

7.4 变量的作用域（22分半）随堂测验

1、全局变量破坏了函数的封装性，不能实现信息隐藏，依赖全局变量的函数很难在其他程序中复用，对于使用全局变量的程序维护也比较困难，因此建议尽量不用全局变量。

7.5 进阶：变量的生存期（33分半）随堂测验

1、下列说法错误的是（）。
    A、变量的作用域决定了变量可以被访问的范围，而变量的存储类型决定了变量的生存期。
    B、静态变量和全局变量都是在静态存储区中分配内存的，而自动变量是在动态存储区中分配内存的。
    C、用extern声明变量为外部变量的时候，编译器是对其分配内存的。
    D、静态局部变量和静态全局变量的生存期是相同的，但二者的作用域是不同的，而静态局部变量和自动变量的作用域都是局部的，但二者的生存期是不同的。

第7周测验

1、下列说法正确的是
    A、递归算法的执行过程可分为递推和回归两个阶段。在递推阶段，必须要有终止递归的情况。当满足递归终止条件时，即获得最简单情况的解以后，开始进入回归阶段，即递归返回阶段。
    B、基本条件是一个能控制递归过程结束的条件，是递归的出口，它本身不再使用递归的方式来定义。一般条件定义了递归关系，控制递归调用向着基本条件的方向转化。
    C、数学归纳法是递归的数学基础。
    D、形参也是局部变量，形参变量和实参变量的作用域是不同的，因此形参变量和实参变量同名时，二者互不干扰。
    E、全局变量破坏了函数的封装性，不能实现信息隐藏，依赖全局变量的函数很难在其他程序中复用，对于使用全局变量的程序维护也比较困难，因此建议尽量不用全局变量。
    F、函数既可以嵌套定义，也可以嵌套调用。
    G、局部变量与全局变量同名时，全局变量隐藏局部变量，即全局变量起作用，局部变量不起作用。
    H、用extern声明变量为外部变量的时候，编译器是对其分配内存的。
    I、静态局部变量和静态全局变量的生存期和作用域都是相同的。

2、以下程序运行后的输出结果是 #include <stdio.h> float Fun(int x,int y) { return(x+y); } int main() { int a=2,b=5,c=8; printf("%3.0f\n",Fun((int)Fun(a+c,b),a-c)); return 0; }
    A、9
    B、21
    C、9.0
    D、编译出错

3、子函数Fun(int a, int b)的功能是，对任意两个整数a和b,返回两者中的最大值。以下程序是通过调用子函数Fun(int a, int b)，找到三个整数中的最大值。若程序运行后的输出结果是8，请补充完整空白处缺少的代码。 #include <stdio.h> int Fun(int a, int b) { if(a>b) return_________; else return________; } int main() { int x=3, y=8, z=6, r; r=_______________; // 找到三个整数x,y,z中的最大值 printf("%d", r); return 0; }
    A、第4行： a 第5行： b 第11行： Fun(Fun(x,y),z)
    B、第4行： b 第5行： a 第11行： Fun(x,y,z)
    C、第4行： 1 第5行： 0 第11行： Fun(x,y,z)
    D、第4行： 0 第5行： 1 第11行： Fun(Fun(x,y),z)

4、写出下面程序的运行结果 #include <stdio.h> void Bin(int x) { if (x/2 > 0) Bin(x/2); printf("%d\n", x%2); } int main() { Bin(12); return 0; }
    A、1 1 0 0
    B、0 0 1 1
    C、6 3 1 0
    D、6 3 1 1

5、下面程序是用辗转相除法计算两个正整数的最大公约数的递归求解方法。请将程序补充完整。 提示：辗转相除法的基本思路是，对正整数a和b，连续进行求余运算，直到余数为0为止，此时非0的除数就是最大公约数。设r=a mod b表示a除以b的余数，若r≠0，则将b作为新的a，r作为新的b，重复a mod b运算，直到r=0时为止，此时b为所求的最大公约数。例如，50和15的最大公约数的求解过程可表示为：Gcd(50, 15)=Gcd(15, 5)=Gcd(5, 0)=5。 int Gcd(int a, int b) { if (a%b == 0) return b; else return ____________________; }
    A、Gcd(b, a%b)
    B、Gcd(a, b%a)
    C、Gcd(b%a, a)
    D、Gcd(a%b, b)

6、以下程序的输出结果是 #include <stdio.h> int Func(); int i=10; int main() { int j=1; j=Func(); printf("%d,",j); j=Func(); printf("%d",j); return 0; } int Func() { int k=0; k=k+i; i=i+10; return(k); }
    A、10,20
    B、0,0
    C、10,10
    D、20,20

7、子函数Incre()的功能是，利用静态变量，使子函数的输出值能够随调用次数的增加依次为： 第1次调用，输出： 的结果 第2次调用，输出： 的结果 第3次调用，输出： 的结果 ..... 在下面的程序中，对子函数Incre()进行了两次调用，若使程序的输出结果是： 2 6 请补充完整空白处缺少的代码。 #include <stdio.h> int x=3; void Incre(); int main() { int i; for (i=1;_______;i++) Incre(); return 0; } void Incre() { ___________; x*=x+1; printf("%d\n",x); }
    A、第7行： i<x 第13行： static int x=1
    B、第7行： i<=x 第13行： static int x=0
    C、第7行： i<x 第13行： int x=1
    D、第7行： i<=x 第13行： int x=0

8、请给出程序的运行结果。 #include <stdio.h> int Fun(int m) { static int n = 0; m /= 2; m = m * 2; if (m) { n *= m; return(Fun(m - 2)); } else return n; } int main() { int a, i; for (i = 0; i < 2; i++) { a = Fun(4 + i); printf("%d\n", a); } return 0; }
    A、0 0
    B、8 8
    C、4 4
    D、64 64

9、写出下面程序的运行结果。 #include <stdio.h> int Square(int i) { return i * i; } int main(void) { int i = 0; i = Square(i); for ( ; i<3; i++) { static int i = 1; i += Square(i); printf("%d,", i); } printf("%d\n", i); return 0; }
    A、2,6,42,3
    B、2,2,2,3
    C、2,2,3,3
    D、2,3,4,3

10、根据最大公约数的如下3条性质，采用递归法编写计算最大公约数的函数Gcd()，在主函数中调用该函数计算并输出从键盘任意输入的两正整数的最大公约数。 性质1 如果a>b，则a和b与a-b和b的最大公约数相同，即Gcd(a, b) = Gcd(a-b, b) 性质2 如果b>a，则a和b与a和b-a的最大公约数相同，即Gcd(a, b) = Gcd(a, b-a) 性质3 如果a=b，则a和b的最大公约数与a值和b值相同，即Gcd(a, b) = a = b 代码如下，请补充程序中缺少的内容。 #include <stdio.h> int Gcd(int a, int b); int main() { int a, b, c; printf("Input a,b:"); scanf("%d,%d", &a, &b); c = Gcd(a, b); if (_________) printf("Greatest Common Divisor of %d and %d is %d\n", a, b, c); else printf("Input number should be positive!\n"); return 0; } int Gcd(int a, int b) { if (_______________) return -1; if (a == b) return __________; else if (a > b) return __________; else return ___________; }
    A、第9行： c!= -1 第18行： a <= 0 || b <= 0 第21行： a 第23行： Gcd(a - b, b) 第25行： Gcd(a, b - a)
    B、第9行： c== -1 第18行： a <= 0 && b <= 0 第21行： a 第23行： Gcd(a - b, b) 第25行： Gcd(a, b - a)
    C、第9行： c!= -1 第18行： a <= 0 && b <= 0 第21行： b 第23行： Gcd(a, b - a) 第25行： Gcd(a - b, b)
    D、第9行： c== -1 第18行： a <= 0 || b <= 0 第21行： a 第23行： Gcd(a, b - a) 第25行： Gcd(a - b, b)

11、函数Sum(int n)是用递归方法计算下面的公式，请补充程序中缺少的内容。 int Sum(int n) { if (n <= 0) printf("data error\n"); if (n == 1)_________________; else return ____________________; }
    A、第4行： return 1 第5行： n+Sum(n-1)
    B、第4行： return 0 第5行： Sum(n-1)
    C、第4行： return 1 第5行： Sum(n-1)
    D、第4行： return 0 第5行： Sum(n)

12、下面函数是求阶乘的递归函数，请将程序补充完整。 long Fact(int n) { if (n < 0) return 0; if (n==1 || n==0) __________________; else ____________________; }
    A、第4行： return 1 第5行： return n*Fact(n-1)
    B、第4行： return 0 第5行： return n*Fact(n-1)
    C、第4行： return -1 第5行： return (n-1)*Fact(n)
    D、第4行： return 1 第5行： return Fact(n-1)

13、Y()是实现n层嵌套平方根计算的函数，其公式如下，请将程序补充完整。 double Y(double x, int n) { if (n == 0) return 0; else return (square(x +___________________)); }
    A、Y(x,n-1)
    B、Y(x,n)
    C、Y(x,n+1)
    D、Y(x,1)

14、程序运行后的输出结果是 #include <stdio.h> int Fun(int n) { if (n==1) return 1; else return Fun(n-1)+1; } int main() { int i,j=0; for(i=1;i<3;i++) j+=Fun(i); printf("%d\n",j); return 0; }
    A、3
    B、4
    C、2
    D、1

15、子函数Fun(char x , char y)的功能是对任意两个字符x和y,如果x为真，则函数返回y的值，否则返回x的值。若使以下程序运行后的输出结果是7，请补充完整空白处缺少的代码。 #include <stdio.h> char Fun(char x , char y) { if(__________) return y; else return x; } int main( ) { char a='9',b='8',c='7'; printf("____",Fun(_______________)); return 0; }
    A、第4行： x 第11行：%c Fun(a,b),Fun(b,c)
    B、第4行： x=0 第11行：%d Fun(b,c),Fun(a,b)
    C、第4行： x==0 第11行：%c Fun(b,a),Fun(c,b)
    D、第4行： x!=0 第11行：%d Fun(c,b),Fun(b,a)

练兵区——单选题——不计入总分

1、写出下面程序的运行结果 #include <stdio.h> void Bin(int x) { if (x/2 > 0) Bin(x/2); printf("%d\n", x%2); } int main() { Bin(12); return 0;
    A、1 1 0 0
    B、0 0 1 1
    C、6 3 1 0
    D、6 3 1 1

2、子函数Incre()的功能是，利用静态变量，使子函数的输出值能够随调用次数的增加依次为： 第1次调用，输出： 的结果 第2次调用，输出： 的结果 第3次调用，输出： 的结果 ..... 在下面的程序中，对子函数Incre()进行了两次调用，若使程序的输出结果是： 2 6 请补充完整空白处缺少的代码。#include <stdio.h> int x=3; void Incre(); int main() { int i; for (i=1;_______;i++) Incre(); return 0; } void Incre() { ___________; x*=x+1; printf("%d\n",x); }
    A、第7行： i<x 第13行： static int x=1
    B、第7行： i<=x 第13行： static int x=0
    C、第7行： i<x 第13行： int x=1
    D、第7行： i<=x 第13行： int x=0

3、函数Sum(int n)是用递归方法计算下面的公式，请补充程序中缺少的内容。 int Sum(int n) { if (n <= 0) printf("data error\n"); if (n == 1)_________________; else return ____________________; }
    A、第4行： return 1 第5行： n+Sum(n-1)
    B、第4行： return 0 第5行： Sum(n-1)
    C、第4行： return 1 第5行： Sum(n-1)
    D、第4行： return 0 第5行： Sum(n)

4、程序运行后的输出结果是#include <stdio.h> int Fun(int n) { if (n==1) return 1; else return Fun(n-1)+1; } int main() { int i,j=0; for(i=1;i<3;i++) j+=Fun(i); printf("%d\n",j); return 0; }
    A、3
    B、4
    C、2
    D、1

5、以下程序运行后的输出结果是#include <stdio.h> float Fun(int x,int y) { return(x+y); } int main() { int a=2,b=5,c=8; printf("%3.0f\n",Fun((int)Fun(a+c,b),a-c)); return 0; }
    A、9
    B、21
    C、9.0
    D、编译出错

6、Y()是实现n层嵌套平方根计算的函数，其公式如下，请将程序补充完整。 double Y(double x, int n) { if (n == 0) return 0; else return (square(x +___________________)); }
    A、Y(x,n-1)
    B、Y(x,n)
    C、Y(x,n+1)
    D、Y(x,1)

7、下面程序是用辗转相除法计算两个正整数的最大公约数的递归求解方法。请将程序补充完整。 提示：辗转相除法的基本思路是，对正整数a和b，连续进行求余运算，直到余数为0为止，此时非0的除数就是最大公约数。设r=a mod b表示a除以b的余数，若r≠0，则将b作为新的a，r作为新的b，重复a mod b运算，直到r=0时为止，此时b为所求的最大公约数。例如，50和15的最大公约数的求解过程可表示为：Gcd(50, 15)=Gcd(15, 5)=Gcd(5, 0)=5。int Gcd(int a, int b) { if (a%b == 0) return b; else return ____________________; }
    A、Gcd(b, a%b)
    B、Gcd(a, b%a)
    C、Gcd(b%a, a)
    D、Gcd(a%b, b)

8、下面函数是求阶乘的递归函数，请将程序补充完整。 long Fact(int n) { if (n < 0) return 0; if (n==1 || n==0) __________________; else ____________________; }
    A、第4行： return 1 第5行： return n*Fact(n-1)
    B、第4行： return 0 第5行： return n*Fact(n-1)
    C、第4行： return -1 第5行： return (n-1)*Fact(n)
    D、第4行： return 1 第5行： return Fact(n-1)

9、子函数Fun(char x , char y)的功能是对任意两个字符x和y,如果x为真，则函数返回y的值，否则返回x的值。若使以下程序运行后的输出结果是7，请补充完整空白处缺少的代码。#include <stdio.h> char Fun(char x , char y) { if(__________) return y; else return x; } int main( ) { char a='9',b='8',c='7'; printf("____",Fun(_______________)); return 0; }
    A、第4行： x 第11行：%c Fun(a,b),Fun(b,c)
    B、第4行： x=0 第11行：%d Fun(b,c),Fun(a,b)
    C、第4行： x==0 第11行：%c Fun(b,a),Fun(c,b)
    D、第4行： x!=0 第11行：%d Fun(c,b),Fun(b,a)

10、下列说法正确的是
    A、递归算法的执行过程可分为递推和回归两个阶段。在递推阶段，必须要有终止递归的情况。当满足递归终止条件时，即获得最简单情况的解以后，开始进入回归阶段，即递归返回阶段。
    B、基本条件是一个能控制递归过程结束的条件，是递归的出口，它本身不再使用递归的方式来定义。一般条件定义了递归关系，控制递归调用向着基本条件的方向转化。
    C、数学归纳法是递归的数学基础。
    D、形参也是局部变量，形参变量和实参变量的作用域是不同的，因此形参变量和实参变量同名时，二者互不干扰。
    E、全局变量破坏了函数的封装性，不能实现信息隐藏，依赖全局变量的函数很难在其他程序中复用，对于使用全局变量的程序维护也比较困难，因此建议尽量不用全局变量。
    F、函数既可以嵌套定义，也可以嵌套调用。
    G、局部变量与全局变量同名时，全局变量隐藏局部变量，即全局变量起作用，局部变量不起作用。
    H、用extern声明变量为外部变量的时候，编译器是对其分配内存的。
    I、静态局部变量和静态全局变量的生存期和作用域都是相同的。

11、子函数Fun(int a, int b)的功能是，对任意两个整数a和b,返回两者中的最大值。以下程序是通过调用子函数Fun(int a, int b)，找到三个整数中的最大值。若程序运行后的输出结果是8，请补充完整空白处缺少的代码。#include <stdio.h> int Fun(int a, int b) { if(a>b) return_________; else return________; } int main() { int x=3, y=8, z=6, r; r=_______________; // 找到三个整数x,y,z中的最大值 printf("%d", r); return 0; }
    A、第4行： a 第5行： b 第11行： Fun(Fun(x,y),z)
    B、第4行： b 第5行： a 第11行： Fun(x,y,z)
    C、第4行： 1 第5行： 0 第11行： Fun(x,y,z)
    D、第4行： 0 第5行： 1 第11行： Fun(Fun(x,y),z)

12、以下程序的输出结果是 #include <stdio.h> int Func(); int i=10; int main() { int j=1; j=Func(); printf("%d,",j); j=Func(); printf("%d",j); return 0; } int Func() { int k=0; k=k+i; i=i+10; return(k); }
    A、10,20
    B、0,0
    C、10,10
    D、20,20

13、请给出程序的运行结果#include <stdio.h> int Fun(int m) { static int n = 0; m /= 2; m = m * 2; if (m) { n *= m; return(Fun(m - 2)); } else return n; } int main() { int a, i; for (i = 0; i < 2; i++) { a = Fun(4 + i); printf("%d\n", a); } return 0; }
    A、0 0
    B、8 8
    C、4 4
    D、64 64

14、写出下面程序的运行结果。#include <stdio.h> int Square(int i) { return i * i; } int main(void) { int i = 0; i = Square(i); for ( ; i<3; i++) { static int i = 1; i += Square(i); printf("%d,", i); } printf("%d\n", i); return 0; }
    A、2,6,42,3
    B、2,2,2,3
    C、2,2,3,3
    D、2,3,4,3

15、根据最大公约数的如下3条性质，采用递归法编写计算最大公约数的函数Gcd()，在主函数中调用该函数计算并输出从键盘任意输入的两正整数的最大公约数。 性质1 如果a>b，则a和b与a-b和b的最大公约数相同，即Gcd(a, b) = Gcd(a-b, b) 性质2 如果b>a，则a和b与a和b-a的最大公约数相同，即Gcd(a, b) = Gcd(a, b-a) 性质3 如果a=b，则a和b的最大公约数与a值和b值相同，即Gcd(a, b) = a = b 代码如下，请补充程序中缺少的内容。#include <stdio.h> int Gcd(int a, int b); int main() { int a, b, c; printf("Input a,b:"); scanf("%d,%d", &a, &b); c = Gcd(a, b); if (_________) printf("Greatest Common Divisor of %d and %d is %d\n", a, b, c); else printf("Input number should be positive!\n"); return 0; } int Gcd(int a, int b) { if (_______________) return -1; if (a == b) return __________; else if (a > b) return __________; else return ___________; }
    A、第9行： c!= -1 第18行： a <= 0 || b <= 0 第21行： a 第23行： Gcd(a - b, b) 第25行： Gcd(a, b - a)
    B、第9行： c== -1 第18行： a <= 0 && b <= 0 第21行： a 第23行： Gcd(a - b, b) 第25行： Gcd(a, b - a)
    C、第9行： c!= -1 第18行： a <= 0 && b <= 0 第21行： b 第23行： Gcd(a, b - a) 第25行： Gcd(a - b, b)
    D、第9行： c== -1 第18行： a <= 0 || b <= 0 第21行： a 第23行： Gcd(a, b - a) 第25行： Gcd(a - b, b)

第10周编程实验题

1、n层嵌套平方根的计算

2、递归法求和

3、猴子吃桃程序_扩展3

4、网购打折商品V2.0

练兵区——编程题——不计入总分

1、谐均值计算

2、输出指定行列数的字符

3、魔术师猜数

4、计算礼炮声响次数

5、水手分椰子

6、递归法计算游戏人员的年龄

7、递归法计算两个数的最大公约数

8、寻找中位数v1.0

9、还原算术表达式

第8周—— 一堆数据来了，你准备好了吗

8.1 数组的定义和初始化（43分）随堂测验

1、下列说法错误的是（）。
    A、C语言中的二维数组在内存中是按列存储的。
    B、在C语言中，数组的下标都是从0开始的。
    C、在C语言中，不带下标的数组名代表数组的首地址，即第一个元素在内存中的地址。
    D、不能使用变量定义数组的大小，但是在访问数组元素时在下标中可以使用变量或表达式。

8.2 向函数传递一堆相同类型的数据（15分半）随堂测验

1、下列说法错误的是（）。
    A、简单变量做函数参数时，是将实参的值传给形参，实参和形参在内存中占用不同的存储单元，因此形参值的改变不会影响实参。
    B、数组做函数参数时，是将实参数组的首地址传给形参，形参数组和实参数组在内存中共享相同的存储单元，因此对形参数组元素值的修改也就相当于是对实参数组元素值的修改。
    C、在声明函数的二维数组形参时，可省略数组第二维的长度，但不能省略数组第一维的长度。
    D、在声明函数的一维数组形参时，通常不指定数组的大小，而用另一个形参来指定数组的大小。

8.3 查找算法——众里寻他千百度（37分半）随堂测验

1、在计算一组数据的最大值之前，通常假设这组数据中的第一个数为最大，即用这组数据中的第一个数为存放最大值的变量初始化。

8.3 查找算法——众里寻他千百度（37分半）随堂测验

1、线性查找算法不要求数据表是已排好序的，而二分查找算法要求数据表是已排好序的。

8.3 查找算法——众里寻他千百度（37分半）随堂测验

1、二分查找算法就是先将表的中间位置记录的关键字与查找关键字相比较，如果两者相等，则查找成功，否则将表分成前、后两个子表，根据比较结果，决定查找前一子表还是后一子表。

第8周测验

1、输入某班学生某门课的成绩（最多不超过40人，具体人数由用户键盘输入），用函数编程统计不及格人数。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define N 40 intGetFailNum(int score[], int n); int main() { int i, n, fail, score[N]; printf("How many students?"); scanf("%d", &n); for (i=0; i<n; i++) { scanf("%d", _________); } fail = _____________; printf("Fail students = %d\n", fail); return 0; } /* 函数功能：统计不及格人数 */ int GetFailNum(int score[], int n) { int i, count = 0; for (i=0; i<n; i++) { if (_________) count++; } return count; }
    A、第11行： &score[i] 第13行： GetFailNum(score, n) 第23行： score[i] < 60
    B、第11行： score[i] 第13行： GetFailNum(score, n) 第23行： score[i] <= 60
    C、第11行： score[i] 第13行： GetFailNum(n,score) 第23行： score[i] < 60
    D、第11行： &score[i] 第13行： GetFailNum(score[i], n) 第23行： score[i] >= 60

2、输入n×n阶矩阵，用函数编程计算并输出其两条对角线上的各元素之和。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define N 10 void InputMatrix(int a[N][N], int n); int AddDiagonal(int a[N][N], int n); int main() { int a[N][N], n, sum; printf("Input n:"); scanf("%d", &n); InputMatrix(a, n); sum = AddDiagonal(a, n); printf("sum = %d\n", sum); return 0; } /* 函数功能： 输入n×n矩阵的元素值，存于数组a中 */ void InputMatrix(___________, int n) { int i, j; printf("Input %d*%d matrix:\n", n, n); for (i=0; i<n; i++) { for (j=0; j<n; j++) { scanf("%d",___________); } } } /* 函数功能： 计算n×n矩阵中两条对角线上的元素之和 */ int AddDiagonal(int a[N][N], int n) { int i, j, sum = 0; for (i=0; i<n; i++) { for (j=0; j<n; j++) { if (________________) sum = sum + a[i][j]; } } return ____________; }
    A、第17行： int a[N][N] 第25行： &a[i][j] 第38行： i==j || i+j==n-1 第42行： sum
    B、第17行： int a[N][N] 第25行： &a[i][j] 第38行： i==j && i+j==n-1 第42行： a[i][j]
    C、第17行： int a[N][N] 第25行： a[i][j] 第38行： i==j || i+j==n-1 第42行： a[N][N]
    D、第17行： int a[][] 第25行： &a[i][j] 第38行： i==j && i+j==n-1 第42行： sum

3、输入某班学生某门课的成绩（最多不超过40人），当输入为负值时，表示输入结束，用函数编程统计成绩高于平均分的学生人数。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define N 40 int Average(int score[], int n); int ReadScore(int score[]); int GetAboveAver(int score[], int n); int main() { int score[N], m, n; n = ReadScore(score); /* 输入成绩，返回学生人数 */ printf("Total students are %d\n", n); m = GetAboveAver(score, n); /* 统计成绩在平均分及其上的学生人数 */ if (______________) printf("Students of above average is %d\n", m); return 0; } /* 函数功能：若n>0，则计算并返回n个学生成绩的平均分，否则返回-1 */ int Average(int score[], int n) { int i, sum = 0; for (i=0; i<n; i++) { sum += score[i]; } return ______________; } /* 函数功能：输入学生某门课成绩，当输入成绩为负值时，结束输入，返回学生人数 */ int ReadScore(int score[]) { int i = -1; do{ i++; printf("Input score:"); scanf("%d", &score[i]); }while (__________); return _______; } /* 函数功能：若n>0，则统计并返回成绩在平均分及平均分之上的学生人数，否则返回-1 */ int GetAboveAver(int score[], int n) { int i, count = 0, aver; aver = ______________; /* 计算并打印平均分 */ if (aver == -1) return -1; printf("Average score is %d\n", aver); for (i=0; i<n; i++) { if (score[i] >= aver) count++; } return __________; }
    A、第12行： m != -1 第24行： n>0 ? sum/n : -1 第35行： score[i] >= 0 第36行： i 第43行： Average(score, n) 第50行： count
    B、第12行： m == -1 第24行： n>0 ? sum/n : -1 第35行： score[i] >= 0 第36行： i 第43行： Average(score, n) 第50行： i
    C、第12行： m != -1 第24行： n>0 ? -1 : sum/n 第35行： score[i] >= 0 第36行： i 第43行： Average(n,score) 第50行： count
    D、第12行： m == -1 第24行： n<=0 ? sum/n : -1 第35行： score[i] >= 0 第36行： score 第43行： Average(score, n) 第50行： aver

4、模拟骰子的6000次投掷，编程统计并输出骰子的6个面各自出现的概率。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include _________ #include <time.h> #include <stdio.h> int main() { int face, roll, frequency[7] = {0}; srand(time (NULL)); for (roll=1; roll<=6000; roll++) { face = _____________; __________________; } printf("%4s%17s\n", "Face", "Frequency"); for (face=1; face<=6; face++) { printf("%4d%17d\n", face, frequency[face]); } return 0; }
    A、第1行： <stdlib.h> 第11行： rand()%6 + 1 第12行： frequency[face]++
    B、第1行： <math.h> 第11行： rand()/6 + 1 第12行： frequency[face]++
    C、第1行： <stdlib.h> 第11行： rand()%6 + 1 第12行： frequency[roll]++
    D、第1行： <math.h> 第11行： rand()/6 + 1 第12行： frequency[roll]++

5、以下程序中函数Fun的功能是对b所指数组中的第m至第n个数据取累加和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> Fun(________,int m,int n) { int i,s=0; for( ______;i<n;i++) s=s+b[i]; return _______; } int main() { int x,a[]={1,2,3,4,5,6,7,8,9}; x=Fun(a,3,7); printf("%d\n",x); return 0; }
    A、第2行： int b[] 第5行： i=m-1 第7行： s
    B、第2行： int b[] 第5行： i=1 第7行： i
    C、第2行： int b 第5行： i=0 第7行： s
    D、第2行： int b[] 第5行： i=n-1 第7行： b[i]

6、下面代码的功能是将数组a中存放的5个整型数据逆序后在屏幕上输出，具体输出内容如下： 5 4 3 2 1 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Fun(int b[],int i,int j) { int t; if(i<j) { _________; b[i]=b[j]; _________; Fun(b,i+1,j-1); } } int main( ) { int i,a[5]={1,2,3,4,5}; _________; for(i=0;i<5;i++) printf("%d\t",a[i]); printf("\n"); return 0; }
    A、第7行： t=b[i] 第10行： b[j]=t 第19行： Fun(a,0,4)
    B、第7行： t=b[i] 第10行： b[i]=t 第19行： Fun(a,0,5)
    C、第7行： t=b[j] 第10行： b[j]=t 第19行： Fun(a,1,4)
    D、第7行： t=b[i] 第10行： b[i]=t 第19行： Fun(a,1,5)

7、某人有5张2分的邮票和5张3分的邮票，问使用这些邮票可以组合出多少种不同面值的邮资。（例如：1张2分邮票加1张3分邮票可以组成5分的邮资；3张2分的邮票或2张3分的邮票都可以组成同样的6分邮资。）按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int i,j,k,s,n=0; int a[100]={0}; for(i=0;_________;i++) for(j=0;________;j++) { s=_____________; for(k=0;a[k]!=0;k++) if(s==a[k]) _________; if(a[k]==0 && s>0) { _________; n++; } } printf("\n %d kinds:",n); for(k=0;a[k];k++) printf("%2d,",a[k]); return 0; }
    A、第7行： i<=5 第8行： j<=5 第10行： 2*i+3*j 第14行： break 第18行： a[k]=s
    B、第7行： i<5 第8行： j<5 第10行： 2*i+3*j 第14行： break 第18行： s=a[k]
    C、第7行： i<=5 第8行： j<=5 第10行： 2i+3j 第14行： continue 第18行： a[k]=s
    D、第7行： i<5 第8行： j<5 第10行： 2*i+3*j 第14行： continue 第18行： s=a[k]+1

8、以下程序中函数Sort的功能是对a所指数组中的数据进行由大到小的排序，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Sort(int a[],int n) { int i,j,t; for(i=0;_________;i++) for(________;j<n;j++) if(a[i]<a[j]) { t=a[i]; __________; a[j]=t; } } int main() { int aa[10]={1,2,30,4,5,6,7,8,9,10},i; __________; for(i=0;i<10;i++) printf("%d,",aa[i]); printf("\n"); return 0; }
    A、第5行： i<n-1 第6行： j=i+1 第10行： a[i]=a[j] 第18行： Sort(aa,10)
    B、第5行： i<n-1 第6行： j=i 第10行： a[i]=a[j] 第18行： Sort(aa[],10)
    C、第5行： i<n 第6行： j=i+1 第10行： a[j]=a[i] 第18行： Sort(aa,10)
    D、第5行： i<=n j第6行： =i 第10行： a[i]=a[j] 第18行： Sort(10,aa)

9、以下程序的功能是：按顺序读入10名学生4门课程的成绩，计算出每位学生的平均分并输出。程序运行后结果不正确，调试中发现有一条语句出现在程序中的位置不正确。这条语句是 #include <stdio.h> int main() { int n,k; float score ,sum,ave; sum=0.0; for(n=1;n<=10;n++) { for(k=1;k<=4;k++) { scanf("%f",&score); sum+=score; } ave=sum/4.0; printf("NO%d:%f\n",n,ave); } return 0; }
    A、sum=0.0;
    B、sum+=score;
    C、ave=sun/4.0;
    D、printf("NO%d:%f\n",n,ave);

10、下面代码的功能是在屏幕上输出以下内容 0 1 3 程序中空白处缺少的代码由下列选项给出，其中有一个不能满足题目要求，请将其找出。 #include <stdio.h> int main() { int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0; for(i=0;i<3;i++) for(j=i;j<=i;j++) { t=t+____________; printf("%d\n",t); } return 0; }
    A、b[j][t]
    B、b[i][b[j][j]]
    C、b[t][j]
    D、b[i][j]

11、以下程序的输出结果是 void swap1(int c[]) { int t; t=c[0]; c[0]=c[1]; c[1]=t; } void swap2(int c0,int c1) { int t; t=c0; c0=c1; c1=t; } int main( ) { int a[2]={3,5},b[2]={3,5}; swap1(a); swap2(b[0],b[1]); printf("%d %d %d %d\n",a[0],a[1],b[0],b[1]); return 0; }
    A、5 3 3 5
    B、5 3 5 3
    C、3 5 3 5
    D、3 5 5 3

12、以下程序中函数Reverse的功能是对数组a中的前一半元素逆序、后一半元素逆序，再将逆序后的前、后两部分数据位置交换。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 例如：主程序中数组b中的元素为{16,22,13,41,50,62,27,18,9,10}，调用函数Reverse后，数组b中元素变为 {10 9 18 27 62 50 41 13 22 16} #include <stdio.h> void Reverse(int a[],int n) { int i,t; for(i=0;________;i++) { t=a[i]; __________; a[n-i]=t; } } int main() { int b[10]={16,22,13,41,50,62,27,18,9,10}; int i,s=0; __________; for(i=0;i<10;i++) { printf("%4d",b[i]); } return 0; }
    A、第5行： i<=n/2 第8行： a[i]=a[n-i] 第17行： Reverse(b,9)
    B、第5行： i<=n 第8行： a[n-i]=a[i] 第17行： Reverse(b,9)
    C、第5行： i<=n/2 第8行： a[n]=a[i] 第17行： Reverse(9,b)
    D、第5行： i<=n/2 第8行： a[i]=a[n] 第17行： Reverse(b,9)

13、某矩阵m存储的数据如下： 1 4 7 2 5 8 3 6 9 现将该矩阵最后一行的所有数据输出到屏幕，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int m[][3]={1,4,7,2,5,8,3,6,9}; int i,j,k=____; for(i=0;_______;i++) { printf("%d",_________); } return 0; }
    A、第5行： 2 第7行： i<3 第9行： m[k][i]
    B、第5行： 3 第7行： i<=3 第9行： m[k][i]
    C、第5行： 2 第7行： i<2 第9行： m[i][k]
    D、第5行： 3 第7行： i<3 第9行： m[i][k]

14、下列说法正确的是
    A、在C语言中，数组的下标都是从0开始的。
    B、在C语言中，不带下标的数组名代表数组的首地址，即第一个元素在内存中的地址。
    C、简单变量做函数参数时，是将实参的值传给形参，实参和形参在内存中占用不同的存储单元，因此形参值的改变不会影响实参。
    D、数组做函数参数时，是将实参数组的首地址传给形参，形参数组和实参数组在内存中共享相同的存储单元，因此对形参数组元素值的修改也就相当于是对实参数组元素值的修改。
    E、在声明函数的一维数组形参时，通常不指定数组的大小，而用另一个形参来指定数组的大小。
    F、C语言中的二维数组在内存中是按列存储的。
    G、可以按任意的顺序对二维数组元素进行赋值，并且也可以按任意的屏幕输出顺序来输出二维数组元素。
    H、在声明函数的二维数组形参时，可省略数组第二维的长度，但不能省略数组第一维的长度。
    I、定义数组的大小、访问数组元素时在下标中都可以使用变量或表达式。

15、用函数编程计算并输出如图所示的杨辉三角形。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include<stdio.h> #define N 20 void CaculateYH(int a[][N], int n); void PrintYH(int a[][N], int n); int main() { int a[N][N] = {0}, n; printf("Input n(n<20):"); scanf("%d", &n); CaculateYH(a, n); PrintYH(a, n); return 0; } /* 函数功能：计算杨辉三角形前n行元素的值 */ void CaculateYH(__________, int n) { int i, j; for (i=0; i<n; i++) { a[i][0] = 1; ___________; } for (_______; i<n; i++) { for (j=1; j<=i-1; j++) { a[i][j] = __________________; } } } /* 函数功能：输出杨辉三角形前n行元素的值 */ void PrintYH(int a[][N], int n) { int i, j; for (i=0; i<n; i++) { for (j=0; _________; j++) { printf("%4d", a[i][j]); } printf("\n"); } }
    A、第16行： int a[][N] 第22行： a[i][i] = 1 第24行： i=2 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<=i
    B、第16行： int a[][] 第22行： a[i][i] = 1 第24行： i=1 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<=i
    C、第16行： int a[][N] 第22行： a[0][i] = 1 第24行： i=2 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<i
    D、第16行： int a[N][] 第22行： a[i][i] = 1 第24行： i=2 第28行： a[j-1][i-1] + a[j][i-1] 第38行： j<=i

16、假设有40个学生被邀请来给餐厅的饮食和服务质量打分，分数划分为1～10这10个等级（1表示最低分，10表示最高分），编程统计并按如下格式输出餐饮服务质量调查结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define M 40 #define N 11 int main() { int i, j, grade, feedback[M], count[N] = {0}; printf("Input the feedbacks of 40 students:\n"); for (i=0; i<M; i++) { scanf("%d", &feedback[i]); } for (i=0; i<M; i++) { _____________; } printf("Feedback\tCount\tHistogram\n"); for (_________; grade<=N-1; grade++) { printf("%8d\t%5d\t", grade, count[grade]); for (j=0; ___________; j++) { printf("%c",'*'); } printf("\n"); } return 0; }
    A、第16行： count[feedback[i]]++ 第21行： grade=1 第24行： j<count[grade]
    B、第16行： feedback[i]++ 第21行： grade=1 第24行： j<N-1
    C、第16行： count[i]++ 第21行： grade=0 第24行： j<N-1
    D、第16行： count[feedback[i]]++ 第21行： grade=0 第24行： j<grade

练兵区——单选题——不计入总分

1、假设有40个学生被邀请来给餐厅的饮食和服务质量打分，分数划分为1～10这10个等级（1表示最低分，10表示最高分），编程统计并按如下格式输出餐饮服务质量调查结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define M 40 #define N 11 int main() { int i, j, grade, feedback[M], count[N] = {0}; printf("Input the feedbacks of 40 students:\n"); for (i=0; i<M; i++) { scanf("%d", &feedback[i]); } for (i=0; i<M; i++) { _____________; } printf("Feedback\tCount\tHistogram\n"); for (_________; grade<=N-1; grade++) { printf("%8d\t%5d\t", grade, count[grade]); for (j=0; ___________; j++) { printf("%c",'*'); } printf("\n"); } return 0; }
    A、第16行： count[feedback[i]]++ 第21行： grade=1 第24行： j<count[grade]
    B、第16行： feedback[i]++ 第21行： grade=1 第24行： j<N-1
    C、第16行： count[i]++ 第21行： grade=0 第24行： j<N-1
    D、第16行： count[feedback[i]]++ 第21行： grade=0 第24行： j<grade

2、输入某班学生某门课的成绩（最多不超过40人，具体人数由用户键盘输入），用函数编程统计不及格人数。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #define N 40 intGetFailNum(int score[], int n); int main() { int i, n, fail, score[N]; printf("How many students?"); scanf("%d", &n); for (i=0; i<n; i++) { scanf("%d", _________); } fail = _____________; printf("Fail students = %d\n", fail); return 0; } /* 函数功能：统计不及格人数 */ int GetFailNum(int score[], int n) { int i, count = 0; for (i=0; i<n; i++) { if (_________) count++; } return count; }
    A、第11行： &score[i] 第13行： GetFailNum(score, n) 第23行： score[i] < 60
    B、第11行： score[i] 第13行： GetFailNum(score, n) 第23行： score[i] <= 60
    C、第11行： score[i] 第13行： GetFailNum(n,score) 第23行： score[i] < 60
    D、第11行： &score[i] 第13行： GetFailNum(score[i], n) 第23行： score[i] >= 60

3、模拟骰子的6000次投掷，编程统计并输出骰子的6个面各自出现的概率。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include _________ #include <time.h> #include <stdio.h> int main() { int face, roll, frequency[7] = {0}; srand(time (NULL)); for (roll=1; roll<=6000; roll++) { face = _____________; __________________; } printf("%4s%17s\n", "Face", "Frequency"); for (face=1; face<=6; face++) { printf("%4d%17d\n", face, frequency[face]); } return 0; }
    A、第1行： <stdlib.h> 第11行： rand()%6 + 1 第12行： frequency[face]++
    B、第1行： <math.h> 第11行： rand()/6 + 1 第12行： frequency[face]++
    C、第1行： <stdlib.h> 第11行： rand()%6 + 1 第12行： frequency[roll]++
    D、第1行： <math.h> 第11行： rand()/6 + 1 第12行： frequency[roll]++

4、以下程序中函数Fun的功能是对b所指数组中的第m至第n个数据取累加和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> Fun(________,int m,int n) { int i,s=0; for( ______;i<=n;i++) s=s+b[i]; return _______; } int main() { int x,a[]={1,2,3,4,5,6,7,8,9}; x=Fun(a,3,7); printf("%d\n",x); return 0; }
    A、第2行： int b[] 第5行： i=m 第7行： s
    B、第2行： int b[] 第5行： i=1 第7行： i
    C、第2行： int b 第5行： i=0 第7行： s
    D、第2行： int b[] 第5行： i=n-1 第7行： b[i]

5、以下程序中函数Sort的功能是对a所指数组中的数据进行由大到小的排序，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Sort(int a[],int n) { int i,j,t; for(i=0;_________;i++) for(________;j<n;j++) if(a[i]<a[j]) { t=a[i]; __________; a[j]=t; } } int main() { int aa[10]={1,2,30,4,5,6,7,8,9,10},i; __________; for(i=0;i<10;i++) printf("%d,",aa[i]); printf("\n"); return 0;
    A、第5行： i<n-1 第6行： j=i+1 第10行： a[i]=a[j] 第18行： Sort(aa,10)
    B、第5行： i<n-1 第6行： j=i 第10行： a[i]=a[j] 第18行： Sort(aa[],10)
    C、第5行： i<n 第6行： j=i+1 第10行： a[j]=a[i] 第18行： Sort(aa,10)
    D、第5行： i<=n j第6行： =i 第10行： a[i]=a[j] 第18行： Sort(10,aa)

6、以下程序的功能是：按顺序读入10名学生4门课程的成绩，计算出每位学生的平均分并输出。程序运行后结果不正确，调试中发现有一条语句出现在程序中的位置不正确。这条语句是#include <stdio.h> int main() { int n,k; float score ,sum,ave; sum=0.0; for(n=1;n<=10;n++) { for(k=1;k<=4;k++) { scanf("%f",&score); sum+=score; } ave=sum/4.0; printf("NO%d:%f\n",n,ave); } return 0;
    A、sum=0.0;
    B、sum+=score;
    C、ave=sun/4.0;
    D、printf("NO%d:%f\n",n,ave);

7、以下程序中函数Reverse的功能是对数组a中的前一半元素逆序、后一半元素逆序，再将逆序后的前、后两部分数据位置交换。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 例如：主程序中数组b中的元素为{16,22,13,41,50,62,27,18,9,10}，调用函数Reverse后，数组b中元素变为 {10 9 18 27 62 50 41 13 22 16}#include <stdio.h> void Reverse(int a[],int n) { int i,t; for(i=0;________;i++) { t=a[i]; __________; a[n-i]=t; } } int main() { int b[10]={16,22,13,41,50,62,27,18,9,10}; int i,s=0; __________; for(i=0;i<10;i++) { printf("%4d",b[i]); } return 0; }
    A、第5行： i<=n/2 第8行： a[i]=a[n-i] 第17行： Reverse(b,9)
    B、第5行： i<=n 第8行： a[n-i]=a[i] 第17行： Reverse(b,9)
    C、第5行： i<=n/2 第8行： a[n]=a[i] 第17行： Reverse(9,b)
    D、第5行： i<=n/2 第8行： a[i]=a[n] 第17行： Reverse(b,9)

8、输入n×n阶矩阵，用函数编程计算并输出其两条对角线上的各元素之和。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #define N 10 void InputMatrix(int a[N][N], int n); int AddDiagonal(int a[N][N], int n); int main() { int a[N][N], n, sum; printf("Input n:"); scanf("%d", &n); InputMatrix(a, n); sum = AddDiagonal(a, n); printf("sum = %d\n", sum); return 0; } /* 函数功能： 输入n×n矩阵的元素值，存于数组a中 */ void InputMatrix(___________, int n) { int i, j; printf("Input %d*%d matrix:\n", n, n); for (i=0; i<n; i++) { for (j=0; j<n; j++) { scanf("%d",___________); } } } /* 函数功能： 计算n×n矩阵中两条对角线上的元素之和 */ int AddDiagonal(int a[N][N], int n) { int i, j, sum = 0; for (i=0; i<n; i++) { for (j=0; j<n; j++) { if (________________) sum = sum + a[i][j]; } } return ____________; }
    A、第17行： int a[N][N] 第25行： &a[i][j] 第38行： i==j || i+j==n-1 第42行： sum
    B、第17行： int a[N][N] 第25行： &a[i][j] 第38行： i==j && i+j==n-1 第42行： a[i][j]
    C、第17行： int a[N][N] 第25行： a[i][j] 第38行： i==j || i+j==n-1 第42行： a[N][N]
    D、第17行： int a[][] 第25行： &a[i][j] 第38行： i==j && i+j==n-1 第42行： sum

9、下面代码的功能是将数组a中存放的5个整型数据逆序后在屏幕上输出，具体输出内容如下： 5 4 3 2 1 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> void Fun(int b[],int i,int j) { int t; if(i<j) { _________; b[i]=b[j]; _________; Fun(b,i+1,j-1); } } int main( ) { int i,a[5]={1,2,3,4,5}; _________; for(i=0;i<5;i++) printf("%d\t",a[i]); printf("\n"); return 0; }
    A、第7行： t=b[i] 第10行： b[j]=t 第19行： Fun(a,0,4)
    B、第7行： t=b[i] 第10行： b[i]=t 第19行： Fun(a,0,5)
    C、第7行： t=b[j] 第10行： b[j]=t 第19行： Fun(a,1,4)
    D、第7行： t=b[i] 第10行： b[i]=t 第19行： Fun(a,1,5)

10、某人有5张2分的邮票和5张3分的邮票，问使用这些邮票可以组合出多少种不同面值的邮资。（例如：1张2分邮票加1张3分邮票可以组成5分的邮资；3张2分的邮票或2张3分的邮票都可以组成同样的6分邮资。）按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { int i,j,k,s,n=0; int a[100]={0}; for(i=0;_________;i++) for(j=0;________;j++) { s=_____________; for(for(k=0;a[k]!=0;k++)) if(s==a[k]) _________; if(a[k]==0&&s>0) { _________; n++; } } printf("\n %d kinds:",n); for(k=0;a[k];k++) printf("%2d,",a[k]); return 0;
    A、第7行： i<=5 第8行： j<=5 第10行： 2*i+3*j 第14行： break 第18行： a[k]=s
    B、第7行： i<5 第8行： j<5 第10行： 2*i+3*j 第14行： break 第18行： s=a[k]
    C、第7行： i<=5 第8行： j<=5 第10行： 2i+3j 第14行： continue 第18行： a[k]=s
    D、第7行： i<5 第8行： j<5 第10行： 2*i+3*j 第14行： continue 第18行： s=a[k]+1

11、某矩阵m存储的数据如下： 1 4 7 2 5 8 3 6 9 现将该矩阵最后一行的所有数据输出到屏幕，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { int m[][3]={1,4,7,2,5,8,3,6,9}; int i,j,k=____; for(i=0;_______;i++) { printf("%d",_________); } return 0; }
    A、第5行： 2 第7行： i<3 第9行： m[k][i]
    B、第5行： 3 第7行： i<=3 第9行： m[k][i]
    C、第5行： 2 第7行： i<2 第9行： m[i][k]
    D、第5行： 3 第7行： i<3 第9行： m[i][k]

12、下列说法正确的是
    A、在C语言中，数组的下标都是从0开始的。
    B、在C语言中，不带下标的数组名代表数组的首地址，即第一个元素在内存中的地址。
    C、简单变量做函数参数时，是将实参的值传给形参，实参和形参在内存中占用不同的存储单元，因此形参值的改变不会影响实参。
    D、数组做函数参数时，是将实参数组的首地址传给形参，形参数组和实参数组在内存中共享相同的存储单元，因此对形参数组元素值的修改也就相当于是对实参数组元素值的修改。
    E、在声明函数的一维数组形参时，通常不指定数组的大小，而用另一个形参来指定数组的大小。
    F、C语言中的二维数组在内存中是按列存储的。
    G、对于一个二维数组，可以按任意的顺序对其进行赋值，输出二维数组元素也可以按任意的顺序来输出。
    H、在声明函数的二维数组形参时，可省略数组第二维的长度，但不能省略数组第一维的长度。
    I、定义数组的大小、访问数组元素时在下标中都可以使用变量或表达式。

13、用函数编程计算并输出如图所示的杨辉三角形。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include<stdio.h> #define N 20 void CaculateYH(int a[][N], int n); void PrintYH(int a[][N], int n); int main() { int a[N][N] = {0}, n; printf("Input n(n<20):"); scanf("%d", &n); CaculateYH(a, n); PrintYH(a, n); return 0; } /* 函数功能：计算杨辉三角形前n行元素的值 */ void CaculateYH(__________, int n) { int i, j; for (i=0; i<n; i++) { a[i][0] = 1; ___________; } for (_______; i<n; i++) { for (j=1; j<=i-1; j++) { a[i][j] = __________________; } } } /* 函数功能：输出杨辉三角形前n行元素的值 */ void PrintYH(int a[][N], int n) { int i, j; for (i=0; i<n; i++) { for (j=0; _________; j++) { printf("%4d", a[i][j]); } printf("\n"); } }
    A、第16行： int a[][N] 第22行： a[i][i] = 1 第24行： i=2 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<=i
    B、第16行： int a[][] 第22行： a[i][i] = 1 第24行： i=1 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<=i
    C、第16行： int a[][N] 第22行： a[0][i] = 1 第24行： i=2 第28行： a[i-1][j-1] + a[i-1][j] 第38行： j<i
    D、第16行： int a[N][] 第22行： a[i][i] = 1 第24行： i=2 第28行： a[j-1][i-1] + a[j][i-1] 第38行： j<=i

14、输入某班学生某门课的成绩（最多不超过40人），当输入为负值时，表示输入结束，用函数编程统计成绩高于平均分的学生人数。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #define N 40 int Average(int score[], int n); int ReadScore(int score[]); int GetAboveAver(int score[], int n); int main() { int score[N], m, n; n = ReadScore(score); /* 输入成绩，返回学生人数 */ printf("Total students are %d\n", n); m = GetAboveAver(score, n); /* 统计成绩在平均分及其上的学生人数 */ if (______________) printf("Students of above average is %d\n", m); return 0; } /* 函数功能：若n>0，则计算并返回n个学生成绩的平均分，否则返回-1 */ int Average(int score[], int n) { int i, sum = 0; for (i=0; i<n; i++) { sum += score[i]; } return ______________; } /* 函数功能：输入学生某门课成绩，当输入成绩为负值时，结束输入，返回学生人数 */ int ReadScore(int score[]) { int i = -1; do{ i++; printf("Input score:"); scanf("%d", &score[i]); }while (__________); return _______; } /* 函数功能：若n>0，则统计并返回成绩在平均分及平均分之上的学生人数，否则返回-1 */ int GetAboveAver(int score[], int n) { int i, count = 0, aver; aver = ______________; /* 计算并打印平均分 */ if (aver == -1) return -1; printf("Average score is %d\n", aver); for (i=0; i<n; i++) { if (score[i] >= aver) count++; } return __________; }
    A、第12行： m != -1 第24行： n>0 ? sum/n : -1 第35行： score[i] >= 0 第36行： i 第43行： Average(score, n) 第50行： count
    B、第12行： m == -1 第24行： n>0 ? sum/n : -1 第35行： score[i] >= 0 第36行： i 第43行： Average(score, n) 第50行： i
    C、第12行： m != -1 第24行： n>0 ? -1 : sum/n 第35行： score[i] >= 0 第36行： i 第43行： Average(n,score) 第50行： count
    D、第12行： m == -1 第24行： n<=0 ? sum/n : -1 第35行： score[i] >= 0 第36行： score 第43行： Average(score, n) 第50行： aver

15、下面代码的功能是在屏幕上输出以下内容 0 1 3 程序中空白处缺少的代码由下列选项给出，其中有一个不能满足题目要求，请将其找出。#include <stdio.h> int main() { int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0; for(i=0;i<3;i++) for(j=i;j<=i;j++) { t=t+____________; printf("%d\n",t); } return 0; }
    A、b[j][t]
    B、b[i][b[j][j]]
    C、b[t][j]
    D、b[i][j]

16、以下程序的输出结果是void swap1(int c[]) { int t; t=c[0]; c[0]=c[1]; c[1]=t; } void swap2(int c0,int c1) { int t; t=c0; c0=c1; c1=t; } int main( ) { int a[2]={3,5},b[2]={3,5}; swap1(a); swap2(b[0],b[1]); printf("%d %d %d %d\n",a[0],a[1],b[0],b[1]); return 0; }
    A、5 3 3 5
    B、5 3 5 3
    C、3 5 3 5
    D、3 5 5 3

第12周编程实验题

1、摘苹果

2、好数对

3、组合三位数

4、求100以内的最大素数

练兵区——编程题——不计入总分

1、三天打渔两天晒网

2、统计用户输入

3、统计正整数中指定数字的个数

4、玫瑰花数

5、四位反序数

6、8除不尽的自然数

7、矩阵转置v1.0

8、兔子生崽问题

9、抓交通肇事犯

10、检验并打印幻方矩阵

第9周——指针：C语言世界中所向披靡的“金箍棒”

9.1 指针变量的定义、初始化及其解引用（19分）随堂测验

1、下列说法错误的是（）。
    A、指针变量占用的内存单元字节数就是它所指向的变量所占用的内存单元字节数。
    B、指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。
    C、指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。
    D、通过间接寻址运算符引用指针变量指向的变量的值，称为指针的解引用。

9.2 指针变量作函数参数（36分半）随堂测验

1、普通变量做函数参数，是将实参值的一个副本传给形参，而指针变量做函数参数是将变量的地址值传给形参，因此你想要修改哪个变量的值，将这个变量的地址传给指针形参就好了。

9.3 进阶：函数指针及其应用（27分）随堂测验

1、int (*f)(int, int); 这条语句定义的是一个函数指针f，它可以指向一个有两个整型形参和整型返回值的函数。假设 int Fun(int a, int b); 那么必须用f=Fun();对f进行初始化，让其指向函数Fun()。

9.4 进阶：数组的趣味应用（50分）随堂测验

1、筛法求素数的核心操作就是在一个按a[2]=2,a[3]=3,......,a[N]=N初始化的数组中依次筛掉所有素数的倍数。

9.4 进阶：数组的趣味应用（50分）随堂测验

1、void MakeDigit(int a[]) { int i, j, temp; srand(time(NULL)); for (i=0; i<10; i++) { a[i] = i; } for (i=0; i<10; i++) { j = rand() % 10; temp = a[j]; a[j] = a[i]; a[i] = temp; } }这个方法其实就是模拟了洗牌的方法对一个有序的数组元素进行随机置乱。

第9周测验

1、下面程序的功能是输入某年某月某日，计算并输出它是这一年的第几天。 程序的运行结果如下： Please enter year, month, day:2014,12,29↙ yearDay = 363 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int DayofYear(int year, int month, int day); int dayTab[2][13] = {{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}}; int main() { int year, month, day, yearDay; printf("Please enter year, month, day:"); scanf("%d,%d,%d", &year, &month, &day); yearDay = DayofYear(year, month, day); printf("yearDay = %d\n", yearDay); return 0; } /* 函数功能：对给定的某年某月某日，计算并返回它是这一年的第几天 */ int DayofYear(int year, int month, int day) { int i, leap; leap = ________________________; /* 若year为闰年，即leap值为1，则用第1行元素dayTab[1][i]计算； 否则leap值为0，用第0行dayTab[0][i]计算 */ for (i=1; _______; i++) { day = ________________; } return day; /* 返回计算出的day的值 */ }
    A、第18行： ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0) 第20： i<month 第22行： day + dayTab[leap][i]
    B、第18行： ((year % 4 == 0) || (year % 100 != 0)) || (year % 400 == 0) 第20： i<month 第22行： day + dayTab[i][leap]
    C、第18行： ((year % 4 == 0) && (year % 100 != 0)) && (year % 400 == 0) 第20： i<12 第22行： day + dayTab[leap][i]
    D、第18行： ((year % 4 != 0) && (year % 100 != 0)) || (year % 400 != 0) 第20： i<=month 第22行： day + dayTab[i][leap]

2、下面程序的功能是从键盘输入10个整数，用函数编程实现计算其最大值和最小值，并互换它们所在数组中的位置。程序运行结果如下： Input n(n<=10):10↙ Input 10 Numbers:1 4 3 0 –2 6 7 2 9 -1 ↙ Exchange results: 1 4 3 0 9 6 7 2 -2 -1 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void ReadData(int a[], int n); void PrintData(int a[], int n); void MaxMinExchang(int a[], int n); void Swap(int *x, int *y); int main() { int a[10], n; printf("Input n(n<=10):"); scanf("%d", &n); printf("Input %d numbers:", n); ReadData(a, n); MaxMinExchang(a, n); printf("Exchange results:"); PrintData(a, n); return 0; } /* 函数功能：输入数组a的n个元素值 */ void ReadData(int a[], int n) { int i; for (i=0; i<n; i++) { scanf("%d", &a[i]); } } /* 函数功能：输出数组a的n个元素值 */ void PrintData(int a[], int n) { int i; for (i=0; i<n; i++) { printf("%5d", a[i]); } printf("\n"); } /* 函数功能：将数组a中的最大数与最小数位置互换 */ void MaxMinExchang(________, int n) { int maxValue = a[0], minValue = a[0], maxPos = 0, minPos = 0; int i; for (i=1; i<n; i++) { if (a[i] > maxValue) { maxValue = _______; maxPos = ____; } if (a[i] < minValue) { minValue = a[i]; minPos = i; } } Swap(________________); } /* 函数功能：两整数值互换 */ void Swap(int *x, int *y) { int ________; temp = *x; _________; *y = temp; }
    A、第41行： int a[] 第49行： a[i] 第50行： i 第58行： &a[maxPos], &a[minPos] 第64行： temp 第66行： *x = *y
    B、第41行： int a 第49行： a[i] 第50行： i 第58行： a[maxPos], a[minPos] 第64行： temp 第66行： *x = *y
    C、第41行： int a[] 第49行： a[0] 第50行： 0 第58行： &a[maxPos], &a[minPos] 第64行： *temp 第66行： x = y
    D、第41行： int a[] 第49行： a[n-1] 第50行： n-1 第58行： *a[maxPos], *a[minPos] 第64行： &temp 第66行： x = y

3、下面程序中子函数MonthDay()的功能是将某年的第几天转换为某月某日。程序的运行结果如下： Please enter year, yearDay:2014,100↙ month = 4, day = 10 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void MonthDay(int year, int yearDay, int *pMonth, int *pDay); int dayTab[2][13] = {{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}}; int main() { int year, month, day, yearDay; printf("Please enter year, yearDay:"); scanf("%d,%d", &year, &yearDay); _________________; printf("month = %d, day = %d\n", month, day); return 0; } /* 函数功能：对给定的某一年的第几天，计算它是这一年的第几月第几日 */ void MonthDay(int year, int yearDay, int *pMonth, int *pDay) { int i, leap; leap = _________________________; for (i=1; yearDay>dayTab[leap][i]; i++) { yearDay = ______________________; } ______________; /* 将计算出的月份值赋值给pMonth所指向的变量 */ *pDay = yearDay; /* 将计算出的日号赋值给pDay所指向的变量 */ }
    A、第10行： MonthDay(year, yearDay, &month, &day) 第19行： ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[leap][i] 第25行： *pMonth = i
    B、第10行： MonthDay(year, yearDay, month, day) 第19行： ((year % 4 == 0) || (year % 100 != 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[leap][i] 第25行： pMonth = i
    C、第10行： MonthDay(&year, &yearDay, &month, &day) 第19行： ((year % 4 == 0) || (year % 100 != 0)) && (year % 400 != 0) 第23行： yearDay + dayTab[i][leap] 第25行： *pMonth = i
    D、第10行： MonthDay(&year, &yearDay, month, day) 第19行： ((year % 4 == 0) && (year % 100 == 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[i][leap] 第25行： pMonth = i

4、子函数Fun的功能是比较形参变量x和y所指的内存单元中的数据大小，将两者中的最小值返回。以下程序执行后输出结果是7,8,7。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int Fun(int *x,int *y) { if(___________) /*如果形参变量x所指的内存单元中的数据小于y所指的内存单元中的数据，则返回该最小值*/ return *x; else return *y; } int main() { int a=7,b=8,_______,r; p=&a; q=&b; r=____________; /*调用子函数Fun，返回变量a和b中的最小值，将其存放到变量r中。*/ printf("%d,%d,%d\n",*p,*q,r); return 0; }
    A、第4行： *x<*y 第12行： *p,*q 第15行： Fun(p,q)
    B、第4行： x<y 第12行： *p,*q 第15行： Fun(*p,*q)
    C、第4行： *x<*y 第12行： p,q 第15行： Fun(&p,&q)
    D、第4行： x<y 第12行： *p,*q 第15行： Fun(a,b)

5、下列函数的功能为________。 void Exchange(int *p1, int *p2) { int p; p = *p1; *p1 = *p2; *p2 = p; }
    A、交换*p1和*p2的值
    B、正确，但无法改变*p1和*p2的值
    C、交换*p1和*p2的地址
    D、可能造成系统故障

6、声明语句int (*p)();的含义是________。
    A、p是一个指向函数的指针，该函数的返回值是一个整型
    B、p是一个指向一维数组的指针变量
    C、p是指针变量，指向一个整型数据
    D、以上都不对

7、声明语句int *f();中f的含义是________。
    A、一个返回值为指针类型的函数名
    B、一个用于指向函数的指针变量
    C、一个用于指向一维数组的行指针
    D、一个用于指向整型数据的指针变量

8、下面程序的功能是用函数编程实现两个数组中对应元素值的交换。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序的运行结果示例： Input array size(n<=10):5↙ Input array a:1 2 3 4 5↙ Input array b:6 7 8 9 10↙ Output array a: 6 7 8 9 10 Output array b: 1 2 3 4 5 #include <stdio.h> #define N 10 void ReadData(int a[], int n); void PrintData(int a[], int n); void Swap(int *x, int *y); int main() { int a[N], b[N], i, n; printf("Input array size(n<=10):"); scanf("%d", &n); printf("Input array a:"); ReadData(a, n); printf("Input array b:"); ReadData(b, n); for (i=0; i<n; i++) { Swap(____________); } printf("Output array a:"); PrintData(a, n); printf("Output array b:"); PrintData(b, n); return 0; } /* 函数功能：输入数组a的n个元素值 */ void ReadData(int a[], int n) { int i; for (i=0; i<n; i++) { scanf("%d", &a[i]); } } /* 函数功能：输出数组a的n个元素值 */ void PrintData(int a[], int n) { int i; for (i=0; i<n; i++) { printf("%5d", a[i]); } printf("\n"); } /* 函数功能：两整数值互换 */ void Swap(int *x, int *y) { int temp; ____________; ____________; ____________; }
    A、第17行：&a[i], &b[i] 第52行：temp = *x 第53行：*x = *y 第54行：*y = temp
    B、第17行：a[i], b[i] 第52行：temp = *x 第53行：*x = *y 第54行：*y = temp
    C、第17行：&a[i], &b[i] 第52行：*temp = *x 第53行：*x = *y 第54行：*y = *temp
    D、第17行：a[i], b[i] 第52行：temp = x 第53行：x = y 第54行：y = temp

9、给出下面程序的运行结果。 #include <stdio.h> int main(void) { static int x[] = {1,2,3}; int s = 1, i, *p = x; for (i=0; i<3; i++) { s*= *(p + i); } printf("%d\n", s); return 0; }
    A、6
    B、3
    C、4
    D、5

10、从键盘任意输入10个整数，计算并输出最大值和最小值及其它们在数组中的下标位置。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序运行结果示例1： Input 10 numbers:1 2 3 4 5 6 7 8 9 10↙ max=10,pos=9 min=1,pos=0 程序运行结果示例2： Input 10 numbers:2 4 5 6 8 10 1 3 5 7 9↙ max=10,pos=5 min=1,pos=6 #include <stdio.h> int FindMax(int a[], int n, int *pMaxPos); int FindMin(int a[], int n, int *pMinPos); int main() { int a[10], maxValue, maxPos, minValue, minPos, i; printf("Input 10 numbers:"); for (i=0; i<10; i++) { scanf("%d", &a[i]); // 输入10个数 } maxValue = FindMax(a, 10, _________); // 找最大值及其所在下标位置 minValue = FindMin(a, 10, _________); // 找最小值及其所在下标位置 printf("max=%d,pos=%d\n", maxValue, maxPos); printf("min=%d,pos=%d\n", minValue, minPos); return 0; } //函数功能：求有n个元素的整型数组a中的最大值及其所在下标位置，函数返回最大值 int FindMax(int a[], int n, int *pMaxPos) { int i, max; max = a[0]; //假设a[0]为最大值 __________; //假设最大值在数组中的下标位置为0 for (i=1; i<n; i++) { if (a[i] > max) { max = a[i]; __________; //pMaxPos指向最大值数组元素的下标位置 } } return max ; } //函数功能：求有n个元素的整型数组a中的最小值及其所在下标位置，函数返回最小值 int FindMin(int a[], int n, int *pMinPos) { int i, min; min = a[0]; //假设a[0]为最小 __________; //假设最小值在数组中的下标位置为0 for (i=1; i<10; i++) { if (a[i] < min) { min = a[i]; __________; //pMinPos指向最小值数组元素的下标位置 } } return min ; }
    A、第13行：&maxPos 第14行：&minPos 第25行：*pMaxPos = 0 第32行：*pMaxPos = i 第43行：*pMinPos = 0 第50行：*pMinPos = i
    B、第13行：maxPos 第14行：minPos 第25行：pMaxPos = 0 第32行：*pMaxPos = i 第43行：pMinPos = 0 第50行：*pMinPos = i
    C、第13行：maxPos 第14行：minPos 第25行：pMaxPos = 0 第32行：pMaxPos = i 第43行：pMinPos = 0 第50行：pMinPos = i
    D、第13行：&maxPos 第14行：&minPos 第25行：pMaxPos = 0 第32行：pMaxPos = i 第43行：*pMinPos = 0 第50行：*pMinPos = i

11、采用梯形法编程实现在积分区间[a,b]内计算下面两个函数的定积分。 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序运行结果示例: y1=1.333350 y2=1.151212 #include <stdio.h> float Fun1(float x); float Fun2(float x); float Integral(float (*f)(float), float a, float b); int main() { float y1, y2; y1 = Integral(Fun1, 0.0, 1.0); y2 = Integral(Fun2, 0.0, 3.0); printf("y1=%f\ny2=%f\n", y1, y2); return 0; } /* 函数功能：计算函数1+x*x的函数值 */ float Fun1(float x) { return 1 + x * x; } /* 函数功能：计算函数x/(1+x*x)的函数值 */ float Fun2(float x) { return x / (1 + x * x); } /* 函数功能：用梯形法计算函数的定积分 */ float Integral(float (*f)(float), float a, float b) { float s, h; int n = 100, i; s = __________; h = __________; for (i=1; i<n; i++) { s += __________; } return __________; }
    A、第31行：((*f)(a) + (*f)(b)) / 2 第32行：(b - a) / n 第36行：(*f)(a + i * h) 第38行：s * h
    B、第31行：(*f)(a+b) / 2 第32行：(b - a) / n 第36行：(*f)(a + i * h) 第38行：s
    C、第31行：((*f)(a) + (*f)(b)) / 2 第32行：(a - b) / n 第36行：*f(a + i * h) 第38行：s * h
    D、第31行：(*f)(a+b) / 2 第32行：(a - b) / n 第36行：*f(a + i * h) 第38行：s

练兵区——单选题——不计入总分

1、下面程序的功能是输入某年某月某日，计算并输出它是这一年的第几天。 程序的运行结果如下： Please enter year, month, day:2014,12,29↙ yearDay = 363 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int DayofYear(int year, int month, int day); int dayTab[2][13] = {{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}}; int main() { int year, month, day, yearDay; printf("Please enter year, month, day:"); scanf("%d,%d,%d", &year, &month, &day); yearDay = DayofYear(year, month, day); printf("yearDay = %d\n", yearDay); return 0; } /* 函数功能：对给定的某年某月某日，计算并返回它是这一年的第几天 */ int DayofYear(int year, int month, int day) { int i, leap; leap = ________________________; /* 若year为闰年，即leap值为1，则用第1行元素dayTab[1][i]计算； 否则leap值为0，用第0行dayTab[0][i]计算 */ for (i=1; _______; i++) { day = ________________; } return day; /* 返回计算出的day的值 */ }
    A、第18行： ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0) 第20： i<month 第22行： day + dayTab[leap][i]
    B、第18行： ((year % 4 == 0) || (year % 100 != 0)) || (year % 400 == 0) 第20： i<month 第22行： day + dayTab[i][leap]
    C、第18行： ((year % 4 == 0) && (year % 100 != 0)) && (year % 400 == 0) 第20： i<12 第22行： day + dayTab[leap][i]
    D、第18行： ((year % 4 != 0) && (year % 100 != 0)) || (year % 400 != 0) 第20： i<=month 第22行： day + dayTab[i][leap]

2、下面程序中子函数MonthDay()的功能是将某年的第几天转换为某月某日。程序的运行结果如下： Please enter year, yearDay:2014,100↙ month = 4, day = 10 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> void MonthDay(int year, int yearDay, int *pMonth, int *pDay); int dayTab[2][13] = {{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}}; int main() { int year, month, day, yearDay; printf("Please enter year, yearDay:"); scanf("%d,%d", &year, &yearDay); _________________; printf("month = %d, day = %d\n", month, day); return 0; } /* 函数功能：对给定的某一年的第几天，计算它是这一年的第几月第几日 */ void MonthDay(int year, int yearDay, int *pMonth, int *pDay) { int i, leap; leap = _________________________; for (i=1; yearDay>dayTab[leap][i]; i++) { yearDay = ______________________; } ______________; /* 将计算出的月份值赋值给pMonth所指向的变量 */ *pDay = yearDay; /* 将计算出的日号赋值给pDay所指向的变量 */ }
    A、第10行： MonthDay(year, yearDay, &month, &day) 第19行： ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[leap][i] 第25行： *pMonth = i
    B、第10行： MonthDay(year, yearDay, month, day) 第19行： ((year % 4 == 0) || (year % 100 != 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[leap][i] 第25行： pMonth = i
    C、第10行： MonthDay(&year, &yearDay, &month, &day) 第19行： ((year % 4 == 0) || (year % 100 != 0)) && (year % 400 != 0) 第23行： yearDay + dayTab[i][leap] 第25行： *pMonth = i
    D、第10行： MonthDay(&year, &yearDay, month, day) 第19行： ((year % 4 == 0) && (year % 100 == 0)) || (year % 400 == 0) 第23行： yearDay - dayTab[i][leap] 第25行： pMonth = i

3、子函数Fun的功能是比较形参变量x和y所指的内存单元中的数据大小，将两者中的最小值返回。以下程序执行后输出结果是7,8,7。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求#include <stdio.h> int Fun(int *x,int *y) { if(___________) /*如果形参变量x所指的内存单元中的数据小于y所指的内存单元中的数据，则返回该最小值*/ return *x; else return *y; } int main() { int a=7,b=8,_______,r; p=&a; q=&b; r=____________; /*调用子函数Fun，返回变量a和b中的最小值，将其存放到变量r中。*/ printf("%d,%d,%d\n",*p,*q,r); return 0; }
    A、第4行： *x<*y 第12行： *p,*q 第15行： Fun(p,q)
    B、第4行： x<y 第12行： *p,*q 第15行： Fun(*p,*q)
    C、第4行： *x<*y 第12行： p,q 第15行： Fun(&p,&q)
    D、第4行： x<y 第12行： *p,*q 第15行： Fun(a,b)

4、下面程序的功能是从键盘输入10个整数，用函数编程实现计算其最大值和最小值，并互换它们所在数组中的位置。程序运行结果如下： Input n(n<=10):10↙ Input 10 Numbers:1 4 3 0 –2 6 7 2 9 -1 ↙ Exchange results: 1 4 3 0 9 6 7 2 -2 -1 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> void ReadData(int a[], int n); void PrintData(int a[], int n); void MaxMinExchang(int a[], int n); void Swap(int *x, int *y); int main() { int a[10], n; printf("Input n(n<=10):"); scanf("%d", &n); printf("Input %d numbers:", n); ReadData(a, n); MaxMinExchang(a, n); printf("Exchange results:"); PrintData(a, n); return 0; } /* 函数功能：输入数组a的n个元素值 */ void ReadData(int a[], int n) { int i; for (i=0; i<n; i++) { scanf("%d", &a[i]); } } /* 函数功能：输出数组a的n个元素值 */ void PrintData(int a[], int n) { int i; for (i=0; i<n; i++) { printf("%5d", a[i]); } printf("\n"); } /* 函数功能：将数组a中的最大数与最小数位置互换 */ void MaxMinExchang(________, int n) { int maxValue = a[0], minValue = a[0], maxPos = 0, minPos = 0; int i; for (i=1; i<n; i++) { if (a[i] > maxValue) { maxValue = _______; maxPos = ____; } if (a[i] < minValue) { minValue = a[i]; minPos = i; } } Swap(________________); } /* 函数功能：两整数值互换 */ void Swap(int *x, int *y) { int ________; temp = *x; _________; *y = temp; }
    A、第41行： int a[] 第49行： a[i] 第50行： i 第58行： &a[maxPos], &a[minPos] 第64行： temp 第66行： *x = *y
    B、第41行： int a 第49行： a[i] 第50行： i 第58行： a[maxPos], a[minPos] 第64行： temp 第66行： *x = *y
    C、第41行： int a[] 第49行： a[0] 第50行： 0 第58行： &a[maxPos], &a[minPos] 第64行： *temp 第66行： x = y
    D、第41行： int a[] 第49行： a[n-1] 第50行： n-1 第58行： *a[maxPos], *a[minPos] 第64行： &temp 第66行： x = y

5、下列函数的功能为________。 void Exchange(int *p1, int *p2) { int p; p = *p1; *p1 = *p2; *p2 = p; }
    A、交换*p1和*p2的值
    B、正确，但无法改变*p1和*p2的值
    C、交换*p1和*p2的地址
    D、可能造成系统故障

6、声明语句int (*p)();的含义是________。
    A、p是一个指向函数的指针，该函数的返回值是一个整型
    B、p是一个指向一维数组的指针变量
    C、p是指针变量，指向一个整型数据
    D、以上都不对

7、声明语句int *f();中f的含义是________。
    A、一个返回值为指针类型的函数名
    B、一个用于指向函数的指针变量
    C、一个用于指向一维数组的行指针
    D、一个用于指向整型数据的指针变量

8、下面程序的功能是用函数编程实现两个数组中对应元素值的交换。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序的运行结果示例： Input array size(n<=10):5↙ Input array a:1 2 3 4 5↙ Input array b:6 7 8 9 10↙ Output array a: 6 7 8 9 10 Output array b: 1 2 3 4 5 #include <stdio.h> #define N 10 void ReadData(int a[], int n); void PrintData(int a[], int n); void Swap(int *x, int *y); int main() { int a[N], b[N], i, n; printf("Input array size(n<=10):"); scanf("%d", &n); printf("Input array a:"); ReadData(a, n); printf("Input array b:"); ReadData(b, n); for (i=0; i<n; i++) { Swap(____________); } printf("Output array a:"); PrintData(a, n); printf("Output array b:"); PrintData(b, n); return 0; } /* 函数功能：输入数组a的n个元素值 */ void ReadData(int a[], int n) { int i; for (i=0; i<n; i++) { scanf("%d", &a[i]); } } /* 函数功能：输出数组a的n个元素值 */ void PrintData(int a[], int n) { int i; for (i=0; i<n; i++) { printf("%5d", a[i]); } printf("\n"); } /* 函数功能：两整数值互换 */ void Swap(int *x, int *y) { int temp; ____________; ____________; ____________; }
    A、第17行：&a[i], &b[i] 第52行：temp = *x 第53行：*x = *y 第54行：*y = temp
    B、第17行：a[i], b[i] 第52行：temp = *x 第53行：*x = *y 第54行：*y = temp
    C、第17行：&a[i], &b[i] 第52行：*temp = *x 第53行：*x = *y 第54行：*y = *temp
    D、第17行：a[i], b[i] 第52行：temp = x 第53行：x = y 第54行：y = temp

9、给出下面程序的运行结果。 #include <stdio.h> int main(void) { static int x[] = {1,2,3}; int s = 1, i, *p = x; for (i=0; i<3; i++) { s*= *(p + i); } printf("%d\n", s); return 0; }
    A、6
    B、3
    C、4
    D、5

10、从键盘任意输入10个整数，计算并输出最大值和最小值及其它们在数组中的下标位置。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序运行结果示例1： Input 10 numbers:1 2 3 4 5 6 7 8 9 10↙ max=10,pos=9 min=1,pos=0 程序运行结果示例2： Input 10 numbers:2 4 5 6 8 10 1 3 5 7 9↙ max=10,pos=5 min=1,pos=6 #include <stdio.h> int FindMax(int a[], int n, int *pMaxPos); int FindMin(int a[], int n, int *pMinPos); int main() { int a[10], maxValue, maxPos, minValue, minPos, i; printf("Input 10 numbers:"); for (i=0; i<10; i++) { scanf("%d", &a[i]); // 输入10个数 } maxValue = FindMax(a, 10, _________); // 找最大值及其所在下标位置 minValue = FindMin(a, 10, _________); // 找最小值及其所在下标位置 printf("max=%d,pos=%d\n", maxValue, maxPos); printf("min=%d,pos=%d\n", minValue, minPos); return 0; } //函数功能：求有n个元素的整型数组a中的最大值及其所在下标位置，函数返回最大值 int FindMax(int a[], int n, int *pMaxPos) { int i, max; max = a[0]; //假设a[0]为最大值 __________; //假设最大值在数组中的下标位置为0 for (i=1; i<n; i++) { if (a[i] > max) { max = a[i]; __________; //pMaxPos指向最大值数组元素的下标位置 } } return max ; } //函数功能：求有n个元素的整型数组a中的最小值及其所在下标位置，函数返回最小值 int FindMin(int a[], int n, int *pMinPos) { int i, min; min = a[0]; //假设a[0]为最小 __________; //假设最小值在数组中的下标位置为0 for (i=1; i<10; i++) { if (a[i] < min) { min = a[i]; __________; //pMinPos指向最小值数组元素的下标位置 } } return min ; }
    A、第13行：&maxPos 第14行：&minPos 第25行：*pMaxPos = 0 第32行：*pMaxPos = i 第43行：*pMinPos = 0 第50行：*pMinPos = i
    B、第13行：maxPos 第14行：minPos 第25行：pMaxPos = 0 第32行：*pMaxPos = i 第43行：pMinPos = 0 第50行：*pMinPos = i
    C、第13行：maxPos 第14行：minPos 第25行：pMaxPos = 0 第32行：pMaxPos = i 第43行：pMinPos = 0 第50行：pMinPos = i
    D、第13行：&maxPos 第14行：&minPos 第25行：pMaxPos = 0 第32行：pMaxPos = i 第43行：*pMinPos = 0 第50行：*pMinPos = i

11、采用梯形法编程实现在积分区间[a,b]内计算下面两个函数的定积分。 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 程序运行结果示例: y1=1.333350 y2=1.151212 #include <stdio.h> float Fun1(float x); float Fun2(float x); float Integral(float (*f)(float), float a, float b); int main() { float y1, y2; y1 = Integral(Fun1, 0.0, 1.0); y2 = Integral(Fun2, 0.0, 3.0); printf("y1=%f\ny2=%f\n", y1, y2); return 0; } /* 函数功能：计算函数1+x*x的函数值 */ float Fun1(float x) { return 1 + x * x; } /* 函数功能：计算函数x/(1+x*x)的函数值 */ float Fun2(float x) { return x / (1 + x * x); } /* 函数功能：用梯形法计算函数的定积分 */ float Integral(float (*f)(float), float a, float b) { float s, h; int n = 100, i; s = __________; h = __________; for (i=1; i<n; i++) { s += __________; } return __________; }
    A、第31行：((*f)(a) + (*f)(b)) / 2 第32行：(b - a) / n 第36行：(*f)(a + i * h) 第38行：s * h
    B、第31行：(*f)(a+b) / 2 第32行：(b - a) / n 第36行：(*f)(a + i * h) 第38行：s
    C、第31行：((*f)(a) + (*f)(b)) / 2 第32行：(a - b) / n 第36行：*f(a + i * h) 第38行：s * h
    D、第31行：(*f)(a+b) / 2 第32行：(a - b) / n 第36行：*f(a + i * h) 第38行：s

第14周编程实验题

1、重复数字检查

2、教授的课

3、寻找鞍点

4、计算三位阶乘和数

第14周-练兵区——编程题——不计入总分

1、二分法求根

2、矩阵转置

3、程序改错

4、蛇形矩阵

5、亲密数_1

6、亲密数_2

7、完全数

8、回文素数

9、梅森尼数

10、工资统计

第10周——字符串：C语言世界中的大力水手

10.1 字符串的存储与表示（28分）随堂测验

1、下列说法正确的是（）。
    A、用双引号括起的一串字符是字符串常量，系统自动为其添加空字符'\0'作为字符串的结束标志。
    B、字符数组的最后一个元素必须是字符'0'才能表示一个字符串。
    C、char *pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
    D、char *pStr; scanf("%s", pStr); 这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。

10.2 字符串处理操作（15分）随堂测验

1、下列说法正确的是（）。
    A、strlen()计算的是包含'\0'在内的字符串的长度。
    B、字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
    C、strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符'\0'将被覆盖。
    D、字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。

10.3 向函数传递和从函数返回字符串（26分）随堂测验

1、向函数传递字符串，既可以用字符数组做函数参数，也可以用字符指针做函数参数，这两种方式都是传引用调用，就是将字符串的首地址、而非字符串中的全部字符传给形参。

10.3 向函数传递和从函数返回字符串（26分）随堂测验

1、函数返回值的类型既可以是字符指针，也可以是字符数组。

第10周测验

1、下面程序的功能是从键盘输入一个字符串，编程将其字符顺序颠倒后重新存放，并输出这个字符串。 程序的运行结果如下： Input a string: abcdef↙ The inversed string is: fedcba 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> void Inverse(char *pStr); int main() { char str[80]; printf("Input a string:\n"); gets(str);//输入字符串 Inverse(str);//将存于str数组中的字符串逆序存放 printf("The inversed string is:\n"); puts(str);//输出字符串 return 0; } void Inverse(char *pStr) { int len = 0; char temp; char *pStart = pStr;//指针变量pStart指向字符串的第一个字符 char *pEnd;//指针变量pEnd指向字符串的最后一个字符 for (; *pStart!='\0'; _________) //求出字符串长度 { len++; } for (pStart=pStr,___________; pStart<pEnd; pStart++,pEnd--) { temp = _________; ________________; *pEnd = temp; } }
    A、第21行： pStart++ 第25行： pEnd=pStr+len-1 第27行： *pStart 第28行： *pStart = *pEnd
    B、第21行： *pStart++ 第25行： pEnd=pStr+len 第27行： *pStart 第28行： *pStart = *pEnd
    C、第21行： pStart++ 第25行： pEnd=pStr+len-1 第27行： pStart 第28行： pStart = pEnd
    D、第21行： *pStart++ 第25行： pEnd=pStr+len 第27行： pStart 第28行： pStart = pEnd

2、Squeeze函数的功能是删除字符串s中所出现的与变量c相同的字符。例如，输入为： abcdef↙ c↙ 输出为： abdef 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> void Squeeze(char *s, char c); int main() { char a[80], c, *s; s = a; gets(a); scanf("%c",&c); Squeeze(s, c); printf("%s\n", s); return 0; } void Squeeze(char *s, char c) { int i, j; for (i = j = 0; s[i] != '\0'; i++) { if (__________) { __________; j++; } } _____________; /* 在字符串t2的末尾添加字符串结束标志 */ }
    A、第20行： s[i] != c 第22行： s[j] = s[i] 第26行： s[j] = '\0'
    B、第20行： s[i] == c 第22行： s[j] = s[i] 第26行： s[i] = '\0'
    C、第20行： s[j] != c 第22行： s[i] = s[j] 第26行： s[j] = '\0'
    D、第20行： s[j] == c 第22行： s[j] = s[i] 第26行： s[i] = '\0'

3、以下程序中函数FindMinString的功能是返回形参指针s1和s2所指字符串中较小字符串的首地址。例如，若运行时依次输入三个字符串： 123↙ 1223↙ 124↙ 输出结果为1223 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> char *FindMinString( _____________ ) { if(_____________) return(s1); else return(s2); } int main() { int i; char string[20], str[3][20]; for(i=0;i<3;i++) { gets(str[i]); } strcpy(string,FindMinString(str[0],str[1])); /*对字符串进行复制*/ strcpy(string,___________________); printf("%s\n",string); return 0; }
    A、第3行： char *s1, char *s2 第5行： strcmp(s1,s2)<0 第20行： FindMinString(string,str[2])
    B、第3行： char s1, char s2 第5行： s1<s2 第20行： FindMinString(string,str[2])
    C、第3行： char s1, char s2 第5行： strcmp(s1,s2)>0 第20行： FindMinString(str[0],str[2])
    D、第3行： char *s1, char *s2 第5行： s1>s2 第20行： strcmp(str[1],str[2])

4、子函数Move的功能是将某字符串中的第i个字符向左移动1位，覆盖第i-1个字符。下面程序通过多次调用Move函数，将字符数组b中存放的字符串依次左移3位，并在移动后的字符串末尾添上字符0补足。程序的运行结果为： 2345678900 3456789000 4567890000 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Move( _________,int i) { a[i-1]=a[i]; } int main( ) { char b[11]={"1234567890"}; int i,j; for (j=0;j<=2;j++) { for(i=1;b[i]!='\0';i++) { __________; printf("%c",b[i-1]); } _________; printf("%c\n",________); } return 0; }
    A、第2行： char *a 第15行： Move(b,i) 第18行： b[i-1]='0' 第19行： b[i-1]
    B、第2行： char a 第15行： Move(b,i) 第18行： b[i-1]='\0' 第19行： b[i-1]
    C、第2行： char *a 第15行： Move(b,i) 第18行： b[i]='0' 第19行： b[i]
    D、第2行： char a 第15行： Move(i,b) 第18行： b[i]='\0' 第19行： b[i]

5、下面能正确进行字符串赋值操作的是
    A、char *s=“ABCDE”;
    B、char s[5]={“ABCDE”};
    C、char s[5]={'A', 'B', 'C', 'D', 'E'};
    D、char *s,scanf(“%s”,s);

6、下列对字符串的定义中，错误的是
    A、char str[7] = "FORTRAN";
    B、char str[] = "FORTRAN";
    C、char *str = "FORTRAN";
    D、char str[] = {'F','O','R','T','R','A','N',0};

7、已知：int *p(); 则p是
    A、一个函数，该函数的返回值是指向int型的指针变量
    B、指向int型的指针变量
    C、int型的指针数组
    D、一个指向函数的指针变量，该函数的返回值是int型

8、下面函数Fun的功能是 #include <stdio.h> #include <string.h> int Fun(char *ps) { char *p; p=ps; while(*p++); return (p-ps); } int main() { char *s; int a1,a2; s = "hello"; a1=Fun(s); a2=strlen(s); printf("%d,%d\n", a1,a2); return 0; }
    A、以上三种说法都不对
    B、比较两个字符串的大小
    C、求字符串的长度
    D、将串ps复制到串s中

9、下面函数Fun的功能是 void Fun(char *s1, char *s2) { while(*s2++=*s1++); }
    A、串复制
    B、求串长
    C、串比较
    D、串反向

10、给出以下定义，则正确的叙述是 char x[ ]= “abcedfg”; char y[ ]={ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’’, ‘g’ };
    A、数组x 的长度大于数组y的长度
    B、数组x 和数组y 等价
    C、数组x 和数组y 的长度相同
    D、数组x 的长度小于数组y的长度

11、执行以下代码段后，输出的字符串是#include <stdio.h> #include <string.h> int main() { char s1[10],*s2="ab\0cdef"; strcpy(s1,s2); puts(s1); ....... return 0; }
    A、ab
    B、cdef
    C、ab\0cdef
    D、内容不确定

12、下面程序的功能是将字符数组中存放的字符串以多种书写形式输出，如“Program”，“PROGRAM”，以及逆序输出的字符串“margorp”等，程序的运行结果为： Program PROGRAM margorp 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> int main(void) { int i = 0; char b[] = "program"; char *a = "PROGRAM"; printf("_____\n", *a, b + 1); /* 输出Program */ while (_________________) /* 输出PROGRAM */ { ___________; i++; } printf("\n"); while (_____) /* 输出margorp */ { putchar (___________); } __________; return 0; }
    A、第8行： %c%s 第9行： *(a+i)!='\0' 第11行： putchar(*(a + i)) 第15行： --i 第17行： *(b + i) 第19行： putchar (*(b + i))
    B、第8行： %s%s 第9行： （*a+i)!='\0' 第11行： putchar(*a + i)) 第15行： i-- 第17行： *(b + i) 第19行： putchar (*(b + i))
    C、第8行： %c%s 第9行： *(a+i)=='\0' 第11行： putchar(*(a + i)) 第15行： --i 第17行： *b + i 第19行： putchar (*b + i))
    D、第8行： %s%s 第9行： （*a+i)=='\0' 第11行： putchar(*a + i)) 第15行： i-- 第17行： *b + i 第19行： putchar (*b + i)

13、下面程序的功能是用字符指针变量作函数参数编程实现字符串连接函数strcat()的功能，将字符串srcStr连接到字符串dstStr的尾部。 程序的运行结果如下： Please enter the source string:abcd↙ Please enter the other string:efgh↙ The concat is: abcdefgh 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void MyStrcat(char *dstStr, char *srcStr); int main() { char s[80]; //源字符串 char t[80]; //待连接字符串 printf("Please enter the source string: \n"); gets(s); printf("Please enter the other string: "); gets(t); //输入字符串 MyStrcat(s, t); //将字符数组t中的字符串连到s的尾部 printf("The concat is:\n"); puts(s); //输出连接后的字符串s return 0; } void MyStrcat(char *dstStr, char *srcStr) //用字符指针作为函数参数 { while (__________) { dstStr++; } while (*srcStr != '\0') //若srcStr所指字符不是字符串结束标志 { _________; //将srcStr所指字符复制到dstStr所指的存储单元中 srcStr++; //使srcStr指向下一个字符 dstStr++; //使dstStr指向下一个存储单元 } _____________; //在字符串dstStr的末尾添加一个字符串结束标志 }
    A、第19行： *dstStr != '\0' 第25行： *dstStr = * srcStr 第29行： *dstStr = '\0'
    B、第19行： dstStr != '\0' 第25行： dstStr = srcStr 第29行： *dstStr = '\0'
    C、第19行： *dstStr == '\0' 第25行： *dstStr = * srcStr 第29行： *dstStr = '\n'
    D、第19行： dstStr == '\0' 第25行： dstStr = srcStr 第29行： *dstStr = '\n'

14、以下程序的功能是分别测量字符数组及数组中存放的字符串的长度，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> int main( ) { char a[]="abcdefg",b[10]="abcdefg"; _________________________; /*测量字符数组a,b的长度，并输出*/ _________________________; /*测量字符数组a,b中存放的字符串的长度，并输出*/ return 0; }
    A、第6行： printf("%d %d\n",sizeof(a) ,sizeof(b)) 第7行： printf("%d %d\n",strlen(a) ,strlen(b))
    B、第6行： printf("%d %d\n",strlen(a) ,strlen(b)) 第7行： printf("%d %d\n",sizeof(a) ,sizeof(b))
    C、第6行： printf("%d %d\n",sizeof(*a) ,sizeof(*b)) 第7行： printf("%d %d\n",strlen(*a) ,strlen(*b))
    D、第6行： printf("%d %d\n",sizeof(&a) ,sizeof(&b)) 第7行： printf("%d %d\n",strlen(&a) ,strlen(&b))

15、下面程序的功能是将一个字符串s2插入到字符串s1中，其起始插入位置为n。 程序运行示例如下： main string:hello,world! sub string:cc site of begining:(<=12)5 After instert:hellocc,world! 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 100 int main() { int n, i, j, k, len; char s1[N], s2[N], s3[2 * N]; printf("main string:"); gets(s1); printf("sub string:"); gets(s2); len = strlen(s1); do { printf("site of begining:(<=%d)", len); scanf("%d", &n); }while (__________); for (i = 0; i < n; i++) { s3[i] = s1[i]; } for (j = 0; s2[j] != '\0'; j++) { __________________; } for (________; s1[k] != '\0'; k++) { ________________; } s3[j + k] = '\0'; printf("After instert:%s\n", s3); return 0; }
    A、第17行： n > len 第25行： s3[i + j] = s2[j] 第27行： k = n 第29行： s3[j + k] = s1[k]
    B、第17行： n < len 第25行： s3[i] = s2[j] 第27行： k = n 第29行： s3[j] = s1[k]
    C、第17行： n <= len 第25行： s2[j]=s3[i + j] 第27行： k = 0 第29行： s3[j] = s1[k]
    D、第17行： n >= len 第25行： s3[j] = s2[j] 第27行： k = 0 第29行： s1[k] = s3[j + k]

16、下面程序的功能是从键盘输入一行字符（最长不超过80字符），用函数编程统计其中单词（以空格作为间隔符的字符串）的个数。 基本思路是：当前被检验字符不是空格，而前一被检验字符是空格，则表示有新单词出现。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。（下面答案中两个单引号''中间都有一个空格） 样例1： Input a string:How are you↙ Numbers of words = 3 样例2： Input a string: How are you↙ Numbers of words = 3 #include <stdio.h> int CountWords(char str[]); int main() { char str[81]; int num; printf("Input a string:\n"); gets(str); num=CountWords(str); printf("Number of words=%d\n", num); return 0; } int CountWords(char str[]) { int i, num; num = (__________) ? 1 : 0; i=1; while (str[i]!='\0') { if (_______________________) { num++; } __________; } return num; }
    A、第17行： str[0] != ' ' 第21行： str[i]!=' ' && str[i-1] == ' ' 第25行： i++
    B、第17行： str[0] == ' ' 第21行： str[i]!=' ' || str[i-1] == ' ' 第25行： i++
    C、第17行： str[0] != '\0 ' 第21行： str[i]==' ' && str[i-1] == ' ' 第25行： i++
    D、第17行： str[0] != ' ' 第21行： str[i]!=' ' && str[i-1] != ' ' 第25行： num++

17、下面程序的功能是实现字符串逆序存放。 程序运行结果如下： Input a string:ABCDEFGHI↙ Inversed results:IHGFEDCBA 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 80 void Inverse(char *pStr); int main() { char a[N]; printf("Input a string:"); gets(a); Inverse(a); printf("Inversed results:%s\n", a); return 0; } /* 函数功能： 实现将字符数组中的字符串逆序存放 */ void Inverse(____________) { int len; char temp; char *pStart; /* 指针变量pStart指向字符串的第一个字符 */ char *pEnd; /* 指针变量pEnd指向字符串的最后一个字符 */ len = strlen(pStr); /* 求出字符串长度 */ for (pStart=pStr,___________; pStart<pEnd; pStart++,__________) { temp = *pStart; ______________; *pEnd = temp; } }
    A、第16行： char *pStr 第23行： pEnd=pStr+len-1 pEnd-- 第26行： *pStart = *pEnd
    B、第16行： char pStr 第23行： pEnd=pStr+len pEnd-- 第26行： *pStart = *pEnd
    C、第16行： char *pStr 第23行： pEnd=pStr+len-1 pEnd++ 第26行： pStart = pEnd
    D、第16行： char pStr 第23行： pEnd=pStr+len+1 pEnd++ 第26行： *pStart = *pEnd

18、下面程序的功能是从键盘输入一行字符（不超过80个），统计其中的英文字符、数字字符、空格和其他字符的个数。例如，输入的一行字符为 *****c language.***** 输出为 English character: 9 digit character: 0 space: 1 other character: 11 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define STR_LEN 80 int main() { char str[STR_LEN+1]; int len, i, letter = 0, digit = 0, space = 0, others = 0; printf("Please input a string:"); ___________; for (i = 0; __________; i++) { if (___________________________) letter ++; /*统计英文字符 */ else if (______________________) digit ++; /*统计数字字符 */ else if (str[i] == ' ' ) space ++; /*统计空格*/ else others ++; /*统计其他字符的个数*/ } printf("English character: %d\n", letter); printf("digit character: %d\n", digit); printf("space: %d\n", space); printf("other character: %d\n", others); return 0; }
    A、第9行： gets(str) 第10行： str[i] != '\0' 第12行： str[i] >= 'a' && str[i] <= 'z' || str[i] >= 'A' && str[i] <= 'Z' 第14行： str[i] >= '0' && str[i] <= '9'
    B、第9行： scanf("%s",str) 第10行： str[i] != '\0' 第12行： 'z' >= str[i] >= 'a' || 'A' <= str[i] <= 'Z' 第14行： 9 >= str[i] >= 0
    C、第9行： puts(str) 第10行： str[i] != '\n' 第12行： 'z' >= str[i] >= 'a' || 'A' <= str[i] <= 'Z' 第14行： str[i] >= '0' && str[i] <= '9'
    D、第9行： scanf("%s",str) 第10行： str[i] != '\n' 第12行： str[i] >= 'a' || str[i] <= 'z' && str[i] >= 'A' || str[i] <= 'Z' 第14行： str[i] >= 0 && str[i] <= 9

19、下面程序的功能是在字符串每个字符间插入一个空格。 程序的运行结果如下： Input a string:Howareyou↙ Insert results:H o w a r e y o u 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 100 void Insert(char s[]); int main() { char str[N]; printf("Input a string:"); gets(str); Insert(str); printf("Insert results:%s\n", str); return 0; } void Insert(char s[]) { char t[N]; int i, j; ____________; for (i=0, j=0; ____________; i++, j++) { ________; j++; ________; } s[j] = '\0';/* 在字符串s的末尾添加字符串结束标志 */ }
    A、第19行：strcpy(t, s) 第20行：t[i]!='\0' 第22行：s[j] = t[i] 第24行：s[j] = ' '
    B、第19行：t=s; 第20行：t[i]!='\0' 第22行：s[i] = t[j] 第24行：s[j] = ' '
    C、第19行：strcpy(t, s) 第20行：t[i]='\0' 第22行：t[j] = s[i] 第24行：s[j] = '\0 '
    D、第19行：strcpy(s, t) 第20行：t[i]=='\0' 第22行：s[j] = t[i] 第24行：s[j] = '0 '

20、子函数Change的功能是将英文大写字母转换为小写字母，下面程序的输出结果是 abc_abc_def 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Change(__________) { int i; for(;________;ch++) { if(____________) _________________; } } int main() { char s[]="ABC_abc_DEF"; Change(s); printf("%s\n",s); return 0; }
    A、第2行： char *ch 第5行： *ch!='\0' 第7行： *ch>='A'&& *ch<='Z' 第8行： *ch=*ch-'A'+'a'
    B、第2行： char ch 第5行： ch!='\0' 第7行： *ch>='A'&& *ch<='Z' 第8行： *ch=*ch-'A'+'a'
    C、第2行： char *ch 第5行： *ch!='\0' 第7行： ch>='A'&& ch<='Z' 第8行： ch=ch-'A'+'a'
    D、第2行： char ch[] 第5行： *ch=='\0' 第7行： *ch>='A'|| *ch<='Z' 第8行： *ch=*ch-'A'+'a'

21、下面程序的功能是比较用户键盘输入的口令userInput与内设的口令password是否相同。若相同，则输出"Correct password! Welcome to the system..."，若userInput<password，则输出"Invalid password!user input<password"，否则输出"Invalid password!user input>password"。 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> int main() { char password[7] = "secret"; char userInput[81] ; printf("Input Password:"); scanf(_____________); if ( ______________ ) printf("Correct password! Welcome to the system...\n"); else if ( ___________________) printf("Invalid password!user input<password\n"); else printf("Invalid password!user input>password\n"); return 0; }
    A、第8行： "%s", userInput 第9行： strcmp(userInput, password) == 0 第11行： strcmp(userInput, password) < 0
    B、第8行： "%c", userInput 第9行： strcmp(userInput, password) = 0 第11行： strcmp(userInput, password) < 0
    C、第8行： "%s", userInput 第9行： userInput==password 第11行： userInput<password
    D、第8行： "%c", userInput 第9行： strcpy(userInput, password) == 0 第11行： strcpy(userInput, password) < 0

22、下列说法错误的是
    A、字符数组的最后一个元素必须是字符'0'才能表示一个字符串。
    B、char *pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
    C、char *pStr; scanf("%s", pStr); 这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。
    D、字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
    E、用双引号括起的一串字符是字符串常量，系统自动为其添加空字符'\0'作为字符串的结束标志。
    F、通过间接寻址运算符引用指针变量指向的变量的值，称为指针的解引用。

23、下列说法正确的是
    A、指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。
    B、指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。
    C、指针变量占用的内存单元字节数就是它所指向的变量所占用的内存单元字节数。
    D、strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符'\0'将被覆盖。
    E、字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
    F、strlen()计算的是包含'\0'在内的字符串的长度。

练兵区——单选题——不计入总分

1、下面能正确进行字符串赋值操作的是
    A、char *s=“ABCDE”;
    B、char s[5]={“ABCDE”};
    C、char s[5]={'A', 'B', 'C', 'D', 'E'};
    D、char *s,scanf(“%s”,s);

2、已知：int *p(); 则p是
    A、一个函数，该函数的返回值是指向int型的指针变量
    B、指向int型的指针变量
    C、int型的指针数组
    D、一个指向函数的指针变量，该函数的返回值是int型

3、给出以下定义，则正确的叙述是 char x[ ]= “abcedfg”; char y[ ]={ ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’’, ‘g’ };
    A、数组x 的长度大于数组y的长度
    B、数组x 和数组y 等价
    C、数组x 和数组y 的长度相同
    D、数组x 的长度小于数组y的长度

4、下面程序的功能是用字符指针变量作函数参数编程实现字符串连接函数strcat()的功能，将字符串srcStr连接到字符串dstStr的尾部。 程序的运行结果如下： Please enter the source string:abcd↙ Please enter the other string:efgh↙ The concat is: abcdefgh 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> void MyStrcat(char *dstStr, char *srcStr); int main() { char s[80]; //源字符串 char t[80]; //待连接字符串 printf("Please enter the source string: \n"); gets(s); printf("Please enter the other string: "); gets(t); //输入字符串 MyStrcat(s, t); //将字符数组t中的字符串连到s的尾部 printf("The concat is:\n"); puts(s); //输出连接后的字符串s return 0; } void MyStrcat(char *dstStr, char *srcStr) //用字符指针作为函数参数 { while (__________) { dstStr++; } while (*srcStr != '\0') //若srcStr所指字符不是字符串结束标志 { _________; //将srcStr所指字符复制到dstStr所指的存储单元中 srcStr++; //使srcStr指向下一个字符 dstStr++; //使dstStr指向下一个存储单元 } _____________; //在字符串dstStr的末尾添加一个字符串结束标志 }
    A、第19行： *dstStr != '\0' 第25行： *dstStr = * srcStr 第29行： *dstStr = '\0'
    B、第19行： dstStr != '\0' 第25行： dstStr = srcStr 第29行： *dstStr = '\0'
    C、第19行： *dstStr == '\0' 第25行： *dstStr = * srcStr 第29行： *dstStr = '\n'
    D、第19行： dstStr == '\0' 第25行： dstStr = srcStr 第29行： *dstStr = '\n'

5、以下程序中函数FindMinString的功能是返回形参指针s1和s2所指字符串中较小字符串的首地址。例如，若运行时依次输入三个字符串： 123↙ 1223↙ 124↙ 输出结果为1223 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <string.h> char *FindMinString( _____________ ) { if(_____________) return(s1); else return(s2); } int main() { int i; char string[20], str[3][20]; for(i=0;i<3;i++) { gets(str[i]); } strcpy(string,FindMinString(str[0],str[1])); /*对字符串进行复制*/ strcpy(string,___________________); printf("%s\n",string); return 0; }
    A、第3行： char *s1, char *s2 第5行： strcmp(s1,s2)<0 第20行： FindMinString(string,str[2])
    B、第3行： char s1, char s2 第5行： s1<s2 第20行： FindMinString(string,str[2])
    C、第3行： char s1, char s2 第5行： strcmp(s1,s2)>0 第20行： FindMinString(str[0],str[2])
    D、第3行： char *s1, char *s2 第5行： s1>s2 第20行： strcmp(str[1],str[2])

6、子函数Move的功能是将某字符串中的第i个字符向左移动1位，覆盖第i-1个字符。下面程序通过多次调用Move函数，将字符数组b中存放的字符串依次左移3位，并在移动后的字符串末尾添上字符0补足。程序的运行结果为： 2345678900 3456789000 4567890000 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> void Move( _________,int i) { a[i-1]=a[i]; } int main( ) { char b[11]={"1234567890"}; int i,j; for (j=0;j<=2;j++) { for(i=1;b[i]!='\0';i++) { __________; printf("%c",b[i-1]); } _________; printf("%c\n",________); } return 0; }
    A、第2行： char *a 第15行： Move(b,i) 第18行： b[i-1]='0' 第19行： b[i-1]
    B、第2行： char a 第15行： Move(b,i) 第18行： b[i-1]='\0' 第19行： b[i-1]
    C、第2行： char *a 第15行： Move(b,i) 第18行： b[i]='0' 第19行： b[i]
    D、第2行： char a 第15行： Move(i,b) 第18行： b[i]='\0' 第19行： b[i]

7、下面程序的功能是将字符数组中存放的字符串以多种书写形式输出，如“Program”，“PROGRAM”，以及逆序输出的字符串“margorp”等，程序的运行结果为： Program PROGRAM margorp 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <string.h> int main(void) { int i = 0; char b[] = "program"; char *a = "PROGRAM"; printf("_____\n", *a, b + 1); /* 输出Program */ while (_________________) /* 输出PROGRAM */ { ___________; i++; } printf("\n"); while (_____) /* 输出margorp */ { putchar (___________); } __________; return 0; }
    A、第8行： %c%s 第9行： *(a+i)!='\0' 第11行： putchar(*(a + i)) 第15行： --i 第17行： *(b + i) 第19行： putchar (*(b + i))
    B、第8行： %s%s 第9行： （*a+i)!='\0' 第11行： putchar(*a + i)) 第15行： i-- 第17行： *(b + i) 第19行： putchar (*(b + i))
    C、第8行： %c%s 第9行： *(a+i)=='\0' 第11行： putchar(*(a + i)) 第15行： --i 第17行： *b + i 第19行： putchar (*b + i))
    D、第8行： %s%s 第9行： （*a+i)=='\0' 第11行： putchar(*a + i)) 第15行： i-- 第17行： *b + i 第19行： putchar (*b + i)

8、Squeeze函数的功能是删除字符串s中所出现的与变量c相同的字符。例如，输入为： abcdef↙ c↙ 输出为： abdef 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <string.h> void Squeeze(char *s, char c); int main() { char a[80], c, *s; s = a; gets(a); scanf("%c",&c); Squeeze(s, c); printf("%s\n", s); return 0; } void Squeeze(char *s, char c) { int i, j; for (i = j = 0; s[i] != '\0'; i++) { if (__________) { __________; j++; } } _____________; /* 在字符串t2的末尾添加字符串结束标志 */ }
    A、第20行： s[i] != c 第22行： s[j] = s[i] 第26行： s[j] = '\0'
    B、第20行： s[i] == c 第22行： s[j] = s[i] 第26行： s[i] = '\0'
    C、第20行： s[j] != c 第22行： s[i] = s[j] 第26行： s[j] = '\0'
    D、第20行： s[j] == c 第22行： s[j] = s[i] 第26行： s[i] = '\0'

9、下列对字符串的定义中，错误的是
    A、char str[7] = "FORTRAN";
    B、char str[] = "FORTRAN";
    C、char *str = "FORTRAN";
    D、char str[] = {'F','O','R','T','R','A','N',0};

10、下面函数Fun的功能是 void Fun(char *s1, char *s2) { while(*s2++=*s1++); }
    A、串复制
    B、求串长
    C、串比较
    D、串反向

11、执行以下代码段后，输出的字符串是#include <stdio.h> #include <string.h> int main() { char s1[10],*s2="ab\0cdef"; strcpy(s1,s2); puts(s1); ....... return 0; }
    A、ab
    B、cdef
    C、ab\0cdef
    D、内容不确定

12、下面程序的功能是从键盘输入一个字符串，编程将其字符顺序颠倒后重新存放，并输出这个字符串。 程序的运行结果如下： Input a string: abcdef↙ The inversed string is: fedcba 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #include <string.h> void Inverse(char *pStr); int main() { char str[80]; printf("Input a string:\n"); gets(str);//输入字符串 Inverse(str);//将存于str数组中的字符串逆序存放 printf("The inversed string is:\n"); puts(str);//输出字符串 return 0; } void Inverse(char *pStr) { int len = 0; char temp; char *pStart = pStr;//指针变量pStart指向字符串的第一个字符 char *pEnd;//指针变量pEnd指向字符串的最后一个字符 for (; *pStart!='\0'; _________) //求出字符串长度 { len++; } for (pStart=pStr,___________; pStart<pEnd; pStart++,pEnd--) { temp = _________; ________________; *pEnd = temp; } }
    A、第21行： pStart++ 第25行： pEnd=pStr+len-1 第27行： *pStart 第28行： *pStart = *pEnd
    B、第21行： *pStart++ 第25行： pEnd=pStr+len 第27行： *pStart 第28行： *pStart = *pEnd
    C、第21行： pStart++ 第25行： pEnd=pStr+len-1 第27行： pStart 第28行： pStart = pEnd
    D、第21行： *pStart++ 第25行： pEnd=pStr+len 第27行： pStart 第28行： pStart = pEnd

13、下面函数Fun的功能是 #include <stdio.h> #include <string.h> int Fun(char *ps) { char *p; p=ps; while(*p++); return (p-ps); } int main() { char *s; int a1,a2; s = "hello"; a1=Fun(s); a2=strlen(s); printf("%d,%d\n", a1,a2); return 0; }
    A、以上三种说法都不对
    B、比较两个字符串的大小
    C、求字符串的长度
    D、将串ps复制到串s中

14、下面程序的功能是从键盘输入一行字符（不超过80个），统计其中的英文字符、数字字符、空格和其他字符的个数。例如，输入的一行字符为 *****c language.***** 输出为 English character: 9 digit character: 0 space: 1 other character: 11 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define STR_LEN 80 int main() { char str[STR_LEN+1]; int len, i, letter = 0, digit = 0, space = 0, others = 0; printf("Please input a string:"); ___________; for (i = 0; __________; i++) { if (___________________________) letter ++; /*统计英文字符 */ else if (______________________) digit ++; /*统计数字字符 */ else if (str[i] == ' ' ) space ++; /*统计空格*/ else others ++; /*统计其他字符的个数*/ } printf("English character: %d\n", letter); printf("digit character: %d\n", digit); printf("space: %d\n", space); printf("other character: %d\n", others); return 0; }
    A、第9行： gets(str) 第10行： str[i] != '\0' 第12行： str[i] >= 'a' && str[i] <= 'z' || str[i] >= 'A' && str[i] <= 'Z' 第14行： str[i] >= '0' && str[i] <= '9'
    B、第9行： scanf("%s",str) 第10行： str[i] != '\0' 第12行： 'z' >= str[i] >= 'a' || 'A' <= str[i] <= 'Z' 第14行： 9 >= str[i] >= 0
    C、第9行： puts(str) 第10行： str[i] != '\n' 第12行： 'z' >= str[i] >= 'a' || 'A' <= str[i] <= 'Z' 第14行： str[i] >= '0' && str[i] <= '9'
    D、第9行： scanf("%s",str) 第10行： str[i] != '\n' 第12行： str[i] >= 'a' || str[i] <= 'z' && str[i] >= 'A' || str[i] <= 'Z' 第14行： str[i] >= 0 && str[i] <= 9

15、下面程序的功能是在字符串每个字符间插入一个空格。 程序的运行结果如下： Input a string:Howareyou↙ Insert results:H o w a r e y o u 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 100 void Insert(char s[]); int main() { char str[N]; printf("Input a string:"); gets(str); Insert(str); printf("Insert results:%s\n", str); return 0; } void Insert(char s[]) { char t[N]; int i, j; ____________; for (i=0, j=0; ____________; i++, j++) { ________; j++; ________; } s[j] = '\0';/* 在字符串s的末尾添加字符串结束标志 */ }
    A、第19行：strcpy(t, s) 第20行：t[i]!='\0' 第22行：s[j] = t[i] 第24行：s[j] = ' '
    B、第19行：t=s; 第20行：t[i]!='\0' 第22行：s[i] = t[j] 第24行：s[j] = ' '
    C、第19行：strcpy(t, s) 第20行：t[i]='\0' 第22行：t[j] = s[i] 第24行：s[j] = '\0 '
    D、第19行：strcpy(s, t) 第20行：t[i]=='\0' 第22行：s[j] = t[i] 第24行：s[j] = '0 '

16、下面程序的功能是实现字符串逆序存放。 程序运行结果如下： Input a string:ABCDEFGHI↙ Inversed results:IHGFEDCBA 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 80 void Inverse(char *pStr); int main() { char a[N]; printf("Input a string:"); gets(a); Inverse(a); printf("Inversed results:%s\n", a); return 0; } /* 函数功能： 实现将字符数组中的字符串逆序存放 */ void Inverse(____________) { int len; char temp; char *pStart; /* 指针变量pStart指向字符串的第一个字符 */ char *pEnd; /* 指针变量pEnd指向字符串的最后一个字符 */ len = strlen(pStr); /* 求出字符串长度 */ for (pStart=pStr,___________; pStart<pEnd; pStart++,__________) { temp = *pStart; ______________; *pEnd = temp; } }
    A、第16行： char *pStr 第23行： pEnd=pStr+len-1 pEnd-- 第26行： *pStart = *pEnd
    B、第16行： char pStr 第23行： pEnd=pStr+len pEnd-- 第26行： *pStart = *pEnd
    C、第16行： char *pStr 第23行： pEnd=pStr+len-1 pEnd++ 第26行： pStart = pEnd
    D、第16行： char pStr 第23行： pEnd=pStr+len+1 pEnd++ 第26行： *pStart = *pEnd

17、子函数Change的功能是将英文大写字母转换为小写字母，下面程序的输出结果是 abc_abc_def 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> void Change(__________) { for(;________;ch++) { if(____________) _________________; } } int main() { char s[]="ABC_abc_DEF"; Change(s); printf("%s\n",s); return 0; }
    A、第2行： char *ch 第5行： *ch!='\0' 第7行： *ch>='A'&& *ch<='Z' 第8行： *ch=*ch-'A'+'a'
    B、第2行： char ch 第5行： ch!='\0' 第7行： *ch>='A'&& *ch<='Z' 第8行： *ch=*ch-'A'+'a'
    C、第2行： char *ch 第5行： *ch!='\0' 第7行： ch>='A'&& ch<='Z' 第8行： ch=ch-'A'+'a'
    D、第2行： char ch[] 第5行： *ch=='\0' 第7行： *ch>='A'|| *ch<='Z' 第8行： *ch=*ch-'A'+'a'

18、下面程序的功能是比较用户键盘输入的口令userInput与内设的口令password是否相同。若相同，则输出"Correct password! Welcome to the system..."，若userInput<password，则输出"Invalid password!user input<password"，否则输出"Invalid password!user input>password"。 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> int main() { char password[7] = "secret"; char userInput[81] ; printf("Input Password:"); scanf(_____________); if ( ______________ ) printf("Correct password! Welcome to the system...\n"); else if ( ___________________) printf("Invalid password!user input<password\n"); else printf("Invalid password!user input>password\n"); return 0; }
    A、第8行： "%s", userInput 第9行： strcmp(userInput, password) == 0 第11行： strcmp(userInput, password) < 0
    B、第8行： "%c", userInput 第9行： strcmp(userInput, password) = 0 第11行： strcmp(userInput, password) < 0
    C、第8行： "%s", userInput 第9行： userInput==password 第11行： userInput<password
    D、第8行： "%c", userInput 第9行： strcpy(userInput, password) == 0 第11行： strcpy(userInput, password) < 0

19、下列说法正确的是
    A、指针变量指向的数据的类型，称为指针的基类型。指针变量只能指向同一基类型的变量。
    B、指针变量使用之前必须初始化，如果你不知道该用什么值对其进行初始化的话，那么就先用NULL对其进行初始化。使用未初始化的结果将是无法预知的。
    C、指针变量占用的内存单元字节数就是它所指向的变量所占用的内存单元字节数。
    D、strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符'\0'将被覆盖。
    E、字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
    F、strlen()计算的是包含'\0'在内的字符串的长度。

20、下列说法错误的是
    A、字符数组的最后一个元素必须是字符'0'才能表示一个字符串。
    B、char *pStr = "Hello China";表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
    C、char *pStr; scanf("%s", pStr); 这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。
    D、字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
    E、用双引号括起的一串字符是字符串常量，系统自动为其添加空字符'\0'作为字符串的结束标志。
    F、通过间接寻址运算符引用指针变量指向的变量的值，称为指针的解引用。

21、以下程序的功能是分别测量字符数组及数组中存放的字符串的长度，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> int main( ) { char a[]="abcdefg",b[10]="abcdefg"; _________________________; /*测量字符数组a,b的长度，并输出*/ _________________________; /*测量字符数组a,b中存放的字符串的长度，并输出*/ return 0; }
    A、第6行： printf("%d %d\n",sizeof(a) ,sizeof(b)) 第7行： printf("%d %d\n",strlen(a) ,strlen(b))
    B、第6行： printf("%d %d\n",strlen(a) ,strlen(b)) 第7行： printf("%d %d\n",sizeof(a) ,sizeof(b))
    C、第6行： printf("%d %d\n",sizeof(*a) ,sizeof(*b)) 第7行： printf("%d %d\n",strlen(*a) ,strlen(*b))
    D、第6行： printf("%d %d\n",sizeof(&a) ,sizeof(&b)) 第7行： printf("%d %d\n",strlen(&a) ,strlen(&b))

22、下面程序的功能是将一个字符串s2插入到字符串s1中，其起始插入位置为n。 程序运行示例如下： main string:hello,world! sub string:cc site of begining:(<=12)5 After instert:hellocc,world! 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #include <string.h> #define N 100 int main() { int n, i, j, k, len; char s1[N], s2[N], s3[2 * N]; printf("main string:"); gets(s1); printf("sub string:"); gets(s2); len = strlen(s1); do { printf("site of begining:(<=%d)", len); scanf("%d", &n); }while (__________); for (i = 0; i < n; i++) { s3[i] = s1[i]; } for (j = 0; s2[j] != '\0'; j++) { __________________; } for (________; s1[k] != '\0'; k++) { ________________; } s3[j + k] = '\0'; printf("After instert:%s\n", s3); return 0; }
    A、第17行： n > len 第25行： s3[i + j] = s2[j] 第27行： k = n 第29行： s3[j + k] = s1[k]
    B、第17行： n < len 第25行： s3[i] = s2[j] 第27行： k = n 第29行： s3[j] = s1[k]
    C、第17行： n <= len 第25行： s2[j]=s3[i + j] 第27行： k = 0 第29行： s3[j] = s1[k]
    D、第17行： n >= len 第25行： s3[j] = s2[j] 第27行： k = 0 第29行： s1[k] = s3[j + k]

23、下面程序的功能是从键盘输入一行字符（最长不超过80字符），用函数编程统计其中单词（以空格作为间隔符的字符串）的个数。 基本思路是：当前被检验字符不是空格，而前一被检验字符是空格，则表示有新单词出现。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。（下面答案中两个单引号''中间都有一个空格） 样例1： Input a string:How are you↙ Numbers of words = 3 样例2： Input a string: How are you↙ Numbers of words = 3 #include <stdio.h> int CountWords(char str[]); int main() { char str[81]; int num; printf("Input a string:\n"); gets(str); num=CountWords(str); printf("Number of words=%d\n", num); return 0; } int CountWords(char str[]) { int i, num; num = (__________) ? 1 : 0; i=1; while (str[i]!='\0') { if (_______________________) { num++; } __________; } return num; }
    A、第17行： str[0] != ' ' 第21行： str[i]!=' ' && str[i-1] == ' ' 第25行： i++
    B、第17行： str[0] == ' ' 第21行： str[i]!=' ' || str[i-1] == ' ' 第25行： i++
    C、第17行： str[0] != '\0 ' 第21行： str[i]==' ' && str[i-1] == ' ' 第25行： i++
    D、第17行： str[0] != ' ' 第21行： str[i]!=' ' && str[i-1] != ' ' 第25行： num++

第16周实验编程题（星期二）

1、数字字符串转换为整型数

2、查找子串

3、统计重复字符

4、凯撒密码

练兵区——编程题——不计入总分

1、有趣的“回文”检测

2、学生成绩管理系统V1.0

3、程序改错——1

4、程序改错——2

5、出售金鱼

6、找最值

7、杨辉三角形

8、颠倒句子中的单词顺序

第11周——指针的孪生兄弟

11.1 指针的运算（8分）随堂测验

1、下列说法错误的是（）。
    A、指针指向数组元素时，指针算术运算才有意义
    B、两个指针指向同一个数组时，指针相减才有意义
    C、指针的算术运算允许通过对指针变量重复自增来访问数组的元素
    D、p++就是将指针变量p加上一个字节

11.2 指针和一维数组间的关系（14分）随堂测验

1、当指针变量指向一维数组的时候，sizeof(数组名）和sizeof(指针变量名）的计算结果是相同的。

11.3 指针和二维数组间的关系（18分）随堂测验

1、二维数组a有m行n列，则在a[i][j]之前的元素个数为（）
    A、j*n+i
    B、i*n+j
    C、i*n+j-1
    D、i*n+j+1

11.4 进阶：指针数组及其应用（22分）随堂测验

1、char *country[] = {"America", "England", "Australia", "China", "Finland"}; 这条语句定义了一个字符指针数组country，并用初始化列表中的每个字符串的首地址为字符指针数组country的元素进行初始化，并不是将初始化列表中的字符串保存到字符指针数组中。

第11周测验

1、下面程序的功能是用指针变量作函数参数编程计算任意m×n阶矩阵的转置矩阵。要求用指向一维数组的指针变量即二维数组的行指针作函数参数。程序的运行结果如下： Please enter matrix: 1 2 3 4↙ 1 2 3 4↙ 1 2 3 4↙ The transposed matrix is: 1 1 1 2 2 2 3 3 3 4 4 4 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> #define ROW 3 #define COL 4 void Transpose(int (*a)[COL], int (*at)[ROW], int row, int col); void InputMatrix(int (*s)[COL], int row, int col); void PrintMatrix(int (*s)[ROW], int row, int col); int main(void) { int s[ROW][COL];//s代表原矩阵 int st[COL][ROW];//st代表转置后的矩阵 printf("Please enter matrix:\n"); InputMatrix(s, ROW, COL);//输入原矩阵,s指向矩阵s的第0行,是行指针 Transpose(s, st, ROW, COL);//对矩阵s进行转置,结果存放于st中 printf("The transposed matrix is:\n"); PrintMatrix(st, COL, ROW); //输出转置矩阵,*st指向st的第0行,是行指针 return 0; } //函数功能： 对任意row行col列的矩阵a转置，转置后的矩阵为at void Transpose(____________,int (*at)[ROW], int row, int col) { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { _____________________; } } } void InputMatrix(___________, int row, int col) //输入矩阵元素 { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { scanf("%d", ___________);// 元素s[i][j] } } } void PrintMatrix(int ___________, int row, int col) //输出矩阵元素 { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { printf("%d\t", *(*(s+i)+j)); // 元素s[i][j] } printf(" \n"); } }
    A、第20行： int (*a)[COL] 第27行： *(*(at+j)+i) = *(*(a+i)+j) 第32行： int(*s)[COL] 第39行： *(s+i)+j 第44行： (*s)[ROW]
    B、第20行： int *a[COL] 第27行： *(*(at+j)+i) = (*(a+i)+j) 第32行： int(*s)[ROW] 第39行： *(s+i)+j 第44行： *s[COL]
    C、第20行： int (*a)[ROW] 第27行： *(at+j+i) = *(*(a+i)+j) 第32行： int(*s)[COL] 第39行： *(s+i+j) 第44行： (*s)[ROW]
    D、第20行： int (*a)[COL] 第27行： *(*(at+j)+i) = *(*(a+i+j)) 第32行： int(*s)[ROW] 第39行： *(s)+i+j 第44行： (*s)[COL]

2、口袋中有若干红、黄、蓝、白、黑5种颜色的球，每次从口袋中取出3个球，编程输出得到3种不同颜色的球的所有可能取法。下面程序用三重循环模拟取球过程，但每次取出的球如果与前面的球颜色相同就抛弃。程序的运行结果如下： 1:RED,YELLOW,BLUE 2:RED,YELLOW,WHITE 3:RED,YELLOW,BLACK 4:RED,BLUE,WHITE 5:RED,BLUE,BLACK 6:RED,WHITE,BLACK 7:YELLOW,BLUE,WHITE 8:YELLOW,BLUE,BLACK 9:YELLOW,WHITE,BLACK 10:BLUE,WHITE,BLACK 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。 #include <stdio.h> int main() { char *bColor[] = {"RED","YELLOW","BLUE","WHITE","BLACK"}; int i, j, k, m = 0; for (i=0; i<5; i++) { for (________; j<5; j++) { for (________; k<5; k++) { m++; printf("%d:%s,%s,%s\n", ___________________); } } } return 0; }
    A、第8行： j=i+1 第10行： k=j+1 第13行： m, bColor[i], bColor[j], bColor[k]
    B、第8行： j=1 第10行： k=1 第13行： m, *bColor+i, *bColor+j, *bColor+k
    C、第8行： j=i 第10行： k=j 第13行： m,*(bColor+i), *(bColor+j), *(bColor+k)
    D、第8行： j=0 第10行： k=0 第13行： m, *bColor[i], *bColor[j], *bColor[k]

3、char (*p)[10];该语句定义了一个
    A、指向含有10个元素的一维字符型数组的指针变量p
    B、指向长度为10的字符串的指针变量p
    C、有10个元素的指针数组p，每个元素可以指向一个字符串
    D、有10个元素的指针数组p，每个元素存放一个字符串

4、设有以下定义： int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int (*ptr)[3] = a; int *p = a[0]; 则以下能够正确表示数组元素a[1][2]的表达式是
    A、*(*(ptr + 1) + 2)
    B、*((*ptr + 1) + 2)
    C、*(*(p + 5))
    D、(*ptr + 1) + 2

5、二维数组a有m行n列，则在a[i][j]之前的元素个数为
    A、i*n+j
    B、j*n+i
    C、i*n+j-1
    D、i*n+j+1

6、下面关于表达式(*p)++和*p++的含义分析说明中，错误的是
    A、(*p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，此时p不再指向原来的存储单元。
    B、(*p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，而p仍然指向原来的存储单元。
    C、*p++则指的是先取出p指向的存储单元中的内容，然后将p值加1，此时p不再指向原来的存储单元。
    D、表达式(*p)++和*p++具有不同的含义，(*p)++并没有修改指针p的指向，而*p++则修改了指针p的指向。

7、假设有下面定义语句： float a[10]; float *p=a; 则p++相当于是加上（）个字节
    A、sizeof(float)
    B、1个字节
    C、sizeof(p)
    D、sizeof(a)
    E、sizeof(float*)

8、下列说法中错误的是
    A、char *country[] = {"French", "England", "Japan", "China", "Finland"}; 这条语句定义了一个字符指针数组country，并将初始化列表中的字符串保存到字符指针数组中。
    B、当指针变量指向一维数组的时候，sizeof(数组名）和sizeof(指针变量名）的计算结果是不相同的。
    C、指针的算术运算允许通过对指针变量重复自增来访问数组的元素。
    D、指针指向数组元素时，指针算术运算才是有意义的。

9、下面程序希望得到的运行结果如下： Total string numbers = 3 How 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 = %d\n", 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、第12行应该是： void Print(char arr[], int len)
    C、第5行应该是： char pArray[] = {"How","are","you"};
    D、第6行应该是： int num = sizeof(pArray/char *);

10、以下程序运行后的输出结果是#include <stdio.h> int main() { int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b; b=p[5]; printf("%d",b); return 0; }
    A、9
    B、5
    C、6
    D、8

11、有以下程序段,则*(p[0]+1)所代表的数组元素是 #include <stdio.h> int main() { int a[3][2]={1,2,3,4,5,6,},*p[3]; p[0]=a[1]; ..... return 0; }
    A、a[1][1]
    B、a[0][1]
    C、a[1][0]
    D、a[1][2]

12、以下程序运行后的输出结果是 #include <stdio.h> int main() { int a[3][3],*p,i; p=&a[0][0]; for(i=0;i<9;i++) { p[i]=i+1; } printf("%d\n",a[1][2]); return 0; }
    A、6
    B、3
    C、9
    D、2

13、如下程序的执行结果是 #include<stdio.h> int main() { int a[ ][4]={1,3,5,7,9,11,13,15,17,19,21,23}; int (*p)[4],i=1,j=2; p=a; printf("%d\n",*(*(p+i)+j)); return 0; }
    A、13
    B、9
    C、11
    D、17

14、在以下程序段中的空白处填写适当的表达式或语句，使程序能正确引用c数组元素。 #include <stdio.h> int main() { int c[4][5],(*p)[5],i,j,d=0; for(i=0;i<4;i++) { for(j=0;j<5;j++) { c[i][j]=d; d++; printf("%4d",c[i][j]); } printf("\n"); } p=c; printf("%d,%d\n",____________); return 0; }
    A、*(p[0]+2),c[0][2]
    B、*(p+1)+3,c[1][3]
    C、*(p+3),c[0][3]
    D、p+1,c[0][1]

15、下面给出的选项中，能定义为一个指针数组的语句是
    A、int *ptr[5];
    B、int (*ptr)[5];
    C、int *(ptr[5]);
    D、int ptr[5];

16、若有定义“int *p[5];”，则以下叙述中正确的是
    A、定义了一个指针数组p，该数组含有5个元素，每个元素都是基类型为int的指针变量
    B、定义了一个基类型为int的指针变量p，该变量有5个指针
    C、定义了一个名为*p的整型数组，该数组含有5个int类型元素
    D、定义了一个可指向一维数组的指针变量p，所指一维数组应具有5个int类型元素

17、设有定义语句 int x[6]={2,4,6,8,5,7},*p=x,i; 要求依次输出x数组6个元素中的值，不能完成此操作的语句是
    A、for(i=0;i<6;i++) printf("%2d",(*p)++);
    B、for(i=0;i<6;i++) printf("%2d",*(p++));
    C、for(i=0;i<6;i++) printf("%2d",*(p+i));
    D、for(i=0;i<6;i++) printf("%2d",*p++);

18、若二维数组a有m行n列，则下面能够正确引用元素a[i][j]的为
    A、*(*(a+i)+j)
    B、*(a+j*n+i)
    C、*(a+i*n+j)
    D、*(*a+i)+j

19、设有语句“int array[3][4];”，则在下面几种引用下标为i和j的数组元素的方法中，不正确的引用方式是________。
    A、*(array + i*4 + j)
    B、array[i][j]
    C、*(*(array + i) + j)
    D、*(array[i] + j)

20、有int *p[10];以下说法错误的是________。
    A、p++操作是合法的
    B、p是数组名
    C、p是一个指针数组
    D、p中每个元素都是一个指针变量

练兵区——单选题——不计入总分

1、口袋中有若干红、黄、蓝、白、黑5种颜色的球，每次从口袋中取出3个球，编程输出得到3种不同颜色的球的所有可能取法。下面程序用三重循环模拟取球过程，但每次取出的球如果与前面的球颜色相同就抛弃。程序的运行结果如下： 1:RED,YELLOW,BLUE 2:RED,YELLOW,WHITE 3:RED,YELLOW,BLACK 4:RED,BLUE,WHITE 5:RED,BLUE,BLACK 6:RED,WHITE,BLACK 7:YELLOW,BLUE,WHITE 8:YELLOW,BLUE,BLACK 9:YELLOW,WHITE,BLACK 10:BLUE,WHITE,BLACK 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> int main() { char *bColor[] = {"RED","YELLOW","BLUE","WHITE","BLACK"}; int i, j, k, m = 0; for (i=0; i<5; i++) { for (________; j<5; j++) { for (________; k<5; k++) { m++; printf("%d:%s,%s,%s\n", ___________________); } } } return 0; }
    A、第8行： j=i+1 第10行： k=j+1 第13行： m, bColor[i], bColor[j], bColor[k]
    B、第8行： j=1 第10行： k=1 第13行： m, *bColor+i, *bColor+j, *bColor+k
    C、第8行： j=i 第10行： k=j 第13行： m,*(bColor+i), *(bColor+j), *(bColor+k)
    D、第8行： j=0 第10行： k=0 第13行： m, *bColor[i], *bColor[j], *bColor[k]

2、二维数组a有m行n列，则在a[i][j]之前的元素个数为
    A、i*n+j
    B、j*n+i
    C、i*n+j-1
    D、i*n+j+1

3、假设有下面定义语句： float a[10]; float *p=a; 则p++相当于是加上（）个字节
    A、sizeof(float)
    B、1个字节
    C、sizeof(p)
    D、sizeof(a)
    E、sizeof(float*)

4、若二维数组a有m行n列，则下面能够正确引用元素a[i][j]的为
    A、*(*(a+i)+j)
    B、*(a+j*n+i)
    C、*(a+i*n+j)
    D、*(*a+i)+j

5、char (*p)[10];该语句定义了一个
    A、指向含有10个元素的一维字符型数组的指针变量p
    B、指向长度为10的字符串的指针变量p
    C、有10个元素的指针数组p，每个元素可以指向一个字符串
    D、有10个元素的指针数组p，每个元素存放一个字符串

6、以下程序运行后的输出结果是#include <stdio.h> int main() { int a[3][3],*p,i; p=&a[0][0]; for(i=0;i<9;i++) { p[i]=i+1; } printf("%d\n",a[1][2]); return 0; }
    A、6
    B、3
    C、9
    D、2

7、如下程序的执行结果是#include<stdio.h> int main() { int a[ ][4]={1,3,5,7,9,11,13,15,17,19,21,23}; int (*p)[4],i=1,j=2; p=a; printf("%d\n",*(*(p+i)+j)); return 0; }
    A、13
    B、9
    C、11
    D、17

8、设有以下定义： int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int (*ptr)[3] = a; int *p = a[0]; 则以下能够正确表示数组元素a[1][2]的表达式是
    A、*(*(ptr + 1) + 2)
    B、*((*ptr + 1) + 2)
    C、*(*(p + 5))
    D、(*ptr + 1) + 2

9、下面关于表达式(*p)++和*p++的含义分析说明中，错误的是
    A、(*p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，此时p不再指向原来的存储单元。
    B、(*p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，而p仍然指向原来的存储单元。
    C、*p++则指的是先取出p指向的存储单元中的内容，然后将p值加1，此时p不再指向原来的存储单元。
    D、表达式(*p)++和*p++具有不同的含义，(*p)++并没有修改指针p的指向，而*p++则修改了指针p的指向。

10、以下程序运行后的输出结果是#include <stdio.h> int main() { int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b; b=p[5]; printf("%d",b); return 0; }
    A、9
    B、5
    C、6
    D、8

11、有以下程序段,则*(p[0]+1)所代表的数组元素是#include <stdio.h> int main() { int a[3][2]={1,2,3,4,5,6,},*p[3]; p[0]=a[1]; ..... return 0; }
    A、a[1][1]
    B、a[0][1]
    C、a[1][0]
    D、a[1][2]

12、在以下程序段中的空白处填写适当的表达式或语句，使程序能正确引用c数组元素。#include <stdio.h> int main() { int c[4][5],(*p)[5],i,j,d=0; for(i=0;i<4;i++) { for(j=0;j<5;j++) { c[i][j]=d; d++; printf("%4d",c[i][j]); } printf("\n"); } p=c; printf("%d,%d\n",____________); return 0; }
    A、*(p[0]+2),c[0][2]
    B、*(p+1)+3,c[1][3]
    C、*(p+3),c[0][3]
    D、p+1,c[0][1]

13、下面给出的选项中，能定义为一个指针数组的语句是
    A、int *ptr[5];
    B、int (*ptr)[5];
    C、int *(ptr[5]);
    D、int ptr[5];

14、下面程序的功能是用指针变量作函数参数编程计算任意m×n阶矩阵的转置矩阵。要求用指向一维数组的指针变量即二维数组的行指针作函数参数。程序的运行结果如下： Please enter matrix: 1 2 3 4↙ 1 2 3 4↙ 1 2 3 4↙ The transposed matrix is: 1 1 1 2 2 2 3 3 3 4 4 4 按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h> #define ROW 3 #define COL 4 void Transpose(int (*a)[COL], int (*at)[ROW], int row, int col); void InputMatrix(int (*s)[COL], int row, int col); void PrintMatrix(int (*s)[ROW], int row, int col); int main(void) { int s[ROW][COL];//s代表原矩阵 int st[COL][ROW];//st代表转置后的矩阵 printf("Please enter matrix:\n"); InputMatrix(s, ROW, COL);//输入原矩阵,s指向矩阵s的第0行,是行指针 Transpose(s, st, ROW, COL);//对矩阵s进行转置,结果存放于st中 printf("The transposed matrix is:\n"); PrintMatrix(st, COL, ROW); //输出转置矩阵,*st指向st的第0行,是行指针 return 0; } //函数功能： 对任意row行col列的矩阵a转置，转置后的矩阵为at void Transpose(____________,int (*at)[ROW], int row, int col) { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { _____________________; } } } void InputMatrix(___________, int row, int col) //输入矩阵元素 { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { scanf("%d", ___________);// 元素s[i][j] } } } void PrintMatrix(int ___________, int row, int col) //输出矩阵元素 { int i, j; for (i=0; i<row; i++) { for (j=0; j<col; j++) { printf("%d\t", *(*(s+i)+j)); // 元素s[i][j] } printf(" \n"); } }
    A、第20行： int (*a)[COL] 第27行： *(*(at+j)+i) = *(*(a+i)+j) 第32行： int(*s)[COL] 第39行： *(s+i)+j 第44行： (*s)[ROW]
    B、第20行： int *a[COL] 第27行： *(*(at+j)+i) = (*(a+i)+j) 第32行： int(*s)[ROW] 第39行： *(s+i)+j 第44行： *s[COL]
    C、第20行： int (*a)[ROW] 第27行： *(at+j+i) = *(*(a+i)+j) 第32行： int(*s)[COL] 第39行： *(s+i+j) 第44行： (*s)[ROW]
    D、第20行： int (*a)[COL] 第27行： *(*(at+j)+i) = *(*(a+i+j)) 第32行： int(*s)[ROW] 第39行： *(s)+i+j 第44行： (*s)[COL]

15、下列说法中错误的是
    A、char *country[] = {"French", "England", "Japan", "China", "Finland"}; 这条语句定义了一个字符指针数组country，并将初始化列表中的字符串保存到字符指针数组中。
    B、当指针变量指向一维数组的时候，sizeof(数组名）和sizeof(指针变量名）的计算结果是不相同的。
    C、指针的算术运算允许通过对指针变量重复自增来访问数组的元素。
    D、指针指向数组元素时，指针算术运算才是有意义的。

16、下面程序希望得到的运行结果如下： Total string numbers = 3 How 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 = %d\n", 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、第12行应该是： void Print(char arr[], int len)
    C、第5行应该是： char pArray[] = {"How","are","you"};
    D、第6行应该是： int num = sizeof(pArray/char *);

17、若有定义“int *p[5];”，则以下叙述中正确的是
    A、定义了一个指针数组p，该数组含有5个元素，每个元素都是基类型为int的指针变量
    B、定义了一个基类型为int的指针变量p，该变量有5个指针
    C、定义了一个名为*p的整型数组，该数组含有5个int类型元素
    D、定义了一个可指向一维数组的指针变量p，所指一维数组应具有5个int类型元素

18、设有定义语句 int x[6]={2,4,6,8,5,7},*p=x,i; 要求依次输出x数组6个元素中的值，不能完成此操作的语句是
    A、for(i=0;i<6;i++) printf("%2d",(*p)++);
    B、for(i=0;i<6;i++) printf("%2d",*(p++));
    C、for(i=0;i<6;i++) printf("%2d",*(p+i));
    D、for(i=0;i<6;i++) printf("%2d",*p++);

19、设有语句“int array[3][4];”，则在下面几种引用下标为i和j的数组元素的方法中，不正确的引用方式是________。
    A、*(array + i*4 + j)
    B、array[i][j]
    C、*(*(array + i) + j)
    D、*(array[i] + j)

20、有int *p[10];以下说法错误的是________。
    A、p++操作是合法的
    B、p是数组名
    C、p是一个指针数组
    D、p中每个元素都是一个指针变量

第16周实验编程题（星期四）

1、山地训练

2、奇偶数分离

3、子串判断

4、星期查找

练兵区——编程题——不计入总分

1、找出按字典顺序排在最前面的国名

2、学生成绩管理系统V2.0

3、月份表示

4、程序改错——1

5、程序改错——2

6、找数组最值

7、冒泡排序

8、删除字符串中与某字符相同的字符

9、求最大数和最小数的最大公约数

10、数列合并

第12周——海陆空齐上阵：又来了一堆数据

12.1 结构体类型（13分）随堂测验

1、关键字typedef主要用于定义一种新的数据类型。

12.1 结构体类型（13分）随堂测验

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}};

12.2 结构体与数组的嵌套（7分）随堂测验

1、在一个结构体内可以包含另一个不同类型的结构体作为其成员。

12.3 结构体的相关计算和操作（19分）随堂测验

1、下列说法错误的是（）。
    A、结构体类型所占内存的字节数就是结构体的每个成员类型所占内存字节数的总和。
    B、结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
    C、计算结构体所占内存的字节数时，一定要使用sizeof运算符。
    D、内存对齐的主要目的就是为了提高内存的寻址效率。不同的系统和编译器，内存对齐方式可能会不同，是机器相关的。

12.3 结构体的相关计算和操作（19分）随堂测验

1、下列说法错误的是（）。
    A、对结构体变量的成员的访问是通过名字并使用成员选择运算符来访问的。
    B、只能在相同类型的结构体变量之间进行赋值。
    C、可以使用==和!=来判定两个结构体相等或不等。
    D、对嵌套的结构体成员，必须以级联的方式来访问。

12.4 向函数传递一堆不同类型的数据（28分半）随堂测验

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;

12.4 向函数传递一堆不同类型的数据（28分半）随堂测验

1、下列说法错误的是（）。
    A、用结构体变量做函数参数，是将整个结构体的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
    B、用结构体数组/结构体指针作函数参数的参数传递效率比用结构体变量做函数参数的参数传递效率要高。
    C、用结构体数组/结构体指针作函数参数，是复制结构体的首地址给被调函数，因此在被调函数中可以修改结构体指针所指向的结构体的内容。
    D、数组和结构体变量都不可以用做函数返回值的类型。

12.5 枚举类型和共用体类型有什么用（25分）随堂测验

1、下列对枚举类型的使用的代码中错误的是（）。
    A、enum {no, yes, none}answer; if (answer == yes) { printf("Yes\n"); }
    B、enum response{no = -1, yes = 1, none = 0}; enum response answer;
    C、answer = yes; printf("%d", answer);
    D、answer = "yes"; printf("%s", answer);

2、和整型、实型、字符型一样，枚举类型也是一种基本数据类型。

12.5 枚举类型和共用体类型有什么用（25分）随堂测验

1、下列说法错误的是（）。
    A、编译器只为共用体中最大的成员分配足够的内存空间。共用体的成员在这个空间内是彼此覆盖的，都从同一起始地址开始存储。
    B、与结构体不同的是，共用体在内存中所占空间的字节数取决于占空间最多的那个成员变量。
    C、共用体变量在每一瞬时只能保存一个成员，起作用的成员是最后一次赋值的成员。
    D、共用体和结构体的成员访问方式以及成员的初始化方式都是一样的，都使用成员选择运算符访问成员变量，都可以在定义的时候对所有成员进行初始化。

第12周测验

1、设有以下说明语句,则下面的叙述中错误的是 struct ex { int x ; float y; char z ; } example;
    A、example是结构体类型名
    B、struct是结构体类型的关键字
    C、x,y,z都是结构体成员名
    D、ex为结构体标签。

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中的任何一个成员都可以进行初始化。

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;

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 %d\n",a.num,b.num); return 0; }
    A、2041 2044
    B、2041 2043
    C、2042 2044
    D、2042 2043

6、下面说法错误的是
    A、在一个结构体内不能包含另一个不同类型的结构体作为其成员。
    B、用结构体变量做函数参数，是将结构体变量的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
    C、结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
    D、和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
    E、用指向结构体变量的指针做函数参数，是将结构体变量的地址传给被调函数，因此在被调函数中对结构体内容的修改会影响原结构体变量。

7、若能使程序运行后的输出结果如下： 201501 201502 201503 则空白处填写的表达式或语句应该是 #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("%s\n",(*p).num); printf("%s\n",(++p)->num); printf("%s\n",stu[2].num);
    B、printf("%s\n",(p++).num); printf("%s\n",(p++).num); printf("%s\n",(p++).num);
    C、printf("%s\n",(++p)->num); printf("%s\n",(++p)->num); printf("%s\n",(*p).num);
    D、printf("%s\n",stu[0]->num); printf("%s\n",stu[1]->num); printf("%s\n",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:%2d\r", 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

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));

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.2f\n",sum); p++; }
    B、sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; } printf("%6.2f\n",sum);
    C、sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; p++; } printf("%6.2f\n",sum);
    D、for (j=0;j<3;j++) { sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; p++; } printf("%6.2f\n",sum); }

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;

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("%d\n", s->k); printf("%d\n", s->i[0]); printf("%d\n", s->c); return 0; }
    A、30 30 30
    B、10 20 30
    C、30 10 随机数
    D、30 10 20

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; }

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:%d\n", ____________________); } printf("Wrong election:%d\n", 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

练兵区——单选题——不计入总分

1、设有以下说明语句，则下面的叙述中错误的是struct ex { int x ; float y; char z ; } example;
    A、example是结构体类型名
    B、struct是结构体类型的关键字
    C、x,y,z都是结构体成员名
    D、ex为结构体标签。

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 %d\n",a.num,b.num); return 0; }
    A、2041 2044
    B、2041 2043
    C、2042 2044
    D、2042 2043

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.2f\n",sum); p++; }
    B、sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; } printf("%6.2f\n",sum);
    C、sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; p++; } printf("%6.2f\n",sum)
    D、for (j=0;j<3;j++) { sum=0; for(i=0;i<3;i++) { sum=sum+p->score[i]; p++; } printf("%6.2f\n",sum); }

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;

6、若能使程序运行后的输出结果如下： 201501 201502 201503 则空白处填写的表达式或语句应该是#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("%s\n",(*p).num); printf("%s\n",(++p)->num); printf("%s\n",stu[2].num);
    B、printf("%s\n",(p++).num); printf("%s\n",(p++).num); printf("%s\n",(p++).num);
    C、printf("%s\n",(++p)->num); printf("%s\n",(++p)->num); printf("%s\n",(*p).num);
    D、printf("%s\n",stu[0]->num); printf("%s\n",stu[1]->num); printf("%s\n",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:%2d\r", 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

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("%d\n", s->k); printf("%d\n", s->i[0]); printf("%d\n", s->c); return 0; }
    A、30 30 30
    B、10 20 30
    C、30 10 随机数
    D、30 10 20

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; }

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:%d\n", ____________________); } printf("Wrong election:%d\n", 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

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));

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中的任何一个成员都可以进行初始化。

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;

第13周——原来内存也可以这么玩，我是指针我怕谁

13.3 进阶：常见的内存错误及其解决对策（52分半）随堂测验

1、指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。

2、用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。

第13周课堂测验

1、下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下： Enter array size:8↙ array[0]=0 array[1]=10 array[2]=20 array[3]=30 array[4]=40 array[5]=50 array[6]=60 array[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]=%d\n",i,*(p+i))
    B、第8行： p=(int *)(n*malloc(sizeof(int*))) 第12行： *p+i=i*10 第16行： printf("array[%d]=%d\n",i,*(p+i))
    C、第8行： p=(int *)malloc(n*sizeof(int)); 第12行： *p+i=i*10 第16行： printf("array[i]=%d\n",i,*p+i)
    D、第8行： p=(int)malloc(n*sizeof(int *)); 第12行： *(p+i)=i*10 第16行： printf("array[i]=%d\n",i,*(p+i))

2、下列说法正确的是
    A、执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
    B、函数free()的参数是指向被释放的动态内存的指针变量。
    C、对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
    D、函数free的函数原型是 void* free(void* p); 表示函数没有返回值。
    E、程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
    F、执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
    G、用动态内存分配函数来申请的内存都是从栈上分配的。
    H、栈的特点是先进先出。
    I、用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));

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

5、下列说法错误的是
    A、无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
    B、用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
    C、在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
    D、对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
    E、对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
    F、用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
    G、计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
    H、为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。

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.

7、下面关于内存泄漏问题的描述错误的是（）
    A、只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
    B、内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
    C、指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
    D、出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
    E、内存泄漏问题通常需要运行相当一段时间后才能发现。
    F、C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
    G、需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。

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存放在静态存储区

9、对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
    A、void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
    B、void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
    C、void *的含义是指该函数没有返回值
    D、以上说法都不对

10、下面说法错误的是
    A、调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
    B、如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
    C、动态内存分配是指在程序运行时为变量分配内存的一种方法。
    D、栈和堆都属于动态存储区。

11、下面程序希望得到的运行结果如下： Total string numbers = 3 How 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 = %d\n", 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"}

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));

练兵区——单选题——不计入总分

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

2、下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下： Enter array size:8↙ array[0]=0 array[1]=10 array[2]=20 array[3]=30 array[4]=40 array[5]=50 array[6]=60 array[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]=%d\n",i,*(p+i))
    B、第8行： p=(int *)(n*malloc(sizeof(int*))) 第12行： *p+i=i*10 第16行： printf("array[%d]=%d\n",i,*(p+i))
    C、第8行： p=(int *)malloc(n*sizeof(int)); 第12行： *p+i=i*10 第16行： printf("array[i]=%d\n",i,*p+i)
    D、第8行： p=(int)malloc(n*sizeof(int *)); 第12行： *(p+i)=i*10 第16行： printf("array[i]=%d\n",i,*(p+i))

3、下列说法正确的是
    A、执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
    B、函数free()的参数是指向被释放的动态内存的指针变量。
    C、对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
    D、函数free的函数原型是 void* free(void* p); 表示函数没有返回值。
    E、程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
    F、执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
    G、用动态内存分配函数来申请的内存都是从栈上分配的。
    H、栈的特点是先进先出。
    I、用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。

4、对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
    A、void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
    B、void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
    C、void *的含义是指该函数没有返回值
    D、以上说法都不对

5、下列说法错误的是
    A、无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
    B、用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
    C、在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
    D、对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
    E、对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
    F、用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
    G、计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
    H、为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。

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.

7、下面关于内存泄漏问题的描述错误的是（）
    A、只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
    B、内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
    C、指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
    D、出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
    E、内存泄漏问题通常需要运行相当一段时间后才能发现。
    F、C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
    G、需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。

8、下面程序希望得到的运行结果如下： Total string numbers = 3 How 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 = %d\n", 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"}

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));

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存放在静态存储区

11、下面说法错误的是
    A、调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
    B、如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
    C、动态内存分配是指在程序运行时为变量分配内存的一种方法。
    D、栈和堆都属于动态存储区。

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));

第14周——结构设计的艺术

第14周测验

1、关于图的说法正确的是
    A、图由顶点和边构成
    B、图的邻接表属于顺序存储方式
    C、图的邻接表属于链式存储方式
    D、图的邻接矩阵中存储的是图的顶点

2、已知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; }

3、关于队列的说法正确的是
    A、队列和栈都属于线性结构
    B、队列存储在数组a中，队首为a[front],队尾为a[rear],则队列为空的条件是rear == front
    C、一个队列的入队顺序是a,b,c,d,则出队顺序应该是d,c,b,a
    D、队列具有先进后出的特点

4、若已建立下面的链表结构，指针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;

5、下列叙述中正确的是
    A、作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
    B、对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
    C、线性链表的长度是固定的，在访问之前就已经确定下来。
    D、构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
    E、线性链表的数据域一般只包含一个成员数据，如data。
    F、作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。

6、下面属于动态数据结构的是
    A、链表
    B、栈
    C、结构体数组
    D、指针数组
    E、字符数组

7、关于树的说法错误的是
    A、树至少有一个结点
    B、树必须有根结点
    C、树是一种非线性结构
    D、树的结点之间是一对多的关系
    E、二叉树的左右子树不能交换

8、以下程序执行后的输出结果是 #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("%d\n",sum); return 0; }
    A、4
    B、3
    C、5
    D、6

9、向建立好的单向链表中的结点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;

10、关于单向链表说法错误的是
    A、单向链表在内存中是连续存储的
    B、结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
    C、存储空间可以动态的获取和释放
    D、与数据相比，单向链表适合反复进行删除、插入操作

11、已知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的前驱结点

12、有以下结构体说明和变量定义，如图所示，指针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;

13、已知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);

练兵区——单选题——不计入总分

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);

3、关于图的说法正确的是
    A、图由顶点和边构成
    B、图的邻接表属于顺序存储方式
    C、图的邻接表属于链式存储方式
    D、图的邻接矩阵中存储的是图的顶点

4、若已建立下面的链表结构，指针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;

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("%d\n",sum); return 0; }
    A、4
    B、3
    C、5
    D、6

6、有以下结构体说明和变量定义，如图所示，指针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;

7、下面属于动态数据结构的是
    A、链表
    B、栈
    C、结构体数组
    D、指针数组
    E、字符数组

8、向建立好的单向链表中的结点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;

9、已知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; }

10、下列叙述中正确的是
    A、作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
    B、对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
    C、线性链表的长度是固定的，在访问之前就已经确定下来。
    D、构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
    E、线性链表的数据域一般只包含一个成员数据，如data。
    F、作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。

11、关于队列的说法正确的是
    A、队列和栈都属于线性结构
    B、队列存储在数组a中，队首为a[front],队尾为a[rear],则队列为空的条件是rear == front
    C、一个队列的入队顺序是a,b,c,d,则出队顺序应该是d,c,b,a
    D、队列具有先进后出的特点

12、关于树的说法错误的是
    A、树至少有一个结点
    B、树必须有根结点
    C、树是一种非线性结构
    D、树的结点之间是一对多的关系
    E、二叉树的左右子树不能交换

13、关于单向链表说法错误的是
    A、单向链表在内存中是连续存储的
    B、结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
    C、存储空间可以动态的获取和释放
    D、与数据相比，单向链表适合反复进行删除、插入操作

第15周——学会保存你的数据

15.4 字符和字符串的文件读写（39分）随堂测验

1、函数fgetc()的功能是从fp所指的文件中读取一个字符，并将位置指针指向下一个字符。若读取成功，则返回该字符，若读到文件末尾或者读取出错，则返回EOF。EOF是一个符号常量，通常在stdio.h中定义为-1。

2、函数feof()的功能是检查是否到达文件尾，只要读完最后一个字符、文件位置指针指向文件尾时（EOF）时，就会返回非0值，否则返回0值。

15.4 字符和字符串的文件读写（39分）随堂测验

1、fgets()与gets()的不同点是，gets()从指定的流读字符串，读到换行符时将换行符替换为'\0'，读入的字符串中不会保留'\n'，而fgets()从指定的流读字符串，读到换行符时不替换为'\0'，读入的字符串中会保留'\n'，在'\n'的后面会再添加一个'\0'。

2、fputs()是向任意流写数据，puts()是向标准输出流写数据，二者在写数据时的不同之处是，puts()会在写入的字符串末尾自动添加换行符，而fputs()不会在写入的字符串末尾自动添加换行符，除非字符串本身含有换行符。

第15周测验

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

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);

7、若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
    A、“wb+”
    B、“ab+”
    C、“rb+”
    D、“ab”

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

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 %d\n",k,n); fclose(fp); return 0; }
    A、123 0
    B、1 2
    C、1 23
    D、0 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+都是可读可写方式，二者是完全一样的。

12、以下叙述中错误的是
    A、不可以用FILE定义指向二进制文件的文件指针。
    B、二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
    C、在程序结束时，应当用fclose()函数关闭已打开的文件。
    D、在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。

13、下列关于C语言数据文件的叙述中正确的是
    A、文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
    B、文件由ASCII码字符序列组成，C语言只能读写文本文件
    C、文件由二进制数据序列组成，C语言只能读写二进制文件
    D、文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件

14、若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
    A、0
    B、1
    C、-1
    D、一个非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没有定义

练兵区——单选题——不计入总分

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

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

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没有定义

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);

7、C语言中标准输入文件stdin是指
    A、键盘
    B、显示器
    C、鼠标
    D、硬盘
    E、U盘

8、若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是
    A、“wb+”
    B、“ab+”
    C、“rb+”
    D、“ab”

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+都是可读可写方式，二者是完全一样的。

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 %d\n",k,n); fclose(fp); return 0; }
    A、123 0
    B、1 2
    C、1 23
    D、0 0

15、以下叙述中错误的是
    A、不可以用FILE定义指向二进制文件的文件指针。
    B、二进制文件打开后可以先读文件的末尾，而顺序文件不可以。
    C、在程序结束时，应当用fclose()函数关闭已打开的文件。
    D、在利用fread()函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据。

16、若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为
    A、0
    B、1
    C、-1
    D、一个非0值