c语言--第二章练习题

最新推荐文章于 2024-07-13 13:25:53 发布

weixin_45958231

最新推荐文章于 2024-07-13 13:25:53 发布

阅读量890

点赞数 28

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/weixin_45958231/article/details/140371800

版权

第一章易错题

5.计算机高级语言程序的运行方法有编译执行和解释执行两种，以下叙述中正确的是( )。
A)C语言程序仅可以编译执行
B)C语言程序仅可以解释执行
C)C语言程序既可以编译执行又可以解释执行
D)以上说法都不对

正确答案是：A)C语言程序仅可以编译执行

解析：

计算机高级语言程序的运行方法有编译执行和解释执行两种：

编译执行：

编译型语言在执行前需要经过编译器将源代码（高阶语言）转化为机器语言（目标代码），然后再执行目标代码。
编译过程产生一个可执行文件，可以在没有源代码的情况下运行。
编译型语言的代表有C、C++、Go等。

解释执行：

解释型语言不需要事先编译，解释器逐行读取源代码并将其转化为机器语言执行。
每次运行都需要源代码和解释器。
解释型语言的代表有Python、JavaScript、Ruby等。

C语言是一种典型的编译型语言。C语言程序需要通过编译器（如gcc、clang等）将源代码编译成可执行文件，然后运行该可执行文件。因此，C语言程序仅可以编译执行，而不能解释执行。

C语言程序的运行过程可以分为以下几个主要步骤：编写源代码、预处理、编译、汇编、链接和执行。以下是每个步骤的详细介绍：

编写源代码：
- 程序员使用文本编辑器（如Visual Studio Code、Sublime Text等）编写C语言源代码，通常保存在以.c为扩展名的文件中。
- 例如：hello.c
```
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}
```
预处理（Preprocessing）：
- 预处理器会处理以#开头的预处理指令（如#include、#define等）。
- 例如，将#include <stdio.h>替换为标准输入输出库的内容。
- 预处理后的文件通常是扩展名为.i的中间文件。
```
gcc -E hello.c -o hello.i
```
编译（Compilation）：
- 编译器将预处理后的源代码翻译成汇编代码。
- 生成的汇编代码文件通常是扩展名为.s的文件。
```
gcc -S hello.i -o hello.s
```
汇编（Assembly）：
- 汇编器将汇编代码翻译成机器代码（目标代码），生成目标文件。
- 目标文件通常是扩展名为.o或.obj的文件。
```
gcc -c hello.s -o hello.o
```
链接（Linking）：
- 链接器将一个或多个目标文件和库文件结合起来，生成可执行文件。
- 链接过程解决了目标文件之间的引用和依赖关系。
```
gcc hello.o -o hello
```
执行（Execution）：
- 生成的可执行文件可以在目标系统上运行。
- 在命令行输入可执行文件的名称来执行程序。
```
./hello
```
- 输出结果：
```
Hello, World!
```

总结

预处理：处理预处理指令，生成扩展名为.i的文件。
编译：将预处理后的文件翻译成汇编代码，生成扩展名为.s的文件。
汇编：将汇编代码翻译成机器代码，生成扩展名为.o的目标文件。
链接：将目标文件和库文件结合起来，生成可执行文件。
执行：运行生成的可执行文件。

每个步骤都可以使用GCC编译器的不同选项进行单独操作，以便更好地理解和调试程序。

知识点讲解

编译型语言的优缺点

优点：

运行速度快：因为编译后生成的机器代码是直接运行的，不需要逐行翻译。
代码保护：编译后生成的可执行文件不包含源代码，保护了代码的知识产权。

缺点：

调试不便：编译前的代码错误需要经过编译器的报错信息排查，调试相对麻烦。
平台相关：编译生成的可执行文件通常只能在特定的平台上运行。

解释型语言的优缺点

优点：

跨平台：源代码可以在任何安装了解释器的环境中运行。
开发效率高：不需要编译，代码修改后可以立即运行，便于调试和开发。

缺点：

运行速度慢：因为每次执行都需要逐行解释，开销较大。
安全性低：源代码直接暴露，容易被修改和盗用。

综上所述，C语言是一种仅可以编译执行的语言，选项A是正确的。

6.以下叙述中错误的是( )。
A)C语言的可执行程序是由一系列机器指令构成的
B)用C语言编写的源程序不能直接在计算机上运行
C)通过编译得到的二进制目标程序需要连接才可以运行
D)在没有安装C语言集成开发环境的机器上不能运行C源程序生成的.exe文件
正确答案是：D)在没有安装C语言集成开发环境的机器上不能运行C源程序生成的.exe文件

解析：

选项分析：

A) C语言的可执行程序是由一系列机器指令构成的：

正确。C语言的可执行程序最终是由机器指令组成的，这些指令是编译器将源代码编译后生成的二进制代码，计算机能够直接执行这些指令。

B) 用C语言编写的源程序不能直接在计算机上运行：

正确。C语言的源代码需要先经过编译（包括预处理、编译、汇编、链接）生成可执行文件后才能在计算机上运行，源代码本身不能直接执行。

C) 通过编译得到的二进制目标程序需要连接才可以运行：

正确。编译得到的目标文件（通常为.o或.obj文件）需要经过链接器将各个目标文件和库文件链接在一起，生成最终的可执行文件。

D) 在没有安装C语言集成开发环境的机器上不能运行C源程序生成的.exe文件：

错误。生成的.exe文件是已经编译好的可执行文件，可以在任何兼容的操作系统上运行，而不需要安装C语言集成开发环境（IDE）。IDE仅仅是在开发阶段使用，用于编写、编译和调试代码，但运行可执行文件只需要操作系统本身支持相应的可执行格式即可。

相关知识点讲解：

C语言程序的运行环境：

编译环境与运行环境：

编译环境：包括编译器、链接器、标准库等，用于将源代码编译成可执行文件。例如，GCC、Clang、Visual Studio等都是C语言的编译环境。
运行环境：仅需要操作系统和所需的动态链接库。编译好的可执行文件可以在没有开发环境的计算机上运行，只要操作系统支持该可执行文件格式并且所有的依赖库都存在。

可执行文件：

可执行文件（如Windows上的.exe文件）是编译后的最终产物，它包含了机器指令和必要的运行时信息。
这些文件可以在不需要编译环境的情况下直接运行，只要目标系统兼容并且包含所有必要的库。

静态链接和动态链接：

静态链接：将所有依赖库直接编译进可执行文件，生成的可执行文件独立运行，不依赖外部库文件。
动态链接：可执行文件在运行时依赖外部动态链接库（如.dll文件），需要目标系统上存在这些库文件。

综上所述，选项D是错误的，因为C语言生成的可执行文件可以在没有安装C语言集成开发环境的机器上运行。

7.以下叙述正确的是( )。
A)C语言程序是由过程和函数组成的
B)C语言函数可以嵌套调用，例如: fun(fun(x))
C)C语言函数不可以单独编译
D)C语言中除了main函数，其他函数不可作为单独文件形式存在

正确答案是：B)C语言函数可以嵌套调用，例如: fun(fun(x))

解析：

选项分析：

A) C语言程序是由过程和函数组成的：

错误。C语言程序是由函数组成的，没有“过程”这一概念。C语言的结构是以函数为基本单位的，每个函数完成特定的任务。

B) C语言函数可以嵌套调用，例如: fun(fun(x))：

正确。C语言支持函数的嵌套调用。一个函数可以调用另一个函数并使用其返回值，例如：result = fun(fun(x));。

C) C语言函数不可以单独编译：

错误。C语言的函数可以单独编译。通过使用extern关键字声明其他文件中定义的函数，多个源文件中的函数可以分别编译，然后通过链接器链接在一起。

D) C语言中除了main函数，其他函数不可作为单独文件形式存在：

错误。C语言中，除了main函数外，其他函数也可以单独存在于不同的源文件中。这种方式常用于模块化编程，增强代码的可读性和可维护性。

解析：

在C语言中，关键字是保留的单词，它们具有特殊的意义，不能用作变量名或函数名。以下是对每个选项的分析：

A) define F type：

define 不是关键字，它是预处理指令。
F 不是关键字。
type 不是关键字。

因此，这组选项中只有define看起来像关键字，但实际上不是。

B) getc char printf：

getc 不是关键字，它是标准库函数。
char 是关键字。
printf 不是关键字，它是标准库函数。

所以这组选项中包含了关键字char。

C) include case scanf：

include 不是关键字，它是预处理指令的一部分（#include）。
case 是关键字。
scanf 不是关键字，它是标准库函数。

因此，这组选项中包含了关键字case。

D) while go pow：

while 是关键字。
go 不是关键字。
pow 不是关键字，它是标准库函数。

所以这组选项中只有while是关键字，而go和pow都不是关键字。

解析：

字符常量在C语言中是用单引号（'）括起来的单个字符。每个字符常量都表示一个字符，且其类型是int。以下是对每个选项的分析：

A) “c”：

这是一个字符串常量，用双引号（"）括起来的字符序列，而不是字符常量。

B) ‘l’：

这是一个合法的字符常量，表示字符l。

C) ‘ ’：

这是一个包含两个空格的字符常量，虽然语法上是合法的，但可能不是我们通常期望的字符常量。

D) ‘K’：

这是一个合法的字符常量，表示字符K。

综上所述，选项A）“c”是不正确的字符常量，因为它是一个字符串常量，而不是字符常量。

27.以下叙述不正确的是( )。
A)在C程序中，逗号运算符的优先级最低
B)在C程序中，MAX和 max是两个不同的变量
C)若a和b类型相同，在计算了赋值表达式a=b后，b中的值将放入a中，而b中的值不变
D)当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值

解析：

选项分析：

A) 在C程序中，逗号运算符的优先级最低：

正确。逗号运算符的优先级在所有运算符中是最低的。它用于顺序求值，在表达式中，逗号运算符左侧的表达式先求值，右侧的表达式后求值，整个表达式的结果是右侧表达式的值。

B) 在C程序中，MAX和max是两个不同的变量：

正确。C语言对变量名是区分大小写的，因此MAX和max是两个不同的变量名。

C) 若a和b类型相同，在计算了赋值表达式a=b后，b中的值将放入a中，而b中的值不变：

正确。在C语言中，赋值运算符=的作用是将右边表达式的值赋给左边的变量，因此a=b会将b的值赋给a，而b的值保持不变。

D) 当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值：

错误。在C语言中，虽然输入时期望输入的数据类型与变量类型匹配，但实际上输入的内容会根据格式说明符进行解析。如果输入的内容与期望类型不匹配，可能会导致未定义行为或输入错误。例如，输入一个浮点数给整型变量会截断小数部分，只保留整数部分。

综上所述，选项D是不正确的，因为在实际操作中，输入的数值类型不一定严格与变量类型匹配。

28.以下叙述不正确的是( )。
A)在C程序中，逗号运算符的优先级最低
B)在C程序中，MAX和 max是两个不同的变量
C)若a和b类型相同，在计算了赋值表达式a=b后，b中的值将放入a中，而b中的值不变
D)当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值
正确答案是：D)当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值

解析：

选项分析：

A) 在C程序中，逗号运算符的优先级最低：

正确。逗号运算符的优先级在所有运算符中是最低的。它用于顺序求值，在表达式中，逗号运算符左侧的表达式先求值，右侧的表达式后求值，整个表达式的结果是右侧表达式的值。

B) 在C程序中，MAX和max是两个不同的变量：

正确。C语言对变量名是区分大小写的，因此MAX和max是两个不同的变量名。

C) 若a和b类型相同，在计算了赋值表达式a=b后，b中的值将放入a中，而b中的值不变：

正确。在C语言中，赋值运算符=的作用是将右边表达式的值赋给左边的变量，因此a=b会将b的值赋给a，而b的值保持不变。

D) 当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值：

错误。在C语言中，虽然输入时期望输入的数据类型与变量类型匹配，但实际上输入的内容会根据格式说明符进行解析。如果输入的内容与期望类型不匹配，可能会导致未定义行为或输入错误。例如，输入一个浮点数给整型变量会截断小数部分，只保留整数部分。同样，输入一个整数给实型变量是允许的。

综上所述，选项D是不正确的，因为在实际操作中，输入的数值类型不一定严格与变量类型匹配。

29.已知字母A的ASCII码为十进制数65，且 c2为字符型，则执行语句c2=‘A’+‘6’-‘3’后，c2中的值为()。
A)D B)68 C)不确定的值 D)c

正确答案是：A)D

解析：

为了求出表达式c2 = 'A' + '6' - '3'的结果，我们需要按照以下步骤进行计算：

了解字符的ASCII值：
- 'A'的ASCII值是65。
- '6'的ASCII值是54。
- '3'的ASCII值是51。

代入ASCII值进行计算：

c2 = 'A' + '6' - '3';

等价于：

c2 = 65 + 54 - 51;

进行加减法运算：

c2 = 65 + 54 - 51;
c2 = 119 - 51;
c2 = 68;

将结果68转换为字符：
- ASCII值为68的字符是'D'。

综上所述，执行语句`c2 = 'A' + '6' - '3'`后，`c2`中的值为`'D'`，因此正确答案是A)D。

30.sizeof(float)是( )。
A)一个双精度型表达式
B)一个整型表达式
C)一种函数表达式
D)一个不合法的表达式

正确答案是：B)一个整型表达式

解析：

选项分析：

A) 一个双精度型表达式：

错误。sizeof运算符返回的是数据类型或变量的字节大小，其结果类型是整型，不是双精度浮点型。

B) 一个整型表达式：

正确。sizeof运算符返回的是一个整数值，表示所测量的类型或对象所占用的字节数。对于sizeof(float)，它的返回值是一个整型常量。

C) 一种函数表达式：

错误。sizeof是一个运算符，而不是一个函数。它在编译时被处理，不会在运行时调用。

D) 一个不合法的表达式：

错误。sizeof(float)是一个合法的表达式，用于获取float类型所占的字节数。

综上所述，`sizeof(float)`是一个整型表达式，因此正确答案是B)一个整型表达式。

31.设有说明: char w; int x; float y; double z;则表达式w*x+z-y值的数据类型为( )。
A) float B) char C) int D) double
32.设以下变量均为int类型，则值不等于7的表达式是（）
A)(x=y=6,x+y,x+1)
B)(x=y=6,x+y,y+1)
C)(x=6,x+1,y=6,x+y)
D)(y=6,y+1,x=y,x+1)

给定表达式：w * x + z - y，其中 w 是 char 类型，x 是 int 类型，y 是 float 类型，z 是 double 类型。

类型转换：

在表达式中，C语言会根据运算符和操作数的类型来进行隐式类型转换，以确保表达式的正确性。
类型提升规则：

如果操作数中有 double 类型，则其他操作数会被提升为 double 类型。
如果操作数中有 float 类型，则其他操作数会被提升为 float 类型。
char 类型会被提升为 int 类型。
计算步骤：

w * x：w 是 char，x 是 int，因此 w 会被提升为 int，计算结果是 int 类型。
w * x + z：z 是 double，因此整个表达式会被提升为 double 类型。
w * x + z - y：y 是 float，因此整个表达式会被提升为 double 类型。
结论：

表达式 w * x + z - y 的值的数据类型是 double。
因此，答案是 D) double。

32.设以下变量均为int类型，则值不等于7的表达式是（）
A)(x=y=6,x+y,x+1)
B)(x=y=6,x+y,y+1)
C)(x=6,x+1,y=6,x+y)
D)(y=6,y+1,x=y,x+1)

我们将逐个检查每个选项，以确定哪些表达式的值不等于7。

选项分析：
A) (x = y = 6, x + y, x + 1)

执行顺序为：y 和 x 被赋值为6，然后计算 x + y 和 x + 1。
结果为：6 + 6 和 6 + 1，即 12 和 7。
包含结果 7，不符合条件。
B) (x = y = 6, x + y, y + 1)

执行顺序为：y 和 x 被赋值为6，然后计算 x + y 和 y + 1。
结果为：6 + 6 和 6 + 1，即 12 和 7。
包含结果 7，不符合条件。
C) (x = 6, x + 1, y = 6, x + y)

执行顺序为：x 被赋值为6，然后计算 x + 1 和 y 被赋值为6，然后计算 x + y。
结果为：6 + 1 和 6 + 6，即 7 和 12。
包含结果 7，不符合条件。
D) (y = 6, y + 1, x = y, x + 1)

执行顺序为：y 被赋值为6，然后计算 y + 1 和 x 被赋值为 y 的值6，然后计算 x + 1。
结果为：6 + 1 和 6 + 1，即 7 和 7。
不包含结果 7，符合条件。
结论：
根据以上分析，选项 D) (y = 6, y + 1, x = y, x + 1) 是唯一一个表达式，其值不等于7。

33.putchar函数可以向终端输出一个( )。
A)整型变量表达式
B)实型变量值
C)字符串
D)字符或字符型变量值

putchar 函数用于向终端输出一个字符或字符型变量值，因此正确答案是：

D) 字符或字符型变量值

解析：
putchar 函数是C标准库中的函数，其作用是输出一个字符到标准输出设备（通常是终端或控制台）。
它接受一个 int 类型的参数，该参数可以是一个字符常量或字符型变量的值。
例如：

char ch = 'A';
putchar(ch); // 输出字符 'A'

34.阅读以下程序，当输入数据的形式为:25，13，10（注:表示回车），则正确的输出结果为( )。
main()
{
int x,y,z;
scanf(“%d%d%d”,&x,&y,&z);
printf(“x+y+z=%din”,x+y+z);
}
A)x+y+7=48
B)x+y+z=35
C) x+z=35
D)不确定值

main() {
int x, y, z;
scanf(“%d%d%d”, &x, &y, &z);
printf(“x+y+z=%din”, x + y + z);
}
根据输入数据形式为 25，13，10（其中表示回车），我们分析如下：

scanf 函数：

scanf(“%d%d%d”, &x, &y, &z); 会将输入的数字分别赋值给变量 x、y、z。
因此，x 的值为 25，y 的值为 13，z 的值为 10。
printf 函数：

printf(“x+y+z=%din”, x + y + z);
替换变量后，变成 printf(“x+y+z=%din”, 25 + 13 + 10);
计算结果为 printf(“x+y+z=48in”);
选项分析：

A) x+y+7=48：这个选项中多出了一个 7，不符合实际的计算结果。
B) x+y+z=35：这个选项中的计算结果和正确的计算结果不一致。
C) x+z=35：这个选项只计算了 x 和 z 的和，没有加上 y 的值。
D) 不确定值：这个选项表示输出结果不确定，但根据我们的分析，输出结果应该是确定的。
综上所述，正确的输出结果应该是：
A) x+y+7=48

第一章复习

1.C语言的基本数据类型有

C语言的基本数据类型有：整型（int）、浮点型（float、double）、字符型（char）、枚举型（enum）、结构体（struct）、联合体（union）和指针型（）。
整型：如 char（1字节）、short（2字节）、int（通常为4字节）、long（通常为4或8字节）、long long（8字节），用于表示整数。
浮点型：如 float（4字节）、double（8字节）、long double（通常为8或16字节），用于表示浮点数。
字符型：char，用于表示单个字符。
枚举型：enum，用于定义一组具有离散取值的常量。
布尔型：bool（在某些编译器中作为扩展支持，用于表示真或假的值）。
指针型：，用于存储变量的内存地址。
数组型：用于存储相同类型数据的集合。
结构体：struct，用于定义一种包含不同数据类型成员的复合数据类型。
联合体：union，用于定义一种可以存储不同数据类型的数据结构，但只能同时存储其中的一种数据类型。

2.实数473.468写成规范化指数形式，则应为

实数473.468写成规范化指数形式，则应为 4.73468e2 或 4.73468E2（E和e在指数形式中是等价的）。

3.语句printf(“\106”)执行的结果输出是

在C语言中，\ 是一个转义字符的开始。当 \ 后面跟着一个或多个数字（通常是八进制数，但也可以是其他形式的转义序列，如 \n 表示换行）时，这些数字表示一个字符的ASCII码或者说是一个字符的另一种表示方式。

在这个例子中，\106 是一个八进制转义序列。八进制数 106 转换为十进制是 6 * 8^1 + 0 * 8^0 = 8 + 0 = 86。但是，这里有一个常见的误解需要注意：在C语言的字符常量中，八进制转义序列实际上表示的是该数值对应的ASCII字符，而不是直接将该数值作为字符的ASCII码值。

然而，在这个特定的情况下，由于ASCII码表中十进制86对应的字符正好是 F（大写字母F的ASCII码是70，但这里显然是一个误解，因为八进制106实际上等于十进制的70，而不是86），但重要的是理解转义序列 \106 如何工作，并且知道它实际上表示的是ASCII码为70的字符，即 F。

因此，printf(“\106”) 的输出结果是 F。

注意：上面的解释中关于ASCII码86的部分是一个误导，因为八进制106转换为十进制是70，而ASCII码70对应的字符是 F。这里主要是为了澄清转义序列的工作方式，并指出原始答案中关于ASCII码86的部分是不准确的。

转义序列的使用
转义序列以反斜杠 \ 开头，后跟一个或多个字符，用于表示特殊字符或控制字符。例如：

\n 表示换行。 \t 表示水平制表符。 \ 表示反斜杠字符本身。 \ddd 和 \xhh 分别用于表示八进制和十六进制字符常量。在
printf 函数中，转义序列用于在输出中包含这些特殊字符或控制字符。

八进制字符常量 \ddd
在C语言中，\ddd 用于表示一个八进制（base-8）的字符常量，其中 d 是一个八进制数字（0-7）。整个 \ddd 序列被视为一个单一的字符，其ASCII码值等于给定的八进制数。例如：

\10 表示八进制数10，转换为十进制是8，对应的ASCII字符是退格符（Backspace），但在大多数情况下，它不会作为可见字符输出。
\07 也表示退格符，因为八进制7等于十进制7，但通常我们不会这样写，因为 \7 就足够了（虽然 \7 实际上会被解析为八进制7，但为了避免混淆，通常会用完整的三位数来表示八进制字符常量，特别是当值小于8时）。
\141 表示八进制数141，转换为十进制是97，对应的ASCII字符是小写字母’a’。
注意：虽然 \ddd 可以用来表示字符常量，但这里的 d 必须是八进制数字（0-7）。如果包含8或9，那么它就不再是有效的八进制转义序列，而是可能导致编译错误或未定义行为。

十六进制字符常量 \xhh
与八进制类似，\xhh 用于表示一个十六进制（base-16）的字符常量，其中 h 是一个十六进制数字（0-9, a-f, A-F）。整个 \xhh 序列也被视为一个单一的字符，其ASCII码值等于给定的十六进制数。例如：

\x41 表示十六进制数41，转换为十进制是65，对应的ASCII字符是大写字母’A’。
\x6f 表示十六进制数6f，转换为十进制是111，对应的ASCII字符是小写字母’o’。
\x0a 表示十六进制数0a，转换为十进制是10，对应的ASCII字符是换行符（Line Feed）。
十六进制转义序列提供了一种方便的方式来表示ASCII字符集中的字符，特别是那些不可见的控制字符或具有特殊含义的字符。

总结
\ddd 用于表示八进制字符常量。
\xhh 用于表示十六进制字符常量。
在这两种情况下，整个转义序列都被视为一个单一的字符。
注意转义序列中的数字必须与其基数（八进制或十六进制）相匹配，否则可能导致编译错误或未定义行为。

4.C语言中，其值可被改变的量成为变量，它具有三个基本要素：

C语言中，其值可被改变的量称为变量，它具有三个基本要素：变量名、变量类型、变量值。
变量名：用于标识变量的唯一名称。
变量类型：决定变量可以存储的数据类型。
变量值：存储在变量中的实际数据。

C语言程序开发到执行通常要经过六个阶段，即编辑、预处理、、链接、加载和执行

C语言程序开发到执行通常要经过六个阶段，即编辑、预处理、编译、链接、加载和执行
编辑：编写程序代码。
预处理：处理预处理器指令，如包含头文件、宏定义等。
编译：将源代码编译成目标代码（通常是机器代码或中间代码）。
链接：将多个目标代码文件（可能包括库文件）链接成一个可执行文件。
加载：将可执行文件加载到内存中，准备执行。
执行：在操作系统上运行程序

6.表达式(int)(13.7+25.6)/4%5的值是

为了计算表达式 (int)(13.7 + 25.6) / 4 % 5 的值，我们需要按照C语言的运算优先级和类型转换规则逐步执行：

加法运算：首先计算 13.7 + 25.6，结果为 39.3。
类型转换：接着，(int)(13.7 + 25.6) 将加法运算的结果 39.3 转换为整型。由于 int 类型的变量不能存储小数部分，因此 39.3 被截断为 39。
除法运算：然后，39 / 4 执行整数除法，结果为 9（因为整数除法会丢弃余数）。
取模运算：最后，9 % 5 执行取模运算，即求 9 除以 5 的余数，结果为 4。
综上所述，表达式 (int)(13.7 + 25.6) / 4 % 5 的值是 4。

7.若有定义char ch1= ’A ’,ch2,ch3;执行ch2=ch1++; ch3=++ch1;printf(“ch1=%c,ch2=%c”,ch1,ch2);则输出为

若有定义char ch1=‘A’,ch2,ch3;执行ch2=ch1++; ch3=++ch1; printf(“ch1=%c,ch2=%c”,ch1,ch2);则输出为ch1=C,ch2=B。这是因为ch1++是后缀递增，先返回ch1的当前值（‘A’），然后ch1自增为’B’。而++ch1是前缀递增，先使ch1自增为’C’，然后返回新的值’C’。但是，printf语句只打印了ch1和ch2，所以输出是ch1=C,ch2=B

8.以下的输出结果是 main() { char c= ‘x’; printf("c:dec=%d,oct=%o,hex=%x,ASCII=%c\n”,c,c,c,c); }

c:dec=120,oct=1
char c = ‘x’;：这一行声明了一个char类型的变量c，并将其初始化为字符’x’。在ASCII码表中，‘x’的十进制值是120。
printf(“c:dec=%d, oct=%o, hex=%x, ASCII=%c\n”, c, c, c, c);：这一行使用printf函数来格式化输出变量c的多种表示形式。
%d：以十进制形式输出c的值，即120。
%o：以八进制形式输出c的值。因为120的八进制表示是170（18^2 + 78^1 + 08^0 = 120），所以这里会输出170。
%x：以十六进制形式输出c的值。因为120的十六进制表示是78（716^1 + 8*16^0 = 120），所以这里会输出78。注意，十六进制输出时，字母a到f通常是小写的，但具体取决于编译器和/或系统的设置。
%c：以字符形式输出c的值，即’x’

9.设有: int a=1,b=2,c=3,d=4,m=2,n=2;执行(m=a>b)&&(n=c>d)后n的值为

首先，a>b 的值为假（因为 1 不大于 2），所以 m=a>b 的结果是 m=0。

由于 && 运算符的左侧表达式的结果为假（0），C语言中的短路行为会阻止对右侧表达式 n=c>d 的评估。因此，n 的值不会被改变。

所以，执行完 (m=a>b)&&(n=c>d) 后，n 的值仍然是 2。

总结：n 的值为 2。

选择题

1.设有程序段int k=10;while(k==O) k=k-1;这下面描述中正确的是( )
a)while循环执行10次
b)循环是无限循环
c)循环体语句一次也不执行
d)循环体语句执行一次
答案：c) 循环体语句一次也不执行

解析：因为 k 的初始值为 10，而循环条件是 k==0，显然不满足循环条件，所以循环体一次也不执行。

相关知识点：while 循环的执行条件是循环开始前进行判断，如果条件为真则执行循环体，然后再次判断条件，直到条件为假时退出循环。

2.进入循环语句 while(!E);中的表达式!E等价于( )
a)E = =0 b)E!=1
c)E!=O d)E==1

答案：a) E==0

解析：!E 是对 E 的逻辑非操作，当 E 为 0（即假）时，!E 为真；当 E 非 0（即真）时，!E 为假。因此，!E 等价于 E==0。

相关知识点：逻辑非操作符 !，它将真变为假，假变为真。

3.下面程序段的运行，循环次数为( )
int n=O;
while(n++<=2)
printf(“%d”,n);
a)2 b)3 c)4 d)有语法错

答案：b) 3

解析：循环开始时 n 为 0，第一次循环后 n 变为 1，打印 1；第二次循环后 n 变为 2，打印 2；第三次循环后 n 变为 3，但此时
n++ 后为 4，不满足 n<=2 的条件，所以退出循环。总共打印了 3 次。

相关知识点：后增操作符 ++ 的使用及其优先级。

4.下面程序的运行结果是( )
#include<stdio.h>
main()
{
int num=O;
while(num<=2)
{
num++;
printf(“%d\n”,num);
}
}
a)1 b)1 c)1 d)1
2 2 2
3 3
4

答案：b) 1 2 3

解析：程序从 num=0 开始，循环条件是 num<=2，每次循环 num 自增 1 并打印。因此，打印的结果是 1 2 3。

相关知识点：循环条件与自增操作。

5.以下程序段( )
int x=-1;
do{
x=x*x;
} while(!x);
a)是死循环 b)循环执行二次 c)循环执行一次 d)有语法错误

答案：c) 循环执行一次

解析：x 初始值为 -1，进入 do-while 循环后，x 被赋值为 x*x 即 1，然后判断 !x 为假（因为 x 是
1），所以退出循环。

相关知识点：do-while 循环的执行流程，逻辑非操作符 !。

6.若有如下语句
int x=3;
do{
printf(“%d\n”,x-=2);
}while(!(–x));
则上面程序段( )
a)输出的是1
b)输出的是1和-2
c)输出的是3和0
d)是死循环

答案：b) 输出的是1和-2

解析：首先 x 是 3，进入 do-while 循环，打印 x-=2 即 1，然后 --x 变为 0，!(–x)
为真，继续循环；第二次循环中，x 已经是 0，打印 x-=2 即 -2，然后 --x 变为 -1，!(–x) 为假，退出循环。

相关知识点：do-while 循环，前缀和后缀自减操作符 – 的区别。

7.下面程序的运行结果是( )
#include<stdio.h>
main()
{
int y=10;
do{
y–;
}while(–y);
printf(“%d\n”,y–);
}
a)-1 b)1 c)8 d)O

答案：d) 0
解析：y 初始值为 10，进入 do-while 循环，循环条件是 --y（先减 1 再判断），因此第一次循环时 y 变为 9，循环继续；第二次循环时 y 变为 8，继续循环；直到 y 变为 0 时，–y 为 -1，条件为假，退出循环。最后打印 y-- 的结果，但此时 y 已经是 -1，所以打印的是 0（因为 y-- 是先取值后减）。

相关知识点：do-while 循环，前缀自减操作符 --。

8.若i为整型变量，则以下循环执行次数是( )
for(i=2;i==O;)
printf(“%d”,i–);
a)无限次 b)O次 c)1次 d)2次

答案：b) 0次

解析：循环条件是 i==0，但 i 的初始值是 2，不满足循环条件，所以循环体一次也不执行。

相关知识点：for 循环的执行条件。

9.执行语句for(i=1;i++<4;);后变量i的值是( )
a)3 b)4 c) 5 d)不确定

答案：c) 5

解析：for 循环的初始化部分 i=1，条件部分 i++<4（先判断后自增），循环体为空。循环结束时，i 的值会是 5（因为当 i 为 4
时，条件为真，执行空

10.以下正确的描述是( )
a)continue语句的作用是结束整个循环的执行
b)只能在循环体内和switch 语句体内使用break语句
c)在循环体内使用break语句或continue语句的作用相同
d)从多层循环嵌套中退出时，只能使用goto 语句

答案：b) 只能在循环体内和switch 语句体内使用break语句

解析： a) continue 语句的作用是结束当前循环的剩余部分，并开始下一次循环的迭代，而不是结束整个循环的执行。 b)
正确。break 语句确实只能用在循环体（如 for、while、do-while）和 switch 语句体内，用于立即退出这些结构。 c)
break 和 continue 在循环体内的作用不同。break 用于退出循环，而 continue
用于跳过当前循环的剩余部分并继续下一次迭代。 d) 从多层循环嵌套中退出时，虽然 goto
语句可以作为一种选择，但通常不推荐使用，因为它可能导致代码难以理解和维护。更常见的做法是使用循环的嵌套结构和 break
语句配合标签（label）来退出多层循环。

11.有以下程序
main()
{
char b,c; int i;
b=‘a’; c=‘A’;
for(i=0;i<6;i++)
{
if(i%2)
putchar(i+b);
else
putchar(i+c);
}
printf(“\n”);
}
程序运行后的输出结果是( )
A)ABCDEF B)AbCdEf C)aBcDeF D)abcdef

答案：C) aBcDeF

解析：程序遍历了 i 从 0 到 5 的范围。在每次迭代中，它检查 i 是否为奇数（i%2 结果为 1 表示奇数）。如果是奇数，它打印 i + b（其中 b = ‘a’），否则打印 i + c（其中 c = ‘A’）。

当 i = 0（偶数），打印 i + c = 0 + ‘A’ = ‘A’ 当 i = 1（奇数），打印 i + b = 1 + ‘a’ = ‘b’ 当 i = 2（偶数），打印 i + c = 2 + ‘A’ = ‘C’ 当 i = 3（奇数），打印 i + b = 3 + ‘a’ = ‘d’ 当 i = 4（偶数），打印 i + c = 4 + ‘A’ = ‘E’ 当 i = 5（奇数），打印 i + b = 5 + ‘a’ = ‘f’ 因此，输出是 AbCdEf，但选项中的大写字母是误导，实际上输出的是小写的字母（因为字符 ‘a’ 和 ‘A’ 被用作基数进行加法运算），所以正确答案是 C) aBcDeF（注意选项中的大小写）。然而，如果严格按照程序输出字符的 ASCII值来看，输出确实是小写的 aBcDeF，但在这个上下文中，我们假设选项的 C 是指实际的输出内容，而不是字符的大小写

。
【程序填空】
1.下面程序段是从键盘输入的字符中统计数字字符的个数，用换行符结束循环。请填空。
int n=0,c;
c=getchar();
while( )
{
if( )
n++;
c=getchar();

int n=0,c;  
c=getchar();  
while(c!='\n')  // 当输入不是换行符时继续循环  
{  
    if(c>='0' && c<='9')  // 如果字符是数字  
        n++;  
    c=getchar();  
}

2.下面程序的运行结果是( )
#include <stdio.h>
main()
{
int a,s,n,count;
a=2;s=O;n=1;count=1;
while(count<=7){
n=n*a;
s=s+n;
++count;
}
printf(“s=%d”,s);
}

#include <stdio.h>  
main()  
{  
    int a,s,n,count;  
    a=2;s=0;n=1;count=1;  // 注意s的初始值应该是0而不是O，这里假设是笔误  
    while(count<=7){  
        n=n*a;  
        s=s+n;  
        ++count;  
    }  
    printf("s=%d",s);  // 输出s的值，根据循环计算，s=2+4+8+16+32+64+128=254  
}  
// 运行结果是：s=254

3.下面程序段的运行结果是( )
i=1;a=O;s=1;
do{
a=a+s*i;
s=-s;
i++;
}while(i<=10);
printf(“a=%d”,a);

i=1;a=0;s=1;  
do{  
    a=a+s*i;  
    s=-s;  
    i++;  
}while(i<=10);  
printf("a=%d",a);  // 根据循环，计算a的值：a=1*1-2*2+3*3-4*4+5*5-6*6+7*7-8*8+9*9-10*10 = 1-4+9-16+25-36+49-64+81-100 = 55  
// 运行结果是：a=55

4.下面程序段的运行结果是( )
i=1;s=3;
do{
s+=i++;
if(s%7==0)
continue;
else ++i;
} while(s<15);
printf(“%d”,i);

i=1;s=3;  
do{  
    s+=i++;  
    if(s%7==0)  
        continue;  // 如果s是7的倍数，则跳过接下来的++i;  
    else  
        ++i;  // 如果s不是7的倍数，i再增加1  
} while(s<15);  
printf("%d",i);  // 循环结束后，i的值是7（因为s在i=7时达到15，此时s=15，不满足循环条件）  
// 注意：由于continue语句的存在，当s=7时，i只增加了1次（从6到7），然后循环结束  
// 运行结果是：7

程序阅读题

#include<stdio.h>  
int main(){  
    char ch1='a', ch2='B', ch3='E';  
    if(ch1 > ch2)  
        if(ch2 > ch3)    
            ch3++;  
        else   
            --ch3;  
    printf("ch3=%c\n", ch3);  
    return 0;  
}

现在来分析这个程序的行为：

字符 a, B, 和 E 在 ASCII 码表中的值分别是 97, 66, 和 69。
首先，比较 ch1（值为 97）和 ch2（值为 66）。因为 97 > 66，所以第一个 if 条件为真。
然后，进入第二个 if 语句，比较 ch2（值为 66）和 ch3（值为 69）。因为 66 < 69，所以第二个 if 条件为假，执行 else 分支，即 ch3–。
因此，ch3 的值从 ‘E’（ASCII 码 69）减少到 ‘D’（ASCII 码 68）。
最后，打印 ch3 的值，即 ‘D’。
所以，程序的输出是：ch3=D

#include<stdio.h>  
  
int main(){  
    char ch1='A', ch2='B'; // 使用英文单引号  
  
    switch(ch1){  
        case 'A': // 使用英文单引号  
            switch(ch2){  
                case 'B': // 使用英文单引号  
                    printf("Good！\n"); // 如果需要输出中文，这里没问题，但注意通常是英文输出环境  
                    break;  
                case 'A': // 这通常不会执行，因为ch2是'B'，但保留以展示结构  
                    printf("Better!\n");  
                    break;  
            }  
            break; // 在内层switch结束后，需要添加break来防止进入外层switch的下一个case  
        case 'B': // 这个case通常不会执行，因为ch1是'A'，但保留以展示结构  
            printf("Best!\n");  
            break;  
    }  
    return 0;  
}

由于 ch1 的值是 ‘A’，所以只有外层 switch 的 ‘A’ 分支会被执行。在内层的 switch 中，由于 ch2 的值是 ‘B’，所以只会执行 case ‘B’: 下的 printf(“Good！\n”); 语句。

输出将会是：Good！
请注意，虽然 switch 语句中的 case ‘A’:（内层和外层都有）在逻辑上对于 ch2 来说是多余的（因为 ch2 是 ‘B’），但它们被保留在这里以展示 switch 语句的结构和如何嵌套使用。在实际应用中，您应该只包含必要的 case 分支。

#include <stdio.h>  
int main()  
{  
    int i = 1, a = 2;  
    if (i == 0)  
        printf("**");  
    else  
        printf("$$");  
    printf("*");  
    return 0;  
}

变量 i 被初始化为 1，a 被初始化为 2，但 a 在这个特定的程序段中没有被使用。
if (i == 0) 检查 i 是否等于 0。由于 i 的值是 1，这个条件为假。
因此，程序执行 else 分支，打印出 `"
"‘。−然后，不管‘if−else‘结构的结果如何，‘printf(“∗”);‘都会被执行，因此‘“∗”‘也会被打印出来。∗

#include <stdio.h>  
  
int main() { // 修改主函数的返回类型为int  
    int m = 10, n = 0, p = 4, q = 20;  
    if (m) { // 由于m非0，这个条件为真  
        if (n) { // 但n为0，所以这个条件为假  
            q = 15 - m; // 这个分支不会执行  
        } else {  
            q = 25 + m; // 这个分支会执行，因为n为0  
        }  
    } else if (p) { // 由于m非0，这个else if实际上永远不会执行  
        q = q + p;  
    }  
    printf("q= %d\n", q); // 注意使用英文双引号  
    return 0; // 添加返回语句  
}

现在，让我们解释程序的逻辑和输出：

变量m、n、p、q分别被初始化为10、0、4、20。
if (m)条件为真（因为m非0），所以执行它下面的代码块。
在这个代码块中，if (n)条件为假（因为n为0），所以执行else分支，即q = 25 + m;。
由于m的值为10，所以q被更新为25 + 10 = 35。
else if §这个条件实际上永远不会执行，因为if (m)已经为真，并且已经执行了它的代码块。
最后，程序打印出q的值，即35。
因此，程序的输出将是：q= 35

weixin_45958231

关注

28
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
c语言--第二章练习题

预处理：处理预处理指令，生成扩展名为.i的文件。编译：将预处理后的文件翻译成汇编代码，生成扩展名为.s的文件。汇编：将汇编代码翻译成机器代码，生成扩展名为.o的目标文件。链接：将目标文件和库文件结合起来，生成可执行文件。执行：运行生成的可执行文件。每个步骤都可以使用GCC编译器的不同选项进行单独操作，以便更好地理解和调试程序。
复制链接

扫一扫