程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版

警察公共关系(江苏警官学院)1467091451答案点击这里查看

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

codeblocks介绍——从HelloWorld开始

1、单选题：
‎#include <stdio.h>是

A: 编译预处理指令
B: 语句
C: 函数
D: 程序入口
答案: 编译预处理指令

debug

1、单选题：
‌codeblocks中运行到下一步(next line)的快捷键是‍

A: F7
B: F5
C: F8
D: F11
答案: F7

变量在内存中所占的字节数

1、单选题：
‍Ｃ语言用sizeof计算变量在内存中的字节数，其中sizeof是（）

A: 函数
B: 运算符
C: 标识符
D: 语句
答案: 运算符

宏常量与const常量

1、单选题：
‌宏定义是（）‍

A: 一条语句
B: 一种编译预处理指令
C: 一个标识符
D: 一个变量
答案: 一种编译预处理指令

2、判断题：
‌const常量有数据类型。‎

A: 正确
B: 错误
答案: 正确

第1周测验

1、单选题：
下列选项中，合法的C语言标识符是‌

A: _a1
B: width.x
C: #abc123
D: 123abc
E: o*k
F: a?
G: a+b
H: %a
I: b!
答案: _a1

2、单选题：
‎以下不适合定义为用户标识符的是

A: int
B: a2
C: def2
D: _3com_
E: PI
F: Source
G: abc
答案: int

3、单选题：
‎#include <stdio.h>是‏

A: 编译预处理指令
B: 语句
C: 函数
D: 什么都不是
E: 有语法错误
答案: 编译预处理指令

4、单选题：
‍在windows下,程序编译链接后形成的可执行文件是‍

A: .obj文件
B: .exe文件
C: .o文件
D: .c文件
E: .h文件
答案: .exe文件

5、单选题：
‏程序编译链接后显示” 0 error,0 warning” 代表‏

A: 程序中没有语法错误
B: 程序是正确的
C: 程序是不正确的
D: 程序中可能存在语法错误
E: 程序中有语义错误
答案: 程序中没有语法错误

6、单选题：
‏用8位无符号二进制数能表示的最大十进制数为

A: 255
B: 127
C: 128
D: 256
答案: 255

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: 不允许字符型和浮点型相加
答案: ‘A’+1.6的结果是浮点型;
a的值还是整型

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
答案: run;
build

11、单选题：
‏程序的开发步骤中不包括‏

A: 撰写文档
B: 运行程序
C: 编译链接
D: 程序测试
E: 编辑（编写代码）
答案: 撰写文档

12、单选题：
下列说法中错误的是（）‍

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

13、单选题：
‎若有定义：int a=8，b=5，c; ，执行语句c=a/b+0.4;后，c的值为‎

A: 1
B: 1.4
C: 2.0
D: 2
答案: 1

14、单选题：
‌在C语言中，字符型数据在内存中以字符的（）形式存放‎

A: ASCII码
B: 国标码
C: BCD码
D: 反码
答案: ASCII码

15、单选题：
‎以下符合C语言语法的实型常量是‏

A: 5e-3
B: 3.14.159e
C: 1.2e0.5
D: e15
答案: 5e-3

16、单选题：
以下选项中可作为C语言合法整数的是‍

A: 0xffa
B: 10110B
C: 038x
D: x2a2
答案: 0xffa

17、单选题：
‏下列说法正确的是‎

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

18、单选题：
‍下列变量定义中合法的是‎

A: long ao=0xfdaL；
B: short _a=1-.1e-1；
C: double b=1+5e2.5；
D: float 2_and=1-e-3；
答案: long ao=0xfdaL；

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

1、单选题：
‍下列选项中，合法的C语言标识符是

A: _a1
B: width
C: #abc123
D: 123abc
E: o*k
F: a?
G: a+b
H: %a
I: b!
答案: _a1;
width

2、单选题：
‎以下不适合定义为用户标识符的是‍

A: float
B: main
C: define
D: _3com_
E: PI
F: Source
G: abc
答案: float ;
main;
define

3、单选题：
‎#include <stdio.h>是‏

A: 编译预处理指令
B: 语句
C: 函数
D: 什么都不是
E: 有语法错误
答案: 编译预处理指令

4、单选题：
在windows下,程序编译链接后形成的可执行文件是

A: .obj文件
B: .exe文件
C: .o文件
D: .c文件
E: .h文件
答案: .exe文件

5、单选题：
‌程序编译链接后显示” 0 error,0 warning” 代表‎

A: 程序中没有语法错误
B: 程序是正确的
C: 程序是不正确的
D: 程序中可能存在语法错误
E: 程序中有语义错误
答案: 程序中没有语法错误

6、单选题：
‏用8位无符号二进制数能表示的最大十进制数为‎

A: 255
B: 127
C: 128
D: 256
答案: 255

7、单选题：
‌关于可执行文件说法正确的是

8、单选题：
若变量a是int类型，并执行了语句：a=’A’+1.6；，则正确的叙述是

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
答案: run;
build

11、单选题：
‌程序的开发步骤中不包括‏

A: 撰写文档
B: 运行程序
C: 编译链接
D: 程序测试
E: 编辑（编写代码）
答案: 撰写文档

12、单选题：
‌下列说法中错误的是（）‎

13、单选题：
‏若有定义：int a=8，b=5，c; ，执行语句c=a/b+0.4;后，c的值为‏

A: 1
B: 1.4
C: 2.0
D: 2
答案: 1

14、单选题：
在C语言中，字符型数据在内存中以字符的（）形式存放‌

A: ASCII码
B: 国标码
C: BCD码
D: 反码
答案: ASCII码

15、单选题：
以下符合C语言语法的实型常量是‏

A: 5e-3
B: 3.14.159e
C: 1.2e0.5
D: e15
答案: 5e-3

16、单选题：
‎以下选项中可作为C语言合法整数的是‏

A: 0xffa
B: 10110B
C: 038x
D: x2a2
答案: 0xffa

17、单选题：
‌下列说法正确的是‍

18、单选题：
‏下列变量定义中合法的是‍

A: long ao=0xfdaL；
B: short _a=1-.1e-1；
C: double b=1+5e2.5；
D: float 2_and=1-e-3；
答案: long ao=0xfdaL；

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

不同类型数据的运算

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

A: 正确
B: 错误
答案: 正确

在定义变量的时候对变量进行初始化

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;
答案: int a=b=c=0;

强制类型转换

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

A: 正确
B: 错误
答案: 错误

第2周测验

1、单选题：
‌下列程序的输出结果是‎‌#include <stdio.h>
int main()
{
   int a=7,b=5;
   printf(“%dn”,b/a);
   return 0;
}‎

A: 0
B: 5
C: 1
D: 0.7
答案: 0

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;)，两种情况下表达式的最终运算结果一定是相同的。
答案: a++的运算过程是：先使用变量a的值，然后再执行a=a+1。

3、单选题：
‏以下程序的输出结果是：‏#include <stdio.h>
int main()
{
    int a=1, b=2;
    a=a+b;
    b=a-b;
    a=a-b;
    printf(“%d,%dn”, a, b );
    return 0;
}‏

A: 2,1
B: 3,1
C: 3,2
D: 1,2
答案: 2,1

4、单选题：
‌程序运行后的输出结果是#include <stdio.h>
int main()
{
    int m=3,n=4,x;
    x=m++;
    ++n;
    x=x+8/n;
    printf(“%d,%dn”,x,m);
    return 0;
}‎

A: 4,4
B: 4,3
C: 5,4
D: 5,3
答案: 4,4

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
答案: 3.500000

6、单选题：
‌以下非法的赋值语句是‎

A: ++(i+1);
B: x=(j–);
C: n=++i;
D: j++;
答案: ++(i+1);

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
答案: 6.000000

8、单选题：
以下程序的运行结果是‎#include <stdio.h>
int main()
{
    int  a = 12, b = 3;
    float  x = 18.5, y = 4.5;
    printf(“%fn”, (float)(a * b) / 2);
    printf(“%dn”, (int)x %(int)y);
    return 0;
}‎

A: 18.0000002
B: 182
C: 182.000000
D: 18.0000002.000000
答案: 18.0000002

9、单选题：
‌设有语句“int a = 3;”，执行语句“a += a -= a * a;”后，变量a的值是‏

A: -12
B: 3
C: 0
D: 9
答案: -12

10、单选题：
‏在C语言中，要求操作数必须是整型的运算符是

A: %
B: /
C: *
D: +
E: –
答案: %

11、单选题：
‍程序运行后的输出结果是#include <stdio.h>
int main()
{
    char a=’a’;
    printf(“%c,”,++a);
    printf(“%cn”,a++);
    return 0;
}‏

A: b,b
B: b,c
C: a,b
D: a,c
答案: b,b

12、单选题：
‌下面哪条语句可以生成0-9之间的随机数‍

A: magic=rand()%10;
B: magic=rand()%10+1;
C: magic=rand()/10;
D: magic=rand()/10+1;
答案: magic=rand()%10;

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;
答案: int a=b=10;

14、单选题：
‍若以下选项中的变量已正确定义，则正确的赋值语句是‏

A: x3=x2=x1=0；
B: x1=26.8%3；
C: 1+2=x2；
D: x4=1+2=3；
答案: x3=x2=x1=0；

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
答案: double

16、单选题：
‍在C程序中如果要使用数学函数，如sin(x),log(x)等，需要在程序中加入的语句是‍

A: #include <math.h>
B: #include <stdio.h>
C: #define <math.h>
D: #define <stdio.h>
答案: #include <math.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;
答案: d=(x-(x/100)*100)/10;;
d=(x%100)/10;;
d=(x/10)%10;

18、单选题：
‌在C语言中对下面的语句而言，哪个说法是错误的？‌int a, b;

A: 变量a和b中的值都是0
B: 变量a和b中都没有数值
C: 变量a和b中的值都是未知的随机数
D: a和b都是整型变量
E: 变量a和b占用的内存空间的大小是相同的
答案: 变量a和b中的值都是0;
变量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
答案: 2和1

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++;
答案: d++;;
(a+b)++;;
(-a)++;;
(a+1)++;

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

1、单选题：
‏设有语句“int a = 3;”，执行语句“a += a -= a * a;”后，变量a的值是

A: -12
B: 3
C: 0
D: 9
答案: -12

2、单选题：
在C程序中如果要使用数学函数，如sin(x),log(x)等，需要在程序中加入的语句是‎

A: #include <math.h>
B: #include <stdio.h>
C: #define <math.h>
D: #define <stdio.h>
答案: #include <math.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++;
答案: d++;;
(a+b)++;;
(-a)++;;
(a+1)++;

4、单选题：
‎下列关于单目运算符++、–的叙述中正确的是‎

5、单选题：
‍以下程序的输出结果是：#include <stdio.h>
int main()
{
    int a=1, b=2;
    a=a+b;
    b=a-b;
    a=a-b;
    printf(“%d,%dn”, a, b );
    return 0;
}

A: 2,1
B: 3,1
C: 3,2
D: 1,2
答案: 2,1

6、单选题：
‌下面哪条语句可以生成0-9之间的随机数‍

A: magic=rand()%10;
B: magic=rand()%10+1;
C: magic=rand()/10;
D: magic=rand()/10+1;
答案: magic=rand()%10;

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;
答案: int a=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
答案: double

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;
答案: d=(x-(x/100)*100)/10;;
d=(x%100)/10;;
d=(x/10)%10;

10、单选题：
在C语言中对下面的语句而言，哪个说法是错误的？‌int a, b;‌

11、单选题：
‍下列程序的输出结果是‏#include <stdio.h>
int main()
{
   int a=7,b=5;
   printf(“%dn”,b/a);
   return 0;
}

A: 0
B: 5
C: 1
D: 0.7
答案: 0

12、单选题：
‏程序运行后的输出结果是‍#include <stdio.h>
int main()
{
    int m=3,n=4,x;
    x=m++;
    ++n;
    x=x+8/n;
    printf(“%d,%dn”,x,m);
    return 0;
}

A: 4,4
B: 4,3
C: 5,4
D: 5,3
答案: 4,4

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
答案: 3.500000

14、单选题：
以下非法的赋值语句是‌

A: ++(i+1);
B: x=(j–);
C: n=++i;
D: j++;
答案: ++(i+1);

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
答案: 2和1

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
答案: 6.000000

17、单选题：
‌以下程序的运行结果是‌#include <stdio.h>
int main()
{
    int  a = 12, b = 3;
    float  x = 18.5, y = 4.5;
    printf(“%fn”, (float)(a * b) / 2);
    printf(“%dn”, (int)x %(int)y);
    return 0;
}

A: 18.0000002
B: 182
C: 182.000000
D: 18.0000002.000000
答案: 18.0000002

18、单选题：
‏在C语言中，要求操作数必须是整型的运算符是‍

A: %
B: /
C: *
D: +
E: –
答案: %

19、单选题：
‏程序运行后的输出结果是‏#include <stdio.h>
int main()
{
    char a=’a’;
    printf(“%c,”,++a);
    printf(“%cn”,a++);
    return 0;
}

A: b,b
B: b,c
C: a,b
D: a,c
答案: b,b

20、单选题：
‏若以下选项中的变量已正确定义，则正确的赋值语句是‎

A: x3=x2=x1=0；
B: x1=26.8%3；
C: 1+2=x2；
D: x4=1+2=3；
答案: x3=x2=x1=0；

运算符的优先级和结合性

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

A: 正确
B: 错误
答案: 正确

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

%c格式转换说明

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

A: 正确
B: 错误
答案: 正确

单个字符的输入输出

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

A: 正确
B: 错误
答案: 正确

格式字符

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

A: 正确
B: 错误
答案: 正确

第3周测验

1、单选题：
‌分析下列程序，写出程序运行结果‌‌#include <stdio.h>
int main()
{
    char c1 = ‘a’, c2 = ‘b’, c3 = ‘c’;
    printf(“a%cb%cc%cabcn”, c1, c2, c3);
    return 0;
}‌

A: aabbccabc
B: acbcabc
C: aabcabc
D: acbbcabc
答案: aabbccabc

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
答案: 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,%cn”,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,5,A,B

4、单选题：
‌给出程序的运行结果,程序运行时从键盘输入：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
答案: 1

5、单选题：
‌以下程序的输出结果为‍‌‍#include <stdio.h>
int main()
{
   float a = 1234.567,b = 55.32;
   printf(“a = %4.2f, b = %5.1fn”, 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
答案: a = 1234.57, b = 55.3

6、单选题：
以下程序的输出结果为‍#include <stdio.h>
int main()
{
      int a=2, c=5;
      printf(“a = %%d, b = %%dn”, a, c);
      return 0;
}‍

A: a = %d, b = %d
B: a = %2, b = %5
C: a = 2, b = 5
D: a = %%d, b = %%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
答案: b

8、单选题：
在调用printf函数输出数据时，当数据的实际位宽小于printf函数中的指定位宽时，下面叙述正确的是

A: 如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。
B: 如果格式字符前面没有负号，那么输出的数据将会左对齐、右补空格；如果格式字符前面有负号，那么输出的数据将会右对齐、左补空格。
C: 如果格式字符前面没有负号，那么输出的数据将会右对齐、左补0；如果格式字符前面有负号，那么输出的数据将会左对齐、右补0。
D: 如果格式字符前面没有负号，那么输出的数据将会左对齐、右补0；如果格式字符前面有负号，那么输出的数据将会右对齐、左补0。
答案: 如果格式字符前面没有负号，那么输出的数据将会右对齐、左补空格；如果格式字符前面有负号，那么输出的数据将会左对齐、右补空格。

9、单选题：
设有语句“char c=’72’;”，则变量c‍

A: 包含1个字符
B: 包含2个字符
C: 包含3个字符
D: 不合法
答案: 包含1个字符

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%dn”,&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);
答案: int a,b;scanf(“%d %f”,&a,&b);;
int a,b;scanf(“%d %d”,a,b);;
int a,b;scanf(“%d%dn”,&a,&b);printf(“%d %d”,a,b);;
float a,b;scanf(“%3.2f %4.2f”,&a,&b);printf(“%f %f”,a,b);

11、单选题：
程序运行后的输出结果是#include <stdio.h>
int main()
{
    int a=666,b=888;
    printf(“%dn”,a,b);
    return 0;
}‏

A: 666
B: 错误信息
C: 888
D: 666,888
答案: 666

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

A: n1=%dnn2=%d
B: n1=%dn2=%dn
C: n1=%d,n2=%d
D: n1=%d n2=%dn
答案: n1=%dnn2=%d

13、单选题：
‎以下选项中合法的字符常量是‌

A: ’10’
B: “B”
C: 68
D: D
答案: ’10’

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
答案: 114,124

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: 输出一个随机数
答案: 57

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
答案: 0

17、单选题：
‎给出程序的运行结果‎#include <stdio.h>
int main()
{
  int a,b,c,d;
  char op1,op2,op3;
  int sum;
  printf(“please input:a+b+c+dn”);
  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
答案: 7

18、单选题：
‏在C语言中，字符型数据在内存中以（）形式存放‍

A: ASCII码
B: 国标码
C: BCD码
D: 反码
答案: ASCII码

19、单选题：
‌‌以下程序的执行结果是‏‏#include  <stdio.h>
int main()
{
   int  a = 5, b = 4, x, y;
   x = 2 * a++;
   y = –b * 2;
   printf(“a=%d, x=%dn”, a, x);
   printf(“b=%d, y=%dn”, b, y);
   return 0;
}

A: a=6, x=10b=3, y=6
B: a=6, x=10b=3, y=8
C: a=6, x=12b=3, y=6
D: 以上均不对
答案: a=6, x=10b=3, y=6

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.1fn”,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
答案: 1,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: 输出乱码
答案: a=1,b=

22、单选题：
‍以下程序的输出结果是‌‍#include <stdio.h>
int main()
{
    int a=1234;
    printf(“%2dn”,a);
    return 0;
}‌

A: 1234
B: 12
C: 34
D: 提示出错、无结果
答案: 1234

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

1、单选题：
‌以下程序的输出结果为‍‌‍#include <stdio.h>
int main()
{
   float a = 1234.567,b = 55.32;
   printf(“a = %4.2f, b = %5.1fn”, 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
答案: a = 1234.57, b = 55.3

2、单选题：
‏以下选项中合法的字符常量是‎

A: ’10’
B: “B”
C: 68
D: D
答案: ’10’

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: 输出乱码
答案: a=1,b=

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
答案: 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,%cn”,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,5,A,B

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
答案: 1

7、单选题：
‌在调用printf函数输出数据时，当数据的实际位宽小于printf函数中的指定位宽时，下面叙述正确的是

8、单选题：
‏程序运行后的输出结果是#include <stdio.h>
int main()
{
    int a=666,b=888;
    printf(“%dn”,a,b);
    return 0;
}

A: 666
B: 错误信息
C: 888
D: 666,888
答案: 666

9、单选题：
‏在C语言中，字符型数据在内存中以（）形式存放

A: ASCII码
B: 国标码
C: BCD码
D: 反码
答案: ASCII码

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.1fn”,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
答案: 1,65,1.5,6.5

11、单选题：
‍以下程序的输出结果是‌‍#include <stdio.h>
int main()
{
    int a=1234;
    printf(“%2dn”,a);
    return 0;
}‌

A: 1234
B: 12
C: 34
D: 提示出错、无结果
答案: 1234

12、单选题：
设有语句“char c=’72’;”，则变量c‏

A: 包含1个字符
B: 包含2个字符
C: 包含3个字符
D: 不合法
答案: 包含1个字符

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

A: n1=%dnn2=%d
B: n1=%dn2=%dn
C: n1=%d,n2=%d
D: n1=%d n2=%dn
答案: n1=%dnn2=%d

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: 输出一个随机数
答案: 57

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
答案: 0

16、单选题：
‌分析下列程序，写出程序运行结果#include <stdio.h>
int main()
{
    char c1 = ‘a’, c2 = ‘b’, c3 = ‘c’;
    printf(“a%cb%cc%cabcn”, c1, c2, c3);
    return 0;
}

A: aabbccabc
B: acbcabc
C: aabcabc
D: acbbcabc
答案: aabbccabc

17、单选题：
‍以下程序的输出结果为‍#include <stdio.h>
int main()
{
      int a=2, c=5;
      printf(“a = %%d, b = %%dn”, a, c);
      return 0;
}

A: a = %d, b = %d
B: a = %2, b = %5
C: a = 2, b = 5
D: a = %%d, b = %%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
答案: b

19、单选题：
‍在下列语句中存在错误的是

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
答案: 114,124

21、单选题：
给出程序的运行结果‎#include <stdio.h>
int main()
{
  int a,b,c,d;
  char op1,op2,op3;
  int sum;
  printf(“please input:a+b+c+dn”);
  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
答案: 7

22、单选题：
以下程序的执行结果是‌#include  <stdio.h>
int main()
{
   int  a = 5, b = 4, x, y;
   x = 2 * a++;
   y = –b * 2;
   printf(“a=%d, x=%dn”, a, x);
   printf(“b=%d, y=%dn”, b, y);
   return 0;
}

A: a=6, x=10b=3, y=6
B: a=6, x=10b=3, y=8
C: a=6, x=12b=3, y=6
D: 以上均不对
答案: a=6, x=10b=3, y=6

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

判断ch是英文字母大写或者小写

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

A: 正确
B: 错误
答案: 正确

条件运算符

1、单选题：
‎下列关于if-else语句的说法中哪个是正确的。‍

A: else总是和离它最近的if配对
B: else总是和前面离它最近的且还未和其他else匹配的在同一语句块内同一层次的if配对
C: else总是和前面离它最近的且位于花括号内的if配对
D: else可以和它前面的尚未与其他else匹配的任何一个if配对
答案: else总是和前面离它最近的且还未和其他else匹配的在同一语句块内同一层次的if配对

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

A: 正确
B: 错误
答案: 正确

浮点数的表数精度

1、单选题：
‍下列说法错误的是（）。‎

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

程序测试

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 %dn”,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
答案: the output data is 7

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
答案: 10,0,0

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=%.2fn", area); } else { printf("It is not a trianglen"); } 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);
答案: 第11行：   s = 1/2 * (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 = %fn”, data1, data2, data1 + data2);
                            break;
                   case ‘-‘:
                            printf(“%f – %f = %fn”, data1, data2, data1 – data2);
                            break;
                   case ‘*’:
                            printf(“%f * %f = %fn”, data1, data2, data1 * data2);
                            break;
                   case ‘/’:
                            printf(“%f/%f = %fn”, 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 = %fn”, 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 = %fn”, data1, data2, data1/data2);
答案: 第20行语句有错误，改成：if (fabs(data2)<=EPS) printf(“Division by zero!n”);else printf(“%f/%f = %fn”, data1, data2, data1/data2);同时，第1行语句下方应加入#include <math.h>#define EPS 1e-6

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
答案: (x-y)<-10||!(y-x)>10

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;
}
答案: {
  a=b;
  b=a;
}

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=%dn”, a, b) ;
   return 0;
}‎

A: a=2, b=2
B: a=2, b=1
C: a=1, b=1
D: a=1, b=0
答案: a=2, b=2

8、单选题：
以下程序运行后的输出结果是#include <stdio.h>
int main()
{
   int a=5,b=4,c=3,d;
   d=(a>b>c);
   printf(“%dn”,d);
   return 0;
}

A: 0
B: 1
C: 5
D: 4
E: 3
答案: 0

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: 有语法错误
答案: **0****2**

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(“%dn”,d);
   return 0;
}‎

A: 2
B: 3
C: 43
D: 44
答案: 2

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 evenn”, m);
        }
        else                    //不能被2整除，则是正奇数
        {
            printf(“%d is a positive oddn”, m);
        }
    }

   _______________          //判断是否为负数

    {
        _______________

        {
             printf(“%d is a negative evenn”, m);   //是负偶数
        }
        else
        {
             printf(“%d is a negative oddn”, m);    //是负奇数
        }
    }
    else
    {
        printf(“%d is zero.It is an evenn”, 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)
答案: 第19行代码： else 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(“%cn”,c);
  return 0;
}‌

A: c+32
B: c+48
C: C+65
D: C+97
答案: c+32

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
答案: 123

14、单选题：

‌编程计算下面的分段函数，根据从键盘输入的x值，在屏幕上输出y值。

‌

‌ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第2张

‌

‌程序代码如下，为完成以上功能，请将第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=%fn", y); return 0; }

‌

‌
A: else if (x == 0)
B: else if (x = 0)
C: if (x == 0)
D: if (x = 0)
答案: else 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,%dn”,k,m);
   return 0;
}‎

A: 1,0
B: 0,0
C: 0,1
D: 1,1
答案: 1,0

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 = %.2fn", p); } else { if (disc > EPS) /* 判别式大于0时，输出两不等实根 */ { printf("x1 = %.2f, x2 = %.2fn", p+q, p-q); } else /* 判别式小于0时，输出两共轭复根 */ { printf("x1 = %.2f+%.2fi, ", p, q); printf("x2 = %.2f-%.2fin", p, q); } } return 0; }

‍
A: if (fabs(a) <= EPS)
B: if (a <= EPS)
C: if (a=0)
D: if (a<= EPS || a>=-EPS)
答案: if (fabs(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语句那样起到判断表达式真假的作用。
答案: case后的“常量表达式”的类型只能是整型。;
若case后面的语句省略不写，则表示它什么也不做。;
switch语句中的break和default可有可无。

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

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 evenn”, m);
        }
        else                    //不能被2整除，则是正奇数
        {
            printf(“%d is a positive oddn”, m);
        }
    }

    _______________          //判断是否为负数

    {
        _______________

        {
             printf(“%d is a negative evenn”, m);   //是负偶数
        }
        else
        {
             printf(“%d is a negative oddn”, m);    //是负奇数
        }
    }
    else
    {
        printf(“%d is zero.It is an evenn”, m);
    }
   return 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: 有语法错误
答案: **0****2**

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,%dn”,k,m);
   return 0;
}

A: 1,0
B: 0,0
C: 0,1
D: 1,1
答案: 1,0

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
答案: 10,0,0

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 = %fn”, data1, data2, data1 + data2);
                            break;
                   case ‘-‘:
                            printf(“%f – %f = %fn”, data1, data2, data1 – data2);
                            break;
                   case ‘*’:
                            printf(“%f * %f = %fn”, data1, data2, data1 * data2);
                            break;
                   case ‘/’:
                            printf(“%f/%f = %fn”, data1, data2,data1/data2);
                            break;
                   default:
                            printf(“Invalid operator!n”);
         }
        return 0;
}‎

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;
}
答案: {
  a=b;
  b=a;
}

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=%dn”, a, b) ;
   return 0;
}

A: a=2, b=2
B: a=2, b=1
C: a=1, b=1
D: a=1, b=0
答案: a=2, b=2

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
答案: 123

9、单选题：

‍编程计算下面的分段函数，根据从键盘输入的x值，在屏幕上输出y值。

‎

‍ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第4张

‎

‍程序代码如下，为完成以上功能，请将第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=%fn", y); return 0; }
A: else if (x == 0)
B: else if (x = 0)
C: if (x == 0)
D: if (x = 0)
答案: else if (x == 0)

10、单选题：

‏以下程序的功能是计算一元二次方程的根。代码如下，请将第10行标号处缺少的语句填写完整。

‎

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第5张

‎#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 = %.2fn", p); } else { if (disc > EPS) /* 判别式大于0时，输出两不等实根 */ { printf("x1 = %.2f, x2 = %.2fn", p+q, p-q); } else /* 判别式小于0时，输出两共轭复根 */ { printf("x1 = %.2f+%.2fi, ", p, q); printf("x2 = %.2f-%.2fin", p, q); } } return 0; }
A: if (fabs(a) <= EPS)
B: if (a <= EPS)
C: if (a=0)
D: if (a<= EPS || a>=-EPS)
答案: if (fabs(a) <= EPS)

11、单选题：

从键盘输入三角形的三边长为a,b,c，按下面公式计算并输出三角形的面积。

‌

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第6张

‌

程序代码如下，但程序运行后输出结果不正确，请找出有问题的语句。

‌#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=%.2fn", area);     }     else     {        printf("It is not a trianglen");         }     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);
答案: 第11行：   s = 1/2 * (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
答案: (x-y)<-10||!(y-x)>10

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

A: c+32
B: c+48
C: c+65
D: c+97
答案: c+32

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 %dn”,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
答案: the output data is 7

15、单选题：
‌以下程序运行后的输出结果是‍#include <stdio.h>
int main()
{
   int a=5,b=4,c=3,d;
   d=(a>b>c);
   printf(“%dn”,d);
   return 0;
}

A: 0
B: 1
C: 5
D: 4
E: 3
答案: 0

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(“%dn”,d);
   return 0;
}

A: 2
B: 3
C: 43
D: 44
答案: 2

17、单选题：
下列说法错误的是（）。‏

赋值中的自动类型转换

1、单选题：
‎在赋值操作中，当赋值表达式左侧的变量的类型与右侧的表达式的类型不一致的时候，下面说法正确的是（）。

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

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

嵌套循环

1、单选题：
下列说法错误的是（）。‎

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

流程的转移控制

1、单选题：
‏下面程序段中的break语句是转移到哪里去执行（）。‎for(…)
{
   for(…)
   {
      switch(…)
      {
         case 1: …
                break;
         case 2:…
         …
      }
      A:  //code
   }
   B:  //code
}
C:  //code‏‎

A: 转到标号A所在的语句行与执行
B: 转到标号B所在的语句行与执行
C: 转到标号C所在的语句行与执行
D: 不进行流程转移，而是继续执行break后面的语句
答案: 转到标号A所在的语句行与执行

程序调试

1、单选题：
‌下列说法错误的是（）。‌

A: 程序测试的目的就是验证程序的正确性。
B: 程序中常见的错误有三种：编译错误，链接错误，以及运行时错误。
C: 编译错误通常是由语法错误造成的。
D: 运行时错误是指在程序运行时发生的错误，运行时错误有两种：一种是导致程序的运行结果与预期的不一致，另一种是导致程序无法正常运行。
答案: 程序测试的目的就是验证程序的正确性。

第5周测验

1、单选题：
‎程序运行后的输出结果是‎‎#include <stdio.h>
int main()
{
        int i;

        for(i=0;i<3;i++)

            switch(i)

                {

                    case 0: printf(“%d”,i);

                    case 2: printf(“%d”,i);

                    default: printf(“%d”,i);

                }

        return 0;

}‎

A: 000122
B: 022111
C: 021021
D: 012
答案: 000122

2、单选题：
若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是‎

A: for( i=1; i<=5; i++ )
{
    p=1;
    p*=i;
}
B: for(i=1,p=1;i<=5;i++) p*=i;
C: i=1;
p=1;
while ( i<=5 )
{
    p*=i;
    i++;
}
D: i=1;
p=1;
do {
        p*=i;
        i++;
} while ( i<=5 );
答案: for( i=1; i<=5; i++ )
{
    p=1;
    p*=i;
}

3、单选题：
‍以下程序执行后的输出结果是‌‍#include <stdio.h>
int main( )
{
    int x=0,y=5,z=3;
    while(z–>0 && ++x<5)
    {
        y=y-1;
    }
    printf(“%d,%d,%dn”,x,y,z);
    return 0;
}‌

A: 3,2,-1
B: 3,2,0
C: 4,3,-1
D: 5,-2,-5
答案: 3,2,-1

4、单选题：
下面程序的输出是‍#include <stdio.h>
int main()
{
    int y=9;
    for( ; y>0; y–)
        {
            if(y%3==0)
                {
                    printf(“%d”, –y);
                    continue;
                }
        }
    return 0;
}‍

A: 852
B: 741
C: 963
D: 875421
答案: 852

5、单选题：
‍爱因斯坦数学题。爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶，最后才正好1阶不剩。请问，这条阶梯共有多少阶？‏‍代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‏‍#include <stdio.h>
int main()
{
    int  x = 1, find = 0;
    while (__________)
    {
        if (______________________)
        {
                printf(“x = %dn”, x);
                find = 1;
        }
        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行：     !find第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
答案: 第5行：     x<=97第7行：     y = 98 – x第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);
答案: i=1;
s=1;
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=%dn”,n);
   return 0;
}‌

A: n=4
B: n=5
C: n=2
D: n=3
答案: n=4

9、单选题：
‍以下正确的描述是‌

A: 只能在循环体内和switch语句体内使用break语句
B: continue语句的作用是结束整个循环的执行
C: 在循环体内使用break语句或continue语句的作用相同
D: continue语句可以写在循环体之外
答案: 只能在循环体内和switch语句体内使用break语句

10、单选题：

计算

‌

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第7张

‌

直到最后一项的绝对值小于程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第8张为止。‍

‌

代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‌

#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 = %fn", 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
答案: 第7行代码： float sign=1第13行代码： sign = -sign

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(“%dn”,s);
    return 0;
}

A: 2
B: -1
C: 3
D: 0
答案: 2

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(“%dn”,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
答案: 2*i-1

15、单选题：
‎程序执行后的输出结果是‏‎#include <stdio.h>
int main( )
{
     int i,s=0;
     for(i=1;i<10;i+=2)
     {
        s+=i+1;
     }
     printf(“%dn”,s);
     return 0;
}‏

A: 自然数1～10中的偶数之和
B: 自然数1～9的累加和
C: 自然数1～10的累加和
D: 自然数1～9中的奇数之和
答案: 自然数1～10中的偶数之和

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(“%dn”,a);
    return 0;
}‏

A: 4
B: 101
C: 6
D: 5
答案: 4

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=%dn”, 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
答案: 第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=%dn”, 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
答案: 第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);
答案: int s=36;
while (s)
{
   –s;
}

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.4fn”,s);
    return 0;
}‍

A: s=s+1/n;
B: printf(“%6.4fn”,s);
C: for(n=10;n>1;n–)
D: s=1.0;
答案: s=s+1/n;

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(“anothern”);
            case ‘1’: printf(“numbern”);
        }
   }
   return 0;
}‎

A: anothernumbernumber
B: numbernumber
C: anothernumber
D: anothernumberanother
答案: anothernumbernumber

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.0ft%6.1fn”, 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行代码： celsius = 5.0 / 9 * (fahr – 32)第10行代码： fahr = fahr + step

23、单选题：

利用泰勒级数：

‏

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第9张

‏

计算e的近似值，当最后一项的绝对值小于程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第10张时认为达到了精度要求，要求统计总共累加了多少项。‍

‏

代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‏

‏
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++
答案: 第6行代码：      double e = 1.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("%dt ",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
答案: 第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
答案: 000122

2、单选题：
‎若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是‏

A: for( i=1; i<=5; i++ ){ p=1; p*=i;}
B: for(i=1,p=1;i<=5;i++) p*=i;
C: i=1;
p=1;
while ( i<=5 )
{
    p*=i;
    i++;
}
D: i=1;
p=1;
do {
        p*=i;
        i++;
} while ( i<=5 );
答案: for( i=1; i<=5; i++ ){ p=1; p*=i;}

3、单选题：
‌下面程序的输出是‎#include <stdio.h>
int main()
{
    int y=9;
    for( ; y>0; y–)
        {
            if(y%3==0)
                {
                    printf(“%d”, –y);
                    continue;
                }
        }
    return 0;
}

A: 852
B: 741
C: 963
D: 875421
答案: 852

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 = %dn”, x);
                find = 1;
        }
        x++;
    }

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

6、单选题：
以下正确的描述是‎

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.0ft%6.1fn”, fahr, celsius);
         ________________ ;
    }
    return 0;
}

8、单选题：

利用泰勒级数：

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第12张

计算e的近似值，当最后一项的绝对值小于程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第10张时认为达到了精度要求，要求统计总共累加了多少项。

代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

#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 = %dn", 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++
答案: 第6行代码： double e = 1.0第10行代码： term = term / n第13行代码： count++

9、单选题：

‏打印所有的“水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如，153是“水仙花数”，因为

‌

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第14张

‌

‏代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‌#include <stdio.h> int main() { int i, j, k, n; printf("result is:"); for (n=100; ________; n++) { i = n / 100; //分离出百位 j = ____________; //分离出十位 k = ____________; //分离出个位 if (_________________________) { printf("%dt ",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
答案: 第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=%dn”,n);
   return 0;
}

A: n=4
B: n=5
C: n=2
D: n=3
答案: n=4

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(“%dn”,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(“%dn”,s);
     return 0;
}

A: 自然数1～10中的偶数之和
B: 自然数1～9的累加和
C: 自然数1～10的累加和
D: 自然数1～9中的奇数之和
答案: 自然数1～10中的偶数之和

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(“anothern”);
            case ‘1’: printf(“numbern”);
        }
   }
   return 0;
}

A: anothernumbernumber
B: numbernumber
C: anothernumber
D: anothernumberanother
答案: anothernumbernumber

14、单选题：
‏以下程序执行后的输出结果是‌#include <stdio.h>
int main( )
{
    int x=0,y=5,z=3;
    while(z–>0 && ++x<5)
    {
        y=y-1;
    }
    printf(“%d,%d,%dn”,x,y,z);
    return 0;
}

A: 3,2,-1
B: 3,2,0
C: 4,3,-1
D: 5,-2,-5
答案: 3,2,-1

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);
答案: i=1;
s=1;
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
答案: 2*i-1

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(“%dn”,a);
    return 0;
}

A: 4
B: 101
C: 6
D: 5
答案: 4

18、单选题：
‍以下不是死循环的程序段是‍

19、单选题：

‏计算

‏

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第15张

‏

‏直到最后一项的绝对值小于程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第8张为止。

‏

‏代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‏#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 = %fn", 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
答案: 第7行代码： float sign=1第13行代码： sign = -sign

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(“%dn”,s);
    return 0;
}

A: 2
B: -1
C: 3
D: 0
答案: 2

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=%dn”, i, j, k);
                    }
                }
        }
    }

    return 0;
}

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=%dn”, x, y, z);
                }
        }
    }

    return 0;‌

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.4fn”,s);
    return 0;
}

A: s=s+1/n;
B: printf(“%6.4fn”,s);
C: for(n=10;n>1;n–)
D: s=1.0;
答案: s=s+1/n;

逗号运算符

1、单选题：
‎下列说法错误的是（）。‌

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

随机数的生成

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()产生的随机数“随机化”。
答案: 函数rand()用于生成一个[0,RAND_MAX]间的随机数，RAND_MAX是不大于双字节整数的最大值32767的宏常量。使用函数rand()必须在程序开头加上这样一条编译预处理指令：#include <stdio.h>

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

函数原型

1、单选题：
‌下列说法错误的是（）。

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

函数名的命名

1、多选题：
‏下面所列举的函数名正确且具有良好风格的是（）

A: 2_abcd()
B: GetNumber()
C: change_directory()
D: chushihua@()
答案: GetNumber() ;
change_directory()

函数封装与程序的健壮性

1、单选题：
‏下列说法错误的是（）。‎

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

函数的参数和返回值

1、单选题：
‌下列说法中错误的是（）。

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

断言

1、单选题：
‍下列说发错误的是（）。

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

断言的使用场合

1、多选题：
‍在下列哪些情况下适合使用断言？‏

A: 检查程序中的各种假设的正确性。
B: 证实或测试某种不可能发生的状况确实不会发生。
C: 捕捉不应该或者不可能发生的非法情况。
D: 捕捉程序中有可能出现的错误。
答案: 检查程序中的各种假设的正确性。;
证实或测试某种不可能发生的状况确实不会发生。;
捕捉不应该或者不可能发生的非法情况。

第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=%dn”,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
答案: 第7行： (k%3==0&&a2==5)||(k%3==0&&a1==5)第22行： Sub(k,n)第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 numbern”, n);
     }
     else
     {
          printf(“%d is not a prime numbern”, 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
答案: 第11行：   ret != 0第29行：   i<=sqrt(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,%dn”,x,y,z);
    return 0;
}

A: 1,3,2
B: 1,2,3
C: 3,1,2
D: 2,3,1
答案: 1,3,2

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);
答案: 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 = %dn”, 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
答案: 第8行： MinCommonMultiple(a, 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 = %dn”, 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
答案: 第8行： MaxCommonFactor(a, b)第29行：    r = a % b第31行：    b = r第32行：    r != 0

10、单选题：
C语言规定：在一个源程序中，main函数的位置‎

A: 可以任意
B: 必须在程序的最开始
C: 必须在系统调用的库函数的后面
D: 必须在程序的最后
答案: 可以任意

11、单选题：

‎编程计算下面组合数的值

‌

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第17张

‌

‎代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‌

‎

‌

#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=%.0fn”, 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++
答案: 第2行： unsigned long Factorial(unsigned int number)第6行：    double p第11行：   m<k || m<0 || k<0第23行：   i=2; 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 numbern”, m);
    else
        printf(“%d is not a perfect numbern”, 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
答案: 第10行： IsPerfect(m)第24行：   i=1; 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,%dn”,d,f,e);
    return 0;
}

A: 5,4,3
B: 3,4,5
C: 5,3,4
D: 3,5,4
答案: 5,4,3

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

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 = %dn”, x);
     }
     else
     {
          printf(“Input error!n”);
     }

     return 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,%dn”,d,f,e);
    return 0;
}

A: 5,4,3
B: 3,4,5
C: 5,3,4
D: 3,5,4
答案: 5,4,3

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);
答案: 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 numbern”, m);
    else
        printf(“%d is not a perfect numbern”, 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
答案: 第10行： IsPerfect(m)第24行： i=1; i<x; i++第26行： x % i == 0

6、单选题：
‌下列说法中正确的是

7、单选题：
以下程序有语法错误，有关错误原因的正确说法是‏#include <stdio.h>
void prt_char();
int main()
{
    int G=5,k;
     ……
    k=prt_char(G);
     ……
    return 0;
}

int prt_char(int x)
{
……
}‏

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=%dn”,n);
    return 0;
}‎

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 numbern”, n);
     }
     else
     {
          printf(“%d is not a prime numbern”, 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;
}

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,%dn”,x,y,z);
    return 0;
}

A: 1,3,2
B: 1,2,3
C: 3,1,2
D: 2,3,1
答案: 1,3,2

11、单选题：
‏若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是‏

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 = %dn”, 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;
}

13、单选题：

编程计算下面组合数的值

‌

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第18张

‌

代码如下,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。

‌

‌#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=%.0fn", 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++
答案: 第2行： unsigned long Factorial(unsigned int number)第6行：    double p第11行：   m<k || m<0 || k<0第23行：   i=2; i<=number; i++

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

全局变量的副作用

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

A: 正确
B: 错误
答案: 正确

函数的嵌套调用和递归调用

1、单选题：
下列说法错误的是（）‌

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

变量的作用域

1、单选题：
下列说法错误的是（）。‍

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

变量的存储类型与变量的作用域

1、单选题：
‌下列说法错误的是（）。‍

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

尾递归

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

A: 正确
B: 错误
答案: 正确

第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.0fn”,Fun((int)Fun(a+c,b),a-c));
    return 0;
}‍

A: 9
B: 21
C: 9.0
D: 编译出错
答案: 9

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行： a第5行： b第11行： Fun(Fun(x,y),z)

4、单选题：
写出下面程序的运行结果‌#include <stdio.h>
void Bin(int x)
{
if (x/2 > 0) Bin(x/2);
printf(“%dn”, x%2);
}

int main()
{
Bin(12);
return 0;
}‌‏‌

A: 1100
B: 0011
C: 6310
D: 6311
答案: 1100

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)
答案: Gcd(b, a%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
答案: 10,20

7、单选题：

‏子函数Incre()的功能是，利用静态变量，使子函数的输出值能够随调用次数的增加依次为：

‌

‏第1次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第19张的结果

‌

‏第2次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第20张的结果

‌

‏第3次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第21张的结果

‌

‏…..

‌

‏

‌

‏在下面的程序中，对子函数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("%dn",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
答案: 第7行： i<x第13行： static int x=1

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(“%dn”, a);
    }

    return 0;
}‏

A: 00
B: 88
C: 44
D: 6464
答案: 00

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(“%dn”, i);
    return 0;
}

A: 2,6,42,3
B: 2,2,2,3
C: 2,2,3,3
D: 2,3,4,3
答案: 2,6,42,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 %dn”, 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)
答案: 第9行： c!= -1第18行： a <= 0 || b <= 0第21行： a第23行： Gcd(a – b, b)第25行： Gcd(a, b – a)

11、单选题：

‎函数Sum(int n)是用递归方法计算下面的公式，请补充程序中缺少的内容。

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第22张

‎

int Sum(int n) { if (n <= 0) printf("data errorn"); 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行： return 1第5行： n+Sum(n-1)

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)
答案: 第4行： return 1 第5行： return n*Fact(n-1)

13、单选题：

‎Y()是实现n层嵌套平方根计算的函数，其公式如下，请将程序补充完整。

‌

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第23张

‌

‎

‌

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)
答案: Y(x,n-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(“%dn”,j);
    return 0;
}‎

A: 3
B: 4
C: 2
D: 1
答案: 3

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)
答案: 第4行： x第11行：%c Fun(a,b),Fun(b,c)

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

1、单选题：
写出下面程序的运行结果‎#include <stdio.h>
void Bin(int x)
{
if (x/2 > 0) Bin(x/2);
printf(“%dn”, x%2);
}

int main()
{
Bin(12);
return 0;‎

A: 1100
B: 0011
C: 6310
D: 6311
答案: 1100

2、单选题：

子函数Incre()的功能是，利用静态变量，使子函数的输出值能够随调用次数的增加依次为：

‍

第1次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第19张的结果

‍

第2次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第20张的结果

‍

第3次调用，输出：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第21张的结果

‍

…..

‍

在下面的程序中，对子函数Incre()进行了两次调用，若使程序的输出结果是：

‍

请补充完整空白处缺少的代码。

‍#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("%dn",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
答案: 第7行： i<x第13行： static int x=1

3、单选题：

函数Sum(int n)是用递归方法计算下面的公式，请补充程序中缺少的内容。

‎

‌ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第27张

‎

‌

‎int Sum(int n) { if (n <= 0) printf("data errorn"); 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行： return 1第5行： n+Sum(n-1)

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(“%dn”,j);
    return 0;
}

A: 3
B: 4
C: 2
D: 1
答案: 3

5、单选题：
‏以下程序运行后的输出结果是#include <stdio.h>
float Fun(int x,int y)
{
return(x+y);
}

int main()
{
    int a=2,b=5,c=8;
    printf(“%3.0fn”,Fun((int)Fun(a+c,b),a-c));
    return 0;
}

A: 9
B: 21
C: 9.0
D: 编译出错
答案: 9

6、单选题：

‌Y()是实现n层嵌套平方根计算的函数，其公式如下，请将程序补充完整。

‌ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第28张

‌

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)
答案: Y(x,n-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)
答案: Gcd(b, a%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)
答案: 第4行： return 1 第5行： return n*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;
}

10、单选题：
‎下列说法正确的是

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

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
答案: 10,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(“%dn”, a);
    }

    return 0;
}

A: 00
B: 88
C: 44
D: 6464
答案: 00

14、单选题：
‌写出下面程序的运行结果。‏#include <stdio.h>
int Square(int i)
{
return i * i;
}

A: 2,6,42,3
B: 2,2,2,3
C: 2,2,3,3
D: 2,3,4,3
答案: 2,6,42,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 %dn”, 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 ___________;
}

递归的数学基础

1、判断题：
‌数学归纳法是递归的数学基础。‎

A: 正确
B: 错误
答案: 正确

递归算法的执行过程

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

A: 正确
B: 错误
答案: 正确

下方是付费阅读内容：本平台商品均为虚拟商品，无法用作二次销售，不支持退换货，请在购买前确认您需要购买的资料准确无误后再购买，望知悉！

完整答案需点击上方按钮支付5元购买,所有答案均为章节测试答案，购买后上方矩形框将出现已付费的隐藏内容。

如果点击【立即购买】不能跳转，请更新一下APP版本，如百度APP可能有兼容性问题，更新版本即可正常使用，或者换一个浏览器（如UC浏览器）再试试

不知道怎么购买？点击这里查看购买教程！

下方是后续章节以及题目答案

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

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);
答案: char *s=“ABCDE”;

2、单选题：
‏已知：int *p(); 则p是‏

A: 一个函数，该函数的返回值是指向int型的指针变量
B: 指向int型的指针变量
C: int型的指针数组
D: 一个指向函数的指针变量，该函数的返回值是int型
答案: 一个函数，该函数的返回值是指向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的长度
答案: 数组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 != ”)  //若srcStr所指字符不是字符串结束标志
    {
        _________; //将srcStr所指字符复制到dstStr所指的存储单元中
        srcStr++;  //使srcStr指向下一个字符
        dstStr++; //使dstStr指向下一个存储单元
    }
     _____________; //在字符串dstStr的末尾添加一个字符串结束标志
}

A: 第19行： *dstStr != ”第25行： *dstStr = * srcStr第29行： *dstStr = ”
B: 第19行： dstStr != ”第25行： dstStr = srcStr第29行： *dstStr = ”
C: 第19行： *dstStr == ”第25行： *dstStr = * srcStr第29行： *dstStr = ‘n’
D: 第19行： dstStr == ”第25行： dstStr = srcStr第29行： *dstStr = ‘n’
答案: 第19行： *dstStr != ”第25行： *dstStr = * srcStr第29行： *dstStr = ”

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(“%sn”,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])
答案: 第3行： char *s1, char *s2第5行： strcmp(s1,s2)<0第20行： FindMinString(string,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]!=”;i++)
        {
            __________;
            printf(“%c”,b[i-1]);
        }
      _________;
      printf(“%cn”,________);
    }
    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]=”第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]=”第19行： b[i]
答案: 第2行： char *a第15行： Move(b,i)第18行： b[i-1]=’0’第19行： b[i-1]

7、单选题：
下面程序的功能是将字符数组中存放的字符串以多种书写形式输出，如“Program”，“PROGRAM”，以及逆序输出的字符串“margorp”等，程序的运行结果为：ProgramPROGRAMmargorp按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#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)!=”第11行： putchar(*(a + i))第15行： –i第17行： *(b + i)第19行： putchar (*(b + i))
B: 第8行： %s%s第9行：（*a+i)!=”第11行： putchar(*a + i))第15行： i–第17行： *(b + i)第19行： putchar (*(b + i))
C: 第8行： %c%s第9行： *(a+i)==”第11行： putchar(*(a + i)) 第15行： –i第17行： *b + i第19行： putchar (*b + i))
D: 第8行： %s%s第9行：（*a+i)==”第11行： putchar(*a + i))第15行： i–第17行： *b + i第19行： putchar (*b + i)
答案: 第8行： %c%s第9行： *(a+i)!=”第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(“%sn”, s);
    return 0;
    }

void  Squeeze(char *s, char c)
    {
        int i, j;
        for (i = j = 0; s[i] != ”; i++)
            {
                if (__________)
                {
                    __________;
                    j++;
                }
            }
        _____________; /* 在字符串t2的末尾添加字符串结束标志 */
     }

A: 第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ”
B: 第20行： s[i] == c第22行： s[j] = s[i]第26行： s[i] = ”
C: 第20行： s[j] != c第22行： s[i] = s[j]第26行： s[j] = ”
D: 第20行： s[j] == c第22行： s[j] = s[i]第26行： s[i] = ”
答案: 第20行： s[i] != c第22行： s[j] = s[i]第26行： s[j] = ”

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};
答案: char str[7] = “FORTRAN”;

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=”abcdef”;
   strcpy(s1,s2);
   puts(s1);
   …….
   return 0;
}

A: ab
B: cdef
C: abcdef
D: 内容不确定
答案: ab

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!=”; _________)    //求出字符串长度
        {
            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
答案: 第21行： pStart++第25行： pEnd=pStr+len-1第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,%dn”, 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:  %dn”, letter);
    printf(“digit character:  %dn”, digit);
    printf(“space:  %dn”, space);
    printf(“other character:  %dn”, others);
    return 0;
    }‏‍‏

A: 第9行： gets(str)第10行： str[i] != ”第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] != ”第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
答案: 第9行： gets(str)第10行： str[i] != ”第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:%sn”, str);
     return 0;
}

void Insert(char s[])
{
    char t[N];
    int  i, j;
    ____________;
    for (i=0, j=0; ____________; i++, j++)
    {
        ________;
        j++;
        ________;
    }
    s[j] = ”;/* 在字符串s的末尾添加字符串结束标志 */
}‌‌

A: 第19行：strcpy(t, s)第20行：t[i]!=”第22行：s[j] = t[i]第24行：s[j] = ‘ ‘
B: 第19行：t=s;第20行：t[i]!=”第22行：s[i] = t[j]第24行：s[j] = ‘ ‘
C: 第19行：strcpy(t, s)第20行：t[i]=”第22行：t[j] = s[i]第24行：s[j] = ‘ ‘
D: 第19行：strcpy(s, t)第20行：t[i]==”第22行：s[j] = t[i]第24行：s[j] = ‘0 ‘
答案: 第19行：strcpy(t, s)第20行：t[i]!=”第22行：s[j] = t[i]第24行：s[j] = ‘ ‘

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:%sn”, 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
答案: 第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(“%sn”,s);
     return 0;
}‌‎‌

A: 第2行： char *ch第5行： *ch!=”第7行： *ch>=’A’&& *ch<=’Z’第8行： *ch=*ch-‘A’+’a’
B: 第2行： char ch第5行： ch!=”第7行： *ch>=’A’&& *ch<=’Z’第8行： *ch=*ch-‘A’+’a’
C: 第2行： char *ch第5行： *ch!=”第7行： ch>=’A’&& ch<=’Z’第8行： ch=ch-‘A’+’a’
D: 第2行： char ch[]第5行： *ch==”第7行： *ch>=’A’|| *ch<=’Z’第8行： *ch=*ch-‘A’+’a’
答案: 第2行： char *ch第5行： *ch!=”第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<passwordn”);
    else
        printf(“Invalid password!user input>passwordn”);
    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
答案: 第8行： “%s”, userInput第9行： strcmp(userInput, password) == 0第11行： strcmp(userInput, password) < 0

19、单选题：
‏下列说法正确的是‍

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

20、单选题：
‍下列说法错误的是‏

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

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 %dn”,sizeof(a) ,sizeof(b))第7行： printf(“%d %dn”,strlen(a) ,strlen(b))
B: 第6行： printf(“%d %dn”,strlen(a) ,strlen(b))第7行： printf(“%d %dn”,sizeof(a) ,sizeof(b))
C: 第6行： printf(“%d %dn”,sizeof(*a) ,sizeof(*b))第7行： printf(“%d %dn”,strlen(*a) ,strlen(*b))
D: 第6行： printf(“%d %dn”,sizeof(&a) ,sizeof(&b))第7行： printf(“%d %dn”,strlen(&a) ,strlen(&b))
答案: 第6行： printf(“%d %dn”,sizeof(a) ,sizeof(b))第7行： printf(“%d %dn”,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] != ”; j++)
      {
           __________________;
      }
    for (________; s1[k] != ”; k++)
     {
           ________________;
     }
    s3[j + k] = ”;
    printf(“After instert:%sn”, 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]
答案: 第17行： n > len第25行： s3[i + j] = s2[j]第27行： k = n第29行： s3[j + k] = s1[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=%dn”, num);
    return 0;
}

int CountWords(char str[])
{
    int  i, num;
    num = (__________) ? 1 : 0;
    i=1;
    while (str[i]!=”)
    {
        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] != ‘ ‘第21行： str[i]==’ ‘ && str[i-1] == ‘ ‘第25行： i++
D: 第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] != ‘ ‘第25行： num++
答案: 第17行： str[0] != ‘ ‘第21行： str[i]!=’ ‘ && str[i-1] == ‘ ‘第25行： i++

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

元素在二维数组中相对于首地址的偏移量

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
答案: i*n+j

字符指针数组

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

A: 正确
B: 错误
答案: 正确

指针和一维数组

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

A: 正确
B: 错误
答案: 错误

指针的算术运算

1、单选题：
‏下列说法错误的是（）。‌

A: 指针指向数组元素时，指针算术运算才有意义
B: 两个指针指向同一个数组时，指针相减才有意义
C: 指针的算术运算允许通过对指针变量重复自增来访问数组的元素
D: p++就是将指针变量p加上一个字节
答案: p++就是将指针变量p加上一个字节

第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(“%dt”, *(*(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]
答案: 第20行： int (*a)[COL]第27行： *(*(at+j)+i) = *(*(a+i)+j)第32行： int(*s)[COL]第39行： *(s+i)+j第44行： (*s)[ROW]

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,%sn”, ___________________);
            }
        }
    }
    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]
答案: 第8行：   j=i+1第10行： k=j+1第13行： m, bColor[i], bColor[j], bColor[k]

3、单选题：
‌char (*p)[10];该语句定义了一个‎

A: 指向含有10个元素的一维字符型数组的指针变量p
B: 指向长度为10的字符串的指针变量p
C: 有10个元素的指针数组p，每个元素可以指向一个字符串
D: 有10个元素的指针数组p，每个元素存放一个字符串
答案: 指向含有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
答案: *(*(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
答案: i*n+j

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的指向。
答案: (*p)++指的是先取出p指向的存储单元中的内容，然后将取出的数值加1，此时p不再指向原来的存储单元。

7、单选题：
假设有下面定义语句：‌float a[10];‌float *p=a;‌则p++相当于是加上（）个字节‌

A: sizeof(float)
B: 1个字节
C: sizeof(p)
D: sizeof(a)
E: sizeof(float*)
答案: sizeof(float)

8、单选题：
‌下列说法中错误的是‌

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

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 = %dn”, num);
    Print(pArray, num);
    return 0;
}

void  Print(char *arr[], int len)
{
    int  i;
    for (i=0; i<len; i++)
    {
        printf(“%s “, arr[i]);
    }
    printf(“n”);
}

A: 第6行应该是： int num = sizeof(pArray) / sizeof(char*);
B: 第12行应该是： void Print(char arr[], int len)
C: 第5行应该是： char pArray[] = {“How”,”are”,”you”};
D: 第6行应该是： int num = sizeof(pArray/char *);
答案: 第6行应该是： int num = sizeof(pArray) / sizeof(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
答案: 9

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]
答案: a[1][1]

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(“%dn”,a[1][2]);
    return 0;
}‌

A: 6
B: 3
C: 9
D: 2
答案: 6

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(“%dn”,*(*(p+i)+j));
     return 0;
}‏

A: 13
B: 9
C: 11
D: 17
答案: 13

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,%dn”,____________);
    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]
答案: *(p[0]+2),c[0][2]

15、单选题：
‎下面给出的选项中，能定义为一个指针数组的语句是‍

A: int *ptr[5];
B: int (*ptr)[5];
C: int *(ptr[5]);
D: int ptr[5];
答案: int *ptr[5];

16、单选题：
‎若有定义“int *p[5];”，则以下叙述中正确的是

A: 定义了一个指针数组p，该数组含有5个元素，每个元素都是基类型为int的指针变量
B: 定义了一个基类型为int的指针变量p，该变量有5个指针
C: 定义了一个名为*p的整型数组，该数组含有5个int类型元素
D: 定义了一个可指向一维数组的指针变量p，所指一维数组应具有5个int类型元素
答案: 定义了一个指针数组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++);
答案: 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
答案: *(*(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)
答案: *(array + i*4 + j)

20、单选题：
‌有int *p[10];以下说法错误的是________。‌

A: p++操作是合法的
B: p是数组名
C: p是一个指针数组
D: p中每个元素都是一个指针变量
答案: 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,%sn”, ___________________);
            }
        }
    }
    return 0;
}

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
答案: i*n+j

3、单选题：
假设有下面定义语句：‌float a[10];‌float *p=a;‌则p++相当于是加上（）个字节‌

A: sizeof(float)
B: 1个字节
C: sizeof(p)
D: sizeof(a)
E: sizeof(float*)
答案: 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
答案: *(*(a+i)+j)

5、单选题：
‍char (*p)[10];该语句定义了一个‎

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(“%dn”,a[1][2]);
    return 0;
}

A: 6
B: 3
C: 9
D: 2
答案: 6

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(“%dn”,*(*(p+i)+j));
     return 0;
}

A: 13
B: 9
C: 11
D: 17
答案: 13

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
答案: *(*(ptr + 1) + 2)

9、单选题：
‏下面关于表达式(*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
答案: 9

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]
答案: a[1][1]

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,%dn”,____________);
    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]
答案: *(p[0]+2),c[0][2]

13、单选题：
‎下面给出的选项中，能定义为一个指针数组的语句是

A: int *ptr[5];
B: int (*ptr)[5];
C: int *(ptr[5]);
D: int ptr[5];
答案: 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;
}

15、单选题：
‍下列说法中错误的是‏

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 = %dn”, num);
    Print(pArray, num);
    return 0;
}

void  Print(char *arr[], int len)
{
    int  i;
    for (i=0; i<len; i++)
    {
        printf(“%s “, arr[i]);
    }
    printf(“n”);
}

17、单选题：
‌若有定义“int *p[5];”，则以下叙述中正确的是‌

18、单选题：
设有定义语句‎int x[6]={2,4,6,8,5,7},*p=x,i;‎要求依次输出x数组6个元素中的值，不能完成此操作的语句是‎

19、单选题：
‏设有语句“int array[3][4];”，则在下面几种引用下标为i和j的数组元素的方法中，不正确的引用方式是________。

A: *(array + i*4 + j)
B: array[i][j]
C: *(*(array + i) + j)
D: *(array[i] + j)
答案: *(array + i*4 + j)

20、单选题：
‎有int *p[10];以下说法错误的是________。

A: p++操作是合法的
B: p是数组名
C: p是一个指针数组
D: p中每个元素都是一个指针变量
答案: p++操作是合法的

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

共用体类型

1、单选题：
‌下列说法错误的是（）。‎

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

关键字typedef

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

A: 正确
B: 错误
答案: 错误

向函数传递结构体

1、单选题：
‌下列说法错误的是（）。‌

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

对结构体的操作

1、单选题：
‏下列说法错误的是（）。

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

枚举类型

1、单选题：
‎下列对枚举类型的使用的代码中错误的是（）。‏

A: enum {no,  yes,  none}answer;
if (answer == yes)
{
    printf(“Yesn”);
}
B: enum response{no = -1,  yes = 1,  none = 0};
enum response answer;
C: answer = yes;
printf(“%d”, answer);
D: answer = “yes”;
printf(“%s”, answer);
答案: answer = “yes”;
printf(“%s”, answer);

2、判断题：
‍和整型、实型、字符型一样，枚举类型也是一种基本数据类型。‏

A: 正确
B: 错误
答案: 正确

第12周测验

1、单选题：
设有以下说明语句,则下面的叙述中错误的是‎struct ex
{
    int x ;
    float y;
    char z ;
} example;‎

A: example是结构体类型名
B: struct是结构体类型的关键字
C: x,y,z都是结构体成员名
D: ex为结构体标签。
答案: example是结构体类型名

2、单选题：
若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。‏‏struct
{
    short a;
    float b;
} v1;‏‏union
{
    short a;
    float b;
} v2;‏

A: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
B: 执行sizeof(v1)获得的结果是6个字节，只能对结构体变量v1中的第一个成员进行初始化。
C: 执行sizeof(v2)获得的结果是6个字节，只能对共用体变量v2中的第一个成员进行初始化。
D: 执行sizeof(v2)获得的结果是4个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
E: 执行sizeof(v2)获得的结果是8个字节，只能对共用体变量v2中的第一个成员进行初始化
F: 执行sizeof(v1)获得的结果是8个字节，只能对结构体变量v1中的第一个成员进行初始化。
G: 执行sizeof(v1)获得的结果是4个字节，对结构体变量v1中的任何一个成员都可以进行初始化。
H: 执行sizeof(v2)获得的结果是6个字节，对共用体变量v2中的任何一个成员都可以进行初始化。
答案: 执行sizeof(v1)获得的结果是8个字节，对结构体变量v1中的任何一个成员都可以进行初始化。

3、单选题：
以下正确的描述是‌

A: 结构体和共用体变量都不能进行比较操作。
B: 两个结构体变量可以比较，但不能将结构体类型作为函数返回值类型。
C: 既可以对两个共用体变量进行比较操作，也可以将共用体变量作为函数参数。
D: 关键字typedef用于定义一种新的数据类型。
E: 结构体和共用体变量都能进行比较操作。
F: 枚举类型和结构体、共用体一样，也是一种构造数据类型。
G: 不同结构体类型的成员名不能相同。
H: 和数组一样，即使是相同类型的结构体变量也不能整体赋值，只能逐个成员进行赋值。
答案: 结构体和共用体变量都不能进行比较操作。

4、单选题：
‏以下选项中不能正确把cl定义成结构体变量的是‌

A: struct color cl
{
    int red;
    int green;
    int blue;
}
B: typedef struct
{
    int red;
    int green;
    int blue;
} COLOR;
COLOR cl;
C: struct color
{
    int red;
    int green;
    int blue;
} cl;
D: struct
{
    int red;
    int green;
    int blue;
} cl;
答案: struct color cl
{
    int red;
    int green;
    int blue;
}

5、单选题：
‍以下程序执行后的输出结果是‏‍#include <stdio.h>
struct STU
{
char name[10];
int num;
};

void Fun1(struct STU c)
{
struct STU b={“LiGuo”,2042};
c=b;
};

void Fun2(struct STU *c)
{
struct STU b={“SunDan”,2044};
*c=b;
};

int main()
{
    struct STU a={“YangHan”,2041},b={“WangYi”,2043};
    Fun1(a);
    Fun2(&b);
    printf(“%d %dn”,a.num,b.num);
    return 0;
}‏

A: 2041 2044
B: 2041 2043
C: 2042 2044
D: 2042 2043
答案: 2041 2044

6、单选题：
‍下面说法错误的是‏

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

7、单选题：
‏若能使程序运行后的输出结果如下：‏‏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(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);
B: printf(“%sn”,(p++).num); printf(“%sn”,(p++).num); printf(“%sn”,(p++).num);
C: printf(“%sn”,(++p)->num); printf(“%sn”,(++p)->num); printf(“%sn”,(*p).num);
D: printf(“%sn”,stu[0]->num); printf(“%sn”,stu[1]->num); printf(“%sn”,stu[2]->num);
答案: printf(“%sn”,(*p).num); printf(“%sn”,(++p)->num); printf(“%sn”,stu[2].num);

8、单选题：
‌以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‏‌#include <stdio.h>
typedef struct clock
{
int hour;
int minute;
int second;
}CLOCK;

/* 函数功能：时、分、秒时间的更新 */
void Update(________)
{
static long m = 1;
t->hour = m / 3600;
t->minute = __________________;
t->second = ___________;
m++;
if (t->hour == 24)  m = 1;
}

/* 函数功能：时、分、秒时间的显示 */
void Display(CLOCK *t)
{
printf(“%2d:%2d:%2dr”, t->hour, t->minute, t->second);
}

/* 函数功能：模拟延迟1秒的时间 */
void Delay(void)
{
long t;
for (t=0; t<50000000; t++)
        {
/* 循环体为空语句的循环，起延时作用 */
        }
}

int main()
{
long i;
CLOCK myclock;
myclock.hour = myclock.minute = myclock.second = 0;
for (i=0; i<100000; i++)   /* 利用循环，控制时钟运行的时间 */
{
Update(&myclock);           /* 时钟值更新 */
Display(__________);           /* 时间显示 */
Delay();                      /* 模拟延时1秒 */
}
        return 0;
}‏

A: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock
B: 第10行： CLOCK *t第14行： (m – 3600 * hour) / 60第15行： m / 60第44行： &myclock
C: 第10行： CLOCK t第14行： (m – 3600 * t->hour) / 60第15行： m / 60第44行： myclock
D: 第10行： CLOCK t第14行： (m – 3600 * hour) / 60第15行： m % 60第44行： myclock
答案: 第10行： CLOCK *t第14行： (m – 3600 * t->hour) / 60第15行： m % 60第44行： &myclock

9、单选题：
‎有以下说明和定义语句，下面各输入语句中错误的是‎#include <stdio.h>
int main()
{
    struct student
    {
         int age;
         char sex;
         char name[8];
    };

    struct student std;
    struct student *p=&std;
    …….
    return 0;
}

A: scanf(“%c”,&std[0].sex);
B: scanf(“%d”,&(*p).age);
C: scanf(“%s”,std.name);
D: scanf(“%c”,&(p->sex));
答案: scanf(“%c”,&std[0].sex);

10、单选题：
‎以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‍‎#include <stdio.h>
struct stu
{
char num[10];
float score[3];
};

int main()
{
    struct stu s[3]={{“20021”,90,95,85},{“20022”,95,80,75},{“20023”,100,95,90}},*p=s;
    int i,j;
    float sum;

    __________

    return 0;
}‍

A:      for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
        p++;
    }
B:          sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
C:          sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
            p++;
        }
        printf(“%6.2fn”,sum);
D:      for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
            p++;
        }
        printf(“%6.2fn”,sum);
    }
答案:         for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
        p++;
    }

11、单选题：

‌

‎

‌某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是

‎

‌ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第39张

‎

‌

‎
A: struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
B: struct student
{
    int number;
    char name[20];
    char sex;
    int year;
    int month;
    int day;
} s;

year = 1984;
month = 11;
day = 11;
C: struct student
{
    int number;
    char name[20];
    char sex;
} s;

struct
{
    int year;
    int month;
    int day;
} birth;

birth.year = 1984;
birth.month = 11;
birth.day = 11;
D: struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.year = 1984;
s.month = 11;
s.day = 11;
答案:   struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;

12、单选题：
下面程序的输出结果是‎#include <stdio.h>
int main()
{
    union
    {
        int i[2];
        int k;
        int c;
    }t,*s = &t;

    s->i[0] = 10;
    s->i[1] = 20;
    s->k=30;
    printf(“%dn”, s->k);
    printf(“%dn”, s->i[0]);
    printf(“%dn”, s->c);
    return 0;
}‎

A: 303030
B: 102030
C: 3010随机数
D: 301020
答案: 303030

13、单选题：

‎设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。

‍

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第40张

‍
A: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                 /* 定义职业结构体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                        /* 姓名 */
    char sex;                             /* 性别 */
    struct date birthday;                 /* 出生日期 */
    struct professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}
B: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                   /* 定义职业结构体类型 */
{
    char college[80];                      /* 所在学院*/
    char professionalTitle[20];            /* 职称 */
    char duty[20];                         /* 职务 */
};
int main()
{
    char name[20];                         /* 姓名 */
    char sex;                              /* 性别 */
    struct date birthday;                  /* 出生日期 */
    struct professionalState occupation;   /* 职业状况 */
    ……
    return 0;
}
C: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
int main()
{
    char name[20];                   /* 姓名 */
    char sex;                        /* 性别 */
    struct date birthday;            /* 出生日期 */
    char college[80];                /* 所在学院*/
    char professionalTitle[20];      /* 职称 */
    char duty[20];                   /* 职务 */
    ……
    return 0;
}
D: #include <stdio.h>
int main()
{
    char name[20];                   /* 姓名 */
    char sex;                        /* 性别 */
    char college[80];                /* 所在学院*/
    char professionalTitle[20];      /* 职称 */
    char duty[20];                   /* 职务 */
    int   year;                      /* 年 */
    int   month;                     /* 月 */
    int   day;                       /* 日 */
    …..
    return 0;
}
E: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
union professionalState                  /* 定义职业共用体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                       /* 姓名 */
    char sex;                            /* 性别 */
    struct date birthday;                /* 出生日期 */
    union professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}
答案: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                 /* 定义职业结构体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                        /* 姓名 */
    char sex;                             /* 性别 */
    struct date birthday;                 /* 出生日期 */
    struct professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}

14、单选题：
‏下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‎‏#include  <stdio.h>
#include  <string.h>
#define NUM_ELECTORATE 10
#define NUM_CANDIDATE 3
struct candidate
{
    char  name[20];
    int   count;
}candidate[3] = {“li”,0, “zhang”,0, “wang”,0};

int main()
{
    int  i, j, flag = 1, wrong = 0;
    char  name[20];
    for (i=1; i<=NUM_ELECTORATE; i++)
    {
       printf(“Input vote %d:”, i);
       scanf(“%s”, name);
       strlwr(name); /* C语言的标准库函数，功能是将name中的字符全部变成小写字母 */
       flag = 1;

       for (j=0; j<NUM_CANDIDATE; j++)
       {
            if (_________________)
            {
                _____________;
                flag = 0;
            }
        }

       if (flag)
        {
            wrong++;  /* 废票计数 */
            ________;
        }
        }
       printf(“Election results:n”);

       for (i=0; i<NUM_CANDIDATE; i++)
       {
            printf(“%s:%dn”, ____________________);
       }

       printf(“Wrong election:%dn”, wrong);
       return 0;
}‎

A: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count
B: 第24行： name == candidate[j].name第26行： count++第34行： flag = 0第41行： name, count
C: 第24行： name = candidate[j].name第26行： count++第34行： flag = 1第41行： candidate[i].name[i], candidate[i].count
D: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 1第41行： name, count
答案: 第24行： strcmp(name, candidate[j].name) == 0第26行： candidate[j].count++第34行： flag = 0第41行： candidate[i].name, candidate[i].count

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

1、单选题：
‎设有以下说明语句，则下面的叙述中错误的是‌struct ex
{
    int x ;
    float y;
    char z ;
} example;

A: example是结构体类型名
B: struct是结构体类型的关键字
C: x,y,z都是结构体成员名
D: ex为结构体标签。
答案: example是结构体类型名

2、单选题：
‏以下正确的描述是‎

3、单选题：
以下程序执行后的输出结果是‌#include <stdio.h>
struct STU
{
char name[10];
int num;
};

void Fun1(struct STU c)
{
struct STU b={“LiGuo”,2042};
c=b;
};

void Fun2(struct STU *c)
{
struct STU b={“SunDan”,2044};
*c=b;
};

int main()
{
    struct STU a={“YangHan”,2041},b={“WangYi”,2043};
    Fun1(a);
    Fun2(&b);
    printf(“%d %dn”,a.num,b.num);
    return 0;
}

A: 2041 2044
B: 2041 2043
C: 2042 2044
D: 2042 2043
答案: 2041 2044

4、单选题：
‏以下程序的功能是计算每个学生3门课成绩的总和，按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‍#include <stdio.h>
struct stu
{
char num[10];
float score[3];
};

int main()
{
    struct stu s[3]={{“20021”,90,95,85},{“20022”,95,80,75},{“20023”,100,95,90}},*p=s;
    int i,j;
    float sum;

    __________

    return 0;
}

A: for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
        p++;
    }
B:         sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
C:         sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
            p++;
        }
        printf(“%6.2fn”,sum)
D:    for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
            p++;
        }
        printf(“%6.2fn”,sum);
    }
答案: for (j=0;j<3;j++)
    {
        sum=0;
        for(i=0;i<3;i++)
        {
            sum=sum+p->score[i];
        }
        printf(“%6.2fn”,sum);
        p++;
    }

5、单选题：

‏某学生的记录描述如下，能将其正确定义并将变量中的“出生日期”赋值为1984年11月11日的是

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第41张

A: struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;
B: struct student
{
    int number;
    char name[20];
    char sex;
    int year;
    int month;
    int day;
} s;

year = 1984;
month = 11;
day = 11;
C: struct student
{
    int number;
    char name[20];
    char sex;
} s;
struct
{
    int year;
    int month;
    int day;
} birth;
birth.year = 1984;
birth.month = 11;
birth.day = 11;
D: struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.year = 1984;
s.month = 11;
s.day = 11;
答案: struct student
{
    int number;
    char name[20];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birth;
} s;

s.birth.year = 1984;
s.birth.month = 11;
s.birth.day = 11;

6、单选题：
若能使程序运行后的输出结果如下：‎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;
}

7、单选题：
‍以下是时钟模拟显示程序,按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‏#include  <stdio.h>
typedef struct clock
{
    int hour;
    int minute;
    int second;
}CLOCK;

/* 函数功能：时、分、秒时间的更新 */
void Update(________)
{
    static long m = 1;
    t->hour = m / 3600;
    t->minute = __________________;
    t->second = ___________;
    m++;
    if (t->hour == 24)  m = 1;
}

/* 函数功能：时、分、秒时间的显示 */
void Display(CLOCK *t)
{
printf(“%2d:%2d:%2dr”, t->hour, t->minute, t->second);
}

/* 函数功能：模拟延迟1秒的时间 */
void Delay(void)
{
    long t;
    for (t=0; t<50000000; t++)
        {
            /* 循环体为空语句的循环，起延时作用 */
        }
}

int main()
{
    long i;
    CLOCK myclock;
    myclock.hour = myclock.minute = myclock.second = 0;
    for (i=0; i<100000; i++)  /* 利用循环，控制时钟运行的时间 */
    {
        Update(&myclock);          /* 时钟值更新 */
        Display(__________);          /* 时间显示 */
        Delay();                     /* 模拟延时1秒 */
    }
    return 0;
}

8、单选题：
‌下面程序的输出结果是‏#include <stdio.h>
int main()
{
    union
    {
        int i[2];
        int k;
        int c;
    }t,*s = &t;

    s->i[0] = 10;
    s->i[1] = 20;
    s->k=30;
    printf(“%dn”, s->k);
    printf(“%dn”, s->i[0]);
    printf(“%dn”, s->c);
    return 0;
}

A: 303030
B: 102030
C: 3010随机数
D: 301020
答案: 303030

9、单选题：

‍设某大学有下列登记表，下面哪个选项采用了最佳方式对它进行类型定义。

‌

‍ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第42张

‌
A: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                 /* 定义职业结构体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                        /* 姓名 */
    char sex;                             /* 性别 */
    struct date birthday;                 /* 出生日期 */
    struct professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}
B: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                   /* 定义职业结构体类型 */
{
    char college[80];                      /* 所在学院*/
    char professionalTitle[20];            /* 职称 */
    char duty[20];                         /* 职务 */
};
int main()
{
    char name[20];                         /* 姓名 */
    char sex;                              /* 性别 */
    struct date birthday;                  /* 出生日期 */
    struct professionalState occupation;   /* 职业状况 */
    ……
    return 0;
}
C: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
int main()
{
    char name[20];                   /* 姓名 */
    char sex;                        /* 性别 */
    struct date birthday;            /* 出生日期 */
    char college[80];                /* 所在学院*/
    char professionalTitle[20];      /* 职称 */
    char duty[20];                   /* 职务 */
    ……
    return 0;
}
D: #include <stdio.h>
int main()
{
    char name[20];                   /* 姓名 */
    char sex;                        /* 性别 */
    char college[80];                /* 所在学院*/
    char professionalTitle[20];      /* 职称 */
    char duty[20];                   /* 职务 */
    int   year;                      /* 年 */
    int   month;                     /* 月 */
    int   day;                       /* 日 */
    …..
    return 0;
}
E: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
union professionalState                  /* 定义职业共用体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                       /* 姓名 */
    char sex;                            /* 性别 */
    struct date birthday;                /* 出生日期 */
    union professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}
答案: #include <stdio.h>
struct date                            /* 定义日期结构体类型 */
{
    int   year;                        /* 年 */
    int   month;                       /* 月 */
    int   day;                         /* 日 */
};
struct professionalState                 /* 定义职业结构体类型 */
{
    char college[80];                    /* 所在学院*/
    char professionalTitle[20];          /* 职称 */
    char duty[20];                       /* 职务 */
};
struct person                            /* 定义职工个人信息结构体类型 */
{
    char name[20];                        /* 姓名 */
    char sex;                             /* 性别 */
    struct date birthday;                 /* 出生日期 */
    struct professionalState occupation;  /* 职业状况 */
};
int main()
{
    ……
    return 0;
}

10、单选题：
‍下面程序的功能是统计候选人的得票数。设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。‎#include  <stdio.h>
#include  <string.h>
#define NUM_ELECTORATE 10
#define NUM_CANDIDATE 3
struct candidate
{
    char  name[20];
    int   count;
}candidate[3] = {“li”,0, “zhang”,0, “wang”,0};

11、单选题：
‏下面说法错误的是‎

12、单选题：
有以下说明和定义语句，下面各输入语句中错误的是‌#include <stdio.h>
int main()
{
    struct student
    {
         int age;
         char sex;
         char name[8];
    };

    struct student std;
    struct student *p=&std;
    …….
    return 0;
}‌

A: scanf(“%c”,&std[0].sex);
B: scanf(“%d”,&(*p).age);
C: scanf(“%s”,std.name);
D: scanf(“%c”,&(p->sex));
答案: scanf(“%c”,&std[0].sex);

13、单选题：
‏若有以下说明，则下面哪个叙述是正确的（已知short占2个字节,float占4个字节）。‏struct
{
    short a;
    float b;
} v1;‏‏union
{
    short a;
    float b;
} v2;

14、单选题：
以下选项中不能正确把cl定义成结构体变量的是‏

结构体变量的定义

1、单选题：
‍下面哪条语句是正确的。

A: typedef  struct  student
{
  long studentID;
  char studentName[10];
  char studentSex;
  int  yearOfBirth;
  int  score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
B: typedef  struct  STUDENT
{
    long studentID;
    char studentName[10];
    char studentSex;
    int  yearOfBirth;
    int  score[4];
};
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
C: struct
{
    long studentID;
    char studentName[10];
    char studentSex;
    int  yearOfBirth;
    int  score[4];
};
struct  stu1;
D: struct student{ long studentID;          char studentName[10];    char studentSex;         int yearOfBirth;        int score[4];         }STUDENT;STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
答案: typedef  struct  student
{
  long studentID;
  char studentName[10];
  char studentSex;
  int  yearOfBirth;
  int  score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};

结构体变量的访问

1、单选题：
已知：typedef  struct  date
{
  int  year;
  int  month;
  int  day;
}DATE;
typedef  struct  student
{
  long studentID;
  char studentName[10];
  char studentSex;
  DATE birthday;
  int  score[4];
}STUDENT;
STUDENT    stu1;
STUDENT    *pt = &stu1;则下列访问结构体变量的方法中，哪个是错误的。

A: stu1. birthday. year = 1999;
B: (*pt). birthday. year = 1999;
C: pt -> birthday -> year = 1999;
D: pt -> birthday. year = 1999;
答案: pt -> birthday -> year = 1999;

结构体的嵌套

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

A: 正确
B: 错误
答案: 正确

结构体类型所占内存的字节数

1、单选题：
下列说法错误的是（）。‍

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

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

指针和内存

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

A: 正确
B: 错误
答案: 错误

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

A: 正确
B: 错误
答案: 错误

第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]=%dn”,i,*(p+i))
B: 第8行： p=(int *)(n*malloc(sizeof(int*)))第12行： *p+i=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
C: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *p+i=i*10第16行： printf(“array[i]=%dn”,i,*p+i)
D: 第8行： p=(int)malloc(n*sizeof(int *));第12行： *(p+i)=i*10第16行： printf(“array[i]=%dn”,i,*(p+i))
答案: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))

2、单选题：
‏下列说法正确的是

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

3、单选题：
‎申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？‌

A: p = (int *) malloc(n * sizeof(int));
B: p = (int *)calloc(n, sizeof(int));
C: p = (int *) malloc(n, sizeof(int));
D: p = (int *)calloc(n * sizeof(int));
E: int p[n];
F: p = (int *) realloc(n * sizeof(int));
答案: p = (int *) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int));

4、单选题：
‏假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。‎‏p = (int *) malloc(m*n*sizeof(int));‎‏或者‎‏p = (int *) calloc(m*n, sizeof(int));‎

A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）

5、单选题：
‌下列说法错误的是

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

6、单选题：
‍下列说法错误的是‎

A: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B: 函数realloc()用于改变原来分配的存储空间的大小。
C: 对于函数void * calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D: 向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E: 函数void * calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F: void*型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type*)为其他类型。
G: 用calloc动态申请的内存会自动初始化为0.
答案: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.

7、单选题：
‍下面关于内存泄漏问题的描述错误的是（）‎

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

8、单选题：
‎关于下面程序中的变量和常量分布的内存区域说法错误的是‍‎#include <stdio.h>
#include <stdlib.h >
static char array2[] = {“dddd”};
char array3[100];
int main()
{
     short b;
     char array1[]=”aaaa”;
     char *p;
     p = (char *)malloc(10*sizeof(int));
     strcpy(p,”bbbb”);
     free(p);
     return 0;
}‍

A: 指针变量p存放在堆中
B: “bbbb”存放在栈中
C: array3数组存放在静态存储区
D: 本题中指针变量p指向的内存空间在堆中
E: “bbbb”存放在常量区
F: array2存放在静态存储区
答案: 指针变量p存放在堆中;
“bbbb”存放在栈中

9、单选题：
‏对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是‎

A: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B: void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C: void *的含义是指该函数没有返回值
D: 以上说法都不对
答案: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。

10、单选题：
‍下面说法错误的是

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

11、单选题：
‏下面程序希望得到的运行结果如下：‏‏Total string numbers = 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 = %dn”, num);
    Print(pArray, num);
    return 0;
}

void  Print(char *arr[], int len)
{
    int  i;
    for (i=0; i<len; i++)
    {
        printf(“%s “, arr[i]);
    }
    printf(“n”);
}‏

A: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
B: 第6行错误改正为：int num = sizeof(char*) / sizeof(pArray);
C: 第12行错误改正为：char arr[]
D: 第5行错误改正为：char *pArray = {“How”,”are”,”you”}
答案: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);

12、单选题：
‌申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？‍

A: p = (int *) malloc(m*n*sizeof(int));
B: p = (int *)calloc(m*n, sizeof(int));
C: p = (int *) malloc(m*n, sizeof(int));
D: p = (int *)calloc(m * n * sizeof(int));
E: int p[m][n];
F: p = (int *) realloc(m * n * sizeof(int));
答案: p = (int *) malloc(m*n*sizeof(int)); ;
p = (int *)calloc(m*n, sizeof(int));

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

1、单选题：
假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。‎p = (int *) malloc(m*n*sizeof(int));‎或者‎p = (int *) calloc(m*n, sizeof(int));‎

A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）

2、单选题：
下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *p,n,i;
    printf(“Enter array size:”);
    scanf(“%d”,&n);
    __________________;

    for(i=0;i<n;i++)
    {
        ____________;
    }
    for(i=0;i<n;i++)
    {
        _______________;
    }
    free(p);
    return 0;
}

3、单选题：
‍下列说法正确的是‌

4、单选题：
‏对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是‏

5、单选题：
‌下列说法错误的是‌

6、单选题：
‍下列说法错误的是

7、单选题：
‍下面关于内存泄漏问题的描述错误的是（）‏

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 = %dn”, num);
    Print(pArray, num);
    return 0;
}

void  Print(char *arr[], int len)
{
    int  i;
    for (i=0; i<len; i++)
    {
        printf(“%s “, arr[i]);
    }
    printf(“n”);
}

9、单选题：
申请一个具有n个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;
}

11、单选题：
‎下面说法错误的是‍

12、单选题：
‌申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？‎

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

第14周测验

1、单选题：
‍关于图的说法正确的是‎

A: 图由顶点和边构成
B: 图的邻接表属于顺序存储方式
C: 图的邻接表属于链式存储方式
D: 图的邻接矩阵中存储的是图的顶点
答案: 图由顶点和边构成

2、单选题：

‌已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点

‎

‌ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第43张

‎

‌且所有结点都已具有如下形式的结构定义：

‎

‌struct node

‎

‌{

‎

‌ int data;

‎

‌ struct node *next;

‎

‌}*p, *pr, *head;

‎

‌若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是

‎
A: pr = head;
while(pr->next!=p)
{
    pr = pr->next;
}
B: p = head;
pr = head;
while(pr->next!=p)
{
   pr = pr->next;
}
C: pr = head;
while(pr!=p)
{
   pr = pr->next;
}
D: p = head;
while(p->next!=pr)
{
   p = p->next;
}
答案: pr = head;
while(pr->next!=p)
{
    pr = pr->next;
}

3、单选题：
‏关于队列的说法正确的是‎

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

4、单选题：

若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第44张

A: p = p->next; q->next = p; p->next = q;
B: q->next = NULL; p = p->next; p->next = q;
C: p = p->next; q->next = p->next; p->next = q;
D: p = (*p).next; (*q).next = (*p).next; (*p).next = q;
答案: p = p->next; q->next = p; p->next = q;

5、单选题：
‎下列叙述中正确的是

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

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(“%dn”,sum);
    return 0;
}‍

A: 4
B: 3
C: 5
D: 6
答案: 4

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;
答案: p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;

10、单选题：
‎关于单向链表说法错误的是‏

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

11、单选题：

已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。

‍

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第45张

‍

且所有结点都已具有如下形式的结构定义：

‍

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;

‌

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第46张

‌
A: r->next=q; q->next=r->next; p->next=r;
B: q->next=r->next; p->next=r; r->next=q;
C: p->next=r; q->next=r->next; r->next=q;
D: q->next=r->next; r->next=q; p->next=r;
答案: r->next=q; q->next=r->next; p->next=r;

13、单选题：

‌已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第47张

‌

‌struct node

‌

‌{

‌

‌ int data;

‌

‌ struct node *next;

‌

‌}*p;

‌

‌若要删除头结点，则下面正确的语句序列是

‌
A: p = head;head = p->next;free(p);
B: head = head->next;free(head);
C: p = head->next;free(p);
D: head = head->next;p = head;free(p);
答案: p = head;head = p->next;free(p);

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

1、单选题：

‏已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。

‍

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第48张

‍

且所有结点都已具有如下形式的结构定义：

‍

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是链表的头指针，且所有结点都已具有如下形式的结构定义：

‏

‎ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第49张

‏

struct node

‏

{

‏

int data;

‏

struct node *next;

‏

}*p;

‏

若要删除头结点，则下面正确的语句序列是

‏
A: p = head;head = p->next;free(p);
B: head = head->next;free(head);
C: p = head->next;free(p);
D: head = head->next;p = head;free(p);
答案: p = head;head = p->next;free(p);

3、单选题：
‎关于图的说法正确的是‌

A: 图由顶点和边构成
B: 图的邻接表属于顺序存储方式
C: 图的邻接表属于链式存储方式
D: 图的邻接矩阵中存储的是图的顶点
答案: 图由顶点和边构成

4、单选题：

‏若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是

‏

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第50张

‏
A: p = p->next; q->next = p; p->next = q;
B: q->next = NULL; p = p->next; p->next = q;
C: p = p->next; q->next = p->next; p->next = q;
D: p = (*p).next; (*q).next = (*p).next; (*p).next = q;
答案: p = p->next; q->next = p; p->next = q;

5、单选题：
‎以下程序执行后的输出结果是#include <stdio.h>
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};

A: 4
B: 3
C: 5
D: 6
答案: 4

6、单选题：

‏有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是

‍struct node { int data; struct node *next; }*p, *q, *r;

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第51张

‍
A: r->next=q; q->next=r->next; p->next=r;
B: q->next=r->next; p->next=r; r->next=q;
C: p->next=r; q->next=r->next; r->next=q;
D: q->next=r->next; r->next=q; p->next=r;
答案: r->next=q; q->next=r->next; p->next=r;

7、单选题：
‎下面属于动态数据结构的是‏

A: 链表
B: 栈
C: 结构体数组
D: 指针数组
E: 字符数组
答案: 链表;
栈

8、单选题：
向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：‌struct node‌{ ‌ int data;‌ struct node *next;‌}*p, *pr, *head;‌则操作正确的是‌

9、单选题：

‏已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点

‏ 程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第52张

且所有结点都已具有如下形式的结构定义：

struct node

{

int data;

struct node *next;

}*p, *pr, *head;

若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是

A: pr = head;
while(pr->next!=p)
{
    pr = pr->next;
}
B: p = head;
pr = head;
while(pr->next!=p)
{
   pr = pr->next;
}
C: pr = head;
while(pr!=p)
{
   pr = pr->next;
}
D: p = head;
while(p->next!=pr)
{
   p = p->next;
}
答案: pr = head;
while(pr->next!=p)
{
    pr = pr->next;
}

10、单选题：
‎下列叙述中正确的是‌

11、单选题：
‌关于队列的说法正确的是

12、单选题：
关于树的说法错误的是

13、单选题：
‏关于单向链表说法错误的是‎

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

fgets()与fputs()

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

A: 正确
B: 错误
答案: 正确

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

A: 正确
B: 错误
答案: 正确

函数fgetc()和feof()

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

A: 正确
B: 错误
答案: 正确

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

A: 正确
B: 错误
答案: 错误

第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
答案: hello

4、单选题：
阅读以下程序,对程序功能的描述中正确的是#icnlude <stdio.h>
int main()
{
    FILE *in, *out;
    char ch, infile[10], outfile[10];
    printf(“Enter the infile name:n”);
    scanf(“%s”, infile);
    printf(“Enter the outfile name:n”);
    scanf(“%s”, outfile);
    if ((in = fopen(infile, “r”)) == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    if ((out = fopen(outfile, “w”)) == NULL)
    {
        printf(“cannot open outfile.n”);
        exit(0);
    }

    while (!feof(in))
    {
        fputc(fgetc(in), out);
    }
    fclose(in);
    fclose(out);
    return 0;
}

A: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。
B: 程序完成将磁盘文件的信息在屏幕上显示的功能。
C: 程序完成将两个磁盘文件合二为一的功能。
D: 程序完成将两个磁盘文件合并并在屏幕上输出的功能。
答案: 程序完成将一个磁盘文件中的信息复制到另一个磁盘文件中的功能。

5、单选题：
‌C语言中标准输入文件stdin是指‎

A: 键盘
B: 显示器
C: 鼠标
D: 硬盘
E: U盘
答案: 键盘

6、单选题：
‍设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是‍struct st
{
    char name[8];
    int num;
    float s[4];
} student[50];

A: fwrite(student, 25 * sizeof(struct st), 1, fp);
B: fwrite(student, sizeof(struct st), 50, fp);
C: fwrite(student, 50 * sizeof(struct st), 1, fp);
D: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
答案: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);

7、单选题：
‏若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是‎

A: “wb+”
B: “ab+”
C: “rb+”
D: “ab”
答案: “wb+”

8、单选题：
以下叙述中错误的是‎

A: Ｃ语言中顺序读写方式不适用于二进制文件
B: Ｃ语言中的文本文件以ASCⅡ码形式存储数据
C: Ｃ语言中对二进制文件的访问速度比文本文件快
D: Ｃ语言中随机读写方式不适用于文本文件
答案: Ｃ语言中顺序读写方式不适用于二进制文件

9、单选题：
‌有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为‌‌#include <stdio.h>
int main()
{
     FILE *fp1;
     fp1=fopen(“f1.txt”,”w”);

     if (fp1 == NULL)
     {
         printf(“cannot open the file.n”);
         exit(0);
     }

     fprintf(fp1,”abc”);
     fclose(fp1);
     return 0;
}‌

A: abc
B: goodabc
C: good
D: abcgood
答案: abc

10、单选题：
‏以下程序执行后输出结果是‏‏#include <stdio.h>
int main()
{
    FILE *fp;
    int i,k=0,n=0;
    fp=fopen(“d1.dat”,”w”);

    if (fp == NULL)
    {
        printf(“cannot open the file.n”);
        exit(0);
    }

    for(i=1;i<4;i++)
    {
        fprintf(fp,”%d”,i);
    }
    fclose(fp);

    fp=fopen(“d1.dat”,”r”);
    if (fp == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    fscanf(fp,”%d%d”,&k,&n);
    printf(“%d %dn”,k,n);
    fclose(fp);
    return 0;
}‏

A: 123 0
B: 1 2
C: 1 23
D: 0 0
答案: 123 0

11、单选题：
关于文件读写，正确的叙述是

A: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。
B: 使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。
C: 使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。
D: 使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。
E: 以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。
F: 以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。
G: 文件打开后一定要检查是否打开成功。
H: 文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。
I: 以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。
J: 以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。
K: 文件一旦按文本方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是文本，对应的内容都是字符‘1’。
L: 文件一旦按二进制方式打开，无论用fwrite还是fprintf函数写入数字1，最后生成的都是二进制文件，对应的内容都是数值1。
M: 用FILE只能定义指向文本文件的文件指针。
N: 用FILE只能定义指向二进制文件的文件指针。
O: C语言中的文件都是流式文件，只能按顺序读写，不能进行随机读写。
P: 文件的读写方式中w+和r+都是可读可写方式，二者是完全一样的。
答案: 可把整型数以二进制形式存放到文件中的函数是fwrite函数。;
使用fread可以直接将数值从二进制文件读入（拷贝）到程序的变量中。;
使用fprintf函数可以将信息以文本的形式写入文件（类似向屏幕输出文本信息的printf函数）。;
使用fscanf函数可以从文本文件，按格式读入int、float等各种类型的数值（类似从键盘读入信息的scanf函数）。;
以二进制形式打开的文件，如果使用fprintf向文件写入所有数据，其结果是生成的文件还是个文本文件。;
以文本方式打开的文件，如果使用fwrite向文件写入所有数据，其结果是生成的文件还是个二进制文件。正因如此，如果用文本编辑器打开这个文件查看文件中的内容会发现是乱码。;
文件打开后一定要检查是否打开成功。;
文件用完一定要关闭，否则，可能会引起数据丢失，或者影响其他文件的打开，因为多数情况下，系统限制同时处于打开状态的文件总数。;
以r（只读）、a（追加）和r+（读写）方式打开文件时，该文件必须是已存在的文件，否则将打开不成功。;
以w（只写）和w+（读写）方式打开一个文件时，无论该文件是否存在，都新建一个文件，这就意味着如果文件已存在，则其原有的内容将丢失。

12、单选题：
以下叙述中错误的是‍

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

13、单选题：
‎下列关于C语言数据文件的叙述中正确的是‍

A: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
B: 文件由ASCII码字符序列组成，C语言只能读写文本文件
C: 文件由二进制数据序列组成，C语言只能读写二进制文件
D: 文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
答案: 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件

14、单选题：
‍若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为

A: 0
B: 1
C: -1
D: 一个非0值
答案: 0

15、单选题：
‏在进行文件操作时，写文件的一般含义是‏

A: 将计算机内存中的信息存入磁盘。
B: 将磁盘中的信息存入计算机内存。
C: 将计算机CPU中的信息存入磁盘。
D: 将磁盘中的信息存入计算机CPU。
答案: 将计算机内存中的信息存入磁盘。

16、单选题：
‍以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是‏‍#include <stdio.h>
int main()
{
    FILE *fout; char ch;
    fout=fopen(‘abc.txt’,’w’);
    if (fout == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    ch=fgetc(stdin);
    while(ch!=’#’)
    {
        fputc(ch,fout);
        ch=fgetc(stdin);
    }

    fclose(fout);
    return 0;
}‏

A: 函数fopen()调用形式错误
B: 输入文件没有关闭
C: 函数fgetc()调用形式错误
D: 文件指针stdin没有定义
答案: 函数fopen()调用形式错误

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

1、单选题：
‏下面的程序执行后，文件test中的内容是‍#include <stdio.h>
#include <string.h>
void Fun(char *fname,char *st)
{
    FILE *myf; int i;
    myf=fopen(fname,”w” );
    if (myf == NULL)
    {
        printf(“cannot open the file.n”);
        exit(0);
    }

   for(i=0;i<strlen(st); i++)
   {
        fputc(st[i],myf);
   }

   fclose(myf);
}

int main()
{
    Fun(“test”,”new world”);
    Fun(“test”,”hello”);
    return 0;
}

A: hello
B: new worldhello
C: new world
D: hello rld
答案: hello

2、单选题：
‎有如下程序, 若文本文件f1.txt中原有内容为：good，则运行以下程序后文件f1.txt中的内容为‎#include <stdio.h>
int main()
{
     FILE *fp1;
     fp1=fopen(“f1.txt”,”w”);

     if (fp1 == NULL)
     {
         printf(“cannot open the file.n”);
         exit(0);
     }

     fprintf(fp1,”abc”);
     fclose(fp1);
     return 0;
}

A: abc
B: goodabc
C: good
D: abcgood
答案: abc

3、单选题：
‌下列关于C语言数据文件的叙述中正确的是

4、单选题：
‍以下程序希望把从终端输入的字符输出到名为abc.txt的文件中，直到从终端读入字符#号时结束输入和输出操作，但程序有错。出错的原因是‏#include <stdio.h>
int main()
{
    FILE *fout; char ch;
    fout=fopen(‘abc.txt’,’w’);
    if (fout == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    ch=fgetc(stdin);
    while(ch!=’#’)
    {
        fputc(ch,fout);
        ch=fgetc(stdin);
    }

    fclose(fout);
    return 0;
}

A: 函数fopen()调用形式错误
B: 输入文件没有关闭
C: 函数fgetc()调用形式错误
D: 文件指针stdin没有定义
答案: 函数fopen()调用形式错误

5、单选题：
‏阅读以下程序,对程序功能的描述中正确的是‎#icnlude <stdio.h>
int main()
{
    FILE *in, *out;
    char ch, infile[10], outfile[10];
    printf(“Enter the infile name:n”);
    scanf(“%s”, infile);
    printf(“Enter the outfile name:n”);
    scanf(“%s”, outfile);
    if ((in = fopen(infile, “r”)) == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    if ((out = fopen(outfile, “w”)) == NULL)
    {
        printf(“cannot open outfile.n”);
        exit(0);
    }

    while (!feof(in))
    {
        fputc(fgetc(in), out);
    }
    fclose(in);
    fclose(out);
    return 0;
}

6、单选题：
‏设有以下结构类型，并且结构数组student中的元素都已有值，若要将这些元素写到硬盘文件fp中，以下形式错误的是‏‏struct st
{
    char name[8];
    int num;
    float s[4];
} student[50];‏

A: fwrite(student, 25 * sizeof(struct st), 2, fp);
B: fwrite(student, sizeof(struct st), 50, fp);
C: fwrite(student, 50 * sizeof(struct st), 1, fp);
D: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);
答案: for (i = 0; i < 50; i++) fwrite(student, sizeof(struct st), 1, fp);

7、单选题：
‎C语言中标准输入文件stdin是指‎

A: 键盘
B: 显示器
C: 鼠标
D: 硬盘
E: U盘
答案: 键盘

8、单选题：
‌若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应该是‎

A: “wb+”
B: “ab+”
C: “rb+”
D: “ab”
答案: “wb+”

9、单选题：
‍在进行文件操作时，写文件的一般含义是

10、单选题：
‏关于文件读写，正确的叙述是‌

11、单选题：
‌若要以“a+”方式打开一个已存在的文件，则以下叙述正确的是‎

12、单选题：
‍在C语言中，从计算机内存中将数据写入文件中，称为

A: 输出
B: 输入
C: 修改
D: 删除
答案: 输出

13、单选题：
以下叙述中错误的是‎

14、单选题：
‏以下程序执行后输出结果是‍#include <stdio.h>
int main()
{
    FILE *fp;
    int i,k=0,n=0;
    fp=fopen(“d1.dat”,”w”);

    if (fp == NULL)
    {
        printf(“cannot open the file.n”);
        exit(0);
    }

    for(i=1;i<4;i++)
    {
        fprintf(fp,”%d”,i);
    }
    fclose(fp);

    fp=fopen(“d1.dat”,”r”);
    if (fp == NULL)
    {
        printf(“cannot open infile.n”);
        exit(0);
    }

    fscanf(fp,”%d%d”,&k,&n);
    printf(“%d %dn”,k,n);
    fclose(fp);
    return 0;
}

A: 123 0
B: 1 2
C: 1 23
D: 0 0
答案: 123 0

15、单选题：
‌以下叙述中错误的是‌

16、单选题：
‌若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为‌

A: 0
B: 1
C: -1
D: 一个非0值
答案: 0

为了方便下次阅读，建议在浏览器添加书签收藏本网页

添加书签方法：

1.电脑按键盘的Ctrl键+D键即可收藏本网页

2.手机浏览器可以添加书签收藏本网页

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第53张

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第54张

获取更多慕课答案，欢迎在浏览器访问我们的网站：http://mooc.mengmianren.com

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第55张

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第57张

注：请切换至英文输入法输入域名，如果没有成功进入网站，请输入完整域名：http://mooc.mengmianren.com/

我们的公众号

打开手机微信，扫一扫下方二维码，关注微信公众号：萌面人APP

本公众号可查看各种网课答案，还可免费查看大学教材答案

点击这里，可查看公众号功能介绍

程序设计基础(中国人民解放军陆军工程大学) 中国大学MOOC答案2024版100分完整版第58张

一键领取淘宝，天猫，京东，拼多多无门槛优惠券，让您购物省省省，点击这里，了解详情