更多资料下载链接如下

需要全套资料的请私信作者

第1章 程序设计和C语言

1.1 考试内容

1.C语言的简史与特点；
2.简单的C程序结构；
3.程序的编辑、编译、链接和运行。
1.2 基本要求
1.掌握Ｃ程序的一般书写形式；
2.掌握Ｃ程序编辑、编译、链接、调试和执行的基本过程。
1.3 主要知识点

一、计算机程序

1.程序就是一组计算机能识别和执行的指令
2.计算机的一切操作都是由程序控制的

二、计算机语言

1.定义
人和计算机交流信息，要解决语言问题。需要创造一种计算机和人都能识别的语言，这就是计算机语言。
2.发展阶段
计算机语言经历了几个发展阶段:
(1)机器语言
(2)符号语言
(3)高级语言

三、C语言的发展及其特点

1.概述
(1) C语言是国际上广泛流行的计算机高级语言。
(2) C语言的祖先是BCPL语言。
2.发展
最初的C语言只是为描述和实现UNIX操作系统提供-种工作语言而设计的，后来逐步发展为一种高级编
程语言，目前C语言使用的标准是1999年修正的C99。
3.特点
(1)语言简洁、紧凑，使用方便、灵活
(2)运算符丰富
(3)数据类型丰富
(4)具有结构化的控制语句
(5)语法限制不太严格，程序设计自由度大
(6)C语言允许直接访问物理地址
(7)用C语言编写的程序可移植性好
(8)生成目标代码质量高，程序执行效率高

四、简单的C语言程序

(1)一个程序由一个或多个源程序文件组成
在一个源程序文件中可以包括3个部分:
①预处理指令
②全局声明
③函数定义
(2)函数是C程序的主要组成部分
①函数是C程序的基本单位。
②一个C语言程序是由一个或多个函数组成的，有且仅有一个main函数。
③一个小程序只包含-一个源程序文件。
④函数既可以是库函数，也可以是用户自定义函数。
(3)函数的两个部分
①函数首部
函数首部包括函数名、函数类型、函数属性、函数参数(形式参数)名、参数类型。
②函数体
即函数首部下面的花括号内的部分。函数体一般包括两部分:声明部分和执行部分。.
(4)程序总是从main函数开始执行的
(5)程序中对计算机的操作是由函数中的C语句完成的
(6)在每个数据声明和语句的最后必须有一个分号
(7)C语言本身不提供输入输出语句
(8)程序应当包含注释

五、运行C程序的步骤与方法

C程序运行步骤图如图1-1所示。其中实线表示操作流程，虚线表示文件的输入输出。

六、程序设计的任务

程序设计是指从确定任务到得到结果、写出文档的全过程。从确定问题到最后完成任务，一般经历以下几个
工作阶段:
1.问题分析
2.设计算法
3.编写程序
4.对源程序进行编辑、编译和连接，得到可执行程序
5.运行程序，分析结果
6.编写程序文档

1.4 练习题库

选择题
1 构成C程序的三种基本结构是（ ）。
A．顺序结构、转移结构、递归结构
B．顺序结构、嵌套结构、递归结构
C．顺序结构、选择结构、循环结构
D．选择结构、循环结构、嵌套结构

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

3 以下叙述中错误的是（ ）。
A．C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令
B．C程序经过编译、链接步骤之后才能形成一个真正可执行的二进制机器指令文件
C．用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中
D．C语言源程序经编译后生成后缀为.obj的目标程序

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

5 以下叙述正确的是（ ）。
A．C编译程序把文件后缀为.c的源程序文件编译成文件后缀为.obj的二进制文件
B．C编译程序把文件后缀为.c的源程序文件编译成文件后缀为.exe的可执行文件
C．C编译程序把文件后缀为.obj的二进制文件编译成文件后缀为.exe的可执行文件
D．链接程序把文件后缀为.c的源程序文件链接成文件后缀为.exe的可执行文件

6 计算机能直接执行的程序是（ ）。
A．源程序
B．目标程序
C．汇编程序
D．可执行程序

7 针对简单程序设计，以下叙述的实施步骤正确的是（ ）。
A．确定算法和数据结构、编码、调试、整理文档
B．编码、确定算法和数据结构、调试、整理文档
C．整理文档、确定算法和数据结构、编码、调试
D．确定算法和数据结构、调试、编码、整理文档

8 以下叙述中正确的是（ ）。
A．程序设计的任务就是编写程序代码并上机调试
B．程序设计的任务就是确定所用数据结构
C．程序设计的任务就是确定所用算法
D．以上三种说法都不完整

9 以下叙述中错误的是（ ）。
A．C程序在运行过程中所有计算都以十进制方式进行
B．C程序在运行过程中所有计算都以二进制方式进行
C．所有C程序都需要编译链接无误后才能运行
D．C程序中字符变量存放的是字符的ASCII值

10 关于程序设计基本概念，以下叙述错误的是（ ）。
A．计算机可以直接执行由任意高级语言编写的程序
B．高级语言都有与之对应的编译程序或解释程序
C．用任何一种计算机高级语言都可以把算法转换为程序
D．结构化算法可以解决任何复杂的问题

11 以下关于算法的叙述中错误的是（ ）。
A．算法可以用伪代码、流程图等多种形式来描述
B．一个正确的算法必须有输入
C．一个正确的算法必须有输出
D．用流程图可以描述的算法可以用任何一种计算机高级语言编写成程序代码

12 以下叙述中错误的是（ ）。
A．算法正确的程序最终一定会结束
B．算法正确的程序可以有零个输出
C．算法正确的程序可以有零个输入
D．算法正确的程序对于相同的输入一定有相同的结果

13 以下选项中叙述正确的是（ ）。
A．C程序中的语句要经过编译才能转换成二进制机器指令
B．算法需要包含所有三种基本结构
C．有些算法不能用三种基本结构来表达
D．简单算法的操作步骤不能超过20步

14 流程图是描述算法的很好的工具，一般的流程图中由几种基本图形组成。其中判断框的图形是（）。
A．菱形
B．长方形
C．平行四边形
D．椭圆型

15 C语言主要是借助以下（ ）功能来实现程序模块化的。
A．定义函数
B．定义常量和外部变量
C．三种基本结构语句
D．丰富的数据类型

16 以下选项中叙述正确的是（ ）。
A．结构化程序的三种基本结构是循环结构、选择结构、顺序结构
B．C语言源程序不编译也能直接运行
C．使用N-S流程图不能描述复杂算法
D．计算机能够直接运行C语言源程序，不必进行任何转换

17 以下选项中关于程序模块化的叙述错误的是（ ）。
A．把程序分成若干相对独立的模块，可便于编码和调试
B．把程序分成若干相对独立、功能单一的模块，可便于重复使用这些模块
C．可采用自底向上、逐步细化的设计方法把若干独立模块组装成所要求的程序
D．可采用自顶向下、逐步细化的设计方法把若干独立模块组装成所要求的程序

18 以下关于结构化程序设计的叙述中正确的是（ ）。
A．一个结构化程序必须同时由顺序、分支、循环三种结构组成
B．结构化程序使用goto语句会很便捷
C．在C语言中，程序的模块化是利用函数实现的
D．由三种基本结构构成的程序只能解决小规模的问题

19 以下叙述中错误的是（ ）。
A．使用三种基本结构构成的程序只能解决简单问题
B．结构化程序由顺序、分支、循环三种基本结构组成
C．C语言是一种结构化程序设计语言
D．结构化程序设计提倡模块化的设计方法

20 以下叙述中正确的是（ ）。
A．在算法设计时，可以把复杂任务分解成一些简单的子任务
B．在C语言程序设计中，所有函数必须保存在一个源文件中
C．只要包含了三种基本结构的算法就是结构化程序
D．结构化程序必须包含所有的三种基本结构，缺一不可

21 以下选项中叙述正确的是（ ）。
A．使用三种基本结构就可以实现任何复杂算法
B．只要程序包含了三种基本结构中的任意一种，就是结构化程序
C．程序语法错误要在运行时才能发现
D．C语言程序不需要包含main( )函数

22 结构化程序由顺序、选择、循环三种基本结构组成，以下相关叙述错误的是（ ）。
A．三种基本结构不可以嵌套使用
B．顺序结构是按语句在程序中的先后顺序逐条执行，没有分支，没有转移
C．选择结构是根据不同的条件执行不同分支中的语句
D．循环结构是根据条件决定是否重复、重复执行多少次循环体语句

23 以下叙述错误的是（ ）。
A．在进行模块化程序设计的时候，应首先完成每个模块的编写调试，再集中考虑主程序中的算法
B．同一程序各模块可由不同人员同时进行编写调试，可提高编写程序的效率
C．模块化的程序设计是采用自顶向下、逐步细化的原则
D．程序的每个模块都可通过三种基本结构实现

1.5 考点必背

1. C语言编译程序的功能是把C源程序翻译成机器代码
2. C语言程序仅可以编译执行
3. C语言中的每条可执行语句最终都将被转换成二进制的机器指令
4. C程序经过编译、链接步骤之后才能形成一个真正可执行的二进制机器指令文件
5. 用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中
6. C语言源程序经编译后生成后缀为.obj的目标程序
7. C语言经过编译链接后的二进制目标代码可以脱离C语言集成开发环境独立运行
8. C语言的可执行程序是由一系列机器指令构成的
9. 用C语言编写的源程序不能直接在计算机上运行
10. 通过编译得到的二进制目标程序需要连接才可以运行
11. C编译程序把文件后缀为.c的源程序文件编译成文件后缀为.obj的二进制文件
12. 计算机能直接执行的程序是可执行程序
13. 对简单程序设计的实施步骤正确的是确定算法和数据结构、编码、调试、整理文档
14. 程序设计是指设计、编程、调试程序的方法和过程，通常分为4 个阶段：① 问题建模；② 算法设计；③ 编写代码；④ 编译调试。
15. C程序在运行过程中所有计算都以二进制方式进行
16. 所有C程序都需要编译链接无误后才能运行
17. C程序中字符变量存放的是字符的ASCII值
18. 一个正确的算法必须有输入（错）
19. 算法正确的程序可以有零个输出（错）
20. C程序中的语句要经过编译才能转换成二进制机器指令
21. 构成C程序的三种基本结构是顺序结构、选择结构、循环结构
22. C语言主要是借助以下定义函数功能来实现程序模块化的
23. 程序模块化：把程序分成若干相对独立的模块，可便于编码和调试；把程序分成若干相对独立、功能单一的模块，可便于重复使用这些模块；可采用自顶向下、逐步细化的设计方法把若干独立模块组装成所要求的程序。
24. 在算法设计时，可以把复杂任务分解成一些简单的子任务
25. 使用三种基本结构就可以实现任何复杂算法
26. 在进行模块化程序设计的时候，应首先完成每个模块的编写调试，再集中考虑主程序中的算法
27. C语言是一个函数式语言，有且仅有一个叫做“main” 的主函数。
28. 程序从“main”中开始，在“main”中结束。
29. 函数不能嵌套定义，可以嵌套使用(每个函数地位一样)。
30. 一个C语言由函数组成，用“;”作语句结束符。
31. 标识符是以字母或下划线开头的一串字母、 数字或下划线构成的序列;标识符
32. 大小写有区别，不能使用关键字。关键字共有32个(主要有: auto, break, case,char,continue,default, do, double, else, extern, float, for, if, int, long,returm,short，singed, sizeof, static， struct， switch, typedef, union， void, while)， 关键字均为小写，若为大写则为合法的标识符(如: Do是合法的)

第2章 算法–程序的灵魂

1.1 考试内容

1.算法的概念、算法的特性和算法的度量；
2.自然语言、流程图、N-S图、伪代码和计算机语言表达算法；
3.结构化程序设计方法。

1.2 基本要求

1.理解什么是算法、算法的特性和算法在时间和空间上的度量；
2.掌握算法的表达方法；理解结构化程序设计的基本思想。

1.3 主要知识点

一、程序=算法+数据结构

一个程序主要包括以下两方面的信息:
(1)对数据的描述，即数据结构( data structure)。
(2)对操作的描述，即算法(algorithm)。

二、算法概述

1.算法定义
广义地说，为解决一个问题而采取的方法和步骤，就称为“算法”。
2.算法分类
(1)数值运算算法，数值运算的目的是求数值解。
(2)非数值运算算法。

三、算法的特性

1.有穷性
一个算法应包含有限的操作步骤，而不能是无限的。
2.确定性
算法中的每一个步骤都应当是确定的，而不应当是含糊的、模棱两可的。
3.有零个或多个输入
输入是指在执行算法时需要从外界取得必要的信息。
4.有一个或多个输出
算法的目的是为了求解，“解”是指输出。
5.有效性
算法中的每一个步骤都应当能有效地执行，并得到确定的结果。

四、怎样表示一个算法

1.用自然语言表示算法
自然语言是指人们日常使用的语言，其特点是通俗易懂，但语义语法不严格，描述能力不足。
2. 用流程图表示算法
(1)概述
美国国家标准化协会ANSI规定了一些常用的流程图符号(如图2-1所示)，已为世界各国程序工作者普遍.
采用。

(2)流程图元素
①菱形框
菱形框的作用是对一个给定的条件进行判断,根据给定的条件是否成立决定如何执行其后的操作。它有一个
入口，两个出口，如图2-2所示。

②连接点
连接点(小圆圈)是用于将画在不同地方的流程线连接起来，如图2-3所示。

③注释框
注释框不是流程图中必要的部分,不反映流程和操作，只是为了对流程图中某些框的操作必要的补充说明，
以帮助阅读流程图的人更好地理解流程图的作用。
(3)流程图组成
①表示相应操作的框;
②带箭头的流程线;
③框内外必要的文字说明。
3.三种基本结构和改进的流程图
(1)传统流程图的弊端
传统的流程图用流程线指出各框的执行顺序，对流程线的使用没有严格限制。
(2)三种基本结构
①顺序结构
如图2-4所示，虚线框内是一个顺序结构。其中A和B两个框是顺序执行的。顺序结构是最简单的一种基
本结构。

②选择结构
选择结构又称选取结构或分支结构,如图2-5所示。虚线框内是一个选择结构，此结构中必包含一个判断框,
根据给定的条件P是否成立而选择执行A框或B框。

③循环结构
又称重复结构，即反复执行某一部分的操作，有两类循环结构，如图2-6所示。

(3)三种结构共同特点
①只有一个入口;
②只有一个出口;
③结构内的每一部分 都有机会被执行到;
④结构内不存在“死循环”。
基本结构并不一定只限于上面3种，只要具有上述4个特点的都可以作为基本结构。如图2-7为经典的
do…while循环结构、而图2-8为经典的switch选择结构。

4.用N-S流程图表示算法
(1)概述
在这种流程图中，完全去掉了带箭头的流程线。全部算法写在一个矩形框内，在该框内还可以包含其他从属于它的框，或者说，由一些基本的框组成一个大的框，这种流程图又称N-S结构化流程图。
(2) N-S流程图符号
①顺序结构
顺序结构用图2-9形式表示。A和B两个框组成-一个顺序结构。

②选择结构
选择结构用图2-10表示，其中p为判断条件。

③循环结构
当型循环结构用图2-11形式表示，当pi条件成立时反复执行A操作，直到pn条件不成立为止。

直到型循环结构用图2-12形式表示，先执行A操作，然后判断p:条件是否成立，如果p1不成立，反复执行
A，只当p1条件成立才停止循环。.

5.用伪代码表示算法
(1)概述
伪代码是用介于自然语言和计算机语言之间的文字和符号来描述算法。
(2)特点
①伪代码书写格式比较自由，容易表达出设计者的思想;
②用伪代码写的算法很容易修改;
③用伪代码很容易写出结构化的算法。
6.用计算机语言表示算法
用流程图或伪代码描述一个算法后,还要将它转换成计算机语言程序。用计算机语言表示的算法是计算机能够执行的算法，其必须严格遵循所用语言的语法规则。
五、结构化程序设计方法
1.基本思路:
结构化程序设计方法的基本思路是:把一个复杂问题的求解过程分阶段进行，每个阶段处理的问题都控制在
人们容易理解和处理的范围内。
2.结构化程序设计方法
(1)自顶向下
(2)逐步细化
(3)模块化设计
(4)结构化编码

1.4 练习题库

1 以下叙述中正确的是（ ）。
A．在C语言程序中，main函数必须放在其他函数的最前面
B．每个后缀为.c的C语言源程序都可以单独进行编译
C．在C语言程序中，只有main函数才可以单独进行编译
D．每个后缀为.c的C语言源程序都应该包含一个main函数

2 以下叙述中错误的是（ ）。
A．C语言编写的函数源程序，其文件名后缀可以是.c
B．C语言编写的函数都可以作为一个独立的源程序文件
C．C语言编写的每个函数都可以进行独立的编译并执行
D．一个C语言程序只能有一个主函数

3 以下叙述中错误的是（ ）。
A．一个C程序可以包含多个不同名的函数
B．一个C程序只能有一个主函数
C．C程序在书写时，有严格的缩进要求，否则不能编译通过
D．C程序的主函数必须用main作为函数名

4 以下叙述中正确的是（ ）。
A．C语言规定必须用main作为主函数名，程序将从此开始执行
B．可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行
C．C语言程序将从源程序中第一个函数开始执行
D．main的各种大小写拼写形式都可以作为主函数名，如：MAIN，Main等

5 下列叙述中错误的是（ ）。
A．C程序可以由一个或多个函数组成
B．C程序可以由多个程序文件组成
C．一个C语言程序只能实现一种算法
D．一个C函数可以单独作为一个C程序文件存在

6 下列叙述中错误的是（ ）。
A．C程序在运行过程中所有的计算都以二进制方式进行
B．C程序在运行过程中所有的计算都以十进制方式进行
C．所有的C程序都需要在连接无误后才能运行
D．C程序中整型变量只能存放整数，实型变量只能存放浮点数

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

9 下列叙述中正确的是（ ）。
A．每个C程序文件中都必须要有一个main函数
B．在C程序中main函数的位置是固定的
C．C程序中所有函数之间都可以相互调用
D．在C程序的函数中不能定义另一个函数

11 以下关于C语言的叙述中正确的是（ ）。
A．C语言中的注释不可以夹在变量名或关键字的中间
B．C语言中的变量可以在使用之前的任何位置进行定义
C．在C语言算术表达式的书写中，运算符两侧的运算数类型必须一致
D．C语言的数值常量中夹带空格不影响常量值的正确表示

12 以下叙述中正确的是（ ）。
A．C程序的基本组成单位是语句
B．C程序中的每一行只能写一条语句
C．简单C语句必须以分号结束
D．C语言必须在一行内写完

13 以下选项中叙述正确的是（ ）。
A．函数体必须由{开始
B．C程序必须由main语句开始
C．C程序中的注释可以嵌套
D．C程序中的注释必须在一行完成

14 以下叙述中正确的是（ ）。
A．C程序中的注释只能出现在程序的开始位置和语句的后面
B．C程序书写格式严格，要求一行内只能写一个语句
C．C程序书写格式自由，一个语句可以写在多行上
D．用C语言编写的程序只能放在一个程序文件中

15 以下叙述中错误的是（ ）。
A．书写风格良好的程序执行效率高
B．书写风格良好的程序易读性好
C．C程序可以在一行上写多条语句
D．C程序允许将一条语句分写在多行上

17 有以下程序

#include <stdio.h>
main()
{ int a=0,b=0; /*给a赋值a=10; b=20;给b赋值*/printf("a+b=%d\n",a+b);/*输出计算结果*/ 
}

程序运行后的输出结果是（ ）。
A．a+b=0
B．a+b=30
C．a+b=10
D．出错

18 关于C语言的变量名，以下叙述正确的是（ ）。
A．变量名不可以与关键字同名
B．变量名不可以与预定义标识符同名
C．变量名必须以字母开头
D．变量名是没有长度限制的

19 以下选项中叙述正确的是（ ）。
A．C语言的标识符可分为关键字、预定义标识符和用户标识符三类
B．C语言的标识符可分为语句、变量和关键字三类
C．C语言的标识符可分为函数名、变量和预定义标识符三类
D．C语言的标识符可分为运算符、用户标识符和关键字三类

21 关于C语言标识符，以下叙述错误的是（ ）。
A．标识符可全部由数字组成
B．标识符可全部由下划线组成
C．标识符可全部由小写字母组成
D．标识符可全部由大写字母组成

22 按照C语言规定的用户标识符命名规则，不能出现在标识符中的是（ ）。
A．大写字母
B．连接符
C．数字字符
D．下划线

23 以下C语言用户标示符中，不合法的是（ ）。
A．_1
B．AaBc
C．a_b
D．a–b

24 以下选项中，能用作用户标识符的（ ）。
A．void
B．8_8
C．0
D．unsigned

28 下列定义变量的语句中错误的是（ ）。
A．double int_;
B．float US$;
C．char For;
D．int _int;

29 以下叙述中错误的是（ ）。
A．非零的数值型常量有正值和负值的区分
B．常量是在程序运行过程中值不能被改变的量
C．定义符号常量必须用类型名来设定常量的类型
D．用符号名表示的常量叫符号常量

31 以下选项中不能用作C程序合法常量的是（ ）。
A．1,234
B．“\123”
C．123
D．“\x7D”

32 以下选项中能表示合法常量的是（ ）。
A．整数：1,200
B．实数：1.5E2.0
C．字符斜杠：‘’
D．字符串：“\007”

33 以下选项中不能作为C语言合法常量的是（ ）。
A．‘cd’
B．0.1e+6
C．“a”
D．‘\011’

34 以下选项中，合法的C语言常量是（ ）。
A．1.234
B．‘C++’
C．"\2.0
D．2Kb

35 以下选项中，能用作数据常量的是（ ）。
A．115L
B．0118
C．1-5e1.5
D．o115

38 以下选项中正确的定义语句是（ ）。
A．double a;b;
B．double a=b=7;
C．double a=7,b=7;
D．double,a,b;

40 以下关于C语言数据类型使用的叙述中错误的是（ ）。
A．若只处理“真”和“假”两种逻辑值，应使用逻辑类型
B．若要保存带有多位小数的数据，可使用双精度类型
C．若要处理如“人员信息”等含有不同类型的相关数据，应自定义结构体类型
D．整数类型表示的自然数是准确无误差的

51 若函数中有定义语句：
int k;
则（ ）。
A．系统将自动给k赋初值0
B．这时k中的值无定义
C．系统将自动给k赋初值-1
D．这时k中无任何值

52 有以下程序
#include<stdio.h>
main()
{
int s,t,A=10;
double B=6;
s=sizeof(A);
t=sizeof(B);
printf(“%d,%d\n”,s,t);
}
在VC++2010平台上编译运行，程序运行后的输出结果是（ ）。
A．2,4
B．4,4
C．4,8
D．10,6

53 关于C语言中数的表示，以下叙述中正确的是（ ）。
A．只有整型数在允许范围内能精确无误地表示，实型数会有误差
B．只要在允许范围内整型和实型都能精确表示
C．只有实型数在允许范围内能精确无误地表示，整型数会有误差
D．只有八进制表示的数才不会有误差

56 以下选项中可用作C程序合法实数的是（ ）。
A．.1e0
B．3.0e0.2
C．E9
D．9.12E
58 以下选项中，合法的C语言实数是（ ）。
A．3.1e0.4
B．.2e0
C．E13
D．7.12E

60 以下选项中，合法的数值型常量是（ ）。
A．3.1415
B．“A”
C．092
D．0xDH

62 若有定义语句：
int a=10;double b=3.14;
则表达式’A’+a+b值的类型是（ ）。
A．char
B．int
C．double
D．float

63 若有定义：
int a=1,b=2,c=3;
则执行表达式(a=b+c)||(++b)后，a、b、c的值依次为（ ）。
A．1,2,3
B．5,3,2
C．5,2,3
D．5,3,3

64 C语言程序中，运算对象必须是整型数的运算符是（ ）。
A．&&
B．/
C．%
D．*

69 设变量x为long int型并已正确赋值，以下表达式中能将x的百位上的数字提取出来的是（ ）。
A．x/10%100
B．x%10/100
C．x%100/10
D．x/100%10

72 若有定义语句：int x=12,y=8,z;，在其后执行语句z=0.9+x/y;，则z的
值为（ ）。
A．1.9
B．1
C．2
D．2.4

73 表达式：(int)((double)9/2)-9%2的值是（ ）。
A．0
B．3
C．4
D．5

74 设有定义：int x=7,y=12;，则以下表达式值为3的是（ ）。
A．(y%=x)-(x%=5)
B．y%=(x%=5)
C．y%=x-x%5
D．y%=(x-x%5)

75 表达式3.6-5/2+1.2+5%2的值是（ ）。
A．4.8
B．3.8
C．3.3
D．4.3

76 表达式a+=a-=a=9的值是（ ）。
A．9
B．-9
C．18
D．0

79 设有定义：
int x=2;
以下表达式中，值不为6的是（ ）。
A．x*=x+1
B．x++,2x
C．x=(1+x)
D．2*x,x+=2

82 以下选项中，当x为大于1的奇数时，值为0的表达式是（ ）。
A．x%2
B．x/2
C．x%2!=0
D．x%2==0

84 有以下程序：

#include<stdio.h>
main()
{ int a; a=(int)1.99*3;printf("%d\n",a);
}

程序的运行结果是（ ）。
A．3
B．5
C．6
D．结果不确定

90 有以下程序：

#include <stdio.h>
#include <math.h>
main()
{ int a = 1,b=4,c =2; double x = 10.5,y = 4.0,z; z = (a + b)/c +sqrt(y)*1.2/c+x; printf("%f\n",z);
}

程序运行后的输出结果是（ ）。
A．13.700000
B．14.000000
C．15.400000
D．14.900000

95 设a、b、c是整型变量，且已正确赋初值，以下选项中错误的赋值语句是（ ）。
A．a=1%(b=c=2);
B．a=(b=3)*c;
C．a=b=c/10;
D．a=2=(b=9)=1;

96 若已有定义语句：int a,b,c;，且变量已正确赋初值，则以下选项中正确的赋值表达式是（ ）。
A．a=(b=c)+8;
B．(a=b)=c=9;
C．a=(b==c)=‘A’;
D．a+b=c+1;

98 若有定义
double a=22;int i=0,k=18;
则不符合C语言规定的赋值语句是（ ）。
A．a=a++,i++
B．i=(a+k)<=(i+k)
C．i=a%11
D．i=!a

99 设变量已正确定义并赋值，以下正确的表达式是（ ）。
A．x=y*5=x+z
B．int(15.8%5)
C．x=y+z+5,++y
D．x=25%5.0

100 若变量均已正确定义并赋值，以下合法的C语
言赋值语句是（ ）。
A．x=y==5;
B．x=n%2.5;
C．x+n=i;
D．x=5=4+1;

101 以下选项中合法的C语言赋值语句是（ ）。
A．++i;
B．a=b=34
C．a=3,b=9
D．k=int(a+b);

102 设有定义：int x=11,y=12,z=0;，以下表达式值不等于12的是（ ）。
A．(z,x,y)
B．(z=x,y)
C．z=(x,y)
D．z=(x==y)

103 若有定义语句：
int x=10;
则表达式x-=x+x的值为（ ）。
A．-20
B．-10
C．0
D．10

104 若有定义语句：
int a=12;
则执行语句：a+=a-=a*a;后，a的值是（ ）。
A．-264
B．552
C．144
D．264

105 有以下定义
int a;
long b;
double x,y;
则以下选项中正确的表达式是（ ）。
A．(a*y)%b
B．a==x<>y
C．a%(int)(x-y)
D．y=x+y=a

106 有以下程序

#include <stdio.h>
#include <math.h>
main()
{ int a =3; printf("%d\n",(a+=a-=a*a));
}

程序运行后的输出结果是（ ）。
A．-12
B．9
C．0
D．3

107 设有定义：
int k=0;
以下选项的四个表达式中与其他三个表达式的值不相同的是（ ）。
A．++k
B．k+=1
C．k++
D．k+1

108 设变量均已正确定义并且赋值，以下与其他三组输出结构不同的一组语句是（ ）。
A．x++;printf(“%d\n”，x);
B．n=++x;printf(“%d\n”,n);
C．++x;printf(“%d\n”,x);
D．n=x++;printf(“%d\n”,n);

110 有以下程序：

#include<stdio.h>
main(){ int i,j,k,a=5,b=6; i=(a==b)?++a:--b; j=a++; k=b; printf("%d,%d,%d\n",i,j,k);
}

程序的运行结果是（ ）。
A．7,6,5
B．5,5,5
C．7,5,5
D．5,6,5

111 有以下程序：

#include<stdio.h>
main()
{ int a; scanf("%d",&a); if(a++<9)printf("%d\n",a); else printf("%d\n",a--);
}

程序运行时键盘输入9<回车>，则输出的结果是（ ）。
A．10
B．11
C．9
D．8

112 有以下程序：

#include <stdio.h>
main()
{ int a=1,b=0; if(--a) b++; else if(a==0) b+=2; else b+=3; printf("%d\n",b);
}

程序运行后的输出结果是（ ）。
A．0
B．1
C．2
D．3

113 有以下程序：

#include <stdio.h>
main()
{ int a=7; while(a--); printf("%d\n",a);
}

程序运行后的输出结果是（ ）。
A．-1
B．0
C．1
D．7

114 有以下程序：

#include <stdio.h>
main()
{ int a=1,b=1; while(a--) b--; printf("%d,%d\n", a,b);
}

程序的运行结果是（ ）。
A．-1,0
B．0,0
C．-1,-1
D．1,1

115 有以下程序

#include <stdio.h>
main()
{ int x,y,z; x=y=1; z=x++,y++,++y; printf("%d,%d,%d\n",x,y,z);
}

程序运行后的输出结果是（ ）。
A．2,3,1
B．2,3,2
C．2,3,3
D．2,2,1

116 以下程序段中的变量已定义为int类型，则
sum=pAd=5;
pAd=sum++,++pAd,pAd++;
printf(“%d\n”,pAd);
程序段的输出结果是（ ）。
A．6
B．4
C．5
D．7

117 有以下程序

#include<stdio.h>
main()
{ int sum,pad,pAd; sum=pad=5; pAd=++sum,pAd++,++pad; printf("%d\n",pad);
}

程序的输出结果是（ ）。
A．8
B．5
C．7
D．6

1.5 考点必背

1. 普通字符常量是用单撇号括起来的一个字符。
2. 常用的以‘\’开头的特殊字符：\n：换行 \t：横向跳格 \b：退格 \r：回车
3. C 语言中没有字符串变量，用字符数组存放。‘a’是字符常量，“a”是字符串 常量，‘ab’既不是字符常量，也不是字符串变量。存储时自动在结尾加’\0’为结 束标志，所以在内存中占的字节要在原本再加一。
4. 变量与变量间用逗号分开；变量必须先定义后使用；定义时系统给该变量分配变量空间，只有分配了变量空间才有意义。
5. a 与！a=0 等价；！a 与 a==0 等价。
6. 在 C 语言中用 1 表示逻辑真，用 0 表示逻辑假。在关系表达式和逻辑表达式中只有两个结果（0 或 1）。
7. 判断 A 与 B 是否相等（fabs（A—B）<1e—6）
8. 用条件表达式求 A、B、C 中最大的数：C>（A>B？A：B）？ C（A>B？A：B）
9. 在进行四则混合运算时，表达式的结果由参与运算的数据项的最高类型决定；编程时，只允许低类型数据向高类型数据转换（如果精度高的向精度低的转换则会丢失精度：如：int i；i=2.56 则结果为 2）。
10. i=3 求 t=（i++）+（i++）+（i++）+（i++）+（++i） 进行此类计算时，先扫描前两项，若有++i 则先运算，然后前两项取同样的值，后面的再依次进行运算。（++i 是先运算再取值，i++是先取值再运算） 此题 t=16，i=8
11. 每个后缀为.c的C语言源程序都可以单独进行编译。
12. 只有含有main函数的经过编译链接才能执行。
13. C程序在书写时没有严格的缩进要求
14. C语言规定，程序从main函数开始执行，从main函数退出
15. 一个C语言程序可以实现多种算法
16. 在C程序运行过程中，编译器的作用是将程序转换为目标代码，目标代码都是二进制的
17. C语言函数可以嵌套调用，例如：fun(fun(x))
18. 函数的定义不能放在另一个函数体内，但是声明可以
19. C语言中的注释不可以夹在变量名或关键字的中间简单
20. C语句必须以分号结束
21. C程序中，一行内可写多个语句，每条语句用分号“;”结束
22. C语言的变量名不可以与关键字同名
23. C语言的标识符可分为关键字、预定义标识符和用户标识符三类
24. C语言标识符只能由字母、数字、下划线构成，且只能以字母、下划线开头
25. C语言中没有逻辑类型，在C++中才引入的
26. VC++2010中整型占4个字节，双精度实型占8个字节
27. 只有整型数在允许范围内能精确无误地表示，实型数会有误差
28. 模（%）运算中不能出现浮点数，运算对象只能是整数
29. 在C语言的算术运算符中，取余运算符“%”的左右两侧的两个运算分量必须是整数
30. 赋值运算符左边必须是一个变量
31. 单目加运算符优先级高于赋值运算符“++”和“–”运算，当以前缀形式出现时，则先进行加一或减一操作，再取值，当以后缀形式出现时，则先取值，再进行加一或减一操作。++x表示先将x值加1后再用，x++表示先使用x值，用后再加1
32. while(a–);程序中执行a–，直到while判断为0时才跳出循环，执行下条语句

第3章 最简单的C程序设计–顺序程序设计

1.1 考试内容

1.关键字与标识符的概念：关键字的含义，标识符的定义，常量和变量的分类；
2.数据类型：数据类型的含义、特点，不同类型常量的表达，不同类型变量的定义、赋初值方法；
3.运算符：各类运算符的含义、优先级，各类表达式的表示方法、运算特点、值的类型和计算方法，各类公式的表达式描述和各类表达式的混合运算；
4.输入输出：常用的输入输出函数，基本的输入输出格式；
5.赋值语句：赋值语句功能和表达方法；
6.顺序程序设计：编写顺序结构语句及程序。

1.2 基本要求

1.理解关键字与标识符的概念、应用特点，理解数据类型的含义和常量、变量的分类；
2.掌握各数据类型的含义、特点，不同类型常量的表达，不同类型变量的定义和赋初值方法；
3.掌握不同数据类型的表示范围和溢出、数据类型的隐式、显式转换；
4.熟练掌握各类运算符的含义、优先级，各类表达式的表示方法、运算特点、
值的类型和计算方法，能够进行各类公式的表达式描述和各类表达式的混合运算；
5.掌握数据输入输出函数的使用方法和特点；
6．熟练掌握顺序程序设计的思想和编程方法，能够熟练编写简单问题的程序并上机调试。

1.3 主要知识点

一、数据的表现形式及其运算

1.常量和变量
(1)常量
在程序运行过程中，其值不能被改变的量称为常量，数值常量就是数学中的常数。
常用的常量有以下几类:
①整型常量:
②实型常量，包括十进制小数形式和指数形式;
③字符常量，包括普通字符和转义字符，常见的转义符有换行符’\n’和制表符’\t’;
④字符串常量，字符串常量是双撇号中的全部字符:
⑤符号常量，用#define 指令，指定用一个符号名称代表一个常量。
(2)变量
变量代表一个有名字的、具有特定属性的一个存储单元，变量必须先定义，后使用。
(3)常变量
常变量是有名字的不变量，而且在变量存在期间其值不能改变。
(4)标识符
①定义
在计算机高级语言中，用来对变量、符号常量名、函数、数组、类型等命名的有效字符序列统称为标识符( identifier )。
②组成规则.
a.C语言规定标识符只能由字母、数字和下划线3种字符组成，且第1个字符必须为字母或下划线。
b.编译系统将大写字母和小写字母认为是两个不同的字符。
2.数据类型
C语言允许使用的类型，如图3-1所示，图中有*的是C99所增加的。

3.整型数据
整型数据常见的存储空间和值的范围如表3-1所示。

4.字符型数据
(1)字符与字符代码
常用的字符与字符代码如表3-2所示。

(2)字符变量
字符变量是用类型符char定义字符变量。字符类型也属于整型，也可以用signed和unsigned修饰符。字符型数据的存储空间和值的范围见表3-3。

5.浮点型数据
浮点型数据的有关情况如表3-4所示。

6.怎样确定常量的类型
从常量的表示形式即可以判定其类型。对于字符常量很简单，只要看到由单撇号括起来的单个字符或转义字
符就是字符常量。对于数值常量按以下规律:
(1)整型常量
不带小数点的数值是整型常量，但应注意其有效范围。
(2)浮点型常量
凡以小数形式或指数形式出现的实数，是浮点型常量，在内存中都以指数形式存储。

二、运算符和表达式

1.C运算符
除了算术运算符外，C还提供其他运算符，共有以下类别:
① 算术运算符(+ - * / % ++ --)
关系运算符(> < == >= <= !=)
逻辑运算符(! && ||) .
位运算符(<< >> ~ | ⋀ &)
赋值运算符(=及其扩展赋值运算符)
条件运算符(?：）
逗号运算符(,)
指针运算符(*和&)
求字节数运算符(sizeof)
强制类型转换运算符((类型))
成员运算符(.->)
下标运算符([])
其他(如函数调用运算符())
2.基本的算术运算符
基本的算术运算符见表3-5。

3.自增、自减运算符
++i, --i: 在使用i之前，先使i的值加(减) 1;
i++，i–: 在使用i之后，使i的值加(减) 1。
4.算术表达式和运算符的优先级与结合性
C算术表达式是指将运算对象通过算术运算符和括号连接起来的、符合C语法规则的表达式。其中算术运算符是自左至右，赋值运算符是自右至左的。
5.不同类型数据间的混合运算
(1) int型、float 与double型数据进行运算，则全部转化为double类型;
(2)字符(char) 型数据与整型数据进行运算，就是把字符的ASCII代码与整型数据进行运算。
6.强制类型转换运算符
(1)系统自动进行的类型转换;
(2)强制类型转换。

三、C语句

1. C语句的结构和分类
   (1) C程序结构可以用图3-2表示。

(2) C语句分为以下5类:
①控制语句.
控制语句用于完成一定的控制功能。C只有9种控制语句，它们的形式是:
a. if()…else… ( 条件语句)
b. for()… ( 循环语句)
c. while()… (循环语句)
d. do…while() ( 循环语句)
e. continue (结束本次循环语句)
f. break ( 中止执行switch或循环语句)
g. switch (多分支选择语句)
h. return (从函数返回语句)
i. goto (转向语句，在结构化程序中基本不用goto语句)
②函数调用语句
函数调用语句由一个函数调用加一个分号构成。
③表达式语句
表达式语句由一个表达式加一个分号构成。
④空语句
⑤复合语句
2.最基本的语句——赋值语句
(1)赋值运算符
赋值符号“=”是指赋值运算符，它的作用是将一个数据赋给一个变量。.
(2)复合的赋值运算符
有关算术运算的复合赋值运算符有+=，-=， *=, /=，%=。
(3)赋值表达式
赋值运算符左侧应该是一个可修改的“左值”(leftvalue， 简写为lvalue)， 能出现在赋值运算符右侧的表达式称为“右值”(rightvalue， 简写为rvalue)。
(4)赋值过程中的类型转换
如果赋值运算符两侧的类型不一致，但都是算术类型时，在赋值时要进行类型转换。
(5)变量赋初值
可以用赋值语句对变量赋值，也可以在定义变量时对变量赋以初值。

四、数据的输入与输出

1.有关数据输入输出的概念
(1)输入输出是以计算机主机为主体
计算机的输入输出如图3-3所示。

(2)输入和输出操作是由C标准函数库中的函数来实现的
(3)在使用系统库函数时，要在程序文件的开头用预处理指令#include<stdio.h>
2.用printf函数输出数据
(1) printf 函数的一般格式
printf函数的一般 格式为: printf(格式控制,输出表列);
括号内包括两部分:
①格式控制
a.格式声明
格式声明总是由“%”字符开始的。
b.普通字符
②输出表列
输出表列是程序需要输出的一些数据，可以是常量、变量或表达式。
(2)格式字符
对不同类型的数据要指定不同的格式声明，而格式声明中最重要的内容是格式字符,常用的有如表3-6所示。

在格式声明中，在%和上述格式字符间可以插入表3-7中列出的几种附加符号(又称修饰符)。

[说明]格式附加字符如“printf(“%5.2f”,f);”即表示输出的f为浮点型数据，其中应保留两位小数，总宽度为5。
3.用scanf函数输入数据
(1) scanf函数的一般形式
scanf(格式控制,地址表列);
①“格式控制”的含义同printf函数。
②“地址表列”是由若干个地址组成的表列，可以是变量的地址，或字符串的首地址。
(2) scanf 函数中的格式声明
与printf函数中的格式声明相似，以%开始，以一个格式字符结束，中间可以插入附加的字符。
表3-8和表3-9列出scanf函数所用的格式字符和附加字符。它们的用法和printf函数中的用法差不多。

(3)使用scanf函数时应注意的问题
①scanf函数中的“格式控制”后面应当是变量地址，而不是变量名。
②如果在“格式控制字符串”中除了格式声明以外还有其他字符，则在输入数据时在对应的位置上应输入与这些字符相同的字符。.
③在用“%c”格式声明输入字符时，空格字符和“转义字符”中的字符都作为有效字符输入。
4.字符输入输出函数
除了可以用printf函数和scanf函数输出和输入字符外，C函数库还提供了–些专门用于输入和输出字符的
函数。
(1)用putchar函数输出一个字符
putchar©;
(2)用getchar 函数输入一个字符
getchar();

1.4 练习题库

1 以下叙述中正确的是（ ）。
A．赋值语句是一种执行语句，必须放在函数的可执行部分
B．scanf和printf是C语言提供的输入和输出语句
C．由printf输出的数据都隐含左对齐
D．由printf输出的数据的实际精度是由格式控制中的域宽和小数的域宽
来完全决定的

2 以下叙述中正确的是（ ）。
A．在scanf函数的格式串中，必须有与输入项一一对应的格式转换说明符
B．只能在printf函数中指定输入数据的宽度，而不能在scanf函数中指定输入数据占的宽度
C．scanf函数中的字符串是提示程序员的，输入数据时不必管它
D．复合语句也被称为语句块，它至少要包含两条语句

4 以下不能输出字符A的语句是（ ）。（注：字符A的ASCII码值为65，字符a的ASCII码值为97。）
A．printf(“%c\n”,‘a’-32);
B．printf(“%d\n”,‘A’);
C．printf(“%c\n”,65);
D．printf(“%c\n”,‘B’-1);

5 设有定义：double x=2.12;，以下不能完整输出变量x值的语句是（ ）。
A．printf(“x=%5.0f\n”,x);
B．printf(“x=%f\n”,x);
C．printf(“x=%1f\n”,x);
D．printf(“x=%0.5f\n”,x);

8 有以下程序段：

char ch;
int k;
ch='a';
k =12;
printf("%c,%d,",ch,ch,k);
printf("k=%d\n",k);

已知字符a的ASCII码十进制值为97，则执行上述程序段后输出的结果是（ ）。
A．因变量类型与格式描述符的类型不匹配，输出无定值
B．输出项与格式描述符个数不符，输出为零值或不定值
C．a,97,12k=12
D．a,97,k=12

9 有以下程序：

#include <stdio.h>
main(){ int a=1,b=0; printf("%d,",b=a+b); printf("%d\n",a=2*b);
}

程序运行后的输出结果是（ ）。
A．0,0
B．1,0
C．3,2
D．1,2

12 有以下程序：

#include <stdio.h>
main(){ char a,b,c,d; scanf("%c%c",&a,&b); c=getchar(); d=getchar(); printf("%c%c%c%c\n",a,b,c,d);
}

当执行程序时，按下列方式输入数据（从第一列开始，代表回车，注意：回车是一个字符）
12
34
则输出结果是（ ）。
A．1234
B．12
C．123
D．1234

13 设有：char s[5],c;，则调用函数scanf能正确给s和c读入数据的是（ ）。
A．scanf(“%s%c”,s,c);
B．scanf(“%d%c”,&s,&c);
C．scanf(“%d%c”,s,&c);
D．scanf(“%s%c”,s,&c);

15 若有定义和语句：
int a,b;
scanf(“%d,%d”,&a,&b);
以下选项中的输入数据，不能把值3赋给变量a、值5赋给变量b的是（ ）（说明：符号u表示空格）。
A．3,5,
B．3,5,4
C．3,u5
D．3,5

16 若有定义：
int a,b;
通过语句：
scanf(“%d;%d”,&a,&b);
能把整数3赋给变量a，5赋给变量b的输入数据是（ ）。
A．3 5
B．3,5
C．3;5
D．35

17 设有以下语句
char ch1,ch2;
scanf(“%c%c”,&ch1,&ch2);
若要为变量ch1和ch2分别输入字符A和B,正确的输入形式应该是（ ）。
A．A和B之间用逗号间隔
B．A和B之间不能有任何间隔符
C．A和B之间可以用回车间隔
D．A和B之间用空格间隔

19 若有定义：
int a;
float b;
double c;
程序运行时输入：a=1,b=2,c=3<回车>，能把值1输入给变量a、值2输入
给变量b、值3输入给变量c的输入语句是（ ）。
A．scanf(“a=%d,b=%f,c=%lf”,&a,&b,&c);
B．scanf(“%d%f%lf”,&a,&b,&c);
C．scanf(“a=%d,b=%lf,c=%lf”,&a,&b,&c);
D．scanf(“a=%d,b=%f,c=%f”,&a,&b,&c);

20 若有定义语句
double x,y,*px,*py;
执行了px=&x;py=&y;之后，输入语句正确的是（ ）。
A．scanf(“%f%f”,x,y);
B．scanf(“%f%f”&x,&y);
C．scanf(“%1f%1e”,px,py);
D．scanf(“%1f%1f”,x,y);

23 设有定义：
double x[10],p=x;
以下能给数组x下标为6的元素读入数据的正确语句是（ ）。
A．scanf(“%f”,&x[6]);
B．scanf(“%1f”,(x+6));
C．scanf(“%1f”,p+6);
D．scanf(“%1f”,p[6]);

24 有以下程序：
main(){
int a1,a2;
char c1,c2;
scanf(“%d%c%d%c”,&a1,&c1,&a2,&c2); printf(“%d,%c,%d,%c”,a1,c1,a2,c2);
}
若想通过键盘输入，使得a1的值为12，a2的值为34，c1的值为a，c2的值为b，程序输出结果是：12，a，34，b，则正确的输入格式是（以下_代表空格，代表回车）（ ）。
A．12a34b
B．12_a_34_b
C．12,a,34,b
D．12_a34_b

25 若变量已正确定义为int型，要通过语句scanf(“%d,%d,%d”,&a,&b,&c);给a赋值1、给b赋值2、给C赋值3，以下输入形式中错误的是（u代表一个空格符）（ ）。
A．uuu1,2,3<回车>
B．1u2u3<回车>
C．1,uuu2,uuu3<回车>
D．1,2,3<回车>

33 下列叙述中正确的是（ ）。
A．可以用关系运算符比较字符串的大小
B．空字符串不占用内存，其内存空间大小是0
C．两个连续的单引号是合法的字符常量
D．两个连续的双引号是合法的字符串常量

34 下列叙述中正确的是（ ）。
A．两个连续的双引号（“”）是合法的字符串常量
B．两个连续的单引号（‘’）是合法的字符常量
C．可以对字符串进行关系运算
D．空字符串不占用内存，其内存空间大小是0

35 若有定义语句
char c=‘\101’;
则变量c在内存中占（ ）。
A．2个字节
B．1个字节
C．3个字节
D．4个字节

37 以下选项中不属于字符常量的是（ ）。
A．‘C’
B．“C”
C．‘\Xcc’
D．’\072’

39 以下选项中非法的C语言字符常量是（ ）。
A．‘aa’
B．‘\b’
C．‘\007’
D．‘\xaa’

44 已知字母A的ASCII码值为65，若变量kk为char型，以下不能正确判断出kk中的值为大写字母的表达式是（ ）。
A．kk>=‘A’&&kk<=‘Z’
B．!(kk>=‘A’||kk<=‘Z’)
C．(kk+32)>=‘a’&&(kk+32)<=‘z’
D．isalpha(kk)&&(kk<91)

45 已知大写字母A的ASCII码是65，小写字母a的ASCII码是97。以下不能将变量c中的大写字母转换为对应小写字母的语句是（ ）。
A．c=(‘A’+c)%26-‘a’
B．c=c+32
C．c=c-‘A’+‘a’
D．c=(c-‘A’)%26+‘a’

46 有以下程序（字母A的ASCII代码为65）：

#include <stdio.h>
main(){ char c1='A',c2='Y'; printf("%d,%d\n",c1,c2);
}

程序运行后的输出结果是（ ）。
A．输出格式不合法，输出出错信息
B．A,Y
C．65,90
D．65,89

47 有以下程序：

#include<stdio.h>
main(){ char ch='Z'; ch=(ch-'A'+1)%26+'A'; putchar(ch);
}

程序的运行结果是（ ）。
A．Z
B．Y
C．B
D．A

48 若有以下程序

#include <stdio.h>
main(){ char c1, c2; c1='C'+'8'-'3'; c2='9'-'0'; printf("%c %d\n",c1,c2);
}

则程序的输出结果是（ ）。
A．H 9
B．表达式不合法输出无定值
C．F ‘9’
D．H ‘9’

52 有以下程序：

#include <stdio.h>
void fun(char *c){while(*c) { if(*c>='a'&&*c<='z')*c=*c-('a'-'A'); c++; }
}
main(){ char s[81]; gets(s); fun(s); puts(s);
}

当执行程序时从键盘上输入Hello Beijing<回车>，则程序的输出结果是
（ ）。
A．hello beijing
B．Hello Beijing
C．HELLO BEIJING
D．HELLO Beijing

53 有以下程序：

#include <stdio.h>
main(){ char b,c; int i; b='a'; c='A'; for(i=0;i<6;i++) { if(i%2) putchar(i+b); elseputchar(i+c); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．ABCDEF
B．AbCdEf
C．aBcDeF
D．abcdef

54 有以下程序：

#include <stdio.h>
void fun(char *s){ while(*s) { if(*s%2==0)printf("%c",*s); s++; }
}
main(){ char a[]=("good"); fun(a); printf("\n");
}

注意：字母a的ASCII码值为97，程序运行后的输出结果是（ ）。
A．d
B．go
C．god
D．good

55 以下不是C语言字符型或字符串常量的是（ ）。
A．“It’s”
B．“0”
C．‘a=0’
D．‘\010’

57 若有说明语句：
char c=‘\72’;
则变量c中存放的是（ ）。
A．2个字符
B．1个字符
C．3个字符
D．说明语句不合法

58 已知字符A的ASCII代码值是65，字符变量c1的值是A，c2的值是D。则执行语句
printf(“%d,%d”,c1,c2-2);
的输出结果是（ ）。
A．A,68
B．65,66
C．A,B
D．65,68

59 有以下程序（说明：字母A的ASCII码值是65）：

#include <stdio.h>
void fun(char *s){ while(*s) { if(*s%2)printf("%c",*s); s++; }
}
main(){ char a[]="BYTE"; fun(a); printf("\n");
}

程序运行后的输出结果是（ ）。
A．BY
B．BT
C．YT
D．YE

60 有以下程序：

#include <stdio.h>
main(){ char c1,c2; c1='A'+'8'-'4'; c2='A'+'8'-'5';printf("%c,%d\n",c1,c2);
}

已知字母A的ASCII码值为65，程序运行后的输出结果是（ ）。
A．E,68
B．D,69
C．E,D
D．输出无定值

61 有以下程序：

#include <stdio.h>
main(){ char ch='B'; while(ch<'E') { printf("%d",ch-'A'); ch++; } printf("\n");
}

程序运行后的输出结果是（ ）。
A．123
B．ABC
C．abc
D．012

62 以下不能输出小写字母a的选项是（ ）。
A．printf(“%c\n”,“a”);
B．printf(“%c\n”,‘A’+32);
C．putchar(97);
D．putchar(‘a’);

64 有如下程序：

#include <stdio.h>
main(){ int i; for(i=0;i<5;i++) putchar('Z'-i);
}

程序运行后的输出结果是（ ）。
A．‘X’‘Y’‘Z’‘W’‘V’
B．VWXYZ
C．ZYXWV
D．‘ABCDE’

65 有如下程序：

#include <stdio.h>
main(){ int i; for(i=0;i<5;i++) putchar('9'-i); printf("\n");
}

程序运行后的输出结果是（ ）。
A．54321
B．98765
C．‘9’‘8’‘7’‘6’‘5’
D．‘43210’

66 有如下程序：

#include <stdio.h>
main(){ char a='3',b='A'; int i; for(i=0;i<6;i++){ if(i%3)putchar(a+i); elseputchar(b+i); }printf("\n");
}

程序运行后的输出结果是（ ）。
A．A45D78
B．ABC678
C．34CD78
D．34AB78

67 有以下程序：

#include <stdio.h>
main(){ char b,c; int i; b='a'; c='A'; for(i=0;i<6;i++) { if(i%2) putchar(i+b); elseputchar(i+c); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．ABCDEF
B．AbCdEf
C．aBcDeF
D．abcdef

71 以下选项中错误的是（ ）。
A．a&=b与a=a & b等价
B．a^=b与a=ab等价
C．a|=b与a=a|b等价
D．a!=b与a=a!b等价

72 变量a中的数据用二进制表示的形式是01011101，变量b中的数据用二进制表示的形式是11110000。若要求将a的高4位取反，低4位不变，所要执行的运算是（ ）。
A．a^b
B．a|b
C．a&b
D．a<<4

78 有以下程序：

#include <stdio.h>
main(){ int a=2,b; b=a<<2; printf("%d\n",b);
}

程序运行后的输出结果是（ ）。
A．2
B．4
C．6
D．8

80 有以下程序：

#include<stdio.h>
main(){ short c=124; c=c______; printf("%d\n",c);
}

若要使程序的运行结果为248，应在下画线处填入的是（ ）。
A．>>2
B．|248
C．&0248
D．<<1

83 有以下程序：

#include <stdio.h>
main(){ int c,d; c=10^3; d=10+3; printf("%d,%d\n",c,d);
}

程序运行后的输出结果是（ ）。
A．103,13
B．13,13
C．10,13
D．9,13

84 若有以下程序段：
int r=8;
printf(“%d\n”,r>>1);
输出结果是（ ）。
A．16
B．8
C．4
D．2

85 有以下程序：

#include<stdio.h>
main(){ int a=5,b=1,t; t=(a<<2)|b; printf("%d\n",t);
}

程序运行后的输出结果是（ ）。
A．21
B．11
C．6
D．1

86 有以下程序：

#include<stdio.h>
main(){ char a=4; printf("%d\n",a=a<<1);
}

程序运行的结果是（ ）。
A．40
B．16
C．8
D．4

87 设有以下语句
int a=1,b=2,c;
c=a^(b<<2);
执行后，c的值为（ ）。
A．9
B．7
C．8
D．6

88 有以下程序

#include <stdio.h>
main(){ unsigned char a=2,b=4,c=5,d; d=a|b; d&=c; printf("%d\n",d);
}

程序运行后的输出结果是（ ）。
A．4
B．3
C．5
D．6

89 有以下程序

#include <stdio.h>
main(){ int i=1; i=i^i; printf("%d\n",i);
}

程序运行后的输出结果是（ ）。
A．7
B．-1
C．1
D．0

91 有如下程序：

#include <stdio.h>
main(){ int a=8,b;b=(a>>2)%2; printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．8,0
B．4,0
C．4,1
D．8,1

92 有如下程序：

#include <stdio.h>
main(){ int a=9,b; b=(a>>3)%4; printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．9,1
B．4,0
C．4,3
D．9,3

93 有以下程序：

#include <stdio.h>
main(){ int c,d; c=(13>>1)|1; d=(13>1)||1; printf("%d,%d\n",c,d);
}

程序运行后的输出结果是（ ）。
A．6,1
B．1,1
C．7,1
D．7,2

94 有以下程序：

#include <stdio.h>
main(){ char c='A'; int x=36,b; b=(x>>2)&&(c<'a'); printf("%d\n",b);
}

程序运行后的输出结果是（ ）。
A．1
B．0
C．2
D．4

96 有以下程序：

#include <stdio.h>
main(){ int i, array[5]={3,5,10,4}; for(i=0;i<5;i++)printf("%d,",array[i]&3); printf("\n");
}

程序运行后的输出结果是（ ）。
A．3,1,2,0,0,
B．3,5,10,4,0,
C．3,3,3,3,0,
D．3,2,2,2,0,

1.5 考点必背

1. if 后面的表达式类型任意，语句可以是复合语句；if（x）等价于 if（x！=0） if（！x）等价于 if（x==0）
2. 多个 case 可以共用一组执行语句（case1： case2： case3：a+=5 则 这三个语句共用 a+=5 ）
3. 赋值语句是一种执行语句，必须放在函数的可执行部分
4. 在scanf函数的格式串中，必须有与输入项一一对应的格式转换说明符
5. 格式控制%m.nf，表示数据输出总的宽度为m位，其中小数部分占n位
6. 在scanf输入整数或实数这类数值型数据时，输入的数据之间必须用空格、回车符、制表符（Tab键）等间隔符隔开
7. %1f用来输入double类型变量，%1e表示用科学计数法输入double
8. 两个连续的双引号是合法的字符串常量
9. 一个字符在内存中占一个字节
10. isalpha(kk)是判断kk是否是字母的函数
11. putchar函数将括号中参数以字符形式输出
12. 二进制右移两位相当于十进制乘以4；二进制左移两位相当于十进制除以4
13. A|1相当于保证这个数是奇数，若不是则加1

第4章 选择结构程序设计

1.1 考试内容

1.条件的表达方式：算术表达式、关系表达式、逻辑表达式，各种运算结果的表达与判别；
2.条件语句：if语句、if_{else语句、else}if结构以及switch和break语句的使用方法；
3.选择结构程序设计：编写带有选择结构的语句及程序。

1.2 基本要求

1.掌握关系表达式的含义和使用；
2.掌握逻辑表达式的含义和使用；
3.熟练掌握编程中条件的描述方法和使用；
4.熟练掌握使用条件语句进行程序设计的方法。

1.3 主要知识点

一、选择结构和条件判断
1.概述
由于程序处理问题的需要,在大多数程序中都会包含选择结构，需要在进行下一个操作之前先进行条件判断。
2.选择语句分类
(1) if语句
用来实现两个分支的选择结构。
(2) switch 语句
用来实现多分支的选择结构。
二、用if语句实现选择结构
1.一般形式
if语句的一般形式如下:
if(表达式)语句1
else语句2.
2.常用的三种形式
(1)没有else子句部分
if(表达式) 语句1
(2)有else子句部分
if(表达式)
语句1
else
语句2
(3)在else部分又嵌套了多层的if语句.
if(表达式1)语句1
else if(表达式2)语句 2
else if(表达式3)语句 3
…
else if(表达式m)语句 m
else 语句m+1
三、关系运算符和关系表达式
1.关系运算符及其优先次序
C语言提供的6种关系运算符如图4-1所示。

[说明]前4种关系运算符(<，<=, >，>=)的优先级别相同，后2种也相同，前4种高于后2种。
2.关系表达式.
(1)用关系运算符将两个数值或数值表达式连接起来的式子，称关系表达式;
(2)关系表达式的值是一个逻辑值，即“真”或“假”。在C的逻辑运算中，以“1”代表“真”，以“0’代表“假”。
四、逻辑运算符和逻辑表达式
1.逻辑运算符及其优先次序
(1)逻辑运算符
C语言逻辑运算符如表4-1所示。

[说明]“&&”和“I”是双目(元)运算符，它要求有两个运算对象(操作数),如(a>b)&&(x>y), (a>b)(x>y)。
“!”是一目(元)运算符，只要求有一个运算对象，如!(a>b)。.
(2)优先次序
赋值运算符、逻辑运算符“&&”和“I”、关系运算符、算术运算符、逻辑运算符“!”的优先级如图4-2所示。

2.逻辑表达式
对于逻辑表达式需要注意的是:
(1)逻辑运算符两侧的运算对象既可以是0和1，也可以是是0和非0的整数，还可以是字符型、浮点型、枚举型或指针型的纯量型数据。
(2)在逻辑表达式的求解中，并不是所有的逻辑运算符都被执行，只是在必须执行下一个逻辑运算符才能求出表达式的解时，才执行该运算符。
五、条件运算符和条件表达式
1.条件运算符
条件运算符由两个符号(?和:) 组成，必须-起使用。要求有3个操作对象，称为三目(元)运算符，它是C语言中唯一的一个三目运算符。
2.条件表达式
(1)一般形式
表达式1?表达式2:表达式3
(2)执行过程
条件表达式的执行过程如图4-3所示。

【总结】运算符优先级(结合图4-2记忆)

六、选择结构的嵌套
在if语句中又包含一个或多个if语句称为if语句的嵌套(nest)， 如图4-4所示。

[说明]应当注意if与else的配对关系，else总是与它上面的最近的未配对的if配对。为了避免混淆，可以。
七、用switch语句实现多分支选择结构
1.基本概念
switch语句的作用是根据表达式的值，使流程跳转到不同的语句。switch 语句的一般形式如下:

2.规则说明
①switch后面括号内的“表达式”，其值的类型应为整数类型(包括字符型);
②switch下面的花括号内是一个复合语句;
③至多可以有一个default标号:
④各个case标号出现次序不影响执行结果:
⑤每一个case常量必须互不相同:
⑥case标号只起标记的作用:
⑦case子句不必用花括号括起来: .
⑧多个case标号可以共用一组执行语句。

1.4 练习题库

1 以下关于逻辑运算符两侧运算对象的叙述中正确的是（ ）。
A．可以是任意合法的表达式
B．只能是整数0或非0整数
C．可以是结构体类型的数据
D．只能是整数0或1

2 以下关于C语言数据类型使用的叙述中错误的是（ ）。
A．若要准确无误差地表示自然数，应使用整数类型
B．若要保存带有多位小数的数据，应使用双精度类型
C．若要处理如“人员信息”等含有不同类型的相关数据，应自定义结构体类型
D．若只处理“真”和“假”两种逻辑值，应使用逻辑类型（错）

3 以下选项中，能表示逻辑值“假”的是（ ）。
A．1
B．0.000001
C．0
D．100.0

4 下列关系表达式中，结果为“假”的是（ ）。
A．(3+4)>6
B．(3!=4)>2
C．3<=4||3
D．(3<4)==1

5 以下表达式的值与x无关、其值恒为真的是（ ）。
A．0<x<5
B．x>10&&x<5
C．x>10||x<5
D．x<10&&x>5

6 当变量c的值不为2、4、6时，值也为“真”的表达式是（ ）。
A．(c= =2)||(c= =4)||(c==6)
B．(c>=2&&c<=6)||(c!=3)||(c!=5)
C．(c>=2&&c<=6)&&!(c%2)
D．(c>=2&&c<=6)&&(c%2!=1)

7 设有定义：int a=0,b=1;，以下表达式中，会产生“短路”现象，致使变量b的值不变的是（ ）。
A．+a||++b
B．a++||++b
C．++a&&b++
D．a++&&b++

8 若有定义语句
int b=2;
则表达式(b<<2)/(3||b)的值是（ ）。
A．4
B．8
C．0
D．2

9 若a是数值类型，则逻辑表达式(a==1)||(a!=1)的值是（ ）。
A．1
B．0
C．2
D．不知道a的值，不能确定

10 以下选项中，当x为大于1的奇数时，值为0的表达式是（ ）。
A．x%21
B．x/2
C．x%2!=0
D．x%20

11 若有定义语句
int k1=10,k2=20;
执行表达式(k1=k1>k2)&&(k2=k2>k1)后，k1和k2的值分别为____。
A．0和1
B．0和20
C．10和1
D．10和20

12 已知a=5，b=6，c=7，d=8，m=2，n=2，执行(m=a>b)&&(n=c<d)后n的值为（ ）。
A．1
B．0
C．2
D．-1

13 执行以下程序段后，w的值为（ ）。
int w=‘A’,x=14,y=15;
w=((x||y)&&(w<‘a’));
A．-1
B．NULL
C．1
D．0

14 有以下程序：

#include<stdio.h>
main(){ int a,b,c=241; a=c/100%9; b=(-1)&&(-1); printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．2,1
B．6,1
C．6,0
D．2,0

15 有以下程序：

#include<stdio.h>
main(){ int a=-2,b=0; while(a++&&++b); printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．1,3
B．0,2
C．0,3
D．1,2

16 有以下程序：

#include <stdio.h>
main(){ int n=2,k=0; while(k++&&n++>2); printf("%d %d\n",k,n);
}

程序运行后的输出结果是（ ）。
A．0 2
B．1 3
C．5 7
D．1 2

17 以下叙述中正确的是（ ）。
A．分支结构是根据算术表达式的结果来判断流程走向的
B．在C语言中，逻辑真值和假值分别对应1和0
C．对于浮点变量x和y，表达式：x==y是非法的，会出编译错误
D．关系运算符两边的运算对象可以是C语言中任意合法的表达式

18 if语句的基本形式是：
if(表达式)语句
以下关于“表达式”值的叙述中正确的是（ ）。
A．必须是逻辑值
B．必须是整数值
C．必须是正数
D．可以是任意合法的数值

21 若变量已正确定义，在if(W)printf(“%d\n”,k);中，以下不可替代W的
是（ ）。
A．a<>b+c
B．c=getchar()
C．a==b+c
D．a++

22 为了避免在嵌套的if-else语句中产生二义性，C语言规定与else子句配对是（ ）。
A．与其在同一行上的if子句
B．在其之后最近的不带else的if子句
C．与其缩排位置相同的if子句
D．在其之前最近的不带else的同层if子句

23 下列条件语句中，输出结果与其他语句不同的是（ ）。
A．
if(a)
printf(“%d\n”,x);
else
printf(“%d\n”,y);

B．
if(a==0)
printf(“%d\n”,y);
else
printf(“%d\n”,x);

C．
if(a!=0)
printf(“%d\n”,x)
else
printf(“%d\n”,y);

D．
if(a==0)
printf(“%d\n”,x)
else
printf(“%d\n”,y);

24 设有定义：
int a=1,b=2,c=3;
以下语句中执行效果与其他三个不同的是（ ）。
A．if(a>b)c=a,a=b,b=c;
B．if(a>b){c=a,a=b,b=c;}
C．if(a>b)c=a;a=b;b=c;
D．if(a>b){c=a;a=b;b=c;}

25 有以下程序段，若变量已正确定义并赋值（ ）。
if(a>b)
printf(“x=%d,”,x);
else
printf(“y=%d,”,y);
if(a<=b)
i++;
else
j++;
则与此程序段功能相同的选项是（ ）。
A．

if(a>b){ 
printf("x=%d,",x); 
j++
}
else{ 
printf("y=%d,",y); 
i++
}

B．

if(a>b){ 
printf("x=%d,",x); 
i++
}
else{ 
printf("y=%d,",y); 
j++
}

C．

if(a<=b){ 
printf("x=%d,",x); 
i++
}
else{ 
printf("y=%d,",y); 
j++
}

D．

if(a>=b){ 
printf("x=%d,",x); 
i++
}
else{ 
printf("y=%d,",y); 
j++
}

27 有以下程序段：
scanf(“%d%d%d”,&a,&b,&c);
if(a>b)a=b;
if(a>c)a=c;
printf(“%d\n”,a);
该程序段的功能是（ ）。
A．输出a、b、c中的最小值
B．输出a、b、c中的最大值
C．输出a的原始值
D．输出a、b、c中值相等的数值

28 有以下程序段：
scanf(“%d%d%d”,&a,&b,&c);
if(a<b)ab;
if(a<c)ac;
printf(“%d\n”,a);
该程序段的功能是（ ）。
A．输出a、b、c中值相等的数值
B．输出a、b、c中的最大值
C．输出a、b、c中的最小值
D．输出a的原始值

29 以下程序的功能是判断输入的一个整数是否能被3或7整除，若能整除，输出YES，否则输出NO。在下划线处应填入的选项是（ ）。

#include<stdio.h>
main(){ int k; printf("Enter a int number:"); scanf("%d",&k); if _____ printf("YES\n"); elseprintf("NO\n"); printf("%d\n",k%3);
}

A．((k%3= =0)||(k%7= =0))
B．(k/3= =0)||(k/7= =0)
C．((k%3=0)||(k%7=0))
D．((k%3= =0)&&(k%7= =0))

30 有以下程序：

#include<stdio.h>
main(){ if('\0'==0)putchar('1'); if('0'==0)putchar('2'); if('a'>'b')putchar('3');
}

程序运行后的输出结果是（ ）。
A．1
B．123
C．23
D．3

31 有以下程序：

#include <stdio.h>
main(){ int x; scanf("%d",&x); if(x>10)printf("1"); else if(x>20) printf("2"); else if(x>30)printf("3");
}

若运行时输入：35<回车>，则输出结果是（ ）。
A．123
B．2
C．3
D．1

33 若变量已正确定义，有以下程序段：
int a=3,b=5,c=7;
if(a>b) a=b;c=a;
if(c!=a) c=b;
printf(“%d,%d,%d\n”,a,b,c);
其输出结果是（ ）。
A．程序段有语法
B．3,5,3
C．3,5,5
D．3,5,7

34 以下函数按每行8个输出数组中的数据：

void fun(int *w,int n){ int i; for(i=0;i<n;i++) { ______ printf("%d",w[i]); } printf("\n");
}

下画线处应填入的语句是（ ）。
A．if(i/8= =0)printf(“\n”);
B．if(i/8= =0)continue;
C．if(i%8= =0)printf(“\n”);
D．if(i%8= =0)continue;

35 有以下程序：

#include<stdio.h>
main(){ 
int x=1,y=2,z=3; 
if(x>1) 
if(y>x) putchar('A'); 
else putchar('B'); 
else if(z<x)putchar('C'); 
else putchar('D');
}

程序的运行结果是（ ）。
A．D
B．C
C．B
D．A

36 有以下程序：

#include<stdio.h>
main(){ int x=1,y=2,z=3; if(x>y) if(y<z) printf("%d",++z); else printf("%d",++y); printf("%d\n",x++);
}

程序运行的结果是（ ）。
A．331
B．41
C．2
D．1

37 有以下程序

#include <stdio.h>
main(){int x=1, y=0;if (!x) y++;else if(x==0)if (x) y+=2;else y+=3;printf("%d\n", y);
}

程序运行后的输出结果是（ ）。
A．0
B．2
C．1
D．3

38 有以下程序

#include<stdio.h>
main(){ int a=1,b=0; if(!a)b++; else if(a==0)if(a) b+=2; else b+=3; printf("%d\n",b);
}

程序运行后的输出结果是（ ）。
A．0
B．1
C．2
D．3

39 有以下程序：

#include<stdio.h>
main(){ int x; scanf("%d",&x); if(x<=3); else if(x!=10) printf("%d\n",x);
}

程序运行时，输入的值在（ ）范围才会有输出结果。
A．不等于10的整数
B．大于3且不等于10的整数
C．大于3或等于10的整数
D．小于3的整数

40 有以下程序：

#include <stdio.h>
main(){ int a=1,b=2,c=3,d=0; if(a==1&&b++==2) if(b!=2||c--!=3)printf("%d,%d,%d\n",a,b,c);else printf("%d,%d,%d\n",a,b,c); else printf("%d,%d,%d\n",a,b,c);
}

程序运行后的输出结果是（ ）。
A．1,2,3
B．1,3,2
C．1,3,3
D．3,2,1

41 若有以下程序

#include<stdio.h>
main(){int a=1,b=2,c=3,d=4;if((a==2)||(b==1))c=2;if((c==3)&&(d==-1))a=5;printf("%d,%d,%d,%d\n",a,b,c,d);
}

则程序的输出结果是（ ）。
A．2,2,2,4
B．2,1,2,-1
C．5,1,2,-1
D．1,2,3,4

42 若有以下程序

#include<stdio.h>
main(){ int a=1,b=2,c=3,d=4; if((a==2)&&(b==1))c=2; if((c==3)||(d==-1))a=5; printf("%d,%d,%d,%d\n",a,b,c,d);
}

则程序的输出结果是（ ）。
A．5,2,3,4
B．2,1,2,-1
C．2,2,2,4
D．1,2,3,4

43 有以下程序

#include<stdio.h>
main(){ int a=0,b=0,c=0,d=0; if(a=1)b=1;c=2; else d=3; printf("%d,%d,%d,%d\n",a,b,c,d);
}

程序输出（ ）。
A．0,0,0,3
B．编译有错
C．1,1,2,0
D．0,1,2,0

46 如有表达式(w)?(-x):(++y)，则其中与w等价的表达式是（ ）。
A．w= =1
B．w= =0
C．w!=1
D．w!=0

47 若有定义：int x,y;,并已正确给变量赋值，则以下选项中与表达式(x-y)?(x++):(y++)中的条件表达式(x-y)等价的是（ ）。
A．(x-y==0)
B．(x-y<0)
C．(x-y>0)
D．(x-y<0||x-y>0)

48 有如下嵌套的if语句

if(a<b)
if(a<c) k=a;
else k=c;
else
if(b<c) k=b;
else k=c;

以下选项中与上述if语句等价的语句是（ ）。
A．k=(a<b)?a:b;k=(b<c)?b:c;
B．k=(a<b)?((b<c)?a:b) : ((b<c)?b:c);
C．k=(a<b)?((a<c)?a:c) : ((b<c)?b:c);
D．k=(a<b)?a:b;k=(a<c)?a:c;

51 以下程序段中，不能实现条件“如果a<b则x=10，
否则x=-10”的是（ ）。
A．x=(a>=b)?-10:10;
B．if(a<b)x=10;else x=-10;
C．x=-10; if(b<a)x=10;
D．if(a<b)x=10;if(b<a)x=-10;

54 有以下程序：

#include <stdio.h>
main(){ char a='H'; a=(a>='A'&&a<='Z')?(a-'A'+'a'):a; printf("%c\n",a);
}

程序运行后的输出结果是（ ）。
A．A
B．a
C．H
D．h

55 有以下程序

#include<stdio.h>
main(){ int x; for(x=3;x<6;x++) printf((x%2)?("*%d"):("#%d"),x); printf("\n");
}

程序的输出结果是（ ）。
A．3#45
B．#3*4#5
C．34#5
D．*3#4#5

57 有以下程序：

#include<stdio.h>
main(){ int a=0,b=0,c=0,d=0; (++a||++b)?++c:++d; printf("%d,%d,%d,%d\n",a,b,c,d);
}

程序的运行结果是（ ）。
A．1,0,1,0
B．1,1,0,1
C．1,0,0,1
D．1,1,1,0

58 下列叙述中正确的是（ ）。
A．在switch语句中，不一定使用break语句
B．在switch语句中，必须使用default
C．break语句必须与switch语句中的case配对使用
D．break语句只能用于switch语句

59 若有定义：
float x=1.5;
int a=1,b=3,c=2;
则正确的switch语句是（ ）。
A．
switch(a+b){
case 1: printf(“\n");
case c: printf(“**\n”);
}
B．
switch((int)x);{
case 1: printf("\n”);
case 2: printf(“\n");
}
C．
switch(x){
case 1.0: printf(“*\n”);
case 2.0: printf("\n”);
}
D．
switch(a+b){
case 1: printf(“*\n”);
case 2+1: printf(“**\n”);
}

60 若以下选项中的变量全部为整型变量，且已正确定义并赋值，则语法正确的switch语句是（ ）。
A．
switch(a+9){
case c1:y=a-b;
case c2:y=a+b;
}
B．
switch ab{
case 10:x=a+b;
default:y=a-b;
}
C．
switch(a+b){
case1:
case2:
case3:y=a+b;break;
case0:
case4:y=a-b;
}
D．
switch(aa+b*b){
default:break;
case 3:y=a+b;break;
case 2:y=ab;break;
}

61 若有定义语句
int a,b;
double x;
则下列选项中没有错误的是（ ）。
A．
switch(x%2){
case 0:a++;break;
case 1:b++;break;
default:a++;b++;
}
B．
switch((int)x/2.0){
case 0:a++;break;
case 1:b++;break;
default:a++;b++;
}
C．
switch((int)x%2){
case 0:a++;break;
case 1:b++;break;
default:a++;b++;
}
D．
switch((int)(x)%2){
case 0.0:a++;break;
case 1.0:b++;break;
default:a++;b++;
}

62 以下选项中与
if(a1)
a=b;
else
a++;
语句功能不同的switch语句是（ ）。
A．
switch(a){
case 1: a=b; break;
default: a++;
}
B．
switch(a1){
case 0: a=b; break;
case 1:a++;
}
C．
switch(a){
default :a++; break;
case 1: a=b;
}
D．
switch(a==1){
case 1: a=b;break;
case 0: a++;
}

63 有以下程序：

#include <stdio.h>
main(){ int k,n=0;charc,str[]="teach";for(k=0;str[k];k++) { c=str[k]; switch(k){ case 1:case 3:case 5: putchar(c); printf("%d",++n);break; default:putchar('N'); } }
}

程序的运行结果是（ ）。
A．Ne1NN
B．e1a2e3
C．Ne1Nc2N
D．Na1NNNN

64 有以下程序：

#include <stdio.h>
main(){ char c; while((c=getchar())!='\n') { switch(c-'2') { case 0: case 1:putchar(c+4); case 2:putchar(c+4);break; case 3:putchar(c+3);default:putchar(c+2);break; } } printf("\n"); 
}

程序运行后从第一列开始输入以下数据：
2473<回车>
程序的输出结果是（ ）。
A．668977
B．4444
C．6677877
D．68766

65 有以下程序

#include<stdio.h>
main(){ int s=0,n; for(n=0;n<3;n++) { switch(s) { case 0: case 1:s+=1; case 2:s+=2;break; case 3:s+=3; default:s+=4; } printf("%d,",s); }
}

程序运行后的输出结果是（ ）。
A．1,2,4,
B．1,3,6,
C．3,10,14,
D．3,6,10,

73 若有以下程序

#include <stdio.h>
main(){ int s=0,n; for(n=0;n<4;n++) { switch(n) { default:s+=4;case 1:s+=1;break; case 2:s+=2;break; case 3:s+=3; } }printf("%d\n",s);
}

则程序的输出结果是（ ）。
A．13
B．10
C．11
D．15

74 有以下程序

#include <stdio.h>
main(){ int k=5,n=0; do { switch(k) { case 1:case 3:n+=1;k--;break; default:n=0;k--; case 2:case 4:n+=2;k--;break; } printf("%d",n); }while(k>0&&n<5);
}

程序运行后的输出结果是（ ）。
A．235
B．0235
C．02356
D．2356

1.5 考点必背

1. C语言中没有逻辑类型（true，false），在C++中才引入的（C语言：非0为真）
2. “短路”现象，要么左边||右边的左边为1，要么左边&&右边的左边为0
3. 左移两位相当于乘以4
4. 运算符“||”为逻辑或运算符，即只要两边的条件表达式中有一个为“真”，则运算结果就为“真”。
5. 运算符“&&”为逻辑与运算符，即只要两边的条件表达式中有一个为“假”，则运算结果就为“假”
6. (表达式1)&&(表达式2)中，如果表达式1为假或0，那么表达式2就不会被执行
7. (表达式1)||(表达式2)中，如果表达式1为真或1，那么表达式2就不会被执行
8. 关系运算符两边的运算对象可以是C语言中任意合法的表达式
9. 在C语言中，表示不等于不能用“<>”，而只能使用“!=”
10. ‘\0’是转义字符，表示空字符，对应的ASCII码为0，’\0’==0成立
11. 按每行8个输出数组中的数据：if(i%8==0)printf(“\n”);
12. else子句总是与前面最近的不带else的if相结合，与书写格式无关
13. 如果if的执行语句含有多个语句（两个以上），则必须使用复合语句，即用花括号把一组语句括起来
14. 条件表达式形式为<表达式1>?<表达式2>:<表达式3>。表达式1的值为真，结果为表达式2的值；表达式1的值为假，结果为表达式3的值
15. 在switch语句中，不一定使用break语句
16. break语句功能是跳出正在执行的条件语句或循环语句，switch语句中可以根据需要选择是否使用break语句
17. case是关键字，与其后面的常量表达式合称case语句标号。
18. 常量表达式的类型必须与swicth后圆括号中的表达式类型相同
19. 各case语句标号的值应该互不相同
20. switch参数值类型必须是这几种类型之一：int，long，short，byte，char
21. switch参数值类型必须是这几种类型之一：int，long，short，byte，char

第5章 循环结构程序设计

1.1 考试内容

1.循环语句：while、do~while和for语句的格式、循环条件的设置以及在循环结构中使用break和continue语句；
2.循环程序设计：编写带有循环结构语句及程序。

1.2 基本要求

1.掌握循环的概念，解决语句重复执行的方法；
2.掌握单重、多重循环结构，熟练使用循环变量有效控制循环运行的方法；
3.掌握break和continue的使用形式和理由；
4.掌握while、do~while和for三种循环结构各自的应用特点和相互转换；5.掌握循环程序设计方法。

1.3 主要知识点

一、为什么需要循环控制

在日常生活中或是在程序所处理的问题中常常遇到需要重复处理的问题，这时只用顺序结构和选择结构是不
够的，还需要用到循环结构(或称重复结构)。

二、用while语句实现循环

1.一般形式
while (表达式)语句
2.执行过程
while语句执行流程图如图5-1所示。

三、用do…while语句实现循环

1.一般形式
do
语句
while(表达式);
2.执行过程
先执行循环语句，然后判别表达式，当表达式的值为非零(“真") 时，返回重新执行循环语句，如此反复，直到表达式的值为0 (“假”)为止，此时循环结束，其流程图如图5-2所示。

3.特点
先无条件地执行循环体，然后判断循环条件是否成立。

四、用for语句实现循环

1. for语句的一般形式
   for(表达式1;表达式2;表达式3)
   语句
   其中3个表达式的主要作用是:
   ①表达式1:设置初始条件，只执行- -次。
   ②表达式2:是循环条件表达式，用来判定是否继续循环，每次循环前执行。
   ③表达式3:作为循环的调整，每次在执行完循环体后进行的。
   2.执行过程
   for语句的执行过程如图5-3所示。

3.详细说明
(1)“表达式1”可以省略，但“表达式1”后的分号不能省略;
(2)“表达式2”也可以省略，即不设置和检查循环的条件:
(3)“表达式3”也可以省略，但此时程序设计者应另外设法保证循环能正常结束;
(4)“表达式1”和“表达式3”可以包含一个以上的简单表达式，中间用逗号间隔。

五、循环的嵌套

一个循环体内又包含另一个完整的循环结构，称为循环的嵌套。内嵌的循环中还可以嵌套循环，这是指多层循环。各种语言中关于循环的嵌套的概念都是一样的。
3种循环( while循环、do…while 循环和for循环)可以互相嵌套。

六、改变循环执行的状态

1.用break语句提前终止循环
break语句的一般形式为:
break;
其作用是使流程跳到循环体之外，接着执行循环体下面的语句，break 语句只能用于循环语句和switch语句
之中，而不能单独使用。
2.用continue语句提前结束本次循环
有时并不希望终止整个循环的操作，只希望提前结束本次循环，而接着执行下次循环，这时可以用continue
语句。continue 语句的一般形式为:
continue;
其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，转到循环体结束点之前，接着执行for语句中的“表达式3"，然后进行下一次是否执行循环的判定。
3. break 语句和continue语句的区别
(1) continue语句只结束本次循环，而接着执行下次循环，如图5-4所示。
(2) break 语句则是结束整个循环过程，不再判断执行循环的条件是否成立，如图5-5所示。

1.4 练习题库

1 在以下给出的表达式中，与while(E)中的(E)不等价的表达式是（ ）。
A．(!E0)
B．(E>0||E<0)
C．(E0)
D．(E!=0)

2 要求通过while循环不断读入字符，当读入字母N时结束循环。若变量已正确定义，以下正确的程序段是（ ）。
A． while((ch=getchar())!=‘N’)
printf(“%c”,ch);
B． while(ch=getchar() =‘N’)
printf(“%c”,ch);
C． while(ch=getchar()‘N’)
printf(“%c”,ch);
D． while((ch=getchar())‘N’)
printf(“%c”,ch);

3 对于“while(!E)s;”，若要执行循环体s，则E的取值应为（ ）。
A．E等于1
B．E不等于0
C．E不等于1
D．E等于0

4 关于“do{循环体}while(条件表达式)”，以下叙述正确的是（ ）。
A．循环体的执行次数总是比条件表达式的执行次数多一次
B．条件表达式的执行次数总是比循环体的执行次数多一次
C．条件表达式的执行次数与循环体的执行次数一样
D．条件表达式的执行次数与循环体的执行次数无关

5 有以下程序：

#include <stdio.h>
main(){while(getchar()!='\n');
}

以下叙述中正确的是（ ）。
A．此while语句将无限循环
B．getchar()不可以出现在while语句的条件表达式中
C．当执行此while语句时，只有按回车键程序才能继续执行
D．当执行此while语句时，按任意键程序就能继续执行

6 若要实现total=1+2+3+4+5求和，以下程序段错误的是（ ）。
A． int i=1,total=1;
while(i<5){
total +=i;
i+=1;
}
B． int i=1,total=0;
while(i<=5){
total +=i;
i+=1;
}
C． int i=0,total=0;
while(i<5){
i +=1;
total+=i;
}
D． int i=0,total=0;
while(i<=5){
total +=i;
i+=1;
}

7 有以下程序

#include<stdio.h>
main(){int y=10; while(y--); printf("y=%d\n",y);
}

程序执行后的输出结果是（ ）。
A．y=0
B．y=-1
C．y=1
D．while构成无限循环

8 有以下程序

#include<stdio.h>
main(){ int k=5; while(--k)printf("%d\n",k-=3); printf("\n");
}

执行后的输出结果是（ ）。
A．1
B．2
C．4
D．死循环

9 有以下程序：

#include <stdio.h>
main(){int a=7; while(a--); printf("%d\n",a);
}

程序运行后的输出结果是（ ）。
A．-1
B．0
C．1
D．7

10 有以下程序：

#include<stdio.h>
main(){ char *s="12134"; int k=0,a=0; while(s[k+1]!='\0') { k++; if(k%2==0) {a = a+s[k]-'0'+1; continue; } a=a+(s[k]-'0'); } printf("k=%d a=%d\n",k,a);
}

程序运行后的输出结果是（ ）。
A．k=6 a=11
B．k=3 a=14
C．k=4 a=12
D．k=5 a=15

11 有以下程序：

#include<stdio.h>
main(){ int a=1,b=2; while(a<6) { b+=a; a+=2; b%=10; } printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．5,11
B．7,1
C．7,11
D．6,1

12 若有以下程序

#include <stdio.h>
main(){ int a=-2,b=0; while(a++)++b; printf("%d,%d\n",a,b);
}

则程序的输出结果是（ ）。
A．1,2
B．0,2
C．1,3
D．2,3

13 有以下程序：

#include<stdio.h>
main(){ int a=-2,b=0; while(a++&&++b); printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．1,3
B．0,2
C．0,3
D．1,2

14 以下叙述正确的是（ ）。
A．do-while语句构成的循环，当while语句中的表达式值为0时结束循环
B．do-while语句和while-do构成的循环功能相同
C．while-do语句构成的循环，当while语句中的表达式值为非0时结束循环
D．do-while语句构成的循环，必须用break语句退出循环

15 以下程序段中，循环次数不超过10的是（ ）。
A． int i=10;
do{
i=i+1;
}while(i<0);
B． int i=5;
do{
i+=1;
}while(i>0);
C． int i=1;
do{
i+=2;
}while(i!=10);
D． int i=6;
do{
i-=2;
}while(i!=1);

16 以下能够实现计算5!的程序段是（ ）。
A． int fac=1,k=0;
do{
k++;
fac*=k;
}while(k<5);
B． int fac=0,k=1;
do{
fac*=k;
k++;
}while(k<5);
C． int fac=1,k=1;
do{
k++;
fac*=k;
}while(k<=5);
D． int fac=1,k=0;
do{
fac*=k;
k++;
}while(k<5);

17 若变量已正确定义，有以下程序段
i=0;
do printf(“%d,”,i);
while(i++);
printf(“%d\n”,i);
其输出结果是（ ）。
A．0,1
B．0,0
C．1,1
D．程序进入无限循环

18 若有以下程序

#include <stdio.h>
main(){ int a=-2,b=0; do { ++b; }while(a++); printf("%d,%d\n",a,b);
}

则程序的输出结果是（ ）。
A．2,3
B．0,2
C．1,2
D．1,3

19 有以下程序：

#include<stdio.h>
main(){ int x=23; do { printf("%2d\n",x--); } while(!x);
}

程序的执行结果是（ ）。
A．输出321
B．输出23
C．不输出任何内容
D．陷入无限循环

20 有以下程序：

#include <stdio.h>
main(){ int i=0,sum=1; do { sum +=i++; }while(i<6); printf("%d\n",sum);
}

程序的输出结果是（ ）。
A．22
B．18
C．20
D．16

21 有以下程序：

#include<stdio.h>
main(){ int sum=0,x=5; do{sum+=x;}while(!--x); printf("%d\n",sum);
}

程序的运行结果是（ ）。
A．0
B．5
C．14
D．15

22 有以下程序（注：字符a的ASCII码值为97）：

#include <stdio.h>
main(){ char *s={"abc"}; do { printf("%d",*s%10); ++s; }while(*s);
}

程序运行后的输出结果是（ ）。
A．abc
B．789
C．7890
D．979800

23 有以下程序：（注意：字母A的ASCII码值为65。）

#include <stdio.h>
main(){ char *s={"ABC"}; do { printf("%d",*( s++)%10); }while(*s);
}

程序运行后的结果是（ ）。
A．5670
B．656667
C．567
D．ABC

24 有以下程序：

#include <stdio.h>
main(){ char c; do { c =getchar(); putchar(c); }while(c!='#'); printf("\n");
}

执行时如输入：abcdefg##<回车>，则输出结果是（ ）。
A．abcdefg#
B．abcdefg
C．abcdefg##
D．##

25 有以下程序：

#include<stdio.h>
main(){ int i=5; do { if(i%3==1) if(i%5==2) { printf("*%d",i);break; } i++; }while(i!=0); printf("\n");
}

程序运行的结果是（ ）。
A．*7
B．35
C．*5
D．26

26 有以下程序：

#include<stdio.h>
main(){ int x=0,y=6; do { while(--y)x++; } while(y--); printf("%d,%d\n",x,y);
}

程序的运行结果是（ ）。
A．5,0
B．6,0
C．5,-1
D．6,-1

27 以下叙述中正确的是（ ）。
A．如果根据算法需要使用无限循环（即通常所称的“死循环”），则只能使用while语句
B．对于“for(表达式1;表达式2;表达式3)循环体”首先要计算表达式2的值，以便决定是否开始循环
C．对于“for(表达式1;表达式2;表达式3)循环体”，只在个别情况下才能转换成while语句
D．只要适当地修改代码，就可以将do-while与while相互转换

28 若变量已正确定义
for(x=0,y=0; (y!=99&&x<4); x++)
则以上for循环（ ）。
A．执行无限次
B．执行3次
C．执行4次
D．执行次数不定

29 若变量已正确定义，则以下for循环（ ）：
for(x=0,y=0; (y!=123)&&(x<4); x++);
A．执行4次
B．执行3次
C．执行次数不确定
D．执行123次

30 若k是int类型变量，且有以下for语句：
for(k=-1;k<0;k++) printf(“****\n”);
下面关于语句执行情况的叙述中正确的是（ ）。
A．循环体执行一次
B．循环体执行两次
C．循环体一次也不执行
D．构成无限循环

31 若i和k都是int类型变量，有以下for语句：
for=(i=0,k=-1;k=1;k++)
printf(“* * * * *\n”);
下面关于语句执行情况的叙述中正确的是（ ）。
A．循环体执行两次
B．循环体执行一次
C．循环体一次也不执行
D．构成无限循环

32 有如下程序段：
int k;
for(k=2;k==0; )
printf(“%d”,k–);
则for循环体执行的次数是（ ）。
A．0次
B．1次
C．2次
D．无限次

33 以下不构成无限循环的语句或者语句组是（ ）。
A． n=0;
do{
++n;
}while(n<=0);
B． n=0;
while(1){
n++;
}
C． n=10;
while(n); {
n–;
}
D． for(n=0,i=1;i++)
n+=i;

34 以下程序段中，与其他三个功能不同的程序段是（ ）。
A． s=0;
i=1;
for(;😉{
s+=i;
i++;
if(i<=10)
break;
}
B． s=0,i=1;
for(;i<=10;){
s+=i;
i++;
}
C． s=0;
for(i=1;i<=10;i++){
s+=i;
}
D．for(s=0,i=1;i<=10;s+=i,i++);

35 有以下程序：

#include<stdio.h>
main(){ int i=4; for(printf("%d",i);i<2;i++)printf("%d",i); printf("\n");
}

程序运行后的输出结果是（ ）。
A．12
B．4
C．1
D．0

36 有以下程序：

#include <stdio.h>
main(){ int i,a; for(i=0;i<=10;i++)a=i; printf("%d,%d\n",i,a);
}

程序的运行结果是（ ）。
A．11,10
B．10,10
C．10,11
D．11,11

37 有如下程序：

#include <stdio.h>
main(){ int i =1; for(printf("%d",i);i<4;i++) printf("%d",i); printf("\n");
}

程序运行后的输出结果是（ ）。
A．1123
B．123
C．0123
D．001

38 以下函数的功能是计算a的n次方作为函数值返回：

double fun(double a,int n){ int i; double s=1.0; for(i=1;i<=n;i++)s=______; return s;
}

为实现上述功能，函数中下划线处应填入的是（ ）。
A．si
B．sa
C．s+ii
D．s+aa

39 有以下程序

#include<stdio.h>
main(){ int a=1,b=2; for(;a<8;a++) { b+=a; a+=2; } printf("%d,%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．9,18
B．8,11
C．7,11
D．10,14

41 有以下程序

#include<stdio.h>
main(){ int a[5] = {1,2,3,4,5}, b[5] ={0,2,1,3,0}, i, s=0; for(i=0;i<5;i++)s=s+a[b[i]]; printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．6
B．10
C．11
D．15

42 以下函数findmax拟实现在数组中查找最大值并作为函数值返回，但程序中有错导致不能实现预定功能。

#define MIN -2147483647
int fingmax (int x[],int n){ int i,max; for(i=0;i<n;i++) {max=MIN; if(max<x[i])max=x[i]; }return max;
}

造成错误的原因是（ ）。
A．定义语句int i,max;中max未赋初值
B．赋值语句max=MIN;中，不应给max赋MIN值
C．语句if(max<x[i]) max=x[i];中判断条件设置错误
D．赋值语句max=MIN;放错了位置

43 设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（ ）。
A． n=0;
while((ch=getchar())!=“\n”)
n++;
B． n=0;
while(getchar()!=“\n”)
n++;
C．for(n=0; getchar()!=“\n”; n++);
D．n=0;
for(ch=getchar()!=“\n”;n++);

44 有以下程序：

#include<stdio.h>
main(){ int a=1,b=0; for(;a<5;a++) { if(a%2==0)break; b+=a; }printf("%d\n",b);
}

程序的运行结果是（ ）。
A．1
B．10
C．0
D．4

45 有以下程序：

#include<stdio.h>
main(){ int x=8; for(;x>0;x--) { if(x%3) { printf("%d,",x--); continue; } printf("%d,",--x); }
}

程序的运行结果是（ ）。
A．7,4,2,
B．8,7,5,2,
C．9,7,6,4,
D．8,5,4,2,

46 有以下程序

#include <stdio.h>
main(){ int y=9; for(;y>0;y--) if(y%3==0)printf("%d",--y);
}

程序的运行结果是（ ）。
A．852
B．963
C．741
D．875421

47 有以下程序

#include <stdio.h>
main(){ int i; for(i=1;i<=40;i++) {if(i++%5==0) if(++i%8==0)printf("%d",i); } printf("\n");
}

执行后的输出结果是（ ）。
A．32
B．24
C．5
D．40

48 有以下程序

#include<stdio.h>
main(){ int i,sum; for(i=1;i<6;i++)sum+=i; printf("%d\n",sum);
}

程序运行后的输出结果是（ ）。
A．0
B．随机值
C．15
D．16

49 若有以下程序

#include<stdio.h>
main(){ int a=6,b=0,c=0; for(;a;) { b+=a; a-=++c; } printf("%d,%d,%d\n",a,b,c);
}

则程序的输出结果是（ ）。
A．0,18,3
B．1,14,3
C．0,14,3
D．0,14,6

50 有以下程序：

#include<stdio.h>
main(){ int i,j; for(i=3;i>=1;i--) { for(j=1;j<=2;j++) printf("%d",i+j); printf("\n"); }
}

程序运行的结果是（ ）。
A．234<换行>345<换行>
B．432<换行>543<换行>45<换行>
C．23<换行>34<换行>23<换行>
D．45<换行>34<换行>23<换行>

51 有以下程序

#include<stdio.h>
main(){ int i,j,m=1; for(i=1;i<3;i++) { for(j=3;j>0;j--) { if(i*j>3)break; m*=i*j; } } printf("m=%d\n",m);
}

程序运行后的输出结果是（ ）。
A．m=6
B．m=2
C．m=4
D．m=5

52 有以下程序：

#include<stdio.h>
main(){ int i,j,x=0; for(i=0;i<2;i++) { x++; for(j=0;j<=3;j++) {if(j%2==0)continue; x++; } x++; } printf("x=%d\n",x);
}

程序的运行结果是（ ）。
A．x=4
B．x=6
C．x=8
D．x=12

53 有以下程序

#include<stdio.h>
main(){ int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=1;for(i=0;i<3;i++) for(j=i;j<=i;j++)t+=b[i][b[j][i]]; printf("%d\n",t);
}

程序运行后的输出结果是（ ）。
A．1
B．3
C．4
D．9

54 以下程序段中的变量已正确定义：
for(i=0;i<4;i++,i++)
for(k=1;k<3;k++);
printf("");
程序段的输出结果是（ ）。
A．*****
B．****
C．**
D．*

55 有以下程序

#include<stdio.h>
main(){ int i,j,m=55; for(i=1;i<=3;i++) for(j=3;j<=i;j++)m=m%j; printf("%d\n",m);
}

程序的运行结果是（ ）。
A．1
B．0
C．2
D．3

56 有以下程序

#include <stdio.h>
main(){ int i,j; for(i=1;i<4;i++) { for(j=i;j<4;j++) printf("%d*%d=%d",i,j,i*j); printf("\n"); }
}

程序运行后的输出结果是（ ）。
A． 11=1 12=2 13=3
22=4 23=6
33=9
B． 11=1 12=2 13=3
21=2 22=4
31=3
C． 11=112=2 22=4
13=3 23=6 33=9
D． 11=121=2 22=4
31=3 32=6 33=9

57 以下叙述中正确的是（ ）。
A．break语句只能用于switch语句体中
B．continue语句的作用是使程序的执行流程跳出包含它的所有循环
C．在循环体内使用break语句和continue语句的作用相同
D．break语句只能用在循环体内和switch语句体内

58 以下叙述中正确的是（ ）。
A．break语句不能用于提前结束for语句的本层循环
B．使用break语句可以使流程跳出switch语句体
C．continue语句使得整个循环终止
D．在for语句中，continue与break的效果是一样的，可以互换

59 有以下程序：

#include <stdio.h>
main(){ int i,data; scanf("%d",&data); for(i=0;i<5;i++) { if(i < data)continue; printf("%d,",i); } printf("\n");
}

程序运行时，从键盘输入：3<回车>后，程序输出结果为（ ）。
A．3,4,
B．1,2,3,4,
C．0,1,2,3,4,5,
D．0,1,2,

60 有如下程序：

#include<stdio.h>
main(){ int i,data; scanf("%d",&data); for(i=0;i<5;i++) { if(i>data)break; printf("%d,",i); } printf("\n");
}

程序运行时，从键盘输入：3<回车>后，程序输出结果为（ ）。
A．3,4,
B．0,1,
C．3,4,5,
D．0,1,2,3,

61 有以下程序：

#include<stdio.h>
main(){ int i; for(i=1;i<=5;i++) { if(i%2)printf("*"); elsecontinue; printf("#"); } printf("$\n");
}

程序运行后的输出结果是（ ）。
A．###$
B．##$
C．##$
D．###$

62 有以下程序：

#include <stdio.h>
main(){ int a=1,b=0; for(;a<5;a++) { if(a%2 == 0)break; elsecontinue; b+= a; } printf("%d \n",b);
}

程序运行后的输出结果是（ ）。
A．0
B．1
C．10
D．4

1.5 考点必背

1. 能够使用 while 语句，尽量不使用 do…while 语句；能够使用 for 语句，尽量不使用 while 语句。
2. 退出循环的条件：1，判断式不成立 2，循环体内包含 break 语句。
3. for 语句括号内必须有两个分号。21.continue 语句只能在循环语句中使用，表示中断本次循环，跳回到条件判断；break 语句用于 swith 和循环语句中，表示跳出循环。

第6章 利用数组处理批量数据

1.1 考试内容

1.数组的概念：数组的概念、一维数组、二维数组和字符数组；
2.数组的使用：数组的定义、数组的初始化、数组元素的引用，数组的一般编程方法。

1.2 基本要求

1.掌握一维、二维数组的基本概念；
2.掌握一维、二维数组的定义、初始化和数组元素引用方法；
3.掌握基于数组的程序设计方法；
4.熟练掌握使用字符数组对字符串进行操作。

1.3 主要知识点

一、定义和引用一维数组

1.定义一维数组
(1)一般形式
类型符数组名[常量表达式];
(2)注意事项
①数组名的命名规则和变量名相同，遵循标识符命名规则;
②方括号中的常量表达式用来表示元素的个数，即数组长度;
③常量表达式中可以包括常量和符号常量，不能包含变量。
(3)存储形式
数组的存储形式如图6-1所示。

2.引用一维数组元素
引用数组元素的表示形式为:
数组名[下标]
3.一维数组的初始化
可以用“初始化列表”方法实现数组的初始化，- *般有:
(1)在定义数组时对全部数组元素赋予初值，例如int a[5]={0,2,4,6,8};.
(2)可以只给数组中的- -部分元素赋值，未赋值元素的为0.
(3)在对全部数组元素赋初值时，由于数据的个数已经确定，因此可以不指定数组长度。

二、定义和引用二维数组.

1.定义二维数组
(1)基本概念
二维数组定义的一般形式为:
类型说明符数组名[常量表达式][常量表达式];
(2)元素存放方式
C语言中，二维数组中元素排列的顺序是按行存放的，即在内存中先顺序存放第1行的元素，接着再存放第
2行的元素。a[3][4]数组 存放的顺序如图6-4所示。

假设数组a存放在从1000字节开始的- -段内存单元中，一个元素占4个字节,则其存放方式如图6-5所示。

(3)多维数组
C语言还允许使用多维数组。例如float a[2][3][4];.
2.引用二维数组的元素
(1)表示形式
数组名[下标][下标]
(2)引用
数组元素可以出现在表达式中，也可以被赋值，例如b[1][2]=a[2][3]/2;。
3.二维数组的初始化
可以用“初始化列表”对二维数组初始化。
(1)分行给二维数组赋初值。例如:
int a[2][3]={ {1,2,3},{4,.5,6}};
(2)可以将所有数据写在-一个花括号内，按数组元素在内存中的排列顺序对各元素赋初值。例如:
int a[2][3]={ 1,2,3,4.5,6};
(3)可以对部分元素赋初值。例如int al21[3]={{1),{4}}，其余元素为0。
(4)如果对全部元素都赋初值(即提供全部初始数据)，则定义数组时对第1维的长度可以不指定，但第2
维的长度不能省。

三、字符数组

1.定义字符数组
定义字符数组的方式:类型说明符数组名[常量表达式];，例如char a[10];。
2.字符数组的初始化
(1)将各个字符依次赋给数组中各元素。例如:
char c[8]={‘s’,‘h’,‘e’,‘n’,‘g’,‘c’,‘a’,‘T’};
(2)花括号中提供的初值个数(即字符个数)大于数组长度，则出现语法错误。如果初值个数小于数组长
度，则只将这些字符赋给数组中前面那些元素，其余的元素自动定为空字符( 即\0)。

1.4 练习题库

1 以下叙述中正确的是（ ）。
A．数组说明符的一对方括号中只能使用整型常量，而不能使用表达式
B．一条语句只能定义一个数组
C．每个数组包含一组具有同一类型的变量，这些变量在内存中占有连续的存储单元
D．在引用数组元素时，下标表达式可以使用浮点数

2 以下叙述中正确的是（ ）。
A．语句“int a[8]={0};”是合法的
B．语句“int a[]={0};”是不合法的，遗漏了数组的大小
C．语句“char a[2]={“A”,“B”};”是合法的，定义了一个包含两个字符的数组
D．语句“char a[3];a=“AB”;”是合法的，因为数组有三个字符空间的容
量，可以保存两个字符

3 以下选项中叙述正确的是（ ）。
A．char c1,c2,*c3,c4[40];是合法的变量定义语句
B．数组说明符的一对方括号中只能使用整型常量，而不能使用表达式
C．数组下标的下限可以是负值
D．若有数组定义float array[4];，则语句printf(“%f”,array[3.12]);是合法的

4 以下叙述中错误的是（ ）。
A．同一个数组中所有元素的类型相同
B．不可以跳过前面的数组元素，给后面的元素赋初值0
C．定义语句：int a[10]={0};，给a数组中所有元素赋初值0
D．若有定义语句：int a[4]={1,2,3,4,5};，编译时将忽略多余的初值

5 若要定义一个具有5个元素的整型数组，以下定义语句错误的是（ ）。
A．int a[5]={0};
B．int b[]={0,0,0,0,0};
C．int c[2+3];
D．int i=5,d[i];

6 设有如下程序段：
int a[8]={0};
int b[]={0};
char c[2]={“A”,“B”};
char d=“AB”;
以下叙述正确的是（ ）。
A．只有a，b，c的定义是合法的
B．a，b，c，d的定义都是合法的
C．只有a，b的定义是合法的
D．只有c的定义是合法的

7 下列选项中，能正确定义数组的语句是（ ）。
A．int N=2008; int num[N];
B．int num[]; int num[N];
C．#define N 2008
int num[N];
D．int num[0…2008];

8 下列定义数组的语句中，正确的是（ ）。
A．int x[];
B．int N=10;int x[N];
C．int x[0…10];
D．#define N 10
int x[N];

9 要求定义一个具有6个元素的int型一维数组，以下选项中错误的是（ ）。
A．int N=6,a[N];
B．int a[2*3]={0};
C．#define N 3
int a[N+N];
D．int a[]={1,2,3,4,5,6};

10 若有定义语句：int m[]={5,4,3,2,1},i=4;，则下面对m数组元素的引用中错误的是（ ）。
A．m[–i]
B．m[2*2]
C．m[m[0]]
D．m[m[i]]

11 若有说明语句：
int*ptr[10];
以下叙述正确的是（ ）。
A．ptr是一个具有10个指针元素的一维数组，每个元素都只能指向整型变量
B．ptr是指向整型变量的指针
C．ptr是一个指向具有10个整型元素的一维数组的指针
D．ptr是一个指向10个整型变量的函数指针

12 有以下程序：

#include <stdio.h>
main(){ int s[12] = {1,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i; for(i=0;i<12;i++) c[s[i]]++; for(i=1;i<5;i++) printf("%d",c[i]); printf("\n");
}

程序的运行结果是（ ）。
A．4332
B．2344
C．1234
D．1123

13 设有n个数按从大到小的顺序存放在数组x中，以下能使这n个数在x数组中的顺序变为从小到大的是（ ）。
A．
for(i=0;i<n/2;i++){
t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}
B．
for(i=0;i<n;i++){
t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}
C．
for(i=0;i<n/2;i++){
t=x[i];
x[i]=x[n-i+1];
x[n-i+1]=t;
}
D．
for(i=0;i<n/2;i+=2){
t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}

14 设有一个M*N的矩阵已经存放在一个M行N列的数组x中，且有以
下程序段：
sum=0;
for(i=0;i<M;i++)
sum+=x[i][0]+x[i][N-1];
for(j=1;j<N-1;j++)
sum+=x[0][j]+x[M-1][j];
以上程序段计算的是（ ）。
A．矩阵两条对角线元素之和
B．矩阵所有不靠边元素之和
C．矩阵所有元素之和
D．矩阵所有靠边元素之和

15 有以下程序段：
int *p1,*p2,a[10];
p1=a;
p2=&a[5];
则p2-p1的值为（ ）。
A．5
B．10
C．12
D．无法确定

16 设有如下定义语句：
int m[ ]={2,4,6,8},k=m;
以下选项中，表达式的值为6的是（ ）。
A．(k+2)
B．k+2
C．*k+2
D．*k+=2

17 若有定义语句：
double x[5]={1.0,2.0,3.0,4.0,5.0}, *p=x;
则错误引用x数组元素的是（ ）。
A．p
B．x[5]
C．(p+1)
D．*x

18 设有定义：
int a[10]={0,1,2,3,4,5,6,7,8,9}, p=a,i;
若0≤i≤9，则对a数组元素的引用错误的是（ ）。
A．a[10]
B．(&a[i])
C．p[i]
D．a[p-a]

19 设有定义
double a[10],*s=a;
以下能够代表数组元素a[3]的是（ ）。
A．(s)[3]
B．(s+3)
C．*s[3]
D．*s+3

20 若有以下定义：
int x[10],pt=x;
则对x数组元素的正确引用是（ ）。
A．&x[10]
B．(x+3)
C．(pt+10)
D．pt+3

21 执行以下程序段后，s的值为（ ）。
int a[]={1,2,3,4,5,6,7,8,9}, s=0,k;
for(k=0;k<8;k+=2)
s+=*(a+k);
A．13
B．16
C．17
D．45

22 有以下程序

#include <stdio.h>
main(){ int i,s=0,t[]={1,2,3,4,5,6,7,8,9}; for(i=0;i<9;i+=2)s+=*(t+i); printf("%d\n",s);
}

程序执行后的输出结果是（ ）。
A．25
B．20
C．45
D．36

23 有以下程序：

#include<stdio.h>
main(){ int a[]={10,20,30,40},*p=a,i; for(i=0;i<=3;i++) { a[i]=*p; p++; }printf("%d\n",a[2]);
}

程序运行后的输出结果是（ ）。
A．30
B．40
C．10
D．20

24 有以下程序：

#include<stdio.h>
main(){ int a[]={1,2,3,4},y,*p=&a[3]; --p; y=*p; printf("y=%d\n",y);
}

程序的运行结果是（ ）。
A．y=0
B．y=1
C．y=2
D．y=3

25 fun函数的功能是：通过键盘输入给x所指的整型数组所有元素赋值。在下划线处应填写的是（ ）。

#include <stdio.h>
#define N 5
void fun(int x[N]){ int m; for(m=N-1;m>=0;m--)scanf("%d",_____);
}

A．&x[++m]
B．&x[m+1]
C．x+(m++)
D．x+m

26 以下函数的功能是：通过键盘输入数据，为数组中的所有元素赋值。

#include <stdio.h>
#define N 10
void fun(int x[N]){ int i=0; while(i<N)scanf("%d",______);
}

在程序中下画线处应填入的是（ ）。
A．x+i
B．&x[i+1]
C．x+(i++)
D．&x[++i]

27 以下程序中给数组所有元素输入数据，请从选项中选择正确的答案
填入下划线处。

#include <stdio.h>
main(){ int a[10],i=0; while(i<10)scanf("%d",______); …
}

A．a+(i++)
B．&a[i+1]
C．a+i
D．&a(i++)

28 有以下程序：

#include <stdio.h>
main(){ int a[10]={11,12,13,14,15,16,17,18,19,20},*p=a,i=9;printf("%d,%d,%d\n",a[p-a],p[i],*(&a[i]));
}

程序运行后的输出结果是（ ）。
A．11,19,19
B．12,20,20
C．11,20,20
D．12,19,20

29 有以下程序：

#include <stdio.h>
void fun(int *p){ printf("%d\n",p[5]);
}
main(){ int a[10]={1,2,3,4,5,6,7,8,9,10}; fun(&a[3]);
}

程序运行后的输出结果是（ ）。
A．5
B．6
C．8
D．9

30 有以下程序

#include <stdio.h>
main(){ int a[]={2,4,6,8,10},x,*p,y=1;p=&a[1]; for(x=0;x<3;x++)y+=*(p+x); printf("%d\n",y);
}

程序的输出结果是（ ）。
A．19
B．13
C．11
D．15

31 有如下程序：

#include <stdio.h>
main(){ int i,*ptr; int array[3]={8,2,4}; for(ptr=array,i=0;i<2;i++) printf("%d,",*ptr++); printf("\n");
}

程序运行后的输出结果是（ ）。
A．8,2,
B．8,8,
C．2,4,
D．4,8,

32 有以下程序：

#include <stdio.h>
main(){ int i,*ptr; int array[4]={1,1,3,4}; for(ptr=array,i=0;i<3;i++) printf("%d,",*ptr++); printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,2,4,
B．1,3,4,
C．1,1,3,
D．1,1,4,

33 有如下程序：

#include <stdio.h>
main(){ int i, *ptr; int array[5] ={5,3,1}; for (ptr=array, i=0; i<5; i++, ptr++) { if (*ptr ==0) putchar('X'); else putchar('A' +*ptr); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．FDBXX
B．FFFXX
C．FDBBB
D．ABCDE

34 有以下程序：

#include <stdio.h>
main(){ int x[]={8,2,6,12,5,15},f1,f2; int *p=x; f1=f2=x[0]; for(;p<=x+5;p++) { if(f1<*p)f1=*p; if(f2>*p)f2=*p; } printf("%d,%d\n",f1,f2);
}

程序的运行结果是（ ）。
A．15,2
B．15,15
C．2,15
D．8,8

38 有以下程序

#include <stdio.h>
void f(int b[]){ int i; for(i=2;i<6;i++)b[i]*=2;
}
main(){ int a[]={1,2,3,4,5,6,7,8,9,10},i; f(a); for(i=0;i<10;i++) printf("%d,",a[i]);
}

程序运行后的输出结果是（ ）。
A．1,2,6,8,10,12,7,8,9,10,
B．1,2,3,4,5,6,7,8,9,10,
C．1,2,3,4,10,12,14,16,9,10,
D．1,2,6,8,10,12,14,16,9,10,

39 有以下程序：

#include<stdio.h>
void fun(int a[],int n){ int i,t; for(i=0;i<n/2;i++) { t=a[i]; a[i]=a[n-1-i]; a[n-1-i]=t; }
}
main(){ int k[10]={1,2,3,4,5,6,7,8,9,10},i; fun(k,5); for(i=2;i<8;i++)printf("%d",k[i]); printf("\n");
}

程序运行的结果是（ ）。
A．345678
B．876543
C．1098765
D．321678

41 有以下程序：

#include <stdio.h>
void fun(int a[], int n){ int i; for(i=0;i<n;i++) { if(i%2==0) a[i] += n; else a[i] -= n; }
}
main(){ int c[5]={5,4,3,2,1},i; fun(c,5); for(i=0;i<5;i++) printf("%d,",c[i]);printf("\n");
}

程序运行后的输出结果是（ ）。
A．10,-1,8,-3,6,
B．5,4,3,2,1,
C．10,2,8,4,6,
D．5,-1,3,-3,1,

42 有以下程序：

#include <stdio.h>
void fun(int a[],int n){ int i; for(i=0;i<n;i++) { if(i % 3==0) a[i]-=n; else a[i]+=n; }
}
main(){ int c[5]={6,7,8,9,10},i;fun(c,5); for(i=0;i<5;i++)printf("%d,",c[i]); printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,12,13,4,15,
B．10,9,8,7,6,
C．1,7,13,9,15,
D．10,12,8,4,6,

47 有以下程序：

#include <stdio.h>
#define N 8
void fun(int *x,int i){ *x=*(x+i);
}
main(){ int a[N]={1,2,3,4,5,6,7,8},i; fun(a,2); for(i=0;i<N/2;i++) { printf("%d,",a[i]); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,3,1,3,
B．2,2,3,4,
C．3,2,3,4,
D．1,2,3,4,

52 有以下程序：

#include <stdio.h>
void fun(int *x,int s,int n){ int i; for(i=s;i>=n;i--) *(x+i+3)=*(x+i);
}
main(){ int m[]={0,1,2,3,4,5,6,7,8,9},k; fun(m,10-4,3); for(k=0;k<10;k++) printf("%d",m[k]);
}

程序的运行结果是（ ）。
A．0123456345
B．0123453456
C．0123456666
D．0123454569

55 有以下程序：
58 设有定义
int x[2][3];
则以下关于二维数组x的叙述中错误的是（ ）。
A．x[0]可看作是由3个整型元素组成的一维数组
B．x[0]和x[1]是数组名，分别代表不同的地址常量
C．数组x包含6个元素
D．可以用语句x[0]=0;为数组所有元素赋初值0

59 以下定义数组的语句中错误的是（ ）。
A．int num[]={1,2,3,4,5,6};
B．int num[][3]={{1,2},3,4,5,6};
C．int num[2][4]={{1,2},{3,4},{5,6}};
D．int num[][4]={1,2,3,4,5,6};

60 以下错误的定义语句是（ ）。
A．int x[][3]={{0},{1},{1,2,3}};
B．int x[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
C．int x[4][]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};
D．int x[][3]={1,2,3,4};

61 以下数组定义中错误的是（ ）。
A．int x[2][3]={{1,2},{3,4},{5,6}};
B．int x[][3]={0};
C．int x[][3]={{1,2,3},{4,5,6}};
D．int x[2][3]={1,2,3,4,5,6};

62 若有定义语句：
int m[ ][3]={1,2,3,4,5,6,7};
则与该语句等价的是（ ）。
A．int m[ ][3]={{1,2,3},{4,5,6},{7}};
B．int m[ ][3]={{1,2},{3,4},{5,6,7}};
C．int m[ ][3]={{1,2,3},{4,5},{6,7}};
D．int m[ ][3]={{1},{2,3,4},{5,6,7}};

63 若有定义：
int a[2][3];
以下选项中对a数组元素正确引用的是（ ）。
A．a[2][!1]
B．a[2][3]
C．a[0][3]
D．a[1>2][!1]

64 有如下程序：

#include <stdio.h>
main(){ int i,k; int array[4][2]={{1,2},{4,9},{6}}; for(i=0;i<2;i++) for(k=0;k<4;k++) { printf("%d,",array[k][i]); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,2,4,9,6,
B．1,4,6,0,2,9,0,0,
C．2,9,0,0,1,4,6,0,
D．2,9,6,1,4,

65 有以下程序：

#include<stdio.h>
main(){ int i,k; int array[4][2]={{1,0},{0},{2,9},{3}}; for(i=0;i<2;i++) for(k=0;k<3;k++) { printf("%d,",array[k][i]); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,0,2,0,0,9,
B．1,2,4,9,6,0,
C．2,9,0,0,1,4,
D．1,2,0,1,4,1,

66 有以下程序

#include<stdio.h>
main(){ int b[3][3] = {0,1,2,0,1,2,0,1,2},i,j,t= 1; for(i = 0;i<3;i++) for(j = i;j <= i;j++)t+=b[i][b[j][i]]; printf("%d\n",t);
}

程序运行后的输出结果是（ ）。
A．4
B．3
C．1
D．9

68 有以下程序

#include<stdio.h>
main(){ int a[4][4] = {{1,4,3,2}, {8,6,5,7},{3,7,2,5}, {4,8,6,1}},i,k,t;for(i=0;i<3;i++) for(k=i+1;k<4;k++) if(a[i][i]<a[k][k]) { t=a[i][i]; a[i][i]=a[k][k]; a[k][k]=t; } for(i=0;i<4;i++) printf("%d,",a[0][i]);
}

程序运行后的输出结果是（ ）
A．6,4,3,2,
B．6,2,1,1,
C．1,1,2,6,
D．2,3,4,6,

69 有以下程序

#include<stdio.h>
main(){ int i,t[][3]={9,8,7,6,5,4,3,2,1}; for(i=0;i<3;i++) printf("%d,",t[2-i][i]);
}

程序执行后的输出结果是（ ）。
A．3,5,7,
B．7,5,3,
C．3,6,9,
D．7,5,1,

71 若有定义语句：
char s[3][10],(*k)[3],*p;
则以下赋值语句正确的是（ ）。
A．p=s;
B．p=k;
C．p=s[0];
D．k=s;

72 有定义语句：
int *p[4];
以下选项中与此语句等价的是（ ）。
A．int p[4];
B．int **p;
C．int *(p[4]);
D．int (*p)[4];

73 若有定义
int(pt)[3];
则下列说法正确的是（ ）。
A．定义了基类型为int的三个指针变量
B．定义了基类型为int的具有三个元素的指针数组pt
C．定义了一个名为pt、具有三个元素的整型数组
D．定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组

74 若有定义语句：
int a[4][10],*p,*q[4];
且0≤i<4，则错误的赋值是（ ）。
A．p=a
B．q[i]=a[i]
C．p=a[i]
D．p=&a[2][1]

75 若有定义语句：
int a[2][3],*p[3];
则以下语句中正确的是（ ）。
A．p[0]=&a[1][2];
B．p[0]=a;
C．p=a;
D．p[1]=&a;

77 设有以下说明和语句：
int x[3][4],(* p)[4];p=a;
则与表达式*(p+2)等价的选项是（ ）。
A．a[0][2]
B．(a+2)[0]
C．(*a+2)[0]
D．a[2][0]

78 有以下程序

#include<stdio.h>
main(){ int x[3][2]={0},i; for(i=0;i<3;i++)scanf("%d",x[i]); printf("%3d%3d%3d\n", x[0][0], x[0][1], x[1][0]);
}

若运行时输入：2 4 6<回车>，则输出结果为（ ）。
A． 2 0 4
B． 2 0 0
C． 2 4 0
D． 2 4 6

79 有以下程序：

#include<stdio.h>
main(){ int x[3][3] = {{2},{4},{6}}, i, *q =&x[0][0]; for(i=0;i<2;i++) { if(i==0) x[i][i+1]=*q+1; else ++q; printf("%d",*q); } printf("\n");
}

程序的运行结果是（ ）。
A．23
B．26
C．33
D．36

95 以下叙述中正确的是（ ）。
A．语句“char str[10]=“string!”;”和“char str[10]={“string!”};”并不等价
B．对于字符串常量“string!”，系统已自动在最后加入了’\0’字符，表示串结尾
C．对于一维字符数组，不能使用字符串常量来赋初值
D．在语句“char str[]=“string!”;”中，数组str的大小等于字符串的长度

96 以下正确的字符串常量是（ ）。
A．“”
B．‘abc’
C．Olympic Games
D．“\”

97 以下能正确定义字符串的语句是（ ）。
A． char str[]=“\0”;
B． char str=“kx43”;
C． char str=";
D．char str[]={‘\064’};

98 设有以下定义：
char s1[]=“0123”;
char s2[]={‘0’,‘1’,‘2’,‘3’};
则以下叙述正确的是（ ）。
A． 数组s1的长度小于s2的长度
B． 数组s1和s2的长度相同
C． 数组s1的长度大于s2的长度
D．数组s1和s2完全等价

99 以下选项中，合法的是（ ）。
A．char str3[]={‘d’, ‘e’, ‘b’, ‘u’, ‘g’, ‘\0’}
B．char str4; str4=“hello world”;
C．char name[10]; name=“china”;
D．char str1[5]=“pass”, str2[6]; str2=str1;

100 以下能正确进行字符串赋值的语句组是
A．char*ch; ch=“abc”;
B．char ch[]={‘a’, ‘b’, ‘c’};
C．char ch[3]= “abc”;
D．char ch[4]; ch=“abc”;

102 有以下程序：

#include <stdio.h>
#include <string.h>
main(){ char str[12]={'s','t', 'r', 'I', 'n', 'g'}; printf("%d\n",strlen(str));
}

程序运行后的输出结果是（ ）。
A．6
B．7
C．11
D．12

103 有以下程序：

#include <stdio.h>
main(){ char s[] = "012xy\08s34f4w2"; int i,n= 0; for(i = 0;s[i]!='0';i++) if(s[i]>'0'&& s[i]<='9')n++; printf("%d\n",n);
}

程序运行后的输出结果是（ ）。
A．0
B．3
C．7
D．8

104 有以下程序：

#include <stdio.h>
main(){ char s[]={"012xy"}; int i,n=0; for(i=0;s[i]!='\0';i++) if(s[i]>='a'&&s[i]<='z')n++; printf("%d\n",n);
}

程序运行后的输出结果是（ ）。
A．0
B．2
C．3
D．5

105 有以下程序：

#include <stdio.h>
main(){ char name[10] ={'S','T','R'}; name[2]='#'; name[6]=0; printf("%s\n",name);
}

程序运行后的输出结果是（ ）。
A．ST#
B．STR#
C．STR#0
D．STR0

106 有如下程序：

#include <stdio.h>
main(){ char name[10] ={'S','T','R','I','N','G'}; name[3]='E'; name[5]=0; printf("%s\n",name);
}

程序运行后的输出结果是（ ）。
A．STRENG
B．STRIEG
C．STREN
D．STREN0

107 有以下程序：

#include <stdio.h>
main(){ int i,j=0;char a[] = "How are you!",b[10]={0}; for(i=0;a[i];i++) if(a[i]=='') b[j++]=a[i-1]; printf("%s\n",b);
}

程序运行后的输出结果是（ ）。
A．we
B．How are you!
C．ay
D．we!

108 有以下程序：

#include <stdio.h>
main(){ int i,j=0; char a[] = "How are you",b[10]={0}; for(i=0;a[i];i++) if(a[i]==' ') b[j++]=a[i+1]; printf("%s\n",b);
}

程序运行后的输出结果是（ ）。
A．Hay
B．How are you
C．we
D．ay

109 以下选项中正确的语句组是（ ）。
A．char s[];s=“BOOK!”;
B．char *s;s={“BOOK!”};
C．char s[10];s=“BOOK!”;
D．char *s;s=“BOOK!”;

110 以下使指针指向一个字符串的选项错误的是（ ）。
A．char str[]=“string”; char * ps; *ps= str;
B．char str[]=“string”; char ps; ps= str;
C．char str[]=“strinh”, ps=str;
D．char * ps; ps=str; ps=“strinh”;

111 下列语句中，正确的是（ ）。
A．char *s; s = “Olympic”;
B．char s[7]; s= “Olympic”;
C．char *s; s= {“Olympic”};
D．char s[7]; s= {“Olympic”};

112 下面选项中的程序段，没有编译错误的是（ ）。
A．char *sp,s[10]; sp = “Hello”;
B．char *sp,s[10]; s = “Hello”;
C．char str1[10] = “conputer”, str2[10]; str2=str1;
D．char mark[]; mark = “PROGRAM”;

113 以下叙述中正确的是（ ）。
A．不能用字符串常量对字符数组名进行整体赋值操作
B．字符串常量"Hello"会被隐含处理成一个无名字符型数组，它有5个元素
C．“char str[7] = “string!”;”在语法上是合法的，运行也是安全的
D．“char *str = “Hello”;”与“char str[]; str = “Hello”;”效果是一样的

114 设有如下程序段：
char s[20]=“Bejing”,p;
p=s;
则执行p=s;语句后，以下叙述正确的是（ ）。
A．可以用p表示s[0]
B．s数组中元素的个数和p所指字符串长度相等
C．s和p都是指针变量
D．数组s中的内容和指针变量p中的内容相等

115 设有定义：
char *c;
以下选项中能够使字符型指针c正确指向一个字符串的是（ ）。
A．char str[]=“string”;c=str;
B．scanf(“%s”,c);
C．c=getchar();
D．*c=“string”;

116 有以下说明语句：
char *s = "“Name\Address\n”;
指针s所指字符串的长度是（ ）。
A．17
B．15
C．14
D．说明语句不合法

117 若有说明和语句：
char str[]=“Hello”, p; p=str;
则此时(p+5)中的值为（ ）。
A．‘\0’
B．‘o’
C．'o’的地址
D．不确定的值

118 有以下程序

#include<stdio.h>
main(){ char s[]="rstuv"; printf("%c\n",*s+2);
}

程序运行后的输出结果是（ ）。
A．tuv
B．字符t的ASCII码值
C．t
D．出错

119 有以下程序

#include<stdio.h>
main(){ char ch[]="uvwxyz",*pc; pc=ch; printf("%c\n",*(pc+5));
}

程序运行后的输出结果是（ ）。
A．0
B．z
C．元素ch[5]的地址
D．字符y的地址

120 有以下程序（字符a的ASCII码值为97）

#include <stdio.h>
main(){ char *s={"abc"}; do { printf("%d",*s%10); ++s; }while(*s);
}

程序运行后的输出结果是（ ）。
A．abc
B．789
C．7890
D．979899

121 有以下程序：

#include<stdio.h>
main(){ char s[10] = "verygood", *ps = s; ps += 4; ps = "nice"; puts(s);
}

程序的运行结果是（ ）。
A．nice
B．verynice
C．nicegood
D．verygood

127 若要求从键盘读入含有空格字符的字符串，应使用函数
（ ）。
A．gets()
B．getc()
C．getchar()
D．scanf()

128 设有定义：
char s[81];int i=0;
以下不能将一行（不超过80个字符）带有空格的字符串正确读入的语句
或语句组是（ ）。
A．gets(s);
B．while((s[i++]=getchar())!=‘\n’);s[i]= ‘\0’;
C．scanf(“%s”,s);
D．do{scanf(“%c”,&s[i]);}while(s[i++]!=‘\n’); s[i]=‘\0’;

131 有以下程序

#include <stdio.h>
main(){ char a[20],b[20],c[20]; scanf("%s%s",a,b); gets(c); printf("%s%s%s\n",a,b,c);
}

程序运行时从第一列开始输入：
This is a cat!<回车>
则输出结果是（ ）。
A．Thisisacat!
B．Thisis a
C．Thisis a cat!
D．Thisisa cat!

132 有以下程序：

#include <stdio.h>
main(){ char a[30],b[30]; scanf("%s",a); gets(b); printf("%s\n%s\n",a,b);
}

程序运行时若输入：
how are you? I am fine<回车>
则输出结果是（ ）。
A．how are you?<换行> I am fine
B．how<换行> are you? I am fine
C．how are you? I am fine
D．how are you?

133 有以下程序：

#include <stdio.h>
main(){ char a,b,c,d; scanf("%c%c",&a,&b); c=getchar(); d=getchar(); printf("%c%c%c%c\n",a,b,c,d);
}

当执行程序时，按下列方式输入数据（从第一列开始，代表回
车，注意：回车是一个字符）
12
34
则输出结果是（ ）。
A．1234
B．12
C．123
D．1234

135 有以下程序：

#include <stdio.h>
main(){ char A,B,C; B='1';C='A'; for(A=0;A<6;A++) { if(A%2)putchar(B+A);else putchar(C+A); }
}

程序运行后输出的结果是（ ）。
A．1
B．3D5FBABCDFE
C．A2C4E6
D．1123456

137 以下选项中有语法错误的是（ ）。
A．char *str[] = {“guest”};
B．char str[][10] = {“guest”};
C．char *str[3]; str[1] = “guest”;
D．char str[3][10]; str[1] = “guest”;

138 以下语句中存在语法错误的是（ ）。
A． char ss[6][20];ss[1]=“right?”;
B． char ss[][20]={“right?”};
C．char ss[6];ss[1]=“right?”;
D．charss[]={“right?”};

139 若有定义：char*ps[]={“aa”,“bb”,“cc”,“dd”};，则以下叙述正确的是
（ ）。
A．ps[0]是字符串"aa"
B．*ps[0]是字符串"aa"的首地址
C．ps[0]是字符串"aa"的首地址
D．*ps[0]是字符串"aa"

140 若有以下程序段
char str[4][12] = {“aa”,“bbb”,“ccccc”,“d”}, *strp[4];
int i;
for(i=0;i<4;i++)strp[i]=str[i];
不能正确引用字符串的选项是（ ）。
A．*strp
B．str[0]
C．strp[3]
D．strp

141 有以下程序：

#include <stdio.h>
main(){ char ch[3][5] ={"AAAA","BBBB","CC"}; printf("%s\n",ch[1]);
}

程序运行后的输出结果是（ ）。
A．AAAA
B．CC
C．BBBCC
D．BBBB

142 有以下程序：

#include <stdio.h>
main(){ char b[4][10]; int i; for(i=0;i<4;i++) scanf("%s",b[i]); printf("%s%s%s%s\n",b[0], b[1], b[2], b[3]);
}

执行时若输入：Fig flower is red.<回车>，则输出结果是（ ）。
A．Figflowerisred.
B．Figflowefis red.
C．Figflower is red.
D．Fig flower is red.

146 有以下程序：

	#include <stdio.h>main(){ char *a[]={"abcd","ef","gh","ijk"}; int i; for(i=0;i<4;i++)printf("%c",*a[i]);
}

程序运行后的输出结果是（ ）。
A．aegi
B．dfhk
C．abcd
D．abcdefghijk

151 以下关于字符串的叙述中正确的是（ ）。
A．C语言中有字符串类型的常量和变量
B．两个字符串中的字符个数相同时才能进行字符串大小的比较
C．可以用关系运算符对字符串的大小进行比较
D．空串比空格打头的字符串小

152 若有定义语句：
char s[10]=“1234567\0\0”;
则strlen(s)的值是（ ）。
A．7
B．8
C．9
D．10

153 下列选项中，能够满足“若字符串s1等于字符串s2，则执行ST”要求的是（ ）。
A．if(strcmp(s2,s1)= =0) ST;
B．if(s1==s2) ST;
C．if(strcpy(s1,s2)==1) ST;
D．if((s1-s2)==0) ST;

154 字符数组a和b中存储了两个字符串，判断字符串a和b是否相等，应当使用的是（ ）。
A．if(strcmp(a,b)= =0)
B．if(strcpy(a,b))
C．if(a= =b)
D．if(a=b)
【答案】A
【解析】C语言中，判断字符串是否相等，使用字符串比较函数strcmp()，不能使用相等操作符“==”。strcmp(s1,s2)函数比较s1和s2所指字符串的大小时，若串s1＞串s2，函数值大于0（正数）；若串s1=串s2，函数值等于0；若串s1＜串s2，函数值小于0（负数）。答案选择A选项。

155 若有定义语句
char*s1=“OK”,*s2=“ok”;
以下选项中能够输出"OK"的语句是（ ）。
A．if(strcmp(s1,s2)==0)puts(s1);
B．if(strcmp(s1,s2)!=0)puts(s2);
C．if(strcmp(s1,s2)==1)puts(s1);
D．if(strcmp(s1,s2)!=0)puts(s1);

156 若有定义语句：
char str1[] = “string”, str2[8], *str3, str4[10] = “string”;
库函数strcpy的功能是复制字符串，以下选项中错误的函数调用是（ ）。
A．strcpy(str3, “HELLO!”);
B．strcpy(str2, “HELLO!”);
C．strcpy(str1, “HELLO!”);
D．strcpy(str4, “HELLO!”);

157 以下不能将s所指字符串正确复制到t所指存储空间的是（ ）。
A．while(*t=*s){t++;s++;}
B．for(i=0;t[j]=s[i];i++);
C．do{*t++=*s++;}while(*s);
D．for(i=0,j=0;t[i++]=s[j++]; );

158 若有以下定义和语句：
char s1[10]=“abcd!”, *s2=“n123\”;
printf(“%d%d\n”, strlen(s1), strlen(s2));
则输出结果是（ ）。
A．55
B．105
C．107
D．58

159 有以下程序

#include <stdio.h>
#include <string.h>
main(){ printf("%d\n",strlen("ATS\n012\1"));
}

程序运行后的输出结果是（ ）。
A．3
B．8
C．4
D．9

160 以下语句的输出结果是（ ）。
printf(“%d\n”,strlen(“\t”\065\xff\n"));
A．5
B．8
C．14
D．输出项不合法，无正常输出

161 有如下程序：

#include <stdio.h>
#include <string.h>
main(){ printf("%d\n",strlen("0\t\nA011\1"));
}

程序运行后的输出结果是（ ）。
A．8
B．9
C．7
D．10

163 有以下程序：

#include<stdio.h>
#include<string.h>
main(){ char str[]={"Hello,Beijing"};printf("%d,%d\n",strlen(str),sizeof(str));
}

程序的运行结果是（ ）。
A．13,13
B．13,14
C．13,15
D．14,15

170 有以下程序：

#include <stdio.h>
#include <string.h>
main(){ char a[20]="ab",b[20]="cdef"; int k=0; strcat(a,b); while(a[k]!='\0') { b[k]=a[k]; k++; }puts(b);
}

程序的运行结果是（ ）。
A．abcdef
B．cbcdef
C．cdef
D．ab

173 有以下程序：
#include <stdio.h>#include <string.h>main(){ char
s[]=“Beijing”; printf(“%d\n”, strlen(strcpy(s,“China”)));}
程序运行后的输出结果是（ ）。
A．5
B．7
C．12
D．14

1.5 考点必背

1. 数组是同种数据类型有序数据的集合，数据必须先定义后使用，定义的同时，系统给该数组分配一个连续的空间。
2. 数组名表示数组的首地址，是一个地址常量，数组原数的引用从 0 开始。
3. 动态数组：int a[10]={};里面的值为任意值；int a[10]={1,2,3,4}后面未赋值的默认为 0；静态数组：static int a[5]；未赋值则默认为 0。 赋值的个数应≤长度。
4. 二维数组当全部赋值时可以缺少行值，不能缺少列值。
5. 当行值缺少时，如何确定行值？若个数能整出列值，则行值为其商，若不能，则行值为其商加 1。
6. scanf（“%s”，c）对字符串进行输入时，遇到回车，空格结束。printf（“%s”，c）对字符串进行输出时，遇到空格，’\0’结束。
7. 一般对字符串输入输出时，用 gets（c）； puts（c）；
8. 字符串不是数据类型，是构造类型。它的实际长度为字符个数，存储长度为字符个数再加 1。（‘a’是字符常量占 1 个字节，“a”是字符串常量占 2 个字节因为多了结束标志’\0’）。
9. char a[i] 最多存储 i—1 个字符，还有一个存储’\0’。

第7章 用函数实现模块化程序设计

1.1 考试内容

1.函数：函数定义的格式，包括类型、参数及返回值；
2.存储类别：存储类别的含义、使用方法；
3.函数的运用：定义函数、调用函数、递归函数。

1.2 基本要求

1.理解一般问题的解决方法和程序的结构化、模块化设计思想；
2.掌握一般函数定义和调用，掌握形式参数的表达方式，函数返回值类型和返回值的表达方式；
3.掌握递归函数的定义和调用；
4.掌握局部变量、全局变量的定义方法和声明形式；
5.理解变量的存储类别，理解内部函数与外部函数的含义。

1.3 主要知识点

一、函数的作用

1.概述
函数是指功能。每一个函数用来实现一个特定的功能，函数的名字应反映其代表的功能。如图7-1 是一个程序中函数调用的示意图。

2.函数分类
(1)从用户使用的角度划分
①库函数
库函数是由系统提供的，用户不必自己定义，可直接使用它们。
②用户自己定义的函数
(2)从函数的形式划分
①无参函数
在调用无参函数时，主调函数不向被调用函数传递数据。
②有参函数
主调函数在调用被调用函数时，通过参数向被调用函数传递数据。

二、定义函数

1.原因
(1)概述.
C语言要求，在程序中用到的所有函数，必须“先定义，后使用”。
(2)主要内容
①指定函数的名字;
②指定函数的类型，即函数返回值的类型;
③指定函数的参数的名字和类型;
④指定函数的功能。
(3)库函数
对于C编译系统提供的库函数，只须用#include指令把有关的头文件包含到本文件模块中即可。
2.定义方法
(1)定义无参函数
类型名函数名()
{
函数体
}
对于有返回值的函数，必须要有相应的返回值(通常是用return语句进行返回)。
(2)定义有参函数
类型名函数名(形式参数表列)
{
函数体
}
(2)定义有参函数
类型名函数名(形式参数表列)
{
函数体
}
(3)定义空函数
在程序设计中有时会用到空函数，它的形式为
类型名函数名()
{}
函数体是空的，调用此函数时，什么工作也不做，没有任何实际作用。

三、调用函数

1.函数调用的形式
(1)一般形式
函数名(实参表列);
若有参数，则用逗号隔开:若无参数，则括号中为空。
(2)函数调用方式
①函数调用语句
把函数调用单独作为一个语句。
②函数表达式
函数调用出现在另一个表达式中，这时要求函数带回一个确定的值以参加表达式的运算。
③函数参数
函数调用作为另一个函数调用时的实参。
2.函数调用时的数据传递
定义函数时括号中的参数为形参，调用该函数括号中的参数为实参，在调用函数过程中发生的实参与形参间
的数据传递，常称为“虚实结合”。实参向形参的数据传递是“值传递”，单向传递，只能由实参传给形参，而不.
能由形参传给实参。
3.函数调用的过程
函数调用过程如图7-2所示。

4.函数的返回值
return语句的返回值类型必须和所定义的函数值类型相同，若无返回值则定义函数为void类型。

四、对被调用函数的声明和函数原型

在一个函数中调用另一个函数( 即被调用函数)需要具备如下条件:
(1)首先被调用的函数必须是已经定义的函数。
(2)如果使用库函数，应该在本文件开头用#include指令进行调用。
(3)如果被调函数在主调函数之后，则应进行声明，函数原型格式如下:
类型名函数名(形参类型1,形参类型…);
[说明]如果已在文件的开头(在所有函数之前)，已对本文件中所调用的函数进行了声明，则在各函数中
不必对其所调用的函数再作声明。写在所有函数前面的外部声明在整个文件范围中有效。

五、函数的嵌套调用

嵌套即在调用一个函数的过程中，又调用另一个函数，如图7-3所示。

六、函数的递归调用

1.定义
在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。
2.分类
(1)直接调用本函数
在定义函数f的过程中，又要调用f函数，这是直接调用本函数，如图7-4所示。

(2)间接调用本函数
如果在调用fl函数过程中要调用f2函数,而在调用f2函数过程中又要调用f1函数,这是间接调用本函数，如图7-5所示。

[说明]为了防止出现无终止的调用，应该用相关的控制语句(如if)来终止自身调用。

七、数组作为函数参数

1.数组元素作函数实参
数组元素可以用作函数实参，不能用作形参。在用数组元素作函数实参时，把实参的值传给形参，是“值传递”方式。数据传递的方向是从实参传到形参，单向传递。
2.一维数组名作函数参数
用数组名既可以做形参也可以做实参，当用数组名作函数实参时，向形参( 数组名或指针变量)传递的是数组首元素的地址。
3.多维数组名作函数参数
可以用多维数组名作为函数的实参和形参，在被调用函数中对形参数组定义时可以指定每一-维的大小，也可
以省略第一维的大小说明。

八、局部变量和全局变量

1.局部变量
(1)定义
局部变量是指在程序中只在特定过程或函数中可以访问的变量。
(2)定义位置
①在函数的开头定义;
②在函数内的复合语句内定义;
③在函数的外部定义。
(3)作用范围
①只在所定义的函数中有效;
②不同函数可以使用相同变量名;
③形式参数只能在本函数内使用;
④在复合语句中的变量作用仅限于该语句。
2.全局变量
(1)概述
在函数之外定义的变量称为外部变量，外部变量是全局变量(也称全程变量)。全局变量可以为本文件中其
他函数所共用。它的有效范围为从定义变量的位置开始到本源文件结束。一般将全局变量名的第1个字母用大写
表示。
(2)作用
设置全局变量增加了函数间数据联系的渠道。由于同一文件中的所有函数都能引用全局变量的值,因此如果
在一个函数中改变了全局变量的值，就能影响到其他函数中全局变量的值。

2.变量的生存期
变量按生存期划分有:

一般地所有全局变量以及静态的局部变量存放在静态存储区中。
3.变量的作用域
变量按作用域划分有:

4.关于作用域和生存期的概念，表7-1是变量的作用域和生存期。

十、关于变量的声明和定义

一般为了叙述方便，把建立存储空间的声明称定义，而把不需要建立存储空间的声明称为声明。显然这里指
的声明是狭义的，即非定义性声明。例如:

十一、内部函数和外部函数

1.内部函数
如果一个函数只能被本文件中其他函数所调用，它称为内部函数。在定义内部函数时，在函数名和函数类型
的前面加static,即
static类型名函数名(形参表);
内部函数又称静态函数,因为它是用static声明的。使用内部函数,可以使函数的作用域只局限于所在文件。
2.外部函数
(1)定义
如果在定义函数时，在函数首部的最左端加关键字extern，则此函数是外部函数，可供其他文件调用。C语
言规定，如果在定义函数时省略extern,
则默认为外部函数。
(2)调用
在需要调用此函数的其他文件中，需要对此函数作声明。在对此函数作声明时，要加关键字extern,表示该
函数“是在其他文件中定义的外部函数”。

1.4 练习题库

1 在源程序的开始处加上“#include<stdio.h>”进行文件引用的原因，以下叙述正确的是（ ）。
A．stdio.h文件中包含标准输入输出函数的函数说明，通过引用此文件以便能正确使用printf、scanf等函数
B．将stdio.h中标准输入输出函数链接到编译生成的可执行文件中，以便能正确运行
C．将stdio.h中标准输入输出函数的源程序插入到引用处，以便进行编译链接
D．将stdio.h中标准输入输出函数的二进制代码插入到引用处，以便进行编译链接

2 有以下程序：
#include<stdio.h>main(){ printf(“%d\n”,NULL);}
程序运行后的输出结果是（ ）。
A．0
B．变量无定义，输出不确定
C．-1
D．1

3 若有代数式 （其中e仅代表自然对数的底数，不是变量），
则以下能够正确表示该代数式的C语言表达式是（ ）。
A．sqrt(fabs(pow(n,x)+exp(x)))
B．sqrt(fabs(pow(n,x)+pow(x,e)))
C．sqrt(abs(n^x+ex))
D．sqrt(fabs(pow(x,n)+exp(x)))

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

5 若函数调用时的实参为变量时，以下关于函数形参和实参的叙述中正确的是（ ）。
A．函数的形参和实参分别占用不同的存储单元
B．形参只是形式上的存在，不占用具体存储单元
C．同名的实参和形参占同一存储单元
D．函数的实参和其对应的形参共占同一存储单元

6 以下叙述中错误的是（ ）。
A．当在程序的开头包含头文件stdio.h时，可以给指针变量赋NULL
B．函数可以返回地址值
C．改变函数形参的值，不会改变对应实参的值
D．可以给指针变量赋一个整数作为地址值

7 以下叙述中错误的是（ ）。
A．C程序必须由一个或一个以上的函数组成
B．函数调用可以作为一个独立的语句存在
C．若函数有返回值，必须通过return语句返回
D．函数可以通过实际参数和形式参数之间进行数据传递

8 以下叙述中正确的是（ ）。
A．不同函数的形式参数不能使用相同名称的标识符
B．用户自己定义的函数只能调用库函数
C．实用的C语言源程序总是由一个或多个函数组成
D．在C语言的函数内部，可以定义局部嵌套函数

9 C语言程序中，若函数无返回值，则应该对函数说明的类型是（ ）。
A．int
B．double
C．char
D．void

10 以下叙述中错误的是（ ）。
A．函数的返回值类型不能是结构体类型，只能是简单类型
B．函数可以返回指向结构体变量的指针
C．可以通过指向结构体变量的指针访问所指结构体变量的任何成员
D．只要类型相同，结构体变量之间可以整体赋值

11 以下关于return语句的叙述中正确的是（ ）。
A．一个自定义函数中必须有一条return语句
B．一个自定义函数中可以根据不同情况设置多条return语句
C．定义成void类型的函数中可以有带返回值的return语句
D．没有return语句的自定义函数在执行结束时不能返回到调用处

12 以下叙述中错误的是（ ）。
A．用户定义的函数中可以没有return语句
B．用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值
C．用户定义的函数中若没有return语句，则应当定义函数为void类型
D．函数的return语句中可以没有表达式

13 以下关于函数的叙述中正确的是（ ）。
A．函数调用必须传递实参
B．函数必须要有形参
C．函数必须要有返回值
D．函数形参的类型与返回值的类型无关

14 下面的函数调用语句中func函数的实参个数是（ ）。
func(f2(v1,v2), (v3,v4,v5), (v6,max(v7,V8)));
A．3
B．4
C．5
D．8

15 函数调用语句：
fun((exp1,exp2),(exp1,exp2,exp3));含有的实参个数
是（ ）。
A．1
B．4
C．5
D．2

16 avg函数的功能是求整型数组中的前若干个元素的平均值，设数组元素个数最多不超过10，则下列函数说明语句错误的是（ ）。
A．int avg(int *a,int n);
B．int avg(int a[10],int n);
C．int avg(int a,int n);
D．int avg(int a[],int n);

17 以下程序的主函数中调用了在其前面定义的函数fun：

#include <stdio.h>…
main(){ double a[15],k; k=fun(a); …
}

则以下选项中错误的fun函数首部是（ ）。
A．double fun(double a[15])
B．double fun(double*a)
C．double fun(double a[])
D．double fun(double a)

18 在C语言程序中，下列说法中正确的是（ ）。
A．函数的定义可以嵌套，但函数的调用不可以嵌套
B．函数的定义不可以嵌套，但函数的调用可以嵌套
C．函数的定义和调用均不可以嵌套
D．函数的定义和调用均可以嵌套

19 设有函数定义：
void sub(int k,char ch){
…
}
则以下对函数sub的调用语句中，正确的是（ ）。
A．sub(1,97);
B．sub(2,‘97’);
C．h=sub(3,‘a’);
D．sub(4,“a”);

20 有以下程序：

#include <stdio.h>
int f(int x);
main(){ int a,b=0; for(a=0;a<3;a++) {b=b+f(a); putchar('A'+b); }
}
int f(int x){return x*x+1;
}

程序运行后的输出结果是（ ）。
A．ABE
B．BDI
C．BCF
D．BCD

21 有以下函数：

#include <stdio.h>
void func(int n){int i; for(i=0;i<=n;i++)printf("*"); printf("#");
}
main(){func(3); printf("????"); func(4); printf("\n");
}

程序运行后的输出结果是（ ）。
A．#???#
B．#???#
C．#???#
D．****#???*#

22 有以下函数：

#include <stdio.h>
void exch(int t[]){ t[0] = t[5];
}
main(){int x[10] = {1,2,3,4,5,6,7,8,9,10},i=0; while(i <= 4) {  exch(&x[i]);i++;} for(i = 0;i <5;i++)printf("%d",x[i]); printf("\n");
}

程序运行后的输出结果是（ ）。
A．2 4 6 8 10
B．1 3 5 7 9
C．1 2 3 4 5
D．6 7 8 9 10

23 有如下程序：

#include <stdio.h>
int sum(int a,int b){return a+b-2;
}
main(){ int i; for(i = 0;i <5;i++) printf("%d",sum(i,3)); printf("\n");
}

程序运行后的输出结果是（ ）。
A．54321
B．01234
C．45678
D．12345

24 有以下程序

#include <stdio.h>
int f(int n){ int t=0,a=5; if(n/2) { int a=6; t+=a++; } else { int a=7; t+=a++; } return t+a++;
}
main(){int s=0,i=0; for(;i<2;i++)s+=f(i); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．24
B．28
C．32
D．36

25 有以下程序：

#include <stdio.h>
double f(double x);
main(){ double a=0; int i; for(i=0;i<30;i+=10)a+=f((double)i); printf("%5.0f\n",a);
}
double f(double x){ return x*x+1;
}

程序运行后的输出结果是（ ）。
A． 503
B． 401
C． 500
D． 1404

26 有以下程序：

#include <stdio.h>
int fun(int x, int y){ if(x==y)return(x); elsereturn((x+y)/2);
}
main(){ int a=4,b=5,c=6; printf("%d\n",fun(2*a,fun(b,c)));
}

程序运行后的输出结果是（ ）。
A．3
B．6
C．8
D．12

27 有以下程序

#include <stdio.h>
int f(int x);
main(){ int n=1,m; m=f(f(f(n))); printf("%d\n",m);
}
int f(int x){ return x*2;
}

程序运行后的输出结果是（ ）。
A．1
B．2
C．4
D．8

28 有以下程序：

#include <stdio.h>
int f(int x, int y){ return((y-x)*x);
}
main(){ int a=3,b=4,c=5,d;d=f(f(a,b),f(a,c)); printf("%d\n",d);
}

程序运行后的输出结果是（ ）。
A．10
B．9
C．8
D．7

29 有以下程序

#include <stdio.h>
int fun(int a,int b){ return a+b;
}
main(){ int x = 6,y=7,z = 8,r; r = fun(fun(x,y),z--); printf("%d\n",r);
}

程序运行后的输出结果是（ ）。
A．15
B．21
C．20
D．31

30 有以下程序

#include <stdio.h>
int f(int x);
main(){ int n=1,m; m=f(f(f(n))); printf("%d\n",m);
}
int f(int x){ return x*2;
}

程序运行后的输出结果是（ ）。
A．4
B．2
C．8
D．1

31 有以下程序

#include <stdio.h>
int fun1(double a){ return (int)(a*= a);
}int fun2(double x,double y){ double a = 0,b = 0; a = fun1(x); b = fun1(y); return (int)(a+b);
}main(){ double w; w = fun2(1.1,2.0); printf("%4.2f",w);
}

程序执行后输出结果是（ ）。
A．5
B．5.00
C．5.21
D．0.0

32 若有以下函数首部
int fun(double x[10],intn)
则下面针对此函数的函数声明语句中正确的是（ ）。
A．int fun(double,int*);
B．int fun(double,int);
C．int fun(double x,int n);
D．int fun(double x,intn);

33 若各选项中所用变量已正确定义，函数fun中通过return语句返回一个函数值，以下选项中错误的程序是（ ）。
A．
float fun(int a,int b){
……
}
main(){
……
x=fun(i,j);
……
}
B．
main(){
……
x=fun(2,10);
……
}
float fun(int a,int b){
……
}
C．
float fun(int,int);
main(){
……
x=fun(2,10);
……
}
float fun(int a,int b){
……
}
D．
main(){
float fun(int i,int j);
……
x=fun(i,j);
……
}
float fun(int a,int b){
……
}

34 有以下程序：

#include <stdio.h>main(){ 
int findmax(int,int,int),m;… m=findmax(a,b,c);…
}
int findmax(int x,int y,int z){ …
}

则以下叙述正确的是（ ）。
A．在main函数中声明了findmax函数
B．在main函数中定义了findmax函数
C．在main函数中两次调用了findmax函数
D．在main函数内、外重复定义了findmax函数

35 以下关于C语言函数参数传递方式的叙述正确的是（ ）。
A．数据只能从实参单向传递给形参
B．数据可以在实参和形参之间双向传递
C．数据只能从形参单向传递给实参
D．C语言的函数，参数既可以从实参单向传递给形参，也可以在实参和形参之间双向传递，可视情况选择使用

36 有以下程序：

#include <stdio.h>
void fun(int p){int d=2; p=d++; printf("%d",p);
}
main(){ int a=1; fun(a); printf("%d\n",a);
}

程序运行后的输出结果是（ ）。
A．32
B．12
C．21
D．22

37 有以下程序：

#include<stdio.h>
void fun(int a,int b){ int t; t=a; a=b; b=t;
}
main(){ int c[10]={1,2,3,4,5,6,7,8,9,0},i; for(i=0;i<10;i+=2)fun(c[i],c[i+1]); for(i=0;i<10;i++)printf("%d,",c[i]); printf("\n");
}

程序运行的结果是（ ）。
A．1,2,3,4,5,6,7,8,9,0,
B．2,1,4,3,6,5,8,7,0,9,
C．0,9,8,7,6,5,4,3,2,1,
D．0,1,2,3,4,5,6,7,8,9,

38 设有定义语句int(*f)(int);，则以下叙述中正确的（ ）。
A．f是基类型为int的指针变量
B．f是指向函数的指针变量，该函数具有一个int类型的形参
C．f是指向int类型一维数组的指针变量
D．f是函数名，该函数的返回值是基类型为int类型的地址

39 设有以下函数：
void fun(int n,char* s){……}
则下面对函数指针的定义和赋值均是正确的是（ ）。
A．void (* pf)();pf=fun;
B．void *pf();pf=fun;
C．void * pf(); pf=fun;
D．void ( pf)(int,char);pf=&fun;

40 有以下程序

#include <stdio.h>
int add(int a,int b){ return (a+b);
}
main(){ int k,(*f)(),a=5,b=10; f=add; …
}

则以下函数调用语句错误的是（ ）。
A．k=*f(a,b);
B．k=add(a,b);
C．k=(*f)(a,b);
D．k=f(a,b);

41 以下叙述中正确的是（ ）。
A．简单递归不需要明确的结束递归的条件
B．任何情况下都不能用函数名作为实参
C．函数的递归调用不需要额外开销，所以效率很高
D．函数既可以直接调用自己，也可以间接调用自己

42 有以下程序：

#include <stdio.h>
int fun(int n){ if(n==1) return 1; else return(n+fun(n-1));
}
main(){ int x; scanf("%d",&x); x=fun(x); printf("%d\n",x);
}

执行程序时，给变量x输入10，程序的输出结果是（ ）。
A．55
B．54
C．65
D．45

43 有以下程序：

#include<stdio.h>
int fun(int n){ if(n)return fun(n-1)+n; elsereturn 0;
}
main(){ printf("%d\n",fun(3));
}

程序的运行结果是（ ）。
A．4
B．5
C．6
D．7

44 有以下函数：

#include <stdio.h>
void fun(char c){ if(c>'x')fun(c1); printf("%c",c);
}
main(){ fun('z');
}

程序运行后的输出结果是（ ）。
A．xyz
B．wxyz
C．zyxw
D．zyx

45 有如下程序：

#include <stdio.h>
void convert(char ch){ if(ch<'D')convert(ch+1); printf("%c",ch);
}
main(){ convert('A'); printf("%\n");
}

程序运行后的输出结果是（ ）。
A．ABCDDCBA
B．ABCD
C．A
D．DCBA

46 设有如下函数定义：

int fun(int k){ if(k<1) return 0; else if(k==1) return 1; elsereturn fun(k-1)+1;
}

若执行调用语句：n=fun(3);，则函数fun()总共被调用的次数是
（ ）。
A．2
B．3
C．4
D．5

47 以下程序：

#include <stdio.h>
void fun(int x){ if(x/2>1)fun(x/2); printf("%d",x);
}
main(){ fun(7); printf("\n");
}

程序运行后的结果是（ ）。
A．137
B．731
C．73
D．37

48 有以下程序：

#include <stdio.h>
void fun(int n){ int i; if((i=n/10)!=0) fun(i); putchar(n%10+'0');
}
main(){ fun(256);
}

程序运行后的输出结果是（ ）。
A．256
B．652
C．2560
D．52

49 有如下程序：

#include<stdio.h>
void get_put(){ char ch; ch=getchar(); if(ch!='\n')get_put(); putchar(ch);
}
main(){ get_put(); printf("\n");
}

程序运行时，输入1234<回车>，则输出结果是（ ）。
A．1234
B．4321
C．4444
D．1111

50 有如下程序：

#include<stdio.h>
void get_put(){ char ch; ch=getchar(); if(ch!='\n')get_put(); putchar(ch);
}
main(){ get_put();
}

程序运行时，输入ABCD<回车>，则输出结果是（ ）。
A．DCDC
B．DCBA
C．BABA
D．ABCD

51 有以下程序：

#include<stdio.h>
void fac2(int);
void fac1(int n){  printf("*"); if(n>0)fac2(n-1);
}
void fac2(int n){ printf("#"); if(n>0)fac2(--n);
}
main(){ fac1(3);
}

程序的运行结果是（ ）。
A．###
B．##*
C．**##f
D．##

52 有以下程序

#include<stdio.h>
int fun(int x){ int p; if(x==0||x==1) return (3); p=x-fun(x-2); return p;
}
main(){ printf("%d\n",fun(7));
}

执行后的输出结果是（ ）。
A．2
B．3
C．7
D．0

53 有以下程序：

#include<stdio.h>
int f(int x){ int y; if(x==0||x==1) return (3); y=x*x-f(x-2); return y;
}
main(){ int z; z=f(3); printf("%d\n",z);
}

程序的运行结果是（ ）。
A．0
B．9
C．6
D．8

54 有以下程序

#include<stdio.h>
int f(int t[],int n);
main(){ int a[4]={1,2,3,4},s; s=f(a,4); printf("%d\n",s);
}
int f(int t[],int n){ if(n>0)return t[n-1]+f(t,n-1); else return 0;
}

程序运行后的输出结果是（ ）。
A．4
B．10
C．14
D．6

55 有以下程序：

#include<stdio.h>
int fun(int a,int b){ if(b==0)return a; elsereturn (fun(--a,--b));
}
main(){ printf("%d\n",fun(4,2));
}

程序运行的结果是（ ）。
A．1
B．2
C．3
D．4

56 若有以下程序

#include<stdio.h>
int f(int a[],int n){ if(n>1) { int t; t=f(a,n-1); return t>a[n-1]?t:a[n-1]; } else return a[0];
}
main(){ int a[]= {8,2,9,1,3,6,4,7,5}; printf("%d\n",f(a,9));
}

则程序的输出结果是（ ）。
A．1
B．9
C．8
D．5

57 有以下程序：

#include<stdio.h>
int f(int x[],int n){ if(n>1) { f(&x[1],n1); printf("%d,",x[0]); } else printf("%d,",x[0]);
}
main(){ int z[6]={1,2,3,4,5,6}; f(z,6); printf("\n");
}

程序的运行结果是（ ）。
A．6,5,4,3,2,1,
B．1,1
C．1,1,1,1,1,1,
D．1,2,3,4,5,6,

58 有以下程序

#include<stdio.h>
void fun(int n,int *s){ int f; if(n == 1)*s = n+ 1; else { fun(n-1,&f); *s = f; }
}
main(){ int x = 0; fun(4,&x); printf("%d\n",x);
}

程序运行后的输出结果是（ ）。
A．3
B．1
C．2
D．4

59 有如下程序：

#include<stdio.h>
int sum(int *array,int len){ if(len == 0) return array[0]; else return array[0]+sum(array+1,len1);
}
main(){ int array[5] = {1,2,3,4,5}; int res =sum(array,4); printf("%d\n",res);
}

程序运行后的输出结果是（ ）。
A．15
B．10
C．8
D．1

60 在一个C源程序文件中所定义的全局变量，其作用域为（ ）。
A．所在文件的全部范围
B．所在程序的全部范围
C．所在函数的全部范围
D．由具体定义位置和extern说明来决定范围

61 以下叙述中正确的是（ ）。
A．只要是用户定义的标识符，都有一个有效的作用域
B．只有全局变量才有自己的作用域，函数中的局部变量没有作用域
C．只有在函数内部定义的变量才是局部变量
D．局部变量不能被说明为static

62 以下叙述中正确的是（ ）。
A．在复合语句中不能定义变量
B．对于变量而言，“定义”和“说明”这两个词实际上是同一个意思
C．全局变量的存储类别可以是静态类
D．函数的形式参数不属于局部变量

63 在C语言中，只有在使用时才占用内存单元的变量，其存储类型是（ ）。
A．auto和register
B．extern和register
C．auto和static
D．static和register

64 当没有指定C语言中函数形参的存储类别时，函数形参的存储类别是（ ）。
A．外部（extern）
B．静态（static）
C．寄存器（register）
D．自动（auto）

65 以下叙述错误的是（ ）。
A．未经赋值的全局变量值不确定
B．未经赋值的auto变量值不确定
C．未经赋值的register变量值不确定
D．未经赋值的静态局部变量值为0

66 以下选项中叙述错误的是（ ）。
A．C程序函数中定义的赋有初值的静态变量，每调用一次函数，赋一次初值
B．在C程序的同一函数中，各复合语句内可以定义变量，其作用域仅限本复合语句内
C．C程序函数中定义的自动变量，系统不自动赋确定的初值
D．C程序函数的形参不可以说明为static型变量

67 设函数中有整型变量n，为保证其在未赋值的情况下初值为0，应选择的存储类别是（ ）。
A．auto
B．register
C．static
D．auto或register

68 有以下程序：

#include<stdio.h>
int sum(int *array,int len){ if(len == 0) return array[0]; else return array[0]+sum(array+1,len1);
}
main(){ int i=1,j=3; printf("%d,",i++); { int i = 0; i+=j*2; printf("%d,%d,",i,j); } printf("%d,%d\n",i,j);
}

程序运行后的输出结果是（ ）。
A．1,6,3,1,3
B．1,6,3,2,3
C．1,6,3,6,3
D．1,7,3,2,3

69 有以下程序

#include<stdio.h>
int f(int n){ int t=0,a=5; if(n/2) { int a=6; t+=a++; } else { int a=7; t+=a++; } return t+a++;
}
main(){ int s=0,i=0; for(;i<2;i++)s+=f(i); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．36
B．28
C．32
D．24

70 有以下程序：

#include<stdio.h>
void fun(int n){ static int num=1; num=num+n; printf("%d",num);
}
main(){ fun(3); fun(4); printf("\n");
}

程序运行后的输出结果是（ ）。
A．48
B．34
C．35
D．45

71 有以下函数：

#include<stdio.h>
void fun(int *s){ static int j=0; do{ s[j]=s[j]+s[j+1]; }while(++j<2);
}
main(){ int k,a[10]={1,2,3,4,5}; for(k=1;k<3;k++) fun(a); for(k=0;k<5;k++)printf("%d",a[k]); printf("\n");
}

程序运行后的输出结果是（ ）。
A．12345
B．23445
C．34756
D．35745

72 有以下程序：

#include<stdio.h>
int f(int m){ static int n=0; n+=m; return n;
}
main(){ int n=0; printf("%d",f(++n)); printf("%d\n",f(n++));
}

程序运行后的输出结果是（ ）。
A．12
B．11
C．23
D．33

73 有以下程序

#include<stdio.h>
int fun(){ static int x=1; x*=2; return x;
}
main(){ int i,s=1; for(i=1;i<=2;i++)s=fun(); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．0
B．1
C．4
D．8

74 有以下程序：

#include<stdio.h>
int fun(){ static int x=1; x*=2; return x;
}
main(){ int i,s=1; for(i=1;i<=3;i++)s*=fun(); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．0
B．10
C．30
D．64

75 有以下程序

#include<stdio.h>
int fun(){ static int x=1; x+=1; return x;
}
main(){ int i,s=1; for(i=1;i<=5;i++)s+=fun(); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．11
B．21
C．6
D．120

76 有以下程序：

#include <stdio.h>
int f(int n);
main(){ int a=3,s; s=f(a); s=s+f(a); printf("%d\n",s);
}
int f(int n){ static int a=1; n+=a++; return n;
}

程序运行以后的输出结果是（ ）。
A．7
B．8
C．9
D．10

77 有以下程序

#include<stdio.h>
int fun(int x,int y){ static int m=0,i=2; i+=m+1; m=i+x+y; return m;
}
main(){ int j=1,m=1,k; k=fun(j,m); printf("%d,",k); k=fun(j,m); printf("%d\n",k);
}

执行后的输出结果是（ ）。
A．5,11
B．5,5
C．11,11
D．11,5

78 有以下程序：

#include<stdio.h>
int fun(int a,int b){ static int m=0,i=2; i+=m+1; m=i+a+b; return m;
}
main(){ int k=4,m=1,p; p=fun(k,m); printf("%d,",p); p=fun(k,m); printf("%d\n",p);
}

程序运行后的输出结果是（ ）。
A．8,17
B．8,16
C．8,8
D．8,20

79 有以下程序

#include<stdio.h>
int fun(int x[],int n){ static int sum=0,i; for(i=0;i<n;i++)sum+=x[i]; return sum;
}
main(){ int a[]={1,2,3,4,5},b[]={6,7,8,9},s=0;s=fun(a,5)+fun(b,4); printf("%d\n",s);
}

程序执行后的输出结果是（ ）。
A．50
B．60
C．45
D．55

80 有以下程序：

#include<stdio.h>
int fun(int n){ static int t=1; int i=1; for(;i<=n;i++)t*=i; return t;
}
main(){ int t=1,i; for(i=2;i<4;i++) t+=fun(i); printf("%d\n",t);
}

程序的运行结果是（ ）。
A．8
B．11
C．15
D．4

81 有如下程序：

#include<stdio.h>
int sum(int data){ static int init=1; return init+=data;
}
main(){ int i; for(i=1;i<=1;i++)printf("%d,",sum(i)); printf("\n");
}

程序运行后的输出结果是（ ）。
A．2,
B．2,3,
C．3,
D．1,

82 有如下程序：

#include<stdio.h>
int sum(int data){ static int init=0; return init+=data;
}
main(){ int i; for(i=1;i<=5;i++)printf("%d,",sum(i)); printf("\n");
}

程序运行后的输出结果是（ ）。
A．1,3,6,10,15,
B．1,2,3,4,5,
C．0,0,0,0,0,
D．1,1,1,1,1,

83 有如下程序：

#include<stdio.h>
int *sum(int data){ static int init=0; init+=data; return &init;
}
main(){ int i,*p; for(i=1;i<=4;i++) sum(i); p=sum(0); printf("%d\n",*p);
}

程序运行后的输出结果是（ ）。
A．15
B．0
C．1
D．10

84 以下针对全局变量的叙述错误的是（ ）。
A．全局变量的作用域是从定义位置开始至源文件结束
B．全局变量是在函数外部任意位置上定义的变量
C．用extern说明符可以限制全局变量的作用域
D．全局变量的生存期贯穿于整个程序的运行期间

85 有以下程序

#include <stdio.h>
void fun2(char a,char b){ printf("%c%c",a,b);
}
char a='A',b='B';
void fun1(){ a='C'; b='D';
}
main(){ fun1(); printf("%c %c ",a,b); fun2('E','F');
}

程序的运行结果是（ ）
A．C D E F
B．A B E F
C．A B C D
D．C D A B

86 有以下程序：

#include <stdio.h>
int b=2;
int fun(int *k){ b=*k+b; return(b);
}
main(){ int a[10]={1,2,3,4,5,6,7,8},i; for(i=2;i<4;i++) { b=fun(&a[i])+b; printf("%d",b); } printf("\n");
}

程序运行后的输出结果是（ ）。
A．1012
B．810
C．1028
D．1016

87 有以下程序：

#include <stdio.h>
int a=1,b=2;
void fun1(int a,int b){ printf("%d%d",a,b);
}
void fun2(){ a=3; b=4;
}
main(){ fun1(5,6); fun2(); printf("%d%d\n",a,b);
}

程序运行后的输出结果是（ ）。
A．1256
B．5634
C．5612
D．3456

88 有以下程序：

#include <stdio.h>
int a=2;int f(){ static int n; int m; m=n=0; n++; a++; m++; return m+n+a;
}
main(){ int k; for(k=0;k<3;k++) printf("%d,",f()); printf("\n");
}

程序的运行结果是（ ）。
A．5,6,7,
B．5,7,9,
C．5,8,11,
D．5,5,5,

89 有以下程序

#include<stdio.h>
int a=4;
int f(int n){ int t=0; static int a=5; if(n%2) { int a=6; t+=a++; } else { int a=7; t+=a++; } return t+a++;
}
main(){ int s=a,i=0; for(;i<2;i++)s+=f(i); printf("%d\n",s);
}

程序运行后的输出结果是（ ）。
A．36
B．24
C．32
D．28

1.5 考点必背

1. 模块化程序设计开发方法：自上而下，逐步分解，分而治之。
2. 用户空间包括：1.程序代码区 2.动态存储区（也可写为栈区和堆区）3.静态存储区（也称为全局数据区，存储全局变量和局部变量）。
3. 函数必须先定义再声明最后调用；调用函数时，系统给该函数供配内存空间；该空间的入口地址是函数名，函数定义没有意义，只有调用时才有意义；调用时实参向形参传递数 1.传数值属于单向传递。对实参没有影响 2.传地址属于双向传递，对实参有影响，双向传递时要动 main 中值才对实参有影响。实参和形参在个数上、类型上、顺序上一一对应。
4. 只有 void 函数类型不用 return 语句，每一个形参必须有类型说明。
5. 函数遇到 return 或最后一个大括号结束。
6. 若函数类型与 return 语句返回类型不一致，以前者为标准。函数的返回值可以作为另一个函数的实参。
7. 函数的递归调用出现在条件语句之后。
8. 定义在函数内的量称为局部变量，局部变量在动态存储区内（栈区）作用域：自定义起到该函数或复合语句结束。
9. 定义在函数外的量称为全局变量，全局变量在静态存储区内，作用域:自定义起到 C 语言程序结束。
10. 编程中要尽量少使用全局变量。
11. 当全局变量与局部变量同名时，屏蔽全局变量，使用局部变量。
12. 通过外部说明可以扩展全局变量的作用域；全局变量只能定义依次，系统分配空间，初始值为 0；说明（extern）可以多次，不分配空间，不能初始化。
13. 静态局部变量是定义在函数体中且关键字“static”标识的变量，可以在函数体内或外，作用域：只在本源文件有效，初始值默认为 0.

编程必背题

题目：输入三个整数x,y,z，请把这三个数由小到大输出。

#include <stdio.h>
int main()
{int x,y,z,t;printf("\n请输入三个数字:\n");scanf("%d%d%d",&x,&y,&z);if (x>y) { /*交换x,y的值*/t=x;x=y;y=t;}if(x>z) { /*交换x,z的值*/t=z;z=x;x=t;}if(y>z) { /*交换z,y的值*/t=y;y=z;z=t;}printf("从小到大排序: %d %d %d\n",x,y,z);
}

题目：输出9*9口诀。

#include<stdio.h>
int main()
{int i,j,result;printf("\n");for (i=1;i<10;i++){for(j=1;j<=i;j++){result=i*j;printf("%d*%d=%-3d",i,j,result); /*-3d表示左对齐，占3位*/}printf("\n"); /*每一行后换行*/}
}

题目：古典问题（兔子生崽）：

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）

#include<stdio.h>
int main()
{int f1=1,f2=1,i;for(i=1;i<=40;i++){printf("%12d%12d",f1,f2);if(i%2==0) printf("\n");f1=f1+f2;f2=f1+f2;}return 0;
}

题目：判断 101 到 200 之间的素数。

```clike
#include <stdio.h>
int main()
{int i,j;int count=0;for (i=101; i<=200; i++) {for (j=2; j<i; j++) {// 如果 j 能被 i 整除再跳出循环if (i%j==0) break;}// 判断循环是否提前跳出，如果 j<i 说明在 2~j 之间,i 有可整除的数if (j>=i) {count++;printf("%d ",i);// 换行，用 count 计数，每五个数换行if (count % 5 == 0) printf("\n");}}    return 0;
}

题目：打印出所有的"水仙花数"。

所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数 本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

#include<stdio.h>int main()
{int i,x,y,z;for(i=100;i<1000;i++){x=i%10;y=i/10%10;z=i/100%10;if(i==(x*x*x+y*y*y+z*z*z))printf("%d\n",i);}return 0;
}

题目：将一个正整数分解质因数。

例如：输入90,打印出90=233*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于（小于的时候，继续执行循环）n，则说明分解质因数的过程已经结束，另外 打印出即可。
(2)但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n.重复执行第二步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。

#include<stdio.h>
int main()
{int n,i;printf("请输入整数：");scanf("%d",&n);printf("%d=",n);for(i=2;i<=n;i++){while(n%i==0){printf("%d",i);n/=i;if(n!=1) printf("*");}}printf("\n");return 0;
}

题目：利用条件运算符的嵌套来完成此题。

学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
程序分析：(a>b)?a:b这是条件运算符的基本例子。

#include<stdio.h>
int main()
{int score;char grade;printf("请输入分数： ");scanf("%d",&score);grade=(score>=90)?'A':((score>=60)?'B':'C');printf("%c\n",grade);return 0;
}

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

程序分析：
（1）最小公倍数=输入的两个数之积除于它们的最大公约数，关键是求出最大公约数；
（2）求最大公约数用辗转相除法（又名欧几里德算法）
1）证明：设c是a和b的最大公约数，记为c=gcd(a,b),a>=b,
令r=a mod b
设a=kc，b=jc，则k，j互素，否则c不是最大公约数
据上，r=a-mb=kc-mjc=(k-mj)c
可知r也是c的倍数，且k-mj与j互素，否则与前述k，j互素矛盾,
由此可知，b与r的最大公约数也是c，即gcd(a,b)=gcd(b,a mod b)，得证。
2）算法描述：
第一步：a ÷ b，令r为所得余数（0≤r
第二步：互换：置 a←b，b←r，并返回第一步。

#include<stdio.h>
int main()
{int a,b,t,r,n;printf("请输入两个数字：\n");scanf("%d %d",&a,&b);if(a<b){t=b;b=a;a=t;}r=a%b;n=a*b;while(r!=0){a=b;b=r;r=a%b;}printf("这两个数的最大公约数是%d，最小公倍数是%d\n",b,n/b);return 0;
}

题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

程序分析：利用while语句,条件为输入的字符不为’\n’。

#include<stdio.h>
int main()
{char c;int letters=0,spaces=0,digits=0,others=0;printf("请输入一些字母：\n");while((c=getchar())!='\n'){if((c>='a'&&c<='z')||(c>='A'&&c<='Z'))letters++;else if(c>='0'&&c<='9')digits++;else if(c==' ')spaces++;elseothers++;}printf("字母=%d,数字=%d,空格=%d,其他=%d\n",letters,digits,spaces,others);return 0;
}

题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。

例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。
程序分析：关键是计算出每一项的值。

#include<stdio.h>
int main()
{int s=0,a,n,t;printf("请输入 a 和 n：\n");scanf("%d%d",&a,&n);t=a;while(n>0){s+=t;a=a*10;t+=a;n--;}printf("a+aa+...=%d\n",s);return 0;
}

题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。

例如6=1＋2＋3.编程找出1000以内的所有完数。

#include<stdio.h>
#define N 1000
int main()
{int i,j,k,n,sum;int a[256];for(i=2;i<=N;i++){sum=a[0]=1;k=0;for(j=2;j<=(i/2);j++){if(i%j==0){sum+=j;a[++k]=j;}}if(i==sum){printf("%d=%d",i,a[0]);for(n=1;n<=k;n++)printf("+%d",a[n]);printf("\n");}}return 0;
}

题目：小球落地问题

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

#include<stdio.h>
int main()
{float h,s;h=s=100;h=h/2; //第一次反弹高度for(int i=2;i<=10;i++){s=s+2*h;h=h/2;}printf("第10次落地时，共经过%f米，第10次反弹高%f米\n",s,h);return 0;
}

题目：猴子吃桃问题。

猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下
的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

#include <stdio.h>
#include <stdlib.h>
int main(){int day, x1 = 0, x2;day=9;x2=1;while(day>0) {x1=(x2+1)*2;  // 第一天的桃子数是第2天桃子数加1后的2倍x2=x1;day--;}printf("总数为 %d\n",x1);return 0;
}

题目：分数求和问题。

2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
程序分析：请抓住分子与分母的变化规律。

#include <stdio.h>
int main()
{int i,t;float sum=0;float a=2,b=1;for(i=1;i<=20;i++){sum=sum+a/b;t=a;a=a+b;b=t;}printf("%9.6f\n",sum);  
}

题目：求1+2!+3!+…+20!的和。

程序分析：此程序只是把累加变成了累乘。

#include <stdio.h>int main()
{int i;long double sum,mix;sum=0,mix=1;for(i=1;i<=20;i++){mix=mix*i;sum=sum+mix;}  printf("%Lf\n",sum);  
}

题目：利用递归方法求5!。

#include <stdio.h>int main()
{int i;int fact(int);for(i=0;i<6;i++){printf("%d!=%d\n",i,fact(i));}
}
int fact(int j)
{int sum;if(j==0){sum=1;} else {sum=j*fact(j-1);}return sum;
}

题目：用递归求年龄

有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。

#include <stdio.h>
int age(n)
int n;
{int c;if(n==1) c=10;else c=age(n-1)+2;return(c);
}
int main()
{printf("%d\n",age(5));
}

题目：一个5位数，判断它是不是回文数。

即12321是回文数，个位与万位相同，十位与千位相同。
程序分析：学会分解出每一位数。

#include <stdio.h>int main( )
{long ge,shi,qian,wan,x;printf("请输入 5 位数字：");scanf("%ld",&x);wan=x/10000;        /*分解出万位*/qian=x%10000/1000;  /*分解出千位*/shi=x%100/10;       /*分解出十位*/ge=x%10;            /*分解出个位*/if (ge==wan&&shi==qian) { /*个位等于万位并且十位等于千位*/printf("这是回文数\n");} else {printf("这不是回文数\n");}
}

题目：求100之内的素数（又称质数）。

程序分析：质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。

#include<stdio.h>
#include<math.h>
int main()
{int i,j,k,n=0;for(i=2;i<=100;i++){k=(int)sqrt(i);for(j=2;j<=k;j++)if(i%j==0) break;if(j>k){printf("%d ",i);n++;if(n%5==0)printf("\n");}}return 0;
}

题目：对10个数进行排序。

程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换， 下次类推，即用第二个元素与后8个进行比较，并进行交换。

#include<stdio.h>
#define N 10
int main()
{int i,j,a[N],temp;printf("请输入 10 个数字：\n");for(i=0;i<N;i++)scanf("%d",&a[i]);for(i=0;i<N-1;i++){int min=i;for(j=i+1;j<N;j++)if(a[min]>a[j]) min=j;if(min!=i){temp=a[min];a[min]=a[i];a[i]=temp;}}printf("排序结果是:\n");for(i=0;i<N;i++)printf("%d ",a[i]);printf("\n");return 0;
}

题目：求一个3*3矩阵对角线元素之和

程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。

#include<stdio.h>
#define N 3
int main()
{int i,j,a[N][N],sum=0;printf("请输入矩阵(3*3)：\n");for(i=0;i<N;i++)for(j=0;j<N;j++)scanf("%d",&a[i][j]);for(i=0;i<N;i++)sum+=a[i][i];printf("对角线之和为：%d\n",sum);return 0;
}

题目：将一个数组逆序输出。

程序分析：用第一个与最后一个交换。

#include<stdio.h>
#define N 10
int main()
{int a[N]={0,1,2,3,4,5,6,7,8,9};int i,t;printf("原始数组是:\n");for(i=0;i<N;i++)printf("%d ",a[i]);for(i=0;i<N/2;i++){t=a[i];a[i]=a[N-1-i];a[N-1-i]=t;}printf("\n排序后的数组:\n");for(i=0;i<N;i++)printf("%d ",a[i]);printf("\n");return 0;
}

题目：打印出杨辉三角形（要求打印出10行）。

#include <stdio.h>int main()
{int i,j;int a[10][10];printf("\n");for(i=0;i<10;i++) {a[i][0]=1;a[i][i]=1;}for(i=2;i<10;i++)for(j=1;j<i;j++)a[i][j]=a[i-1][j-1]+a[i-1][j];for(i=0;i<10;i++) {for(j=0;j<=i;j++)printf("%5d",a[i][j]);printf("\n");}
}

题目：写一个函数，求一个字符串的长度

在 main 函数中输入字符串，并输出其长度。

#include <stdio.h>int main()
{int i,j;int a[10][10];printf("\n");for(i=0;i<10;i++) {a[i][0]=1;a[i][i]=1;}for(i=2;i<10;i++)for(j=1;j<i;j++)a[i][j]=a[i-1][j-1]+a[i-1][j];for(i=0;i<10;i++) {for(j=0;j<=i;j++)printf("%5d",a[i][j]);printf("\n");}
}

题目：输入一个整数，并将其反转后输出。

#include <stdio.h>
int main()
{int n, reversedNumber = 0, remainder;printf("输入一个整数: ");scanf("%d", &n);while(n != 0){remainder = n%10;reversedNumber = reversedNumber*10 + remainder;n /= 10;}printf("反转后的整数: %d", reversedNumber);return 0;
}

题目：猴子分桃

海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只 猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了 一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的， 问海滩上原来最少有多少个桃子？

#include<stdio.h>
#include<stdlib.h>
int main()
{int x,i=0,j=1;while(i<5){x=4*j;for(i=0;i<5;i++){if(x%4!=0){break;}x=(x/4)*5+1;}j++;}printf("%d\n",x);return 0;
}

题目：输入三角形的三边长，求三角形面积。

为简单起见，设输入的三边长a、b、c能构成三角形。从数学知识已知求三角形面积的公式为area=√(s(s-a)(s-b)(s-c) )
其中s=(a+b+c)/2

#include <stdio.h>
#include <math.h>void main()
{　
double a,b,c,s,area;scanf("%lf,%lf,%lf”,&a,&b,&c);s=(a+b+c)/2;area=sqrt(s*(s-a)*(s-b)*(s-c));printf(“三角形面积=%f\n”, area);
｝

题目：求出1到1000之内能被7或11整除 但不能同时被7和11整除的所有整数。要求输出结果5个一行。

#include<stdio.h>
void  main()
{
int num,n=0;
printf("1000以内能被7或11整除但又不能同时被7和11整除的数有：\n");
for(num=1;num<=1000;num++){if(num%7==0||num%11==0)if(!(num%7==0&&num%11==0)){printf("%5d",num);n=n+1;if (n%5==0)printf("\n");}
}
printf("\n");
}