二、C语言程序设计的高频考点特训
（一） C语言概述
【考点1】 C语言基础知识
1.C语言的构成
（1）源程序由函数构成，每个函数完成相对独立的功能。
（2）每个源程序中必须有且只能有一个主函数，可以放在任何位置，但程序总是从主函数开始执行。
（3）函数体：在函数后面用一对花括号括起来的部分。
（4）每个语句以分号结束，但预处理命令、函数头之后不能加分号。
（5）注释：括在“/*”与“*/”之间，没有空格，允许出现在程序的任何位置。
（6）预处理命令：以“＃”开头的语句。
2.C程序的生成过程
（1）C程序是先由源文件经编译生成目标文件，然后经过连接生成可执行文件。
（2）源程序的扩展名为.c，目标程序的扩展名为.obj，可执行程序的扩展名为.exe。
【考点2】 常量、变量和数据类型
1.标识符
（1）标识符的命名规则。
只能由字母、数字或下画线组成。
第一个字符必须是字母或下画线，不能是数字。
区分字母的大小写。
（2）标识符的分类。
C语言的标识符可以分为3类。
①关键字：C语言规定的专用的标识符，它们有着固定的含义，不能更改。
②预定义标识符：和“关键字”一样也有特定的含义。
③用户标识符：由用户根据需要定义的标识符。
命名应注意做到“见名知义”。
不能与关键字相同。
2.常量
定义：在程序运行中，其值不能被改变的量。
常量的类型：整型常量、实型常量、字符常量、字符串常量和符号常量。
（1）整型常量。
①表示形式：十进制整型常量、八进制整型常量和十六进制整型常量。
②书写形式。
十进制整型常量：基本数字范围为0～9。
八进制整型常量：以0开头，基本数字范围为0～7。
十六进制整型常量：以0x开头，基本数字范围为0～15，其中10～15写为A～F或a～f。
（2）实型常量。
①表示形式：小数形式和指数形式。
②书写形式。
十进制小数形式：小数点两边必须有数字。
指数形式：e前必须有数字，e后必须为整数。
（3）字符常量。
一个字符常量代表ASCII码字符集里的一个字符，在程序中用单撇号括起来，区分大小写。
特殊的字符常量：即转义字符。其中“\”是转义的意思，后面跟不同的字符表示不同的意思。
\n：换行。
\\：反斜杠字符“\”。
\ddd：1～3位八进制数所代表的一个ASCII字符。
\xhh：1～2位十六进制数所代表的一个ASCII字符。
（4）字符串常量。
字符串常量是用双撇号括起来的一个或一串字符。
（5）符号常量（无）。
符号常量是由预处理命令“＃define”定义的常量，在C程序中可用标识符代表一个常量。
3.变量
定义：值可以改变的量。
变量要有变量名，在使用前必须先定义。
在内存中占据一定的存储单元，不同类型的变量其存储单元的大小不同。
存储单元里存放的是该变量的值。
变量的类型：整型变量、实型变量、字符变量。
（1）整型变量。
①分类：基本型（int）、短整型（short int 或short）、长整型（long int 或 long）和无符号型（unsigned int，unsigned short， unsigned long）。
②数值范围。
整型［signed］int，占16位；短整型［signed］short［int］，占16位；长整型［signed］long［int］，占32 位；无符号整型 un-signed［int］，占16 位；无符号短整型 unsigned short［int］，占16位；无符号长整型unsigned long［int］，占32位。
（2）实型变量。
①分类：单精度类型（float）和双精度类型（double）。
②定义方法：float a；，double m；。
③所占字节：float 型在内存中占4个字节（32位），doub-le型占8个字节（64位）。单精度实数提供7位有效数字，双精度实数提供15～16位有效数字。
④实型常量：不分float型和double型，一个实型常量可以赋给一个float型或double型变量，但变量根据其自身类型截取实型常量中相应的有效数字。
（3）字符变量。
①作用：用来存放字符常量。
②定义：用关键字char定义，每个字符变量中只能存放一个字符。
③定义形式：char cr1，cr2；。
④赋值：cr1=＇m＇，cr2=＇n＇；。
⑤存储方法：存储字符对应的ASCII码到内存单元中。
字符型数据与整型数据之间可以通用，一个字符能用字符的形式输出，也能用整数的形式输出。
字符数据进行算术运算，相当于对它们的ASCII码进行运算。
4.类型的自动转换和强制转换
（1）类型的自动转换。
①当同一表达式中各数据的类型不同时，编译程序会自动把它们转变成同一类型后再进行计算。
②转换优先级为：char ＜ int ＜ float ＜ double，即左边级别“低”的类型向右边转换。
③在做赋值运算时，若赋值号左右两边的类型不同，则赋值号右边的类型向左边的类型转换；当右边的类型高于左边的类型时，则在转换时对右边的数据进行截取。
（2）类型的强制转换。
表示形式：（类型）（表达式）；
真题演练
（1）以下叙述中错误的是（ ）。
A）使用3种基本结构构成的程序只能解决简单问题
B）结构化程序由顺序、分支、循环3种基本结构组成
C）C语言是一种结构化程序设计语言
D）结构化程序设计提倡模块化的设计方法
（2）以下关于结构化程序设计的叙述中正确的是（ ）。
A）结构化程序使用GOTO语句会很便捷
B）在C语言中，程序的模块化是利用函数实现的
C）一个结构化程序必须同时由顺序、分支、循环3种结构组成
D）由3种基本结构构成的程序只能解决小规模的问题
（3）计算机能直接执行的程序是（ ）。
A） 源程序 B） 目标程序
C） 汇编程序 D） 可执行程序
（4）以下选项中关于程序模块化的叙述错误的是（ ）。
A）可采用自底向上、逐步细化的设计方法把若干独立模块组装成所要求的程序
B）把程序分成若干相对独立、功能单一的模块，可便于重复使用这些模块
C）把程序分成若干相对独立的模块，可便于编码和调试
D）可采用自顶向下、逐步细化的设计方法把若干独立模块组装成所要求的程序
（5）以下叙述中错误的是（ ）。
A）C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令
B）C程序经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件
C）用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中
D）C语言源程序经编译后生成后缀为.obj的目标程序
（6）下列叙述中错误的是（ ）。
A）C程序可以由多个程序文件组成
B）一个C语言程序只能实现一种算法
C）C程序可以由一个或多个函数组成
D）一个C函数可以单独作为一个C程序文件存在
（7）以下4个程序中，完全正确的是（ ）。
A）＃include ＜stdio.h＞
main（）；
｛/*/ programming /*/printf（＂programming！\n＂）；｝
B）＃include ＜stdio.h＞
main（）
｛/* programming */ printf（＂programming！\n＂）；｝
C）＃include ＜stdio.h＞
main（）
｛/*/*programming*/*/printf（＂programming！\n＂）；｝
D）include ＜stdio.h＞
main（）
｛/* programming */printf（＂programming！\n＂）；｝
（8）对于一个正常运行的 C 程序，以下叙述中正确的是（ ）。
A）程序的执行总是从main函数开始，在程序的最后一个函数中结束
B）程序的执行总是从程序的第一个函数开始，在main函数结束
C）程序的执行总是从main函数开始
D）程序的执行总是从程序的第一个函数开始，在程序的最后一个函数中结束
（9）以下叙述中正确的是（ ）。
A）C语言规定必须用main作为主函数名，程序将从此开始执行
B）可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行
C）C语言程序将从源程序中的第一个函数开始执行
D）main的各种大小写拼写形式都可以作为主函数名，如MAIN、Main等
（10）以下叙述中错误的是（ ）。
A）算法正确的程序可以有零个输入
B）算法正确的程序最终一定会结束
C）算法正确的程序可以有零个输出
D）算法正确的程序对于相同的输入一定有相同的结果
（11）以下叙述中正确的是（ ）。
A）C语句必须在一行内写完
B）C程序中的每一行只能写一条语句
C）C语言程序中的注释必须与语句写在同一行
D）简单C语句必须以分号结束
（12）以下叙述中正确的是（ ）。
A）用C语言编写的程序只能放在一个程序文件中
B）C程序书写格式严格，要求一行内只能写一个语句
C）C程序中的注释只能出现在程序的开始位置和语句的后面
D）C程序书写格式自由，一个语句可以写在多行上
（13）以下关于C语言的叙述中正确的是（ ）。
A）C语言的数值常量中夹带空格不影响常量值的正确表示
B）C语言中的变量可以在使用之前的任何位置进行定义
C）在C语言算术表达式的书写中，运算符两侧的运算数类型必须一致
D）C语言中的注释不可以夹在变量名或关键字的中间
（14）下列叙述中错误的是（ ）。
A）C程序可以由多个程序文件组成
B）一个C语言程序只能实现一种算法
C）C程序可以由一个或多个函数组成
D）一个C函数可以单独作为一个C程序文件存在
（15）C语言源程序名的后缀是（ ）。
A） .C B） .exe C） .obj D） .cp
（16）下列叙述中正确的是（ ）。
A）C程序中所有函数之间都可以相互调用
B）C程序中main函数的位置是固定的
C）在C程序的函数中不能定义另一个函数
D）每个C程序文件中都必须要有一个main函数
（17）以下叙述中正确的是（ ）。
A）C语言函数可以嵌套调用，例如：fun（fun（x））
B）C语言程序是由过程和函数组成的
C）C语言函数不可以单独编译
D）C语言中除了main函数外，其他函数不可作为单独文件形式存在
（18）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int a=0，b=0；
/* 给a赋值 a=10；b=20；给b赋值 */
printf（＂a+b=% d\n＂，a+b）；
/* 输出计算结果 */
｝
程序的运行结果是（ ）。
A） 出错 B） a+b=30 C） a+b=10 D） a+b=0
（19）以下叙述中错误的是（ ）。
A）C程序在运行过程中的所有计算都以二进制方式进行
B）C程序在运行过程中的所有计算都以十进制方式进行
C）所有C程序都需要编译链接无误后才能运行
D）C程序中字符变量存放的是字符的ASCII码值
（20）以下选项中不合法的标识符是（ ）。
A） &a B） FOR C） print D） _00
（21）按照C语言规定的用户标识符命名规则，不能出现在标识符中的是（ ）。
A） 大写字母 B） 下画线
C） 数字字符 D） 连接符
（22）以下选项中，能用作用户标识符的是（ ）。
A） _0_ B） 8_8 C） void D） unsigned
（23）下列定义变量的语句中错误的是（ ）。
A） int _int； B） double int_；
C） char For； D） float US＄；
（24）以下选项中，不合法的C语言用户标识符是（ ）。
A） a_b B） AaBc C） a--b D） _1
（25）阅读以下程序：
＃include ＜stdio.h＞
main（）
｛ int case；
float printF；
printf（＂请输入2个数：＂）；
scanf（＂% d % f＂，&case，&printF）；
printf（＂% d % f\n＂，case，printF）；
｝
该程序在编译时产生错误，其出错原因是（ ）。
A）定义语句出错，case是关键字，不能用作用户自定义标识符
B）定义语句出错，printF不能用作用户自定义标识符
C）定义语句无错，scanf不能作为输入函数使用
D）定义语句无错，printf不能输出case的值
（26）以下选项中合法的标识符是（ ）。
A） 1_ _ B） 1-1 C） 1_1 D） _11
（27）以下选项中能表示合法常量的是（ ）。
A） 1，200 B） 1.5E2.0 C） ＇\ ＇ D） ＂\007＂
（28）以下选项中不能作为C语言合法常量的是（ ）。
A） 0.1e+6 B） ＇cd＇ C） ＂\a＂ D） ＇\011＇
（29）以下选项中关于C语言常量的叙述错误的是（ ）。
A）经常被使用的变量可以定义成常量
B）常量分为整型常量、实型常量、字符常量和字符串常量
C）常量可分为数值型常量和非数值型常量
D）所谓常量，是指在程序运行过程中，其值不能被改变的量
（30）以下不合法的数值常量是（ ）。
A） 8.0E0.5 B） 1e1
C） 011 D） 0xabcd
（31）以下选项中不能用作C程序合法常量的是（ ）。
A） 123 B） ＇\123＇ C） 1，234 D） ＂\x7D＂
（32）以下选项中，值为1的表达式是（ ）。
A） 1 - ＇0＇ B） 1 - ＇\0＇
C） ＇1＇ -0 D） ＇\0＇ - ＇0＇
（33）以下选项中，合法的一组C语言数值常量是（ ）。
A） 12.0Xa23 4.5e0 B） 028 .5e-3 -0xf
C） .177 4e1.5 0abc D） 0x8A 10，000 3.e5
（34）以下选项中能用作数据常量的是（ ）。
A） 115L B） 0118 C） 1.5e1.5 D） o115
（35）C源程序中不能表示的数制是（ ）。
A） 十六进制 B） 八进制
C） 十进制 D） 二进制
（36）以下选项中可用作C程序合法实数的是（ ）。
A） 3.0e0.2 B） .1e0
C） E9 D） 9.12E
（37）在下列定义语句中，编译时会出现编译错误的是（ ）。
A） char a= ＇\x2d＇； B） char a= ＇\n＇；
C） char a= ＇a＇； D） char a=＂aa＂；
（38）以下不合法的字符常量是（ ）。
A） ＇\\ ＇ B） ＇\＂ ＇
C） ＇\018＇ D） ＇\xcc＇
（39）已知大写字母 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＇
（40）以下能正确定义字符串的语句是（ ）。
A） char str=＂\x43＂； B） char str［］ =＂\0＂；
C） char str= ＇＇； D） char str［］ =｛ ＇\064＇｝；
（41）以下关于字符串的叙述中正确的是（ ）。
A）空串比空格打头的字符串小
B）两个字符串中的字符个数相同时才能进行字符串大小的比较
C）可以用关系运算符对字符串的大小进行比较
D）C语言中有字符串类型的常量和变量
（42）以下正确的字符串常量是（ ）。
A） ＂\\\＂ B） ＇abc＇
C） Olympic Games D） ＂＂
（43）以下定义语句中正确的是（ ）。
A）int a=b=0；
B）char A=65+1，b= ＇b＇；
C）float a=1，*b=&a，*c=&b；
D）double a=0.0；b=1.1；
（44）以下关于 C 语言数据类型使用的叙述中错误的是（ ）。
A）若要处理如“人员信息”等含有不同类型的相关数据，应自定义结构体类型
B）若要保存带有多位小数的数据，可使用双精度类型
C）若只处理“真”和“假”两种逻辑值，应使用逻辑类型
D）整数类型表示的自然数是准确无误差的
（45）有以下程序：
＃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 6.0平台上编译运行，程序运行后的输出结果是（ ）。
A） 10，6 B） 4，4 C） 2，4 D） 4，8
（46）有以下程序：
＃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） 0.0 B） 5 C） 5.21 D） 5.00
（二） 运算符与表达式
【考点3】 常考的C语言运算符
1.C语言运算符简介
算术运算符：+，-，*，/，%。
关系运算符：＞，＞=，==，！=，＜，＜=。
位运算符：＞＞，＜＜，～，&，｜，∧。
逻辑运算符：！，｜｜，&&。
条件运算符：？：。
指针运算符：&，*。
赋值运算符：=。
逗号运算符：，。
字节运算符：sizeof。
强制运算符：（类型名）（表达式）。
其他：下标、分量、函数。
2.运算符的结合性和优先级
（1）结合性。所有的单目运算符、条件运算符、赋值运算符及其扩展运算符，结合方向都是从右向左，其余运算符的结合方向是从左向右。
（2）优先级比较。初等运算符＞单目运算符＞算术运算符（先乘除后加减）＞关系运算符 ＞逻辑运算符（不包括“！”）＞条件运算符＞赋值运算符＞逗号运算符。
初等运算符包括：圆括号（），下标运算符［］和结构体成员运算符-＞。
3.强制类型转换运算符
（1）可以利用强制类型转换符将一个表达式转换成所需类型。
（2）一般形式：（类型名）（表达式）。
4.逗号运算符和逗号表达式
（1）逗号表达式：用逗号运算符将几个表达式连接起来。
（2）一般形式：表达式1，表达式2，…，表达式n。
（3）求解过程：先求解表达式1，然后依次求解表达式2，直到表达式n的值。表达式n的值就是整个逗号表达式的值。
【考点4】 算术运算符和算术表达式
1.基本的算术运算符
（1）分类：+（加法运算符或正值运算符）、-（减法运算符或负值运算符）、*（乘）、/（除）和%（求余）。
其中，“%”运算的两端必须都是整型，其余的运算对象都可以是整型或者实型。
（2）双目运算符两边的数值类型必须一致才能进行运算，如果不一致，系统先进行一致性转换。
转换规则：char -＞short -＞int -＞unsigned -＞long -＞double-＞float。
（3）所有实数的运算都是以双精度方式进行的，若是单精度数值，则需要在尾数后面补0转换为双精度数。
2.算术表达式和运算符的优先级与结合性
（1）定义：用算术运算符和括号将运算量连接起来的、符合C语言语法规则的表达式。
（2）运算对象：函数、常量和变量等。
（3）运算规则。
可使用多层圆括号，但括号必须配对。运算时由内向外依次计算各表达式的值。
对于不同优先级的运算符，按运算符的优先级由高到低进行运算，若优先级相同，则按结合方向进行运算。
若运算符两侧的操作数类型不同，则先利用自动转换或强制类型转换，然后进行运算。
3.自加、自减运算符
（1）作用：自加运算符“++”使运算变量的值增1，自减运算符“--”使运算变量的值减1。
（2）均是单目运算符。运算对象可以是整型或实型变量，但不可以是常量和表达式。
（3）均可作为前缀运算符，也可作为后缀运算符构成一个表达式。
++i，--i：在使用i之前，先使i的值加1或者减1，再使用此时的表达式的值参加运算。
i++，i--：在使用i之后，使i的值加1或者减1，再使用此时的表达式的值参加运算。
（4）结合方向：自右向左。
【考点5】 赋值运算符和赋值表达式
1.赋值运算符和赋值表达式
（1）“=”称作赋值运算符，作用是将一个数值赋给一个变量或将一个变量的值赋给另一个变量，由赋值运算符组成的表达式称为赋值表达式。
（2）一般形式：变量名=表达式。
赋值运算符的优先级别高于逗号运算符。
赋值运算符“=”和等于运算符“==”有很大差别。
赋值运算符的左侧只能是变量，而不能是常量或者表达式。右侧可以是表达式，包括赋值表达式。
规定最左边变量所得到的新值就是整个赋值表达式的值。
2.复合的赋值运算符
在赋值运算符之前加上其他运算符可以构成复合赋值运算符。例如，+=、-=、*=、/ =、%=等。
两个符号之间不可以有空格。
复合赋值运算符的优先级与赋值运算符的相同。
3.赋值运算中的类型转换
如果赋值运算符两侧的类型不一致，在赋值前系统将自动先把右侧表达式求得的数值按赋值号左边变量的类型进行转换（也可以用强制类型转换的方式）。
【考点6】 位运算
1.C语言提供6种位运算符
按位与“&”：若两个相应的二进制位都为1，则该位的结果为1，否则为0。
按位或“｜”：两个相应的二进制位中只要有一个为1，则该位的结果为1，否则为0。
按位异或“∧”：若两个二进制位相同，则结果为0，不同则为1。
按位求反“～”：按位取反，即0变1，1变0。
左移“＜＜”：将一个数的二进制位全部左移若干位。
右移“＞＞”：将一个数的二进制位全部右移若干位。
2.说明
位运算中除“～”以外，均为双目运算符，要求两侧各有一个运算量。
运算量只能是整型或字符型数据，不能为实型数据。
真题演练
（1）表达式（int）（（double）9/2）- 9% 2的值是（ ）。
A） 0 B） 3 C） 4 D） 5
（2）若有定义int x，y；并已正确给变量赋值，则以下选项中与表达式（x-y）？（x++）：（y++）中的条件表达式（x-y）等价的是（ ）。
A）（x-y＜0｜｜x-y＞0） B）（x-y＜0）
C）（x-y＞0） D）（x-y==0）
（3）若变量已正确定义，在if（W）printf（＂% d\n＂，k）；中，以下不可替代W的是（ ）。
A） a＜ ＞b+c B） ch=getchar（）
C） a==b+c D） a++
（4）若有定义语句：int x=10；，则表达式x-=x+x的值为（ ）。
A） 0 B） -20 C） -10 D） 10
（5）设有定义：int x =2；，以下表达式中，值不为6的是（ ）。
A） 2*x，x+=2 B） x++，2*x
C） x*=（1+x） D） x*=x+1
（6）若有定义语句：int x=12，y=8，z；，在其后执行语句 z=0.9+x/y；，则z的值为（ ）。
A） 1 B） 1.9 C） 2 D） 2.4
（7）表达式3.6-5/2+1.2+5%2的值是（ ）。
A） 4.3 B） 4.8 C） 3.3 D） 3.8
（8）有定义语句：int a；long b；double x，y；，则以下选项中正确的表达式是（ ）。
A） a=x＜ ＞y B） a%（int）（x-y）
C）（a*y）%b D） y=x+y=x
（9）设变量已正确定义并赋值，下列表达式中正确的是（ ）。
A） x=y+z+5， ++y B） int（15.8% 5）
C） x=y*5=x+z D） x=25% 5.0
（10）有以下程序：
＃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，3 B） 2，3，2 C） 2，3，1 D） 2，2，1
（11）以下不能将s所指字符串正确复制到t所指存储空间的是（ ）。
A）do｛*t++=*s++；｝while（*s）；
B）for（i=0；t［i］=s［i］；i++）；
C）while（*t=*s）｛t++；s++｝
D）for（i=0，j=0；t［i++］=s［j++］；）；
（12）设有定义：int k=0；，以下选项的4个表达式中与其他3个表达式的值不相同的是（ ）。
A） ++k B） k+=1 C） k++ D） k+1
（13）若有定义语句：int year=2009，*p=&year；，以下不能使变量year中的值增至2010的语句是（ ）。
A）（*p）++； B） *p++；
C） ++（*p）； D） *p+=1；
（14）若有定义：double a=22；int i=0，k=18；，则不符合C语言规定的赋值语句是（ ）。
A）i=（a+k）＜=（i+k）；
B）i=a% 11；
C）a=a++，i++
D）i=！a；
（15）若变量x、y已正确定义并赋值，以下符合C语言语法的表达式是（ ）。
A） x+1=y B） ++x，y=x--
C） x=x+10=x+y D） double（x）/10
（16）若变量均已正确定义并赋值，以下合法的C语言赋值语句是（ ）。
A） x=y==5； B） x=n% 2.5；
C） x+n=i； D） x=5=4+1；
（17）以下选项中正确的定义语句是（ ）。
A）double，a，b；
B）double a=b=7；
C）double a；b；
D）double a=7，b=7；
（18）若有定义语句：int a=3，b=2，c=1；，以下选项中错误的赋值表达式是（ ）。
A）a=（b=4）=3；
B）a=b=c+1；
C）a=（b=4）+c；
D）a=1+（b=c=4）；
（19）表达式 a+=a -= a=9的值是（ ）。
A） 18 B） -9 C） 0 D） 9
（20）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int a=1，b=0；
printf（＂% d，＂，b=a+b）；
printf（＂% d\n＂，a=2*b）；
程序运行后的输出结果是（ ）。
A） 1，2 B） 1，0 C） 3，2 D） 0，0
（21）有以下程序：
＃include ＜stdio.h＞
main（）
｛ unsigned char a=8， c；
c = a＞＞3；
printf（＂% d\n＂，c）；
｝
程序运行后的输出结果是（ ）。
A） 16 B） 1 C） 32 D） 0
（22）有以下程序：
＃include ＜stdio.h＞
main（）
｛
unsigned char a=2，b=4，c=5，d；
d = a ｜ b；
d &= c；
printf（＂% d\n＂，d）；
｝
程序运行后的输出结果是（ ）。
A） 3 B） 4 C） 5 D） 6
（23）设有以下语句：
int a=1，b=2，c；
c=a＾（b＜＜2）；
执行后，c的值为（ ）。
A） 7 B） 9 C） 8 D） 6
（24）若有以下程序段：
int r=8；
printf（＂% d\n＂，r＞＞1）；
输出结果是（ ）。
A） 16 B） 8 C） 4 D） 2
（25）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int a=1， b=2， c=3， x；
x =（a＾b）&c；
printf（＂% d\n＂，x）；
｝
程序的运行结果是（ ）。
A） 3 B） 1 C） 2 D） 0
（26）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int a=2， b；
b = a＜＜2；
printf（＂% d\n＂，b）；
｝
程序运行后的输出结果是（ ）。
A） 2 B） 4 C） 6 D） 8
（27）有以下程序：
＃include ＜stdio.h＞
main（）
｛ char a=4；
printf（＂% d\n＂，a=a＜＜1）；
｝
程序的运行结果是（ ）。
A） 16 B） 8
C） 40 D） 4
（28）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int a=5，b=1，t；
t=（a＜＜2）｜b；
printf（＂% d\n＂，t）；
｝
程序运行后的输出结果是（ ）。
A） 1 B） 11 C） 6 D） 21
（29）若变量已正确定义，则语句s=32；s＾=32；printf（＂% d＂，s）；的输出结果是（ ）。
A） -1 B） 0
C） 1 D） 32
（三） 基本语句
【考点7】 单个字符的输入与输出
1.字符输出函数putchar（）
putchar（）函数的作用是向终端输出一个字符。
2.字符输入函数getchar（）
getchar（）函数的作用是从终端输入一个字符。
getchar（）函数没有参数，函数值就是从输入设备得到的字符。
【考点8】 数据格式的输入与输出
1.格式化输出函数printf（）
printf（）函数是C语言提供的标准输出函数，它的作用是向终端（或系统隐含指定的输出设备）按指定格式输出若干个数据。
（1）printf（）函数的一般形式。
printf（格式控制，输出表列）；
①“格式控制”：用双引号括起来的字符串是“格式控制”字符串，它包括两种信息。
格式转换说明，由“%”和格式字符组成。
需要原样输出的字符也写在格式控制内。
②“输出表列”：需要输出的一些数据，可以是常量、变量或表达式。输出表列中的各输出项用逗号隔开。
（2）格式字符。
可在“%”与格式字符之间插入“宽度说明”、左对齐符号“-”、前导零符号“0”等。
d格式符，用来对十进制数进行输入输出。
o格式符，以八进制数形式输出整数。
x格式符，以十六进制数形式输出整数。
u格式符，用来输出 unsigned 型数据，即输出无符号的十进制数。
c格式符，用来输出一个字符。
s格式符，用来输出一个字符串。
f格式符，用来输出实数（包括单、双精度），以小数形式输出，使整数部分全部输出。
e格式符，以指数形式输出实数。
g格式符，用来输出实数。
（3）使用printf（）函数时的注意事项。
在格式控制串中，格式说明与输出项从左到右在类型上必须一一对应匹配。
在格式控制串中，格式说明与输出项个数要相等。
在格式控制串中，可以包含任意的合法字符（包括转义字符），这些字符在输出时将被“原样输出”。
如果要输出“%”，则应该在格式控制串中用两个连续的百分号“%%”来表示。
2.格式化输入函数scanf（）
（1）scanf（）函数的一般形式。
scanf（格式控制，地址表列）；
其中scanf是函数名，“格式控制”的含义同 printf（）函数，“地址表列”由若干个变量地址组成，既可以是变量的地址，也可以是字符串的首地址。
（2）格式说明。
scanf（）函数中的格式说明也是以%开始，以一个格式字符结束，中间可以加入附加的字符。
●对unsigned型变量的数据，可以用% d、% o、% x格式输入。
●在scanf（）函数中格式字符前可以用一个整数指定输入数据所占宽度，但对于输入实型数则不能指定其小数位的宽度。
在格式控制串中，格式说明的个数应该与输入项的个数相等，且要类型匹配。
（3）使用scanf（）函数时的注意事项。
scanf（）函数中的输入项只能是地址表达式，而不能是变量名或其他内容。
如果在“格式控制”字串中除了格式说明以外还有其他字符，则在输入数据时应输入与这些字符相同的字符。
●在用“%c”格式输入字符时，空格字符和转义字符都可作为有效字符输入。
在输入数据时，若实际输入数据少于输入项个数， scanf（）函数会等待输入，直到满足条件或遇到非法字符才结束；若实际输入数据多于输入项个数，多余的数据将留在缓冲区备用，作为下一次输入操作的数据。
在输入数据时，遇到以下情况时认为输入结束：空格、“回车”或“跳格”（“Tab”）键，上述字符统一可称为“间隔符”。
真题演练
（1）有以下程序：
＃include ＜stdio.h＞
main（）
｛
char c1，c2，c3，c4，c5，c6；
scanf（＂% c% c% c% c＂，&c1，&c2，&c3，&c4）；
c5=getchar（）；
c6=getchar（）；
putchar（c1）；
putchar（c2）；
printf（＂% c% c\n＂，c5，c6）；
｝
程序运行后，若从键盘输入（从第1列开始）123＜回车＞ 45678＜回车＞
则输出结果是（ ）。
A） 1245 B） 1256
C） 1278 D） 1267
（2）有以下程序：
＃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）；
｝
当执行程序时，按下列方式输入数据（从第1列开始，＜CR＞代表回车，注意：回车也是一个字符）：
12＜CR＞
34＜CR＞
则输出结果是（ ）。
A）12 34
B）12
C）1234
D）12 3
（3）以下叙述中错误的是（ ）。
A）gets函数用于从终端读入字符串
B）getchar函数用于从磁盘文件读入字符
C）fputs函数用于把字符串输出到文件
D）fwrite函数用于以二进制形式输出数据到文件
（4）要求通过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）；
（5）以下不能输出字符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）；
（6）已知字符A的ASCII码值是65，字符变量c1的值是＇A＇，c2的值是＇D＇，则执行语句 printf（＂% d，% d＂，c1，c2-2）；的输出结果是（ ）。
A） 65，68 B） A，68 C） A，B D） 65，66
（7）有以下程序：
＃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） 输出无定值
（8）有如下程序段：
int x=12；
double y=3.141593；
printf（＂% d% 8.6f＂，x，y）；
其输出结果是（ ）。
A）123.141593
B）12 3.141593
C）12，3.141593
D）123.1415930
（9）若变量已正确定义为int型，要通过语句 scanf（＂% d，% d，%d＂，&a，&b，&c）；给a赋值1、给b赋值2、给 c赋值3，以下输入形式中错误的是（注：□代表一个空格符）（ ）。
A）1，2，3＜回车＞
B）□□□1，2，3 ＜回车＞
C）1，□□□2，□□□3＜回车＞
D）1□2□3＜回车＞
（10）设变量均已正确定义，若要通过 scanf（＂% d% c% d% c＂，&a1，&c1，&a2，&c2）；语句为变量 a1 和 a2 赋数值10和20，为变量c1和c2赋字符X和Y。以下所示的输入形式中正确的是（注：□代表空格字符）（ ）。
A）10□X＜回车＞
20□Y＜回车＞
B）10□X20□Y＜回车＞
C）10X＜回车＞
20Y＜回车＞
D）10□X□20□Y＜回车＞
（11）若有定义：int a，b；，通过语句 scanf（＂% d；% d＂，&a，&b）；能把整数3赋给变量a、5赋给变量b的输入数据是（ ）。
A） 3 5 B） 3，5 C） 3；5 D） 35
（12）若有定义语句：int a，b，c，*p=&c；，接着执行以下选项中的语句，则能正确执行的语句是（ ）。
A）scanf（＂% d＂，a，b，c）；
B）scanf（＂% d% d% d＂，a，b，c）；
C）scanf（＂% d＂，p）；
D）scanf（＂% d＂，&p）；
（13）设有定义：int a；float b；，执行 scanf（＂% 2d% f＂，&a，&b）；语句时，若从键盘输入 876 543.0 ＜回车＞，则a和b的值分别是（ ）。
A） 87和6.0 B） 876和543.0
C） 87和543.0 D） 76和543.0
（14）有以下程序：
＃include ＜stdio.h＞
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，则正确的输入格式是（以下［ 代表空格，＜CR＞代表回车）（ ）。
A）12［ a34［ b＜CR＞
B）［ 12 a［ 34］［ b＜CR＞
C）12，a，34，b＜CR＞
D）12a34b＜CR＞
（15）有以下程序段：
＃include ＜stdio.h＞
int j；
float y；char name［50］；
scanf（＂% 2d% f% s＂，&j，&y，name）；
当执行上述程序段时，从键盘上输入55566 7777abc后， y的值为（ ）。
A） 566.0 B） 55566.0 C） 7777.0 D） 566777.0
（四） 选择结构
【考点9】 关系运算符和关系表达式
1.关系运算符及其优先次序
C语言提供了6种关系运算符：小于（＜）、小于等于（＜=）、大于等于（＞=）、大于（＞）、等于（==）、不等于（！=）。
（1）结合性：自左向右。
（2）优先级。
前4种关系运算符（＜，＜=，＞=，＞）的优先级别相同，后两种（==，！=）优先级相同。
前4种优先级高于后两种。
关系运算符的优先级低于算术运算符，高于赋值运算符。
2.关系表达式
（1）定义：由关系运算符连成的表达式。关系运算符的两边可以是C语言中任意合法的表达式。
（2）关系运算符的结果是一个整数值——“0 或者1”，用非零值来表示“真”，用零值来表示“假”。
（3）当关系运算符两边值的类型不一致时，系统将自动转化。
【考点10】 逻辑运算符和逻辑表达式
1.逻辑运算符及其优先级
C语言提供了3 种逻辑运算符：逻辑与（&&）、逻辑或（‖）、逻辑非（！）。其中“&&”和“‖”是双目运算符，而“！”是单目运算符，要求必须出现在运算对象的左边。
（1）结合性：自左至右。
（2）优先级：“！”＞“&&”＞“‖”。
“！”＞算术运算符＞关系运算符＞“&&”＞“‖”＞赋值运算符。
2.逻辑表达式
（1）逻辑表达式由逻辑运算符和运算对象组成。
（2）参与逻辑运算的对象可以是一个具体的值，还可以是C语言中任意合法的表达式。
（3）逻辑表达式的运算结果为1（真）或者为0（假）。
A&&B运算中，只有A、B同为真时才为真。
A‖B运算中，只有A、B同为假时才为假。
关系运算符不能连用，即不能使用0＜x＜10，可改写成0＜x&&x＜10。
【考点11】 if语句和用if语句构成的选择结构
1.if语句的几种形式
（1）if（表达式）语句。
if是C语言的关键字。
表达式两侧的括号不可少，并且只能是圆括号。
紧跟着的语句，称为if子句，如果在if子句中需要多个语句，则应该使用大括号（｛｝）把一组语句括起来构成复合语句。
（2）if（表达式）语句1
else语句2
（3）if（表达式1）语句1
else if（表达式2）语句2
else if（表达式3）语句3
…
else if（表达式m）语句m
else 语句n
●“语句1”是if子句，“语句2…语句m”是else子句。这些子句在语法上要求是一条语句，当需要执行多条语句时，应该使用花括号（｛｝）把这些语句括起来组成复合语句。
else必须与if配对，共同组成if…else语句。
2.if语句的嵌套
在if语句中又包含一个或多个if语句结构，称为if语句的嵌套。
3.条件运算符构成的选择结构
（1）条件运算符：？：。
（2）条件表达式的一般形式：表达式1？表达式2：表达式3。
（3）求解过程：先求表达式1的值，当表达式1的值是非0时，以表达式2的值作为整个条件表达式的值；当表达式1的值是0时，以表达式3的值作为整个条件表达式的值。
4.优先级
条件运算符高于赋值运算符，但低于逻辑运算符、关系运算符和算术运算符。
【考点12】 switch语句
switch语句是C语言提供的多分支选择语句，用来实现多分支选择结构。
一般形式：
switch（表达式）
｛
case 常量表达式1：语句1
case 常量表达式2：语句2
…
case 常量表达式n：语句n
default：语句n+1
｝
switch后面用花括号括起来的部分是switch语句体。
●switch后面括号内的“表达式”，可以是C语言中任意合法表达式，但表达式两侧的括号不能省略。
case与其后面的常量表达式合称case语句标号，常量表达式的类型必须与switch后面的表达式的类型相匹配，且各case语句标号的值各不相同，不能重复。
default也是关键字，起标号的作用，代表除了以上所有case标号之外的那些标号，default标号可以出现在语句体中任何标号位置上，当然，也可以没有。
case语句标号后的语句1、语句2 等，可以是一条语句，也可以是若干条，在必要时，case语句标号后的语句可以省略不写。
真题演练
（1）下列选项中，当x为大于1的奇数时，值为0的表达式是（ ）。
A） x% 2==0 B） x/2
C） x% 2！=0 D） x% 2==1
（2）若a是数值类型，则逻辑表达式（a==1）｜｜（a！=1）的值是（ ）。
A） 1 B） 0
C）2 D） 不知道a的值，不能确定
（3）当变量 c的值不为2、4、6 时，值为“真”的表达式是（ ）。
A）（c＞=2 && c＜=6）&&（c% 2！=1）
B）（c==2）｜｜（c==4）｜｜（c==6）
C）（c＞=2 && c＜=6）&&！（c% 2）
D）（c＞=2 && c＜=6）｜｜（c！=3）｜｜（c！=5）
（4）有以下程序：
＃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，3，2 B） 1，3，3
C） 1，2，3 D） 3，2，1
（5）下列关于逻辑运算符两侧运算对象的叙述中正确的是（ ）。
A）可以是任意合法的表达式
B）只能是整数0或非0整数
C）可以是结构体类型的数据
D）只能是整数0或1
（6）设有宏定义：＃define IsDIV（k，n）（（k% n==1）？1：0），且变量m已正确定义并赋值，则宏调用：IsDIV（m， 5）&& IsDIV（m，7）为真时所要表达的是（ ）。
A）判断m是否能被5和7整除
B）判断m被5和7整除是否都余1
C）判断m被5或者7整除是否余1
D）判断m是否能被5或者7整除
（7）if语句的基本形式是：if（表达式）语句，以下关于“表达式”值的叙述中正确的是（ ）。
A） 必须是逻辑值 B） 必须是整数值
C） 必须是正数 D） 可以是任意合法的数值
（8）有以下计算公式：
若程序前面已在命令行中包含math.h文件，不能够正确计算上述公式的程序段是（ ）。
A）if（x＞=0）y=sqrt（x）；
if（x＜0）y=sqrt（-x）；
B）if（x＞=0）y=sqrt（x）；
else y=sqrt（-x）；
C）y=sqrt（x）；
if（x＜0）y=sqrt（-x）；
D）y=sqrt（x＞=0？x：-x）；
（9）下列条件语句中，输出结果与其他语句不同的是（ ）。
A）if（a！=0）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）printf（＂% d\n＂，x）；else printf（＂% d\n＂， y）；
（10）有以下程序：
＃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）1，1，2，0B）0，0，0，3 C）编译有错 D）0，1，2，0
（11）有以下程序段：
＃include ＜stdio.h＞
int a，b，c；
a=10；b=50；c=30；
if（a＞b）a=b，b=c；c=a；
printf（＂a=% d b=% d c=% d\n＂，a，b，c）；
程序的输出结果是（ ）。
A） a=10 b=50 c=30 B） a=10 b=50 c=10
C） a=10 b=30 c=10 D） a=50 b=30 c=50
（12）设有定义：int a=1，b=2，c=3；以下语句中执行效果与其他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；｝
（13）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int x；
scanf（＂% d＂，&x）；
if（x＜=3）；
else if（x！=10）
printf（＂% d\n＂，x）；
｝
程序运行时，输入的值在哪个范围才会有输出结果（ ）。
A）小于3的整数
B）不等于10的整数
C）大于3或等于10的整数
D）大于3且不等10的整数
（14）有以下程序：
＃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） 3 B） 2 C） 1 D） 0
（15）有嵌套的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）？（（b＜c）？a：b）：（（b＞c）？b：c）；
B）k=（a＜b）？（（a＜c）？a：c）：（（b＜c）？b：c）；
C）k=（a＜b）？a：b；k=（b＜c）？b：c；
D）k=（a＜b）？a：b；k=（a＜c）？a：c；
（16）有以下程序：
＃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） 1 B） 41 C） 2 D） 331
（17）以下程序段中，与语句k=a＞b？（b＞c？1：0）：0；功能相同的是（ ）。
A）if（（a＞b）｜｜（b＞c））k=1；
else k=0；
B）if（（a＞b）&&（b＞c））k=1；
else k=0；
C）if（a＜=b）k=0；
else if（b＜=c）k=1；
D）if（a＞b）k=1；
else if（b＞c）k=1；
else k=0；
（18）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int x=1， y=0， a=0， b=0；
switch（x）
｛ case 1：
switch（y）
｛ case 0： a++； break；
case 1：b++；break；
｝
case 2：a++；b++；break；
case 3：a++；b++；
｝
printf（＂a=% d，b=% d\n＂，a，b）；
｝
程序的运行结果是（ ）。
A） a=2，b=2 B） a=2，b=1
C） a=1，b=1 D） a=1，b=0
（19）有以下程序：
＃include ＜stdio.h＞
int i，n；
for（i=0；i＜8；i++）
｛ n = rand（） % 5；
switch（n）
｛ case 1：
case 3：printf（＂% d \n＂，n）；break；
case 2：
case 4：printf（＂% d \n＂，n）；continue；
case 0：exit（0）；
｝
printf（＂% d \n＂，n）；
｝
以下关于程序段执行情况的叙述，正确的是（ ）。
A）for循环语句固定执行8次
B）当产生的随机数n为4时结束循环操作
C）当产生的随机数n为1和2时不做任何操作
D）当产生的随机数n为0时结束程序运行
（20）若有定义：float x=1.5；int a=1，b=3，c=2；，则正确的switch语句是（ ）。
A）switch（a+b）
｛ case 1：printf（＂*\n＂）；
case 2+1：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 c：printf（＂**\n＂）；｝
（21）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int a［］ =｛2，3，5，4｝，i；
for（i=0；i＜4；i++）
switch（i% 2）
｛ case 0：switch（a［i］% 2）
｛ case 0：a［i］ ++；break；
case 1：a［i］--；
｝ break；
case 1：a［i］=0；
｝
for（i=0；i＜4；i++）printf（＂% d ＂，a［i］）；printf（＂\
n＂）；
｝
程序运行后的输出结果是（ ）。
A） 0304 B） 2050 C） 3344 D） 3040
（22）下列叙述中正确的是（ ）。
A）在switch语句中不一定使用break语句
B）在switch语句中必须使用default语句
C）break语句必须与switch语句中的case配对使用
D）break语句只能用于switch语句
（23）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int c=0，k；
for（k=1；k＜3；k++）
switch（k）
｛ default：c+=k；
case 2：c++；break；
case 4：c+=2；break；
｝
printf（＂% d\n＂，c）；
｝
程序运行后的输出结果是（ ）。
A） 7 B） 5 C） 3 D） 9
（24）有以下程序：
＃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） 02356 B） 0235 C） 235 D） 2356
（25）有以下程序：
＃include ＜stdio.h＞
main（）
｛ int s；
scanf（＂% d＂，&s）；
while（s＞0）
｛ switch（s）
｛ case 1：printf（＂% d＂，s+5）；
case 2：printf（＂% d＂，s+4）；break；
case 3：printf（＂% d＂，s+3）；
default：printf（＂% d＂，s+1）；break；｝
scanf（＂% d＂，&s）；｝ ｝
运行时，若输入123450 ＜回车 ＞，则输出结果是（ ）。
A） 66656 B） 6566456 C） 66666 D） 6666656
（26）下列选项中与 if（a==1）a=b；else a++；语句功能不同的switch语句是（ ）。
A）switch（a==1）
｛case 0：a=b；break；
case 1：a++；
｝
B）switch（a）
｛case 1：a=b；break；
default：a++；
｝
C）switch（a）
｛default：a++；break；
case 1：a=b；
｝
D）switch（a==1）
｛case 1：a=b；break；
case 0：a++；
｝
（五） 循环结构
【考点13】 while 循环语句
（1）一般形式：while（表达式）循环体。
while是C语言的关键字。
紧跟其后的表达式可以是C语言中任意合法的表达式，该表达式是循环条件，由它来控制循环体是否执行。
循环体只能是一条可执行语句，当多项操作需要多次重复做时，可以使用复合语句。
（2）执行过程。
第一步：计算紧跟while后括号中表达式的值，当表达式的值为非0时，则接着执行while语句中的内嵌语句；当表达式值为0时，则跳过该while语句，执行该while结构后的其他语句。
第二步：执行循环体内嵌语句。
第三步：返回去执行步骤（1），直到条件不满足，即表达式的值为0时，退出循环，while结构结束。
（3）特点：先对表达式进行条件判断，后执行语句。
【考点14】 do…while 语句
（1）一般形式：
do｛
循环体语句
｝while（表达式）；
do是C语言的关键字，必须和while联合使用，不能独立出现。
do…while 循环由 do 开始，用while结束。
while后面的圆括号中的表达式，可以是C语言中任意合法的表达式，由它控制循环是否执行，且圆括号不可丢。
在语法上，在do和while之间只能是一条语句，如需要执行多条语句时，可使用复合语句。
while（表达式）后的分号不可丢。
（2）执行过程。
先执行一次指定的循环体语句。
执行完后，判别while后面的表达式的值，当表达式的值为非零（真）时，程序流程返回，去重新执行循环体语句。
如此反复，直到表达式的值等于零为止，此时循环结束。
（3）特点。
先执行循环体一次，然后判断循环条件是否成立。
【考点15】 for语句
（1）一般形式为：for（表达式1；表达式2；表达式3）。
圆括号中通常是3 个表达式，用于for循环的控制。for语句中的表达式可以部分或者全部省略，但两个“；”是不可省略的。
各个表达式之间用“；”隔开，且圆括号不可省略。
按照语法规则，循环体只能是一条语句，如需要完成多项操作，须使用复合语句。
（2）执行过程。
①先求表达式1的值。②求表达式2的值，若其值为真（非0），则执行for语句中指定的内嵌语句，然后执行下面步骤③；若其值为假（0），则退出循环，执行 for语句以下的其他语句。③求表达式3的值。④重复执行步骤②。
【考点16】 循环的嵌套
（1）定义：在某一个循环体内部又包含了另一个完整的循环结构，称为循环的嵌套。
（2）前面介绍的3种类型的循环都可以互相嵌套，循环的嵌套可以多层，但要保证每一层循环在逻辑上必须是完整的。
【考点17】 几种循环的比较
●while和do…while循环，只在while后面指定循环条件，循环体内应包含使循环趋于结束的语句，for中使循环趋于结束的操作可以包含在“表达式3”中。
由while完成的循环，用for循环都能完成。
【考点18】 break语句和continue语句
1.break语句
（1）在break后面加上分号就可以构成break语句，break语句还可以用于从循环体内跳出，即提前结束循环。
（2）说明。
break语句只能出现在循环体内及switch语句内，不能用于其他语句。
当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。当break出现在循环体中，但并不在switch语句体内时，则在执行 break 后，跳出本层循环，当然也不再去进行条件判断。
2.continue语句
（1）一般形式为：continue。
（2）作用：结束本次循环，即跳过循环体中下面尚未执行的语句，而转去重新判定循环条件是否成立，从而确定下一次循环是否继续执行。
真题演练
（1）有以下程序：
＃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构成无限循环
（2）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int k=5；
while（--k）
printf（＂% d＂，k -= 3）；
printf（＂\n＂）；
｝
执行后的输出结果是（ ）。
A） 1 B） 2 C） 4 D） 死循环
（3）有以下函数：
int fun（char *s）
｛
char *t=s；
while（*t++）；
return（t-s）；
｝
该函数的功能是（ ）。
A）计算s所指字符串的长度
B）比较两个字符串的大小
C）计算s所指字符串占用内存字节的个数
D）将s所指字符串复制到字符串t中
（4）有以下函数：
int aaa（char *s）
｛
char *t=s；
while（*t++）；
t--；
return（t-s）；
｝
以下关于aaa函数功能叙述正确的是（ ）。
A）将串s复制到串t
B）比较两个串的大小
C）求字符串s的长度
D）求字符串s所占字节数
（5）在以下给出的表达式中，与while（E）中的（E）不等价的表达式是（ ）。
A）（E＞0｜｜E＜0） B）（E==0）
C）（！ E==0） D）（E！=0）
（6）有以下程序：
＃include ＜stdio.h＞
int fun（char s［］）
｛
int n=0；
while（*s ＜= ＇9＇&&*s ＞= ＇0＇）
｛
n=10*n+*s- ＇0＇；
s++；
｝
return（n）；
｝
main（）
｛
char s［10］=｛ ＇6＇， ＇1＇， ＇*＇， ＇4＇， ＇*＇， ＇9＇， ＇*＇， ＇0＇， ＇*＇｝；
printf（＂% d\n＂，fun（s））；
｝
程序的运行结果是（ ）。
A） 5 B） 9 C） 61 D） 61490
（7）以下不构成无限循环的语句或语句组是（ ）。
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；
（8）若变量已正确定义，有以下程序段：i=0；do printf（＂% d，＂，i）；while（i++）；printf（＂% d\n＂，i）；程序的运行结果是（ ）。
A） 0，1 B） 0，0
C） 1，1 D） 程序进入无限循环
（9）以下程序段中的变量已正确定义：
for（i=0；i＜4；i++，i++）
for（k=1；k＜3；k++）；
printf（＂*＂）；
程序的运行结果是（ ）。
A） ** B） ****
C） * D） ********
（10）有以下程序：
＃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
（11）有以下程序：
＃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
（12）有以下程序：
＃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，
（13）有以下程序：
＃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）1*1=11*2=21*3=3
2*2=42*3=6
3*3=9
B）1*1=11*2=21*3=3
2*1=22*2=4
3*1=3
C）1*1=1
1*2=22*2=4
1*3=32*3=63*3=9
D）1*1=1
2*1=22*2=4
3*1=33*2=63*3=9
（14）有以下程序：
＃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） *2*6 B） *3*5 C） *5 D） *7
（15）有以下程序：
＃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）43
25
43
B）45
34
23
C）23
34
45
D）23
34
23
（16）有以下程序：
＃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=4 B） m=2 C） m=6 D） m=5
（17）有以下程序：
＃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） 3 B） 4 C） 1 D） 9
（18）有以下程序：
＃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） 5 B） 24 C） 32 D） 40
（19）有以下程序：
＃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）；
else putchar（i+c）；
｝
printf（＂\n＂）；
｝
程序的运行结果是（ ）。
A） abcdef B） ABCDEF
C） aBcDeF D） AbCdEf
（20）有以下程序：
＃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）continue；
x++；
｝
x++；
｝
printf（＂x=% d\n＂，x）；
｝
程序的运行结果是（ ）。
A） x=4 B） x=8
C） x=6 D） x=12
（21）有以下程序：
＃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） 0 B） 1 C） 2 D） 3
（22）下列叙述中正确的是（ ）。
A）continue语句的作用是使程序的执行流程跳出包含它的所有循环
B）break语句只能用在循环体内和switch语句体内
C）在循环体内使用break语句和continue语句的作用相同
D）break语句只能用于switch语句体中
（六） 数组
【考点19】 一维数组的定义和引用
1.一维数组的定义
一维数组是指数组中的每个元素只带有一个下标的数组。定义方式为：类型说明符 数组名［常量表达式］；
2.一维数组元素的引用
数组元素的引用形式为：数组名［下标表达式］；
一个数组元素实质上是一个变量名，代表内存中的一个存储单元，一个数组占据的是一连串连续的存储单元。
引用数组元素时，数组的下标可以是整型常量，也可以是整型表达式。
数组必须先定义后使用。
只能逐个引用数组元素而不能一次引用整个数组。
3.一维数组的初始化
当数组定义后，系统会为该数组在内存中开辟一串连续的存储单元，但这些存储单元中并没有确定的值。可以在定义数组时为所包含的数组元素赋初值。
例如：int a［6］=｛ 0，1，2，3，4，5 ｝；
所赋初值放在一对花括号中，数值类型必须与所说明类型一致。
所赋初值之间用逗号隔开，系统将按这些数值的排列顺序，从a［0］元素开始依次给数组a中的元素赋初值。
不能跳过前面的元素给后面的元素赋初值，但是允许为前面元素赋值为0。
当所赋初值个数少于所定义数组的元素个数时，将自动给后面的其他元素补初值0。
可以通过赋初值来定义一维数组的大小，定义数组时的一对方括号中可以不指定数组的大小。
【考点20】 二维数组的定义和引用
1.二维数组的定义
（1）在C语言中，二维数组中元素排列的顺序是：按行存放，即在内存中先顺序存放第一行的元素，再存放第二行的元素。二维数组元素的存储总是占用一块连续的内存单元。
（2）一般形式为：
类型说明符 数组名［常量表达式］［常量表达式］；
2.二维数组元素的引用
表示形式为：数组名［下标表达式1］［下标表达式2］；
数组的下标可以是整型表达式。
数组元素可以出现在表达式中，也可以被赋值。
3.二维数组的初始化
可以在定义二维数组的同时给二维数组的各元素赋初值。
全部初值放在一对花括号中，每一行的初值又分别括在一对花括号中，之间用逗号隔开。
当某行一对花括号内的初值个数少于该行中元素的个数时，系统将自动地给后面的元素赋初值0。
不能跳过每行前面的元素而给后面的元素赋初值。
4.通过赋初值定义二维数组的大小
对于一维数组，可以在数组定义语句中省略方括号中的常量表达式，通过所赋初值的个数来确定数组的大小；对于二维数组，只可以省略第一个方括号中的常量表达式，而不能省略第二个方括号中的常量表达式。
【考点21】 字符数组
1.字符数组的定义
字符数组就是数组中的每个元素都是字符。定义方法同普通数组的定义相同，即逐个对数组元素赋值。
2.字符数组的初始化及引用
（1）初始化。对字符数组初始化，可逐个元素地赋值，即把字符逐个赋给数组元素。
如果花括号中提供的初值个数（即字符个数）大于数组长度，则编译时会按语法错误处理。
如果初值个数小于数组长度，则将这些字符赋给数组中前面那些元素，其余的元素定为空字符（‘\0’）。
（2）引用形式。采用下标引用，即数组名［下标］。
3.字符串和字符串结束标志
C语言中，将字符串作为字符数组来处理。为了测定字符串的实际长度，C语言规定了一个字符串结束标志，以字符‘\0’代表。就是说，在遇到字符‘\0’时，表示字符串结束，由它前面的字符组成字符串。
4.字符数组的输入输出
字符数组的输入输出有以下两种方法。
用“%c”格式符，将字符逐个输入或输出。
用“%s”格式符，将整个字符串一次输入或输出。
5.字符串处理函数
C语言没有提供对字符串进行整体操作的运算符，但在C语言的函数库中提供了一些用来处理字符串的函数。在调用这些函数前，须在程序前面的命令行包含标准头文件“string.h”。
puts（）：调用形式为puts（字符数组），将一个字符串（以‘\0’结束）输出到终端设备。
gets（）：调用形式为gets（字符数组），从终端输入一个字符串到字符数组中，并且得到一个函数值。
strcpy（）：调用形式为strcpy（字符数组1，字符数组2），把字符数组2所指字符串的内容复制到字符数组1所指存储空间中。函数返回字符数组1的值，即目的串的首地址。
strcat（）：调用形式为strcat（字符数组1，字符数组2），该函数将字符数组2所指字符串的内容连接到字符数组1所指的字符串后面，并自动覆盖字符数组 1 串末尾的‘\0’。该函数返回字符数组1的地址值。
strlen（）：调用形式为strlen（字符数组），此函数计算出以字符数组为起始地址的字符串的长度，并作为函数值返回。
strcmp（）：调用形式为strcmp（字符数组1，字符数组2），该函数用来比较字符数组1和字符数组2所指字符串的大小。若字符数组1＞字符数组2，函数值大于0（正数）；若字符数组1=字符数组2，函数值等于0；若字符数组1＜字符数组2，函数值小于0（负数）。
真题演练
（1）若有定义：int x［10］，*pt=x；，则对x数组元素的正确引用是（ ）。
A） pt+3 B） *&x［10］
C） *（pt+10） D） *（x+3）
（2）有以下程序：
＃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） 20 B） 25 C） 45 D） 36
（3）有以下程序：
＃include ＜stdio.h＞
void fun（int *s，int n1，int n2）
｛
int i，j，t；
i=n1；j=n2；
while（i＜j）
｛
t=s［i］；
s［i］=s［j］；
s［j］=t；
i++；
j--；
｝
｝
main（）
｛
int a［10］=｛1，2，3，4，5，6，7，8，9，0｝，k；
fun（a，0，3）；
fun（a，4，9）；
fun（a，0，9）；
for（k=0；k＜10；k++）
printf（＂% d＂，a［k］）；
printf（＂\n＂）；
｝
程序的运行结果是（ ）。
A） 4321098765 B） 5678901234
C） 0987654321 D） 0987651234
（4）有以下程序：
＃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） 2344 B） 4332 C） 1234 D） 1123
（5）下列定义数组的语句中正确的是（ ）。
A）＃define N 10
int x［N］；
B）int N=10；
int x［N］；
C）int x［0..10］；
D）int x［］；
（6）下列选项中能正确定义数组的语句是（ ）。
A） int num［0...2008］； B） int num［］；
C）int N=2008；
int num［N］；
D）＃define N 2008
int num［N］；
（7）若要求定义具有10个int型元素的一维数组a，则以下定义语句中错误的是（ ）。
A）＃define n 5
int a［2*n］；
B）int n=10，a［n］；
C）int a［5+5］；
D）＃define N 10
int a［N］；
（8）设有定义：double a［10］，*s=a；，以下能够代表数组元素a［3］的是（ ）。
A）（*s）［3］ B） *（s+3） C） *s［3］ D） *s+3
（9）有以下程序：＃include ＜stdio.h＞
＃define N 4
void fun（int a［］［N］，int b［］）｛
int i；
for（i=0；i＜N；i++）b［i］= a［i］［i］；
｝
main（）
｛
int x［］［N］=｛｛1，2，3｝，｛4｝，｛5，6，7，8｝，｛9，10｝｝，y
［N］，i；
fun（x，y）；
for（i=0；i＜N；i++）
printf（＂% d，＂，y［i］）；
printf（＂\n＂）；
｝
程序的运行结果是（ ）。
A） 1，0，7，0， B） 1，2，3，4，
C） 1，4，5，9， D） 3，4，8，10，
（10）有以下程序：
＃include ＜stdio.h＞
int fun（int（*s）［4］，int n，int k）
｛
int m，i；m=s［0］［k］；
for（i=1；i＜n；i++）
if（s［i］［k］＞m）
m= s［i］［k］；
return m；
｝
main（）
｛
int a［4］［4］=｛｛1，2，3，4｝，｛11，12，13，14｝，｛21，
22，23，24｝，｛31，32，33，34｝｝；
printf（＂% d\n＂，fun（a，4，0））；
｝
程序的运行结果是（ ）。
A） 4 B） 34 C） 31 D） 32
（11）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int a［4］［4］=｛｛1，4，3，2｝，｛8，6，5，7｝，｛3，7，2，5｝，
｛4，8，6，1｝｝；
int i，j，k，t；
for（i=0；i＜4；i++）
for（j=0；j＜3；j++）
for（k=j+1；k＜4；k++）
if（a［j］［i］＞ a［k］［i］）
｛
t=a［j］［i］；
a［j］［i］= a［k］［i］；
a［k］［i］= t；
｝ /* 按列排序 */
for（i=0；i＜4；i++）
printf（＂% d，＂，a［i］［i］）；
｝
程序的运行结果是（ ）。
A） 1，6，2，1， B） 8，7，3，1，
C） 4，7，5，2， D） 1，6，5，7，
（12）有以下程序：
＃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） 357 B） 753 C） 369 D） 751
（13）有以下程序：
＃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）1，1，2，6，B）6，2，1，1，C）6，4，3，2，D）2，3，4，6，
（14）下列定义语句中错误的是（ ）。
A）int x［4］［3］=｛｛1，2，3｝，｛1，2，3｝，｛1，2，3｝，｛1，2， 3｝｝；
B）int x［4］［］= ｛｛1，2，3｝，｛1，2，3｝，｛1，2，3｝，｛1，2， 3｝｝；
C）int x［］［3］=｛｛0｝，｛1｝，｛1，2，3｝｝；
D）int x［］［3］=｛1，2，3，4｝；
（15）下列定义数组的语句中错误的是（ ）。
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｝｝；
（16）下列定义数组的语句中错误的是（ ）。
A）int num［］［3］=｛ ｛1，2｝，3，4，5，6 ｝；
B）int num［2］［4］=｛ ｛1，2｝，｛3，4｝，｛5，6｝ ｝；
C）int num［］=｛ 1，2，3，4，5，6 ｝；
D）int num［］［4］=｛1，2，3，4，5，6｝；
（17）有以下程序：
＃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］）；
｝
若运行时输入：246 ＜回车 ＞，则程序的运行结果为（ ）。
A） 204 B） 200 C） 240 D） 246
（18）若有定义语句：char s［10］=＂1234567\0\0＂； ，则strlen（s）的值是（ ）。
A） 7 B） 8 C） 9 D） 10
（19）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
main（）
｛
char p［20］=｛ ＇a＇， ＇b＇， ＇c＇， ＇d＇｝，q［］=＂abc＂，r［］=＂
abcde＂；
strcat（p，r）；
strcpy（p+strlen（q），q）；
printf（＂% d\n＂，strlen（p））；
｝
程序的运行结果是（ ）。
A） 11 B） 9 C） 6 D） 7
（20）有以下程序（strcat函数用于连接两个字符串）：
＃include ＜stdio.h＞
＃include ＜string.h＞
main（）
｛
char a［20］=＂ABCD\0EFG\0＂，b［］=＂IJK＂；
strcat（a，b）；
printf（＂% s\n＂，a）；
｝
程序的运行结果是（ ）。
A） IJK B） ABCDE\0FG\0IJK
C） ABCDIJK D） EFGIJK
（21）有以下程序：
char name［20］；
int num；
scanf（＂name=% s num=% d＂，name，&num）；
当执行上述程序，并从键盘输入：name=Lili num=1001
＜回车＞后，name的值为（ ）。
A） name=Lili num=1001 B） name=Lili
C） Lili num= D） Lili
（22）有以下程序：
＃include ＜stdio.h＞
main（）
｛
char ch［］=＂uvwxyz＂，*pc；pc=ch；
printf（＂% c\n＂，*（pc+5））；
｝
程序的运行结果是（ ）。
A） z B） 0
C） 元素ch［5］的地址 D） 字符y的地址
（23）有以下程序：
＃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
（24）若有以下定义和语句：
＃include ＜stdio.h＞
char s1［10］= ＂abcd！＂，*s2=＂\n123\\＂；
printf（＂% d % d\n＂，strlen（s1），strlen（s2））；
程序的运行结果是（ ）。
A） 107 B） 105 C） 55 D） 58
（25）有以下程序：
＃include ＜stdio.h＞
void fun1（char *p）
｛
char *q；
q=p；
while（*q！= ＇\0＇）｛（*q）++；q++；｝
｝
main（）
｛
char a［］=｛＂Program＂｝，*p；
p=&a［3］；
fun1（p）；
printf（＂% s\n＂，a）；
｝
程序的运行结果是（ ）。
A） Prphsbn B） Prohsbn C） Progsbn D） Program
（26）有以下程序：
＃include ＜stdio.h＞
void fun（char *a，char *b）
｛
while（*a== ＇*＇）a++；
while（*b=*a）
｛
b++；
a++；
｝
｝
main（）
｛
char *s=＂*****a*b****＂ ，t［80］；
fun（s，t）；
puts（t）；
｝
程序的运行结果是（ ）。
A） ab B） a*b
C） *****a*b D） a*b****
（27）设有如下程序：
＃include ＜stdio.h＞
char s［20］=＂Beijing＂，*p；
p=s；
则执行p=s；语句后，以下叙述正确的是（ ）。
A）s和p都是指针变量
B）s数组中元素的个数和p所指字符串长度相等
C）可以用*p表示s［0］
D）数组s中的内容和指针变量p中的内容相同
（28）有以下程序：
＃include ＜stdio.h＞
main（）
｛
char s［］=＂abcde＂；
s+=2；
printf（＂% d\n＂，s［0］）；
｝
程序的运行结果是（ ）。
A） 输出字符c的ASCII码 B） 程序出错
C） 输出字符c D） 输出字符a的ASCII码
（29）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
void fun（char *s［］，int n）
｛
char *t；
int i，j；
for（i=0；i＜n-1；i++）
for（j=i+1；j＜n；j++）
if（strlen（s［i］）＞ strlen（s［j］））
｛
t = s［i］；
s［i］= s［j］；
s［j］= t；
｝
｝
main（）
｛
char *ss［］= ｛＂bcc＂，＂bbcc＂，＂xy＂，＂aaaacc＂，
＂aabcc＂｝；
fun（ss，5）；
printf（＂% s，% s\n＂，ss［0］，ss［4］）；
｝
程序的运行结果是（ ）。
A）aaaacc，xy B）xy，aaaacc C）bcc，aabcc D）aabcc，bcc
（30）有以下程序：
＃include ＜stdio.h＞
int fun（char p［］［10］）
｛
int n=0，i；
for（i=0；i＜7；i++）
if（p［i］［0］== ＇T＇）n++；
return n；
｝
main（）
｛
char str［］［10］=｛＂Mon＂，＂Tue＂，＂Wed＂，＂Thu＂，
＂Fri＂，＂Sat＂，＂Sun＂｝；
printf（＂% d\n＂，fun（str））；
｝
程序的运行结果是（ ）。
A） 1 B） 2 C） 3 D） 0
（31）有以下程序：
＃include ＜stdio.h＞
void fun（char *t，char *s）
｛
while（*t！=0）t++；
while（（*t++ =*s++）！=0）；
｝
main（）
｛
char ss［10］=＂acc＂，aa［10］=＂bbxxyy＂；
fun（ss，aa）；
printf（＂% s，% s\n＂，ss，aa）；
｝
程序的运行结果是（ ）。
A） acc，bbxxyy B） accbbxxyy，bbxxyy
C） accxxyy，bbxxyy D） accxyy，bbxxyy
（32）有以下程序：
＃include ＜stdio.h＞ ＃include ＜string.h＞
void fun（char *w，int m）
｛
char s，*p1，*p2；
p1=w；
p2=w+m-1；
while（p1＜p2）
｛
s=*p1；
*p1=*p2；
*p2=s；
p1++；
p2--；
｝
｝
main（）
｛
char a［］=＂123456＂；
fun（a，strlen（a））；
puts（a）；
｝
程序的运行结果是（ ）。
A） 123456 B） 116611 C） 161616 D） 654321
（33）有以下程序：
＃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） 8 10 B） 10 28 C） 10 12 D） 10 16
（34）设有定义：char p［］=｛ ＇1＇， ＇2＇， ＇3＇｝，*q=p；，以下不能计算出一个 char 型数据所占字节数的表达式是（ ）。
A） sizeof（p） B） sizeof（char）
C） sizeof（*q） D） sizeof（p［0］）
（35）设有定义：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＇；
（36）有以下程序：
＃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
（37）若有定义语句：char *s1=＂OK＂，*s2=＂ok＂；，以下选项中，能够输出“OK”的语句是（ ）。
A）if（strcmp（s1，s2）！=0）puts（s2）；
B）if（strcmp（s1，s2）！=0）puts（s1）；
C）if（strcmp（s1，s2）==1）puts（s1）；
D）if（strcmp（s1，s2）==0）puts（s1）；
（38）若要求从键盘读入含有空格字符的字符串，应使用函数（ ）。
A） getchar（） B） getc（） C） gets（） D） scanf（）
（39）下列选项中，能够满足“只要字符串s1等于字符串s2，则执行ST”要求的是（ ）。
A）if（s1-s2==0）ST；
B）if（s1==s2）ST；
C）if（strcpy（s1，s2）==1）ST；
D）if（strcmp（s2，s1）==0）ST；
（七） 函数
【考点22】 函数概述
在C语言中，子程序的作用是由函数完成的。一个C程序可由一个主函数和若干个其他函数构成，并且只能有一个主函数。由主函数来调用其他函数，其他子函数之间也可以互相调用。
C程序的执行总是从main（）函数开始。调用其他函数完毕后，程序流程回到main（）函数，继续执行主函数中的其他语句，直到main（）函数结束，则整个程序的运行结束。
从用户的使用的角度看，函数分类如下。
标准函数，即库函数。这些函数由系统提供，可以直接使用。
自定义的函数。用以解决用户需要时设计定义的函数。
从函数的形式看，函数分类如下。
无参函数。
有参函数。
【考点23】 函数参数和函数返回值
1.形式参数和实际参数
在定义函数时，函数名后面括号中的变量称为“形式参数”（简称“形参”）。
在主调函数中，函数名后面括号中的参数（可以是一个表达式）称为“实际参数”（简称“实参”）。
2.函数的返回值
（1）定义：函数的返回值就是通过函数调用使主调函数能得到一个确定的值。
（2）表达形式：return 表达式；或return（表达式）；或re-turn。
return 语句中的表达式值的类型必须与函数首部所说明的类型一致。若类型不一致，则以函数值的类型为准，由系统自动进行强制转换。
当函数没有指明返回值，或没有返回语句时，函数返回一个不确定的值。为了使函数不返回任何值，可以使用void定义无类型函数。
【考点24】 函数的调用
1.函数调用的一般形式
函数名（实参表列）；
函数的调用可分为调用无参函数和调用有参函数两种。
调用无参函数，不用“实参表列”，但括号不能省略。
调用有参函数时，若实参列表中有多个实参，各参数间用逗号隔开。实参与形参要求类型一致。
2.函数的说明
C语言中，除了主函数外，对于用户定义的函数要遵循先定义后使用的规则。把函数的定义放在调用之后，应该在调用之前对函数进行说明（或函数原型说明）。
函数说明的一般形式如下：
类型名 函数名（参数类型1，参数类型2，…，参数类型n）；或
类型名 函数名（参数类型1参数名1，参数类型2参数名2，…，参数类型n参数名n）；
【考点25】 函数的嵌套调用与递归调用
1.函数的嵌套调用
C语言的函数定义都是独立的、互相平行的，C语句不允许嵌套定义函数，即一个函数内不能定义另一个函数。但可以嵌套调用函数，即在调用一个函数的过程中，又调用另一个函数。
2.函数的递归调用
在调用一个函数的过程中又出现直接或间接地调用该函数本身的，称为函数的递归调用。
使用递归法解决问题，需符合的条件如下。
可以把要解决的问题转化为一个新的问题。而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。
可以应用这个转化过程使问题得到解决。
必须要有一个明确的结束递归的条件。
【考点26】 数组作为函数参数
1.数组元素作为函数实参
数组元素可以作为函数的实参，与用变量作为实参一样，按照单向值传递的方式进行传递。
2.数组名可以作为函数参数
可以用数组名作为函数参数，此时实参与形参都应用数组名，此时的数组名是整个数组的首地址。
【考点27】 全局变量和局部变量
在函数内部定义的变量称为局部变量，只能在本函数内部使用。
在函数之外定义的变量称为外部变量，外部变量是全局变量。全局变量可以为本文件中其他函数所共用，它的有效范围从定义变量开始到本文件结束。
如果在同一个源文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量被“屏蔽”，即它不起作用。
【考点28】 变量的存储类别
1.auto变量
当在函数内部或复合语句内定义变量时，如果没有指定存储类别，或使用了auto说明符，系统就认为所定义的变量具有自动类别。
2.register变量
寄存器变量也是自动类变量。它与auto变量的区别仅在于：用register说明变量是建议编译程序将变量的值保留在CPU的寄存器中，而不是像一般变量那样占用内存单元。
3.静态存储类别的局部变量
当函数体（或复合语句）内部用static来说明一个变量时，可以称该变量为静态局部变量。它与auto变量、register变量的本质区别如下。
在整个程序运行期间，静态局部变量在内存中的静态存储区中占据着永久性的存储单元。即使退出函数后，下次再进入该函数时，静态局部变量仍使用原来的存储单元。由于不释放这些存储单元，这些存储单元中的值得以保留，因而可以继续使用存储单元中原来的值。
静态局部变量的初值是在编译时赋予的，在程序执行期间不再赋以初值。对未赋值的局部变量，C语言编译程序自动给它赋初值为0。
真题演练
（1）若有代数式 
（其中e仅代表自然对数的底数，不是变量），则以下能够正确表示该代数式的C语言表达式是（ ）。
A）sqrt（fabs（pow（n，x）+exp（x）））
B）sqrt（fabs（pow（n，x）+pow（x，e）））
C）sqrt（abs（n＾x+e＾x））
D）sqrt（fabs（pow（x，n）+exp（x）））
（2）下列叙述中错误的是（ ）。
A）可以给指针变量赋一个整数作为地址值
B）函数可以返回地址值
C）改变函数形参的值，不会改变对应实参的值
D）当在程序的开头包含头文件stdio.h时，可以给指针变量赋NULL值
（3）有以下程序：
＃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
（4）有以下程序：
＃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） 28 B） 24 C） 32 D） 36
（5）若函数调用时的实参为变量，下列关于函数形参和实参的叙述中正确的是（ ）。
A）函数的形参和实参分别占用不同的存储单元
B）形参只是形式上的存在，不占用具体存储单元
C）同名的实参和形参占同一存储单元
D）函数的实参和其对应的形参共占同一存储单元
（6）下列叙述中错误的是（ ）。
A）C程序必须由一个或一个以上的函数组成
B）函数调用可以作为一个独立的语句存在
C）若函数有返回值，必须通过return语句返回
D）函数形参的值也可以传回给对应的实参
（7）以下程序中函数f的功能是：当flag为1时，进行由小到大排序；当flag为0时，进行由大到小排序。
＃include ＜stdio.h＞
void f（int b［］，int n，int flag）
｛
int i，j，t；
for（i=0；i＜n-1；i++）
for（j=i+1；j＜n；j++）
if（flag？b［i］＞b［j］：b［i］＜b［j］）
｛
t=b［i］；
b［i］=b［j］；
b［j］=t；
｝
｝
main（）
｛
int a［10］=｛5，4，3，2，1，6，7，8，9，10｝，i；
f（&a［2］，5，0）；
f（a，5，1）；
for（i=0；i＜10；i++）
printf（＂% d，＂，a［i］）；
｝
程序的运行结果是（ ）。
A）1，2，3，4，5，6，7，8，9，10，
B）3，4，5，6，7，2，1，8，9，10，
C）5，4，3，2，1，6，7，8，9，10，
D）10，9，8，7，6，5，4，3，2，1，
（8）下列关于return语句的叙述中正确的是（ ）。
A）一个自定义函数中必须有一条return语句
B）一个自定义函数中可以根据不同情况设置多条return语句
C）定义成void类型的函数中可以有带返回值的return语句
D）没有return语句的自定义函数在执行结束时不能返回到调用处
（9）已定义以下函数 int fun（int *p）｛ return *p；｝fun函数的返回值是（ ）。
A） 一个整数 B） 不确定的值
C） 形参p中存放的值 D） 形参p的地址值
（10）下列叙述中错误的是（ ）。
A）用户定义的函数中可以没有return语句
B）用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值
C）用户定义的函数中若没有return语句，则应当定义函数为void类型
D）函数的return语句中可以没有表达式
（11）若各选项中所用变量已正确定义，函数fun中通过re-turn语句返回一个函数值，下列选项中错误的程序是（ ）。
A）main（）
｛ … x=fun（2，10）；…｝
float fun（int a，intB）｛…｝
B）float fun（int a，intB）｛…｝
main（）
｛ … x=fun（i，j）；…｝
C）float fun（int，int）；
main（）
｛ … x=fun（2，10）；… ｝
float fun（int a，intB）｛…｝
D）main（）…
｛ float fun（int i，int j）；… x=fun（i，j）；… ｝
float fun（int a，intB）｛…｝
（12）有以下程序：
＃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，
（13）有以下程序：
＃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（＂% 3.0f\n＂，a）；
｝
double f（double x）
｛
return x*x+1；
｝
程序的运行结果是（ ）。
A） 500 B） 401 C） 503 D） 1404
（14）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int m=1，n=2，*p=&m，*q=&n，*r；
r=p；
p=q；
q=r；
printf（＂% d，% d，% d，% d\n＂，m，n，*p，*q）；
｝
程序的运行结果是（ ）。
A） 2，1，1，2 B） 1，2，1，2 C） 2，1，2，1 D） 1，2，2，1
（15）有以下程序：
＃include ＜stdio.h＞
void f（int *q）
｛
int i=0；
for（；i＜5；i++）
（*q）++；
｝
main（）
｛
int a［5］=｛1，2，3，4，5｝，i；
f（a）；
for（i=0；i＜5；i++）
printf（＂% d，＂，a［i］）；
｝
程序的运行结果是（ ）。
A） 6，2，3，4，5， B） 2，2，3，4，5，
C） 1，2，3，4，5， D） 2，3，4，5，6，
（16）有以下程序：
＃include ＜stdio.h＞
void fun（int *a，int *b）
｛
int *c；
c=a；
a=b；
b=c；
｝
main（）
｛
int x=3，y=5，*p=&x，*q=&y；
fun（p，q）；
printf（＂% d，% d，＂，*p，*q）；
fun（&x，&y）；
printf（＂% d，% d\n＂，*p，*q）；
｝
程序的运行结果是（ ）。
A） 3，5，3，5 B） 3，5，5，3 C） 5，3，3，5 D） 5，3，5，3
（17）有以下程序：
＃include ＜stdio.h＞void fun（int *a，int n）/* fun函数的功能是将a所指
数组元素进行从大到小排序 */
｛
int t，i，j；
for（i=0；i＜n-1；i++）
for（j=i+1；j＜n；j++）
if（a［i］＜a［j］）
｛
t=a［i］；
a［i］=a［j］；
a［j］=t；
｝
｝
main（）
｛
int c［10］=｛1，2，3，4，5，6，7，8，9，0｝，i；
fun（c+4，6）；
for（i=0；i＜10；i++）
printf（＂% d，＂，c［i］）；
printf（＂\n＂）；
｝
程序的运行结果是（ ）。
A）1，2，3，4，9，8，7，6，5，0，B）0，9，8，7，6，5，1，2，3，4，
C）0，9，8，7，6，5，4，3，2，1，D）1，2，3，4，5，6，7，8，9，0，
（18）若有函数首部 int fun（double x［10］，int *n），则下列针对此函数的函数声明语句中正确的是（ ）。
A）int fun（double，int）；
B）int fun（double *，int *）；
C）int fun（double *x，int n）；
D）int fun（double x，int *n）；
（19）有以下程序：
＃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） 8 B） 2 C） 4 D） 1
（20）有以下程序：
＃include ＜stdio.h＞
int fun（int x，int y）
｛ if（x！=y）
return（（x+y）/2）；
else return（x）；
｝
main（）
｛ int a=4， b=5， c=6；
printf（＂% d\n＂，fun（2*a，fun（b，c）））；
｝
程序的运行结果是（ ）。
A） 6 B） 3 C） 8 D） 12
（21）有以下程序：
＃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） 7 B） 10 C） 8 D） 9
（22）设有如下函数定义：
＃include ＜stdio.h＞
int fun（int k）
｛ if（k＜1） return 0；
else if（k==1）return 1；
else return fun（k-1）+1；
｝
若执行调用语句n=fun（3）；，则函数fun总共被调用的次数是（ ）。
A） 2 B） 3 C） 4 D） 5
（23）有以下程序：
＃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
（24）有以下程序：
＃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
（25）有以下程序：
＃include ＜stdio.h＞
int fun（int a，int B）
｛
if（b==0）
return a；
else
return（fun（--a，--b））；
｝
main（）
｛
printf（＂% d\n＂，fun（4，2））；
｝
程序的运行结果是（ ）。
A） 1 B） 2 C） 3 D） 4
（26）有以下程序：
＃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
（27）有以下程序：
＃include ＜stdio.h＞
void f（int b［］）
｛
int i；
for（i=2；i＜6；i++）
b［i］*= 2；
｝
main（）
｛
int a［10］=｛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，3，4，5，6，7，8，9，10，
B）1，2，6，8，10，12，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，
（28）有以下程序：
＃include ＜stdio.h＞
void fun2（char a，charB）
｛
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） A B E F B） C D E F C） A B C D D） C D A B
（29）在一个C源程序文件中所定义的全局变量，其作用域为（ ）。
A）由具体定义位置和extern说明来决定范围
B）所在程序的全部范围
C）所在函数的全部范围
D）所在文件的全部范围
（30）在C语言中，只有在使用时才占用内存单元的变量，其存储类型是（ ）。
A） auto和static B） extern和register
C） auto和register D） static和register
（31）有以下程序：
＃include ＜stdio.h＞
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
（32）有以下程序：
＃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） 10 B） 30 C） 0 D） 64
（33）有以下程序：
＃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） 9 B） 8 C） 7 D） 10
（34）有以下程序：
＃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） 120 B） 11 C） 6 D） 21
（35）有以下程序：
＃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） 55 B） 50 C） 45 D） 60
（36）有以下程序：
＃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） 3，3 B） 1，1 C） 2，3 D） 1，2
（37）下列叙述中错误的是（ ）。
A）C程序函数中定义的自动变量，系统不自动赋确定的初值
B）在C程序的同一函数中，各复合语句内可以定义变量，其作用域仅限本复合语句内
C）C程序函数中定义的赋有初值的静态变量，每调用一次函数赋一次初值
D）C程序函数的形参不可以说明为static型变量
（38）有以下程序：
＃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
（八） 指针
【考点29】 关于地址和指针
在C语言中，将地址形象地称为“指针”。一个变量的地址称为变量的“指针”。一个专门用来存放另一个变量的地址的变量（即指针），则称它为“指针变量”。
【考点30】 变量的指针和指向变量的指针变量
1.指针变量的定义
定义指针变量的一般形式：
类型名 *指针变量名1，*指针变量名2，…；
例如：int *p，*t；
2.指针变量的引用
指针变量中只能存放地址（指针），与指针相关的两个运算符是“&”（取地址运算）和“*”（指针运算符）。
3.指针变量作为函数参数
指针类型数据可以作为函数参数来进行传递。
作用：将一个变量的地址传送到另一个函数中，参与该函数的运算。
形参指针变量的值的改变不能使实参指针变量的值发生改变。
【考点31】 数组与指针
1.指向数组元素的指针
C语言规定数组名代表数组的首地址，也就是数组中第0号元素的地址。
定义指向数组元素的指针变量的方法，与定义指向变量的指针变量相同。
2.通过指针引用数组元素
如果指针变量p已指向数组中的一个元素，则p+1 指向同一数组中的下一个元素。
3.用数组名作为函数参数
当数组名作为参数被传递时，若形参数组中各元素发生了变化，则原实参数组各元素的值也随之变化。
如果用数组元素作为实参，情况就与用变量作为实参时一样，是“值传递”方式。
4.指向多维数组的指针和指针变量
多维数组可以看作是一维数组的延伸，多维数组的内存单元也是连续的内存单元。C语言实际上是把多维数组当成一维数组来处理的。
【考点32】 字符串与指针
1.字符串的表示形式
用字符数组存放一个字符串，然后输出该字符串。
用字符指针指向一个字符串。用字符指针指向字符串中的字符。
2.字符串指针作为函数参数
将一个字符串从一个函数传递到另一个函数，可以用地址传递的办法，即用字符数组名作为参数或用指向字符串的指针变量作为参数，进行传递。
3.字符指针变量和字符数组的区别
字符数组是由若干个元素组成的，每个元素中存放一个字符，而字符指针变量中存放的是地址，绝不是将字符串的内容存放到字符指针变量中。
赋值方式不同。
字符数组可以在定义时对其整体赋初值，但在赋值语句中不能完成整体赋值。而字符指针变量既可以在定义时赋初值，也可以在赋值语句中完成。
编译时不同。
在程序中指针变量的值可以改变。而数组名虽然代表了地址，但它的值是一个固定的值，不能改变。
【考点33】 指向函数的指针
指针变量可以指向一个函数，编译时，一个函数将被分配给一个入口地址，这个入口地址就称为该函数的指针。因此，可以通过使用一个指向函数的指针变量调用此函数。
说明：
指向函数的指针变量的一般定义形式为：
数据类型（*指针变量名）（）；
在给函数指针变量赋值时，只需给出函数名而不必给出参数。
用函数指针变量调用函数时，只需将（*s）代替函数名即可（s为已经定义过的指向函数的指针变量名），在（*s）之后的括号中根据需要写上实参。
对指向函数的指针变量，有些运算，如++s、--s、s+3等都是没有意义的。
【考点34】 指针数组和指向指针的指针
1.指针数组的概念
若在一个数组中，其元素均为指针类型数据，这样的数组称为指针数组。
一维指针数组的定义形式为：
类型名 *数组名［数组长度］；
2.指向指针的指针
指向指针数据的指针变量，简称为指向指针的指针，通常称为二级指针。
定义一个指向指针数据的指针变量的形式：
类型名 **a；
真题演练
（1）有以下程序：
＃include ＜stdio.h＞void f（int *p，int *q）；
main（）
｛
int m=1，n=2，*r=&m；
f（r，&n）；
printf（＂% d，% d＂，m，n）；
｝
void f（int *p，int *q）
｛
p=p+1；
*q=*q+1；
｝
程序的运行结果是（ ）。
A） 2，3 B） 1，3 C） 1，4 D） 1，2
（2）设已有定义float x；，则下列对指针变量p进行定义且赋初值的语句中正确的是（ ）。
A） int *p=（float）x； B） float *p=&x；
C） float p=&x； D） float *p=1024；
（3）若有定义语句double a，*p=&a；，下列叙述中错误的是（ ）。
A）定义语句中的*号是一个间址运算符
B）定义语句中的*号是一个说明符
C）定义语句中的p只能存放double类型变量的地址
D）定义语句中，*p=&a把变量a的地址作为初值赋给指针变量p
（4）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int a=1，b=3，c=5；
int *p1=&a，*p2=&b，*p=&c；
*p =*p1*（*p2）；
printf（＂% d\n＂，c）；
｝
程序的运行结果是（ ）。
A） 1 B） 2 C） 3 D） 4
（5）有以下程序：
＃include ＜stdio.h＞
main（）
｛
int n，*p=NULL；
*p=&n；
printf（＂Input n：＂）；
scanf（＂% d＂，&p）；
printf（＂output n：＂）；
printf（＂% d\n＂，p）；
｝
该程序试图通过指针p为变量n读入数据并输出，但程序有多处错误，下列语句中正确的是（ ）。
A） int n，*p=NULL； B） *p=&n；
C） scanf（＂% d＂，&p） D） printf（＂% d\n＂，p）；
（6）若有定义语句double x，y，*px，*py；，执行了px=&x；py=&y；之后，正确的输入语句是（ ）。
A）scanf（＂% lf % le＂，px，py）；
B）scanf（＂% f % f＂ &x，&y）；
C）scanf（＂% f % f＂，x，y）；
D）scanf（＂% lf % lf＂，x，y）；
（7）下列程序段中完全正确的是（ ）。
A）int *p；scanf（＂% d＂，&p）；
B）int *p；scanf（＂% d＂，p）；
C）int k，*p=&k；scanf（＂% d＂，p）；
D）int k，*p；*p=&k；scanf（＂% d＂，p）；
（8）若有定义语句int a［2］［3］，*p［3］；，则以下语句中正确的是（ ）。
A） p=a； B） p［0］ =a；
C） p［0］ =&a［1］［2］； D） p［1］ =&a；
（9）有以下程序：
＃include ＜stdio.h＞
＃include ＜stdlib.h＞
int fun（int n）
｛ int *p；
p =（int*）malloc（sizeof（int））；
*p=n；
return *p；
｝
main（）
｛ int a；
a = fun（10）；
printf（＂% d\n＂，a+fun（10））；
｝
程序的运行结果是（ ）。
A） 0 B） 10 C） 20 D） 出错
（10）有以下程序：
＃include ＜stdio.h＞
void swap（char *x，char *y）
｛ char t；
t=*x；
*x=*y；
*y=t；
｝
main（）
｛ char *s1=＂abc＂，*s2=＂123＂；
swap（s1，s2）；
printf（＂% s，% s\n＂，s1，s2）；
｝
程序的运行结果是（ ）。
A） 321，cba B） abc，123 C） 123，abc D） 1bc，a23
（11）有以下程序：
＃include ＜stdio.h＞
void fun（char *c，int d）
｛
*c=*c+1；
d=d+1；
printf（＂% c，% c，＂，*c，d）；
｝
main（）
｛
char b= ＇a＇，a= ＇A＇；
fun（&b，a）；
printf（＂% c，% c\n＂，b，a）；
｝
程序的运行结果是（ ）。
A）b，B，b，AB）b，B，B，A C）a，B，B，a D）a，B，a，B
（12）以下函数实现按每行8个输出w所指数组中的数据：
＃include ＜stdio.h＞
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；
（13）有以下程序：
＃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
（14）设有以下函数：void fun（int n，char*s）｛ …｝，则下列对函数指针的定义和赋值均正确的是（ ）。
A）void（*pf）（int，char）；pf=&fun；
B）void *pf（）；pf=fun；
C）void *pf（）；*pf=fun；
D）void（*pf）（int，char*）；pf=fun；
（15）下列函数的功能是（ ）。
void fun（char *a，char *b）
｛ while（（*b=*a）！= ＇\0＇） ｛ a++；b++；｝
｝
A）将a所指字符串赋给b所指空间
B）使指针b指向a所指字符串
C）将a所指字符串和b所指字符串进行比较
D）检查a和b所指字符串中是否有＇\0＇
（16）有以下程序：
＃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） 321678 B） 876543
C） 1098765 D） 345678
（17）有以下程序：＃include ＜stdio.h＞
＃define N 4
void fun（int a［］［N］，int b［］）
｛ int i；
for（i=0；i＜N；i++）b［i］= a［i］［i］- a［i］
［N-1-i］；
｝
main（）
｛ int x［N］［N］ =｛｛1， 2， 3， 4｝， ｛5， 6， 7， 8｝，
｛9，10，11，12｝，｛13，14，15，16｝｝，y［N］，i；
fun（x，y）；
for（i=0；i＜N；i++）
printf（＂% d，＂，y［i］）；
printf（＂\n＂）；
｝
程序的运行结果是（ ）。
A） -3，-1，1，3， B） -12，-3，0，0，
C） 0，1，2，3， D） -3，-3，-3，-3，
（18）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
main（）
｛ char str［］［20］ = ｛＂ One*World＂，＂ One*
Dream！＂｝，*p=str［1］；
printf（＂% d，＂，strlen（p））；
printf（＂% s\n＂，p）；
｝
程序的运行结果是（ ）。
A） 10，One*Dream！ B） 9，One*Dream！
C） 9，One*World D） 10，One*World
（19）若有定义int w［3］［5］；，则以下不能正确表示该数组元素的表达式是（ ）。
A） *（&w［0］［0］+1） B） *（*w+3）
C） *（*（w+1）） D） *（w+1）［4］
（20）有以下程序：
＃include ＜stdio.h＞
void fun（char **p）
｛ ++p；
printf（＂% s\n＂，*p）；
｝
main（）
｛ char *a［］ = ｛＂Morning＂， ＂Afternoon＂， ＂Eve-
ning＂，＂Night＂｝；
fun（a）；
｝
程序的运行结果是（ ）。
A） Afternoon B） fternoon C） Morning D） orning
（21）有以下程序（程序中的库函数islower（ch）用以判断ch中的字母是否为小写字母）：
＃include ＜stdio.h＞
＃include ＜ctype.h＞
void fun（char *p）
｛
int i=0；
while（p［i］）
｛
if（p［i］== ＇ ＇&& islower（p［i-1］））
p［i-1］=p［i-1］- ＇a＇+ ＇A＇；
i++；
｝
｝
main（）
｛
char s1［100］=＂ab cd EFG！＂；
fun（s1）；
printf（＂% s\n＂，s1）；
｝
程序的运行结果是（ ）。
A） ab cd EFg ！ B） Ab Cd EFg ！
C） ab cd EFG ！ D） aB cD EFG ！
（22）下列语句组中正确的是（ ）。
A）char *s；s=＂Olympic＂；
B）char s［7］；s=＂Olympic＂；
C）char *s；s=｛＂Olympic＂｝；
D）char s［7］；s=｛＂Olympic＂｝；
（23）有以下程序（注：字符a的ASCII码值为97）：
＃include ＜stdio.h＞
main（）
｛ char *s =｛ ＂abc＂ ｝；
do
｛ printf（＂% d＂，*s% 10）；
++s；
｝while（*s）；
｝
程序的运行结果是（ ）。
A） 789 B） abc C） 7890 D） 979899
（24）设有定义“char*c；”，以下选项中能够使c正确指向一个字符串的是（ ）。
A）char str［］=＂string＂；c=str；
B）scanf（＂% s＂，c）；
C）c=getchar（）；
D）*c=＂string＂；
（25）有以下程序（说明：字母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） BT B） YE C） YT D） BY
（26）有以下函数：
int fun（char *x，char *y）
｛ int n=0；
while（（*x==*y）&& *x！= ＇\0＇）
｛ x++；
y++；
n++；
｝
return n；
｝
函数的功能是（ ）。
A）将y所指字符串赋给x所指存储空间
B）查找x和y所指字符串中是否有＇\0＇
C）统计x和y所指字符串中最前面连续相同的字符个数
D）统计x和y所指字符串中相同的字符个数
（27）下列语句组中正确的是（ ）。
A）char *s；s=｛＂BOOK！＂｝；
B）char *s；s=＂BOOK！＂；
C）char s［10］；s=＂BOOK！＂；
D）char s［］；s=＂BOOK！＂；
（28）设有定义语句“int（*f）（int）；”则下列叙述中正确的是（ ）。
A）f是基类型为int的指针变量
B）f是指向函数的指针变量，该函数具有一个int类型的形参
C）f是指向int类型一维数组的指针变量
D）f是函数名，该函数的返回值是基类型为int类型的地址
（29）有以下程序：
＃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）；
（30）有以下程序：
＃include ＜stdio.h＞
＃include ＜stdlib.h＞
main（）
｛
int *a，*b，*c；
a=b=c=（int *）malloc（sizeof（int））；
*a=1；
*b=2，*c=3；
a=b；
printf（＂% d，% d，% d\n＂，*a，*b，*c）；
｝
程序的运行结果是（ ）。
A） 1，1，3 B） 2，2，3 C） 1，2，3 D） 3，3，3
（31）下列语句中存在语法错误的是（ ）。
A）char ss［6］［20］；ss［1］= ＂right？＂；
B）char ss（）［20］=｛ ＂right？＂｝；
C）char *ss［6］；ss［1］= ＂right？＂；
D）char *ss（）=｛ ＂right？＂｝；
（九） 编译预处理和动态存储分配
【考点35】 宏定义
1.不带参数的宏定义
（1）定义形式：＃define宏名 替换文本 或＃define宏名。
（2）说明。
在define宏名和宏替换文本之间要用空格隔开。
可以用 ＃undef 命令终止宏定义的作用域。
在进行宏定义时，可以引用已定义的宏名。
同一个宏名不能重复定义。
2.带参数的宏定义
（1）定义形式：＃define宏名（参数表）字符串。
宏定义不只进行简单的字符串替换，还可进行参数替换。
（2）执行过程。
如果程序中有带实参的宏，则按＃define命令行中指定的字符串从左到右进行置换。
●如果字符串中包含宏中的形参（如x，y），则将程序语句中相应的实参（可以是常量、变量或表达式）代替形参。
如果宏定义中的字符串中的字符不是参数字符（如（x*y）中的“*”号），则保留。这样就形成了置换的字符串。
【考点36】 关于动态存储的函数
malloc（）函数
函数原型为：void * malloc（unsigned int size）；
函数的作用：系统自动在内存的动态存储区中，分配长度为size的一段连续空间。若此函数执行成功，则函数返回值为指向被分配域的起始地址的指针（该函数的返回值的基本类型为void）。若该函数执行失败（如内存空间不足的情况），则函数返回值为空指针（NULL）。
真题演练
（1）下列叙述中正确的是（ ）。
A）在C语言中，预处理命令行都以“＃”开头
B）预处理命令行必须位于C源程序的起始位置
C）＃include ＜stdio.h＞必须放在C程序的开头
D）C语言的预处理不能实现宏定义和条件编译的功能（2）下列关于宏的叙述中正确的是（ ）。
A）宏替换没有数据类型限制
B）宏定义必须位于源程序中所有语句之前
C）宏名必须用大写字母表示
D）宏调用比函数调用耗费时间
（3）有以下程序：
＃include ＜stdio.h＞
＃define PT 3.5；
＃define S（x）PT*x*x；
main（）
｛ int a=1，b=2；
printf（＂% 4.1f\n＂，S（a+b））；
｝
程序的运行结果是（ ）。
A）7.5
B）31.5
C）程序有错无输出结果
D）14.0
（4）若程序中有宏定义行：＃define N 100，则下列叙述中正确的是（ ）。
A）宏定义行中定义了标识符N的值为整数100
B）在编译程序对C源程序进行预处理时用100替换标识符N
C）上述宏定义行实现将100赋给标识符N
D）在运行时用100替换标识符N
（5）有以下程序：
＃include ＜stdio.h＞
＃define S（x）4*（x）*x+1
main（）
｛
int k=5，j=2；
printf（＂% d\n＂，S（k+j））；
｝
程序的运行结果是（ ）。
A） 33 B） 197 C） 143 D） 28
（6）有以下程序：
＃include ＜stdio.h＞
＃define SUB（a）（a）-（a）main（）
｛
int a=2，b=3，c=5，d；
d=SUB（a+b）*c；
printf（＂% d\n＂，d）；
｝
程序的运行结果是（ ）。
A） 0 B） -12 C） -20 D） 10
（7）有以下程序：
＃include ＜stdio.h＞
＃define f（x）x*x*x
main（）
｛
int a=3，s，t；
s=f（a+1）；
t=f（（a+1））；
printf（＂% d，% d\n＂，s，t）；
｝
程序的运行结果是（ ）。
A） 10，64 B） 10，10 C） 64，10 D） 64，64
（8）有以下程序：
＃include ＜stdio.h＞
＃define N 5
＃define M N+1
＃define f（x）（x*M）
main（）
｛
int i1，i2；
i1 = f（2）；
i2 = f（1+1）；
printf（＂% d % d\n＂，i1，i2）；
｝
程序的运行结果是（ ）。
A） 12 7 B） 12 12 C） 11 11 D） 11 7
（9）下列叙述中错误的是（ ）。
A）C程序对预处理命令行的处理是在程序执行过程中进行的
B）预处理命令行的最后不能以分号表示结束
C）＃define MAX 是合法的宏定义命令行
D）在程序中，凡是以“＃”开始的语句行都是预处理命令行
（十） 结构体和共用体
【考点37】 用typedef说明一种新类型
（1）一般形式：typedef 类型名 标识符；
其中，“类型名”一定是在此语句之前已有定义的类型标识符。“标识符”是一个用户定义标识符，用来标识新的类型名。
（2）typedef语句的作用：用“标识符”来代表已存在的“类型名”，并没有产生新的数据类型，因此，原有的类型名依然有效。
（3）声明一个新的类型名的具体步骤如下。
先按定义变量的方法写出定义的主体（如float a；）。
将变量名换成新类型名（如将a换成FLO）。
在最左面加上关键字typedef（如typedef float FLO；）。
●然后可以用新类型名去定义其他的变量（如FLO b；）。
【考点38】 结构体数据类型
（1）声明一个结构体类型的一般形式为：
struct 结构体名
｛ 成员表列 ｝；
（2）结构体类型可以用以下形式说明：
struct 结构体标识名
｛
类型名1 结构体成员名表1；
类型名2 结构体成员名表2；
……
类型名n 结构体成员名表n；
｝；
说明：
①“结构体标识名”和“结构体成员名表”都必须是合法的用户定义的标识符。
②每个“结构体成员名表”中都可以含有多个同类型的成员名，它们之间以逗号分隔。
③结构体类型说明中的“类型名1”～“类型名n”，不仅可以是简单数据类型，也可以是某种结构体类型。当结构体说明中又包含结构体时，称为结构体的嵌套。
④ANSI C标准规定结构体至多允许嵌套15层，并且允许内嵌结构体成员的名字与外层成员的名字相同。
【考点39】 结构体类型变量的定义
1.先声明结构体类型再定义变量名
如已经定义了一个结构体类型struct time，可以如下定义：
struct time time1，time2；
结构体类型名 结构体变量名；
time1和time2 为struct time 类型变量，即它们都具有struct time类型的结构。
2.在声明类型的同时定义变量
一般形式为：
struct 结构体名 ｛ 成员表列 ｝ 变量名表列；
3.直接定义结构体类型变量
一般形式为：
struct ｛ 成员表列 ｝ 变量名表列；
即不出现结构体名。
【考点40】 结构体类型变量的引用
引用结构体变量时应注意如下几点。
结构体变量不能作为一个整体而对其进行任何操作，只能对结构体变量中的各个成员分别进行输入和输出等操作。结构体变量中的成员用以下方式引用：结构体变量名.成员名
如果结构体的某个成员本身又是一个结构体类型，则可以使用若干个成员运算符“.”，一级一级地找到最低的一级成员，只能对最低一级的成员进行赋值或存取及运算。
结构体变量的初始化，是指逐个对结构体变量的各个成员进行初始化的过程。
【考点41】 结构体数组
（1）一般形式为：
struct 结构体变量名 ｛ 成员表列｝ 数组名［常量表达式］；
（2）结构体数组的初始值应顺序地放在一对花括号中。
【考点42】 指向结构体类型数据的指针
1.指向结构体变量的指针
●“-＞”称为指向运算符。
●“结构体变量.成员名”、“（*结构体指针变量名）.成员名”和“结构体指针变量名-＞成员名”这3种形式是等价的。
2.指向结构体数组的指针
结构体数组及其元素也可以用指针变量来指向。在使用指针变量指向结构体数组时，只要把该结构体数组中的每个元素当作普通的结构体变量使用即可。
3.用结构体变量和指向结构体的指针作为函数参数
将一个结构体变量的值传递给另一个函数，有如下方法。
结构体变量的成员作为实参传递给主调函数。
可以用结构体变量作为一个整体实参。
C语言中，允许将结构体变量的地址作为实参传递，这时，对应的形参应该是一个基类型相同的结构体类型的指针。
【考点43】 链表
1.链表的概念
（1）定义：链表是一种常见的重要的数据结构，它是动态地进行存储单元分配的一种结构。
（2）说明。
链表中的各元素在内存中不一定是连续存放的。
一个结点中应包含一个指针变量，用它存放下一结点的地址。
链表最后一个结点的指针域置成‘\0’（NULL）值，标志着链表的结束。
每一个链表都用一个“头指针”变量来指向链表的开始，称为head指针。在head指针中存放了链表第一个结点的地址。
2.顺序访问链表中各结点的数据域
所谓“访问”，可以理解为取各结点的数据域中的值进行各种运算、修改各结点的数据域中的值等一系列的操作。
输出单向链表各结点数据域中内容的算法比较简单，只需利用一个工作指针（p），从头到尾依次指向链表中的每个结点，当指针指向某个结点时，就输出该结点数据域中的内容，直到遇到链表结束标志为止。如果是空链表，就只输出提示信息并返回调用函数。
3.删除链表中的结点
为了删除单向链表中的某个结点，首先要找到待删除的结点的前趋结点（即当前要删除结点的前面一个结点），然后将此前趋结点的指针域去指向待删除结点的后续结点（即当前要删除结点的下一个结点），最后释放被删除结点所占的存储空间即可。
真题演练
（1）若有语句typedef struct S ｛ int g；char h；｝ T；，则下列叙述中正确的是（ ）。
A） 可用S定义结构体变量 B） 可用T定义结构体变量
C） S是struct类型的变量 D） T是struct S类型的变量
（2）设有语句typedef struct TT｛ char c；int a［4］；｝ CIN；，则下列叙述中正确的是（ ）。
A）CIN是struct TT类型的变量
B）TT是struct类型的变量
C）可以用TT定义结构体变量
D）可以用CIN定义结构体变量
（3）下列叙述中错误的是（ ）。
A）可以用typedef将已存在的类型用一个新的名字来代表
B）可以通过typedef增加新的类型
C）用typedef定义新的类型名后，原有类型名仍有效
D）用typedef可以为各种类型起别名，但不能为变量起别名
（4）有以下程序：
＃include ＜stdio.h＞
main（）
｛
struct STU
｛
char name［9］；
char sex；
double score［2］；
｝；
struct STU a=｛＂Zhao＂， ＇m＇，85.0，90.0｝，b =｛＂
Qian＂， ＇f ＇，95.0，92.0｝；
b=a；
printf（＂% s，% c，% 2.0f，% 2.0f\n＂，b.name，b.sex，
b.score［0］，b.score［1］）；
｝
程序的运行结果是（ ）。
A） Qian，m，85，90 B） Zhao，m，85，90
C） Zhao，f，95，92 D） Qian，f，95，92
（5）下列结构体类型说明和变量定义中正确的是（ ）。
A）struct REC；
｛ int n；char c；｝；
REC t1，t2；
B）typedef struct
｛ int n；char c；｝ REC；
REC t1，t2；
C）typedef struct REC；
｛ int n=0；char c= ＇A＇；｝ t1，t2；
D）struct
｛ int n；char c；｝ REC；
REC t1，t2；
（6）下列结构体的定义语句中错误的是（ ）。
A）struct ord ｛int x；int y；int z；｝ struct ord a；
B）struct ord ｛int x；int y；int z；｝；struct ord a；
C）struct ord ｛int x；int y；int z；｝ a；
D）struct ｛int x；int y；int z；｝ a；
（7）设有定义：
struct complex
｛ int real，unreal；
｝
data1=｛1，8｝，data2；
则下列赋值语句中错误的是（ ）。
A）data2=（2，6）；
B）data2=data1；
C）data2.real=data1.real；
D）data2.real=data1.unreal；
（8）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
struct A
｛ int a；
char b［10］；
double c；
｝；
struct A f（struct A t）；
main（）
｛ struct A a=｛1001，＂ZhangDa＂，1098.0｝；
｝
a=f（a）；
printf（＂% d，% s，% 6.1f\n＂，a.a，a.b，a.c）；
struct A f（struct A t）
｛ t.a=1002；
strcpy（t.b，＂ChangRong＂）；
t.c=1202.0；return t；
｝
程序的运行结果是（ ）。
A）1002，ZhangDa，1202.0 B）1002，ChangRong，1202.0
C） 1001，ChangRong，1098.0 D） 1001，ZhangDa，1098.0
（9）有以下程序：
struct st ｛ int x；int *y；｝ *pt；
int a［］=｛1，2｝，b［］=｛3，4｝；
struct st c［2］=｛10，a，20，b｝；
pt=c；
以下选项中表达式值为11的是（ ）。
A） ++pt-＞x B） pt-＞x
C） *pt-＞y D）（pt++）-＞x
（10）有以下程序：
＃include ＜stdio.h＞
struct S
｛
int n；
int a［20］；
｝；
void f（int *a，int n）
｛
int i；
for（i=0；i＜n-1；i++）
a［i］+=i；
｝
main（）
｛
｝
int i；
struct S s=｛10，｛2，3，1，6，8，7，5，4，10，9｝｝；
f（s.a，s.n）；
for（i=0；i＜s.n；i++）
printf（＂% d，＂，s.a［i］）；
程序的运行结果是（ ）。
A）2，3，1，6，8，7，5，4，10，9，
B）3，4，2，7，9，8，6，5，11，10，
C）2，4，3，9，12，12，11，11，18，9，
D）1，2，3，6，8，7，5，4，10，9，
（11）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
typedef struct
｛
char name［9］；
char sex；
float score［2］；
｝ STU；
void f（STU A）
｛
STU b=｛＂Zhao＂， ＇m＇，85.0，90.0｝；
int i；
strcpy（a.name，b.name）；
a.sex = b.sex；
for（i=0；i＜2；i++）
a.score［i］= b.score［i］；
｝
main（）
｛
STU c=｛＂Qian＂， ＇f ＇，95.0，92.0｝；
f（c）；
printf（＂% s，% c，% 2.0f，% 2.0f\n＂，c.name，c.sex，
c.score［0］，
c.score［1］）；
｝
程序的运行结果是（ ）。
A） Zhao，m，85，90 B） Qian，m，85，90
C） Zhao，f，95，92 D） Qian，f，95，92
（12）有以下程序：＃include ＜stdio.h＞
＃include ＜string.h＞
struct A
｛
int a；
char b［10］；
double c；
｝；
void f（struct A t）；
main（）
｛
struct A a=｛1001，＂ZhangDa＂，1098.0｝；
f（a）；
printf（＂% d，% s，% 6.1f\n＂，a.a，a.b，a.c）；
｝
void f（struct A t）
｛
t.a=1002；
strcpy（t.b，＂ChangRong＂）；
t.c=1202.0；
｝
程序的运行结果是（ ）。
A）1002，ZhangDa，1202.0
B）1002，ChangRong，1202.0
C）1001，ChangRong，1098.0
D）1001，ZhangDa，1098.0
（13）有以下定义和语句：
struct workers
｛
int num；
char name［20］；char c；
struct
｛
int day；
int month；
int year；
｝
s；
｝；
struct workers w，*pw；
pw=&w；
能给w中year成员赋1980的语句是（ ）。
A） pw-＞year=1980； B） w.year=1980；
C） w.s.year=1980； D） *pw.year=1980；
（14）有以下程序：
＃include ＜stdio.h＞
struct tt ｛ int x；struct tt *y；｝ *p；
struct tt a［4］=｛20，a+1，15，a+2，30，a+3，17，a｝；
main（）
｛
int i；
p=a；
for（i=1；i＜=2；i++）
｛
printf（＂% d，＂，p-＞x）；
p=p-＞y；
｝
｝
程序的运行结果是（ ）。
A） 20，30， B） 30，17
C） 15，30， D） 20，15，
（15）设有定义：struct ｛char mark［12］；int num1；double num2；｝ t1，t2；，若变量均已正确赋初值，则下列语句中错误的是（ ）。
A）t1=t2；
B）t2.num1=t1.num1；
C）t2.mark=t1.mark；
D）t2.num2=t1.num2；
（16）有以下程序：＃include ＜stdio.h＞
struct S
｛ int a， b；
｝
data［2］=｛10，100，20，200｝；
main（）
｛ struct S
p=data［1］；
printf（＂% d\n＂，++（p.a））；
｝
程序的运行结果是（ ）。
A） 10 B） 11 C） 20 D） 21
（17）有以下程序：
＃include ＜stdio.h＞
struct ord
｛
｝
int x，y；
dt［2］=｛1，2，3，4｝；
main（）
｛
struct ord *p=dt；
printf（＂% d，＂，++（p-＞x））；
printf（＂% d\n＂，++（p-＞y））；
｝
程序的运行结果是（ ）。
A） 3，4 B） 4，1 C） 2，3 D） 1，2
（18）有以下结构体说明、变量定义和赋值语句：
struct STD ｛ char name［10］；int age；char sex；｝ s［5］，
*ps；ps=&s［0］；
则下列scanf函数调用语句有错误的是（ ）。
A）scanf（＂% s＂，s［0］.name）；
B）scanf（＂% d＂，&s［0］.age）；
C）scanf（＂% c＂，&（ps-＞sex））；
D）scanf（＂% d＂，ps-＞age）；
（19）有以下程序：
＃include ＜stdio.h＞
typedef struct ｛ int b，p；｝ A；
void f（A c）/* 注意：c是结构变量名 */
｛ int j；
c.b += 1；
c.p+=2；
｝
main（）
｛ int i；
Aa=｛1，2｝；
f（a）；
printf（＂% d，% d\n＂，a.b，a.p）；
｝
程序的运行结果是（ ）。
A） 2，4 B） 1，2 C） 1，4 D） 2，3
（20）有以下程序：
＃include ＜stdio.h＞
struct S
｛int n；int a［20］；｝；
void f（struct S *p）
｛
int i，j，t；
for（i=0；i＜p-＞n-1；i++）
for（j=i+1；j＜p-＞n；j++）
if（p-＞a［i］＞ p-＞a［j］）
｛
t= p-＞a［i］；
p-＞a［i］= p-＞a［j］；
p-＞a［j］= t；
｝
｝
main（）
｛
int i；
struct S s=｛10，｛2，3，1，6，8，7，5，4，10，9｝｝；
f（&s）；
for（i=0；i＜s.n；i++）
printf（＂% d，＂，s.a［i］）；
｝
程序的运行结果是（ ）。
A）2，3，1，6，8，7，5，4，10，9，
B）10，9，8，7，6，5，4，3，2，1，
C）1，2，3，4，5，6，7，8，9，10，
D）10，9，8，7，6，1，2，3，4，5，
（21）有以下程序：
＃include ＜stdio.h＞
＃include ＜string.h＞
typedef struct ｛ char name［9］；
char sex；
int score［2］；｝ STU；
STU f（STU a）
｛ STU b=｛＂Zhao＂， ＇m＇，85，90｝；
int i；
strcpy（a.name，b.name）；
a.sex = b.sex；
for（i=0；i＜2；i++）a.score［i］= b.score
［i］；
return a；
｝
main（）
｛
STU c= ｛ ＂Qian＂， ＇f ＇，95，92 ｝，d；
d = f（c）；
printf（＂% s，% c，% d，% d，＂，d.name，d.sex，d.
score［0］，d.score［1］）；
printf（＂% s，% c，% d，% d\n＂，c.name，c.sex，
c.score［0］，c.score［1］）；
｝
程序的运行结果是（ ）。A）Zhao，m，85，90，Qian，f，95，92
B）Zhao，m，85，90，Zhao，m，85，90
C）Qian，f，95，92，Qian，f，95，92
D）Qian，f，95，92，Zhao，m，85，90
（22）程序中已构成如下不带头结点的单向链表结构，指针变量s、p、q均已正确定义，并用于指向链表结点，指针变量s总是作为指针指向链表的第一个结点。
若有以下程序段：
q=s；
s=s-＞next；
p=s；
while（p-＞next）p=p-＞next；
p-＞next=q；
q-＞next=NULL；
该程序段实现的功能是（ ）。
A） 删除尾结点 B） 尾结点成为首结点
C） 删除首结点 D） 首结点成为尾结点
（23）假定已建立以下链表结构，且指针p和q已指向如图所示的结点。
则下列选项中可将q所指结点从链表中删除并释放该结点的语句组是（ ）。
A）p-＞next=q-＞next；free（q）；
B）p=q-＞next；free（q）；
C）p=q；free（q）；
D）（*p）.next=（*q）.next；free（p）；
（十一） 文件
【考点44】 C语言文件的概念
C程序把文件分为ASCII文件和二进制文件。ASCII文件又称文本文件。
在C语言中，文件是一个字节流或二进制流，也就是说，对于输入输出的数据都按“数据流”的形式进行处理。
文件输入输出方式也称“存取方式”。C语言中，文件有两种存取方式：顺序存取和直接存取。
【考点45】 文件类型指针
可以用该结构体类型来定义文件类型的指针变量，一般形式为：
FILE *fp；
fp是一个指向FILE结构体类型的指针变量。
【考点46】 文件的打开与关闭
1.fopen（）函数
（1）调用形式为：
fopen（文件名，文件使用方式）；
函数返回一个指向FILE类型的指针。
无论哪种使用方式，当打开文件时出现了错误，fopen函数都将返回NULL。
（2）最常用的文件使用方式及其含义如下。
●“r”：为读而打开文本文件。
●“rb”：为读而打开一个二进制文件。
●“w”：为写而打开文本文件。
●“wb”：为写而打开一个二进制文件。
●“a”：为在文件后面添加数据而打开文本文件。
●“ab”：为在文件后面添加数据而打开一个二进制文件。其余功能与“a”相同。
●“r+”：为读和写而打开文本文件。
●“rb+”：为读和写而打开一个二进制文件。
●“w+”：首先建立一个新文件，进行写操作，随后可以从头开始读。如果指定的文件已存在，则原有的内容将全部消失。
●“wb+”：功能与“w+”相同，只是在随后的读和写时，可以由位置函数设置读和写的起始位置。
●“a+”：功能与“a”相同，只是在文件尾部添加新的数据之后，可以从头开始读。
●“ab+”：功能与“a+”相同，只是在文件尾部添加新的数据之后，可以由位置函数设置开始读的起始位置。
2.fclose（）函数
调用形式为：
fclose（文件指针）；
若对文件的操作方式为“读”方式，则经以上函数调用之后，要使文件指针与文件脱离联系，可以重新分配文件指针去指向其他文件。
若对文件的操作方式为“写”方式，则系统首先把该文件缓冲区中的剩余数据全部输出到文件中，然后使文件指针与文件脱离联系。
在完成了对文件的操作之后，应当关闭文件，否则文件缓冲区中的剩余数据就会丢失。
当执行了关闭操作后，成功则函数返回0，否则返回非0。
【考点47】 文件的读写
1.fread（）函数和fwrite（）函数
当要求一次性读写一组数据时，例如，一个实数或一个结构体变量的值，就可以使用fread（）函数和fwrite（）函数，它们的一般调用形式为：
fread（buffer，size，count，fp）；
fwrite（buffer，size，count，fp）；
其中，buffer代表的是一个指针变量；size代表的是要读写的字节数；count用来指定每读写一次，输入或输出数据块的个数（每个数据块具有size个字节）；fp是文件类型指针。
2.fscanf（）函数和fprintf（）函数
fscanf（）函数和fprintf（）函数都是格式化的读写函数，与scanf（）和printf（）函数作用相似，但fscanf（）函数和fprintf（）函数读写对象是磁盘文件上的数据。
它们的一般形式如下：
fscanf（文件指针，格式字符串，输入列表）；
fprintf（文件指针，格式字符串，输出列表）；
3.fputs（）函数
fputs（）函数是用来把字符串输出到文件中，调用形式如下：fputs（str，fp）；
其中str是要输出的字符；fp是文件指针，字符串末尾的‘\0’不输出。
【考点48】 文件的定位
rewind（）函数的调用形式如下：
rewind（fp）；
该函数的功能是使文件的位置指针重新返回到文件的开头，其中fp为文件指针，且该函数没有返回值。
真题演练
（1）下列关于C语言文件的叙述中正确的是（ ）。
A）文件由一系列数据依次排列组成，只能构成二进制文件
B）文件由结构序列组成，可以构成二进制文件或文本文件
C）文件由数据序列组成，可以构成二进制文件或文本文件
D）文件由字符序列组成，其类型只能是文本文件
（2）下列叙述中正确的是（ ）。
A）当对文件的读（写）操作完成之后，必须将它关闭，否则可能导致数据丢失
B）打开一个已存在的文件并进行写操作后，原有文件中的全部数据必定被覆盖
C）在一个程序中对文件进行写操作后，必须先关闭该文件然后再打开才能读到第一个数据
D）C语言中的文件是流式文件，因此只能顺序存取数据
（3）有以下程序：
＃include ＜stdio.h＞
main（）
｛ FILE *fp；int a［10］=｛1，2，3｝，i，n；
fp = fopen（＂d1.dat＂，＂w＂）；
for（i=0；i＜3；i++）
fprintf（fp，＂% d＂，a［i］）；
fprintf（fp，＂\n＂）；
fclose（fp）；
fp = fopen（＂d1.dat＂，＂r＂）；
fscanf（fp，＂% d＂，&n）；
fclose（fp）；
printf（＂% d\n＂，n）；
｝
程序的运行结果是（ ）。
A） 321 B） 12300 C） 1 D） 123
（4）设文件指针 fp 已定义，执行语句 fp = fopen（＂file＂，＂w＂）；后，下列针对文本文件file操作叙述的选项中正确的是（ ）。
A）只能写不能读
B）写操作结束后可以从头开始读
C）可以在原有内容后追加写
D）可以随意读和写
（5）有以下程序：
＃include ＜stdio.h＞
main（）
｛
FILE *f；
f=fopen（＂filea.txt＂，＂w＂）；
fprintf（f，＂abc＂）；
fclose（f）；
｝若文本文件filea.txt中原有内容为hello，则运行以上程序后，文件filea.txt中的内容为（ ）。
A） abclo B） abc C） helloabc D） abchello
（6）读取二进制文件的函数调用形式为：fread（buffer，size， count，fp）；，其中buffer代表的是（ ）。
A）一个内存块的字节数
B）一个整型变量，代表待读取的数据的字节数
C）一个文件指针，指向待读取的文件
D）一个内存块的首地址，代表读入数据存放的地址
（7）有以下程序：
＃include ＜stdio.h＞
main（）
｛
FILE *pf；
char *s1=＂China＂，*s2=＂Beijing＂；
pf=fopen（＂abc.dat＂，＂wb+＂）；
fwrite（s2，7，1，pf）；
rewind（pf）；/*文件位置指针回到文件开头*/
fwrite（s1，5，1，pf）；
fclose（pf）；
｝
程序执行后，abc.dat文件的内容是（ ）。
A） China B） Chinang
C） ChinaBeijing D） BeijingChina
（8）有以下程序：
＃include ＜stdio.h＞
main（）
｛
FILE *fp；int a［10］=｛1，2，3，0，0｝，i；
fp = fopen（＂d2.dat＂，＂wb＂）；
fwrite（a，sizeof（int），5，fp）；
fwrite（a，sizeof（int），5，fp）；
fclose（fp）；
fp = fopen（＂d2.dat＂，＂rb＂）；
fread（a，sizeof（int），10，fp）；
fclose（fp）；
for（i=0；i＜10；i++）
printf（＂% d，＂，a［i］）；
｝
程序的运行结果是（ ）。
A）1，2，3，0，0，0，0，0，0，0，
B）1，2，3，1，2，3，0，0，0，0，
C）123，0，0，0，0，123，0，0，0，0，
D）1，2，3，0，0，1，2，3，0，0，
（9）有以下程序：
＃include ＜stdio.h＞
main（）
｛
FILE *fp；
int k，n，a［6］=｛1，2，3，4，5，6｝；
fp = fopen（＂d2.dat＂，＂w＂）；
fprintf（fp，＂% d% d% d\n＂，a［0］，a［1］，a［2］）；
fprintf（fp，＂% d% d% d\n＂，a［3］，a［4］，a［5］）；
fclose（fp）；
fp = fopen（＂d2.dat＂，＂r＂）；
fscanf（fp，＂% d% d＂，&k，&n）；
printf（＂% d % d\n＂，k，n）；
fclose（fp）；
｝
程序的运行结果是（ ）。
A） 1 2 B） 1 4 C） 123 4 D） 123 456
（10）有以下程序：
＃include ＜stdio.h＞
main（）
｛
FILE *fp；char str［10］；
fp=fopen（＂myfile.dat＂，＂w＂）；
fputs（＂abc＂，fp）；
fclose（fp）；
fp=fopen（＂myfile.dat＂，＂a+＂）；
fprintf（fp，＂% d＂，28）；
rewind（fp）；
fscanf（fp，＂% s＂，str）；
puts（str）；
fclose（fp）；
｝
程序的运行结果是（ ）。
A） abc B） 28c
C） abc28 D） 因类型不一致而出错
（11）设fp为指向某二进制文件的指针，且已读到此文件末尾，则函数feof（fp）的返回值为（ ）。
A） 0 B） ＇\0＇ C） 非0值 D） NULL