自考高级语言程序设计（一）串讲笔记
课程说明
串讲的目的和作用：
1、将相对零散的知识建立一个整体的筐架，形成整体的知识体系。
2、将考核知识点进行提炼
3、分析历年真题，掌握题目所含知识点的同时分析出题思路，使复习时做到有的放矢。
本次串讲的参考教材
《高级语言程序设计》 全国高等教育自学考试指导委员会组编，迟成文主编，经济科学出版社出版，2006年版。
本次串讲的要讲解的重要知识点（共37个）
1、高级语言与Ｃ语言的特点
2、Ｃ语言的基本字符集、转义字符、保留字及其含义和Ｃ语言标识符的构成规则。
3、Ｃ程序的基本结构与书写Ｃ程序的基本规则
4、Ｃ语言中数据类型的分类
5、整型、实型、字符型、字符串常量的书写方法
6、符号常量的应用和宏定义命令的使用
7、整型、实型、字符型变量的定义、初始化方法
8、基本类型数据在内存中的存放方式
9、基本运算符的运算规则、优先级别和结合性
10、掌握算术表达、关系和逻辑表达式、赋值表达式、逗号和条件表达式的构成和运算规则
11、变量赋值及表达式计算时的数据类型转换规则
12、字符输入／输出函数和格式输入／输出函数的使用
13、三条选择语句和三种选择结构的程序设计
14、三条循环语句和三种循环结构的程序设计
15、一维数组的定义、初始化和数组元素的引用方法
16、二维数组的定义、初始化和数组元素的引用方法
17、字符数组的定义、初始化和数组元素的引用方法
18、字符数组中存放的字符串的输入/输出和处理方法
19、字符串处理的常用系统函数及其使用
20、指针变量的定义、初始化、赋值和一般使用形式
21、指向变量的指针变量、指向一维数组元素的指针变量、指向字符串的指针变量的使用方法。
22、指针数组的定义、初始化和引用
23、函数的结构与定义方法，握函数的一般调用方法
24、函数调用时参数的值传递方法、地址传递方法、返回值传递方法和利用全局外部变量在函数间传递数据的方法。
25、变量的存储类型及其定义方法、变量的生存期和作用域。
26、函数嵌套调用和递归函数的特点和设计方法
27、指针型函数的定义方法和调用方法
28、常用系统函数的使用
29、结构型数据的特点和应用及结构型的定义方法
30、结构型变量的定义、初始化和成员引用方法
31、结构型数组的定义、初始化和引用结构型数组元素的成员的方法。
32、结构型指针变量的定义、初始化和利用结构型指针变量引用结构型数据的成员的方法
33、用户自定义类型的定义和使用
34、文件名的组成规则、文件的分类及其特点
36、文件型指针的定义方法
37、缓冲文件系统中各类系统函数的使用
u （1）打开/关闭文件函数的使用方法。
u （2）文件尾测试函数的使用方法。
u （3）文件读/写中字符读/写函数的使用方法。
u （4）文件读/写中字符串读/写函数的使用方法。
u （5）文件读/写中数据读/写函数的使用方法。
u （6）文件定位函数（定位文件头、随机定位）的使用方法。
第一章 概述
程序：是用某种计算机能理解并执行的计算机语言描述解决问题的方法步骤。
机器语言：采用计算机能直接识别和执行的二进制代码来表示的程序设计语言。
汇编语言：采用文字方式（助记符）表示的程序设计语言，其中大部分指令和机器语言中的指令一一对应，但不能被计算机的硬件直接识别。
机器语言和编语言又称为“面向机器的语言”或“低级语言”。
高级语言：是描述算法过程很方便、同时脱离了对机型的要求，能在任何计算机上运行的计算机语言。又称为“面向过程的语言”。
用高级语言编写的程序称为源程序。
高级语言程序的执行有两种：
一种是翻译一句执行一句，称为“解释执行”方式，完成翻译工作的程序就称为“解释程序”；
一种是全部翻译成二进制程序后再执行，承担翻译工作的程序就称为“编译程序”，编译后的二进制程序称为“目标程序”。
Ｃ语言的主要特点：
比其它高级语言更接近硬件，比低级语言更容易描述算法，程序易编、易读、易查错、易修改。可以说兼有高级语言和低级语言的优点。C语言既可以用来编写系统软件，也可以用来编写应用软件。
1．编译程序的功能是（ ）
A.将汇编语言程序转换为目标程序
B.将汇编语言程序转换为高级语言程序
C.将高级语言程序转换为目标程序
D.将高级语言程序转换为汇编语言程序
答案：C
第二章 C语言的基本知识
Ｃ语言的基本词法
1 字符集
Ｃ语言的字符集就是ASCII字符集，主要包含下列几类：
（1）大小写英文字母A～Z、a～z（52个）
（2）数字0、1、2、…、9（10个）
（3）非字母数字的可显示字符（33个）键盘可输入的字符。
字符集的真题
1.C语言不能选用的字母是( )
A.w B.π C.I D.i
答案：B
2.转义字符
在C语言的字符集中，还有一些不可显示的字符，C语言使用所谓的“转义字符”在程序中表示这些字符。转义字符由“反斜杠字符\”开始后跟单个字符或若干个字符组成。
\n \t \v \b \r \f | 回车换行符号 Tab符号 垂直制表符号 左退一格符号 回车符号 换页符号 | \a \" \’ \\ \ddd \xhh | 响铃符号 双引号 单引号 反斜杠 1～3位8进制数ddd对应的符号 1～2位16进制数hh对应的符号 |
转义字符的有关真题
1.下列不正确的转义字符是( )
A. ′\\′ B. ′\″
C. ′\086′ D. ′\0′
答案：C
2. 下列转义字符中错误的是( )
A′\000′ B. ′\14′
C. ′\x111′ D. ′\2′
答案：C
3.保留字
auto break case char continue const default do double else enum | 自动 中止 情况 字符 继续 常量 缺省 做 双 否则 枚举 | extern float for goto int if long register return short signed | 外部 浮点 对于 转向 整 如果 长 寄存器 返回 短 带符号 | sizeof static struct switch typedef union unsigned void volatile while | 计算字节数 静态 结构 开关 类型定义 共用 无符号 空 可变的 当 |
说明：
1、所有的保留字均由小写字母组成的，一旦有一个字母大写，其不再是保留字原来的含义。
2、根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。
• 保留字的有关真题
• 1.下列标识符中，不是C语言保留字的是( )
• char B.while
• C. min D.default
• 答案：C
• 2. 下列不属于C语言保留字的是( )
• char B.while
• C.typedef D.look
• 答案：D
• 3．表示空类型的保留字是 。
• 答案：void （注意一定小写）
• 数据类型关键字(12个)：char, double, enum, float, int, long, short,signed, struct, union, unsigned, void
• 控制语句关键字(12个)：break, case, continue, default, do, else,for, goto, if, return, switch, while
• 存储类型关键字(4个)：auto, extern, register, static
• 其它关键字(4个)：const, sizeof, typedef, volatile
4.标识符
标识符是用户自定义的字符序列，比如符号常量名、变量名、数组名、函数名等。
Ｃ语言规定，标识符是由字母或下划线开头的字母、数字、下划线组成的字符序列。标识符中的字母是区分大小写的。
标识符的有关真题
1. 正确的C语言用户自定义标识符是 ( )
A. print B. float C. when D. random
答案：A
2.可以用作C程序标识符的一组是（ ）
A.print oodb aBc
B.i\am one-half 3pai
C.Pxq line# His.age
D.Cpp while pow
答案：A
3.C语言标识符的第一个字符必须为下划线或者 。
答案：字母
C程序构成的特点：
(１)Ｃ程序是由若干个函数构成的。 每个Ｃ程序有且仅有一个主函数，该主函数的函数名规定为main。
(２)每个函数（包括主函数）的定义分为两个部分：函数头和函数体。
函数头：返回值的类型 函数名(类型 形式参数１，．．．)
函数体：{ 数据定义部分
实现函数功能的语句串
}
函数名后面的一对圆括号“”是用来写函数的参数的。参数可以有，也可以没有，但圆括号不能省略。
(３)Ｃ程序中的每个语句以“分号”作为语句的结束，“分号”是C语句的组成部分，不可以省略。
(４)用“/*”和“*/”括住的任意字符序列，称为“注释”。源程序编译时，注释被忽略。
(５)Ｃ程序的书写格式很灵活，在一行上可以书写多个语句，一个语句也可以写在多行上。在程序清单的任何一处都可以插入空格符号或回车符号。但是，为了程序清单层次分明、便于阅读，通常都采用缩格并对齐的书写方法。
（6）Ｃ程序的执行总是从主函数开始，并在主函数中结束。主函数和其它函数的位置是任意的。其它函数总是通过函数调用语句被执行。
（7）主函数可以调用任何其它函数；任何其它函数都可以相互调用，但不能调用主函数。
（8）C语言编译系统区分字母大小写。
C程序构成的真题
1.构成一个C程序的是( )
A.一个主函数和若干个非主函数
B.若干个主函数和若干个非主函数
C.一个主函数和最多一个非主函数
D.若干个主函数和最多一个非主函数
答案：A
2．组成C语言程序的是（ ）
A.过程 B.函数 C.子程序 D.主程序和子程序
答案：B
3.一个C程序一般由若干个函数构成，其中至少应包含一个 函数。
答案：主
4. C语言程序编译时，程序中的注释部分 （ ）
A.参加编译，并会出现在目标程序中
B.参加编译，但不会出现在目标程序中
C.不参加编译，但会出现在目标程序中
D.不参加编译，也不会出现在目标程序中
答案：D
第三章 基本数据类型、运算符和表达式
C语言数据类型及分类关系图
┌ 带符号整型
┌ 带符号整型┼ 带符号短整型
│ └ 带符号长整型
┌ 整型┤ ┌ 无符号整型
│ └ 无符号整型┼ 无符号短整型
│ └ 无符号长整型
┌ 基本类型┤ ┌ 单精度型
│ ├ 实型┤
│ │ └ 双精度型
│ └ 字符型
数据类型┤ ┌ 数组型
├ 构造类型┤
│ └ 结构型
├ 指针型
└ 空类型( void)
C语言数据类型的真题
1.属于C语言基本数据类型的是( )
A.指针型 B.无符号整型
C.数组型 D.结构型
答案：B
常量
整型常量
在Ｃ语言中，整型常量有三种书写形式:
(１)十进制整数:由数字0-9和正负号表示。如:0、-111、+15、21等。
（２）八进制整数(在前面0)。例如00、-0111、+015、021。
（３）十六进制整数(在前面0x)。例如 0x0 、-0x111、+0xff、0x2d。
整型常量在一般微型机中占用2个字节，数值范围都是十进制的-32768+32767。
长整型常量（在整数的末尾字母“L”）：长整型常量在计算机中占用4个字节。
10和10L是不同的整型常量， 虽然它们有相同的数值，但它们在内存中占用不同数量的字节。
更多优质自考资料尽在百度贴吧自考乐园俱乐部
（http://tieba.baidu.com/club/5346389）欢迎❤加入...欢迎❤交流...止不住的惊喜等着你.........
常量的真题
1、C语言的长整型数值在计算机中占用的字节个数是( )
A.1 B.2 C.3 D.4
答案：D
2、在C语言中，整型常量的书写形式包括：八进制、十进制和 进制。
答案：十六
实型常量
实型常量只使用十进制，它的书写形式有两种:
1、十进制数形式：(必须有小数点） 如0.123, .123, 123.0, 0.0, 123.
2、指数形式：（e或E之前必须有数字；指数必须为整数）如:
12.3e3 ,123E2, 1.23e4 , e-5 , 1.2E-3.5
说明：
1、实型常量在一般的微型机中占用4个字节数。
2、实型常量有效数字是7位。
实型常量的真题
1．C语言中，错误的int类型的常数是（ ）
A．1E5 B．0 C．037 D．0xaf
答案：A
2、在C语言中，一个双精度数-5.88在二进制文件里占用的字节数是 。
答案：8
字符常量
字符常量用两个单引号(’)前后括住的单个字符来表示。
例如，’a’、’1’、 ’%’ 、’A’、 ’\n’、’\101’。
说明：
1、C语言规定，字母是区分大小写的。
2、在内存中，每个字符常量都占用一个字节，具体存放的是该字符对应的ASCII代码值。
3、在C语言中，一个字符常量也可以看成是“整型常量”，其值就是该字符的ASCII代码值。例如，’a’ ，可以看作是97。
4、如果其值在0～127之间，整型常量也可以将其看成一个字符型常量.例如97,可以当成字符常量’a’来使用。
字符常量真题
1. 设 char x =′a′；则printf(″x = ﹪c, y = ﹪c \ n″，x，97)；的输出是（ ）
A. x = a，y = 97 B. x = 97，y = a
C. x = 97，y = 97 D. x = a，y = a
答案：D
2.设char a=‘\70’；则变量a中（ ）
A.包含1个字符 B.包含2个字符 C.包含3个字符 D.是非法表示
答案：A
字符串常量
字符串常量简称为“字符串”。字符串就是用两个双引号（"）前后括住的一串字符。
空字符串:没有字符的字符串称为“空字符串”。例如，""。
字符串的长度:一个字符串中所有字符的个数称为该字符串的长度
例如，“”的长度为0； “ab12c” 的长度为5； "\101\n\x43ab"的长度为5
说明：1、空串与空格串是不同的。空串前者不含任何字符，长度为0；空格串是包含若干空格字符的字符串其长度为所含空格字符的个数。
2、每个字符串在内存中占用的字节数等于字符串的长度+1。其中最后一个字节存放的字符为“空字符”，其值为0 ，书写时常用转义字符“\0”来表示，称为字符串结束标记。
字符串常量真题
1.下列数据中，不是C语言常量的是( )
A. ′\n′ B. ″a″ C. e-2 D. 012
答案：C
2.字符串″ABCD\t\\\123″的长度是 。
答案：7
符号常量
符号常量的定义方法如下: #define 符号常量 常量
【例】#define PI 3.14159
说明：
1、符号常量标识符的规则构成，建议用大写英文字母组成。其中的常量可以是任何类型的常量。
2、符号常量的定义一般放在程序的开头，每个定义必须独占一行，其后不跟分号。
宏定义命令
宏定义命令的一般格式如下：#define 宏名 一串符号
说明：
1、其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。 “一串符号”可以是常数、表达式、格式串等。
2、当对源程序清单进行编译之前，将把所有的“宏名”替换成对应的“一串符号”，切不可自行添加其它符号。
3、宏可以嵌套宏定义
宏定义的真题
1.下列叙述中，正确的是 （ ）
A.引用带参的宏时，实际参数的类型应与宏定义时的形式参数类型相一致
B.宏名必须用大写字母表示
C.宏替换不占用运行时间，只占编译时间
D.在程序的一行上可以出现多个有效的宏定义
答案：C
2.在下列有关宏替换的叙述中，正确的说法是( )
A.宏替换占用运行时间
B.宏名有类型
C.带参数的宏替换和函数等价
D.宏替换只是字符替换
答案：D
3.下列程序的运行结果是( )
# define A 5
# define B A+1
main( )
{int a;
a=B;
printf(″%d\n″a--);
}
A.6 B.5 C.4 D.出错
答案：A
变量
变量的概念
在程序运行过程中，其值可以被改变的量称为变量。
变量的四个要素
(1)变量名。每个变量都必须有一个名字──变量名，变量命名遵循标识符命名规则。
(2)变量值。在程序运行过程中，变量值存储在内存中。
(3)变量类型:int char float 等
(4)变量的存储类型：aoto register static exit
变量的数据类型及其定义
数据类型 | 数据类型符 | 占用字节数 | 数值范围 |
整型 | int | 2(或4) | 同短整型(或长整型) |
短整型 | short | 2 | -32768～+32767 (-215～215-1) |
长整型 | long | 4 | -2147483648～+2147483647 (-231～231-1) |
无符号整型 | unsigned [int] | 2(或4) | 同无符号短整型(或长整型) |
无符号短整型 | unsigned short | 2 | 0～65535 (0～216-1) |
无符号长整型 | unsigned long | 4 | 0～4294967295 (0～232-1) |
单精度实型 | float | 4 | -1038～1038（保留7位有效数字） |
双精度实型 | double | 8 | -10308～10308（保留11位有效数字） |
字符型 | char | 1 | -128～+127 |
有名常量的定义
定义方法如下：
const 数据类型符 变量名1=初值1,变量名2=初值1,...;
说明：有名常量的值是通过赋初值的方式获得，不能用赋值方式获得值。而且，获得初值后，程序中将不能改变其值。
【例】定义有名常量举例。
const char char_y=’Y’,char_n=’N’;
/* 定义字符型有名常量char_y和char_n，其值分别为字符Y和N */
运算符
算术运算符 (+、-；+、-、*、/、%)
说明：
（1） 除运算(/)和运算对象的数据类型有关。
例如，14/5=2 1/2=0 1/2.0=0.5 1.0/2=0.5。
（2）模运算(%)的对象必须是整型数据，结果是整除后的余数，运算结果的符号必须与被除数相同。
例如，14%5=4 14%-5=4 -14%5=-4 -14%-5=-4。
增１、减１运算符 （++ --）
注意：增1、减1运算符的运算对象是变量，不能是常量或表达式。
关系运算符（>=、>、<=、< ==、!=）和逻辑运算符（&& || !）
说明：
（1）关系运算和逻辑运算的结果是整型数据0或1。
（2）运算符的优先级如下:
! 优先于 双目算术运算符 优先于 关系运算符 优先于 && 优先于 ||
注意：用&&对两个表达式进行计算时，若第一个表达式的值为“假”，则运算结果与第二个表达式的值无关，结果肯定为“假”，所以Ｃ语言规定此时第二个表达式将不再计算。同样用||对两个表达式进行计算时，若第一个表达式的值为“真”，则运算结果与第二个表达式的值无关，结果肯定为“真”，所以Ｃ语言规定此时第二个表达式也不再计算。
赋值运算符 （=）
算术自反赋值运算符 (+= -= *= /= %=)
说明：
（1）算术自反赋值运算符和赋值运算符的优先级是相同的，只比逗号运算符高。
（2）自反赋值运算符右边的表达式是自动加括号的。
【例】“c%=a-3”不能理解为“c=c%a-3”，应理解为“c=c%(a-3)”。
逗号运算符 （,）
说明：
（1）由逗号运算符组成的式子也是表达式,其值等于右边表达式的值。
（2）任何运算符都优先于号运算符。
条件运算符 （？：）
说明：
（1）条件运算符是唯一的三目运算符。
（2）条件运算符的优先级：优先于 赋值、算术自反赋值运算符 逗号运算符（排倒数第三）
长度运算符 （sizeof）
【例】 设变量定义如下：int n; 表达式sizeof(n)的值是2。
表达式sizeof(long)的值是4。
位运算符（~ & | ^）
位运算的对象只能是整型数据（包括字符型）。运算结果仍是整型数据。
a | b | a&b | a|b | a^b |
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 0 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
位移位运算符 ( << 左移， >> 右移)
运算符真题
1.下列表达式的值为0的是（ ）
A. 3﹪5 B. 3/5.0 C. 3/5 D. 3<5
答案：C
2.设int a = 3；则表达式a<1&& - - a>1的运算结果和a的值分别是
（ ）
A. 0和2 B. 0和3 C. 1和2 D. 1和3
答案：B
3.设 int m1=5,m2=3；表达式m1>m2?(m1=1):(m2=-1)运算后，m1和m2
的值分别是( )
A.1和-1 B.1和3 C.5和-1 D.5和3
答案：B
4.设float m=4.0,n=4.0;使m为10.0的表达式是( )
A.m-=n*2.5 B.m/=n+9 C.m*=n-6 D.m+=n+2
答案：D
5.表达式5&2||5|2的值是( )
A.0 B.1 C.2 D.3
答案：B
6.设int x=-1;执行表达式++x||++x||++x后，x的值是( )
A.0 B.1 C.2 D.3
答案：B
7.设int x;则执行printf(″%x\n″,~x^x)；的结果是( )
A.0 B.1 C.ff D.ffff
答案：D
8.C语言中计算a3正确的表达是( )
A.a^3 B.pow(a,3) C.a**3 D.power(a,3)
答案：B
9．不用第三个变量，将变量a和b的值进行互换的操作是（ ）
A.a+=b;b-=a;a-=b; B.a+=b;b=a-b;a-=b;
C.b-=a;a-=b;a-=b; D.b-=a;a=b-a;a+=b;
答案：B
10．设int a=1,b=2,c=4;经过表达式（c=a!=b）&&(a= =b)&&(c=b)运算后，a、b和c的值分别是（ ）
A.1，2，0 B.1，2，1
C.1，2，2 D.1，2，3
答案：B
11.若定义了int a，x，y；，则下列语句中不正确的是( )
A. x=3，y=5； B. ++x； C. x=y+=x*30； D. a=y+x=30；
答案：D
12.若定义了x=100；，则表达式x++>100?x+20：x+10的值是( )
A.110 B.111 C.120 D.121
答案：B
13. 执行语句printf(″%x″, -1)；后输出结果是( )
A. -1 B. –ffff C. 1 D. ffff
答案：D
14. 设float a=2, b=4, c=3；，以下C语言表达式与代数式1/2(a+b)c计算结果不一致的是( )
A. (a+b)*c/2 B. (1/2)*(a+b)*c
C. (a+b)*c*1/2 D. c/2*(a+b)
答案：B
15. 设int a=10, b=20, c=30;条件表达式a<b? a=5∶c的值是( )
A. 5 B. 10 C. 20 D. 30
答案：A
16. 在位运算中，操作数左移一位，其结果相当于操作数( )
A. 乘以2 B. 除以2 C. 乘以4 D. 除以4
答案：A
1.初始化值是0.618的双精度变量a的定义形式为__________。
答案：double a=0.618;
2.表达式 !10! = 1的值是___________。
答案：1
3.“20<x≤30”的C语言表达式是____________________。
答案：x>20&&x<=30
4.表达式a=1，a+1，a++ 的值是___________________。
答案：1
5.利用运算符--，下列两个语句 b=5+a;a-=1; 的功能可以仅由一个语句实现，这个语句是________。
答案：b=5+a--
6.“n是小于整数m的偶数”的C语言表达式是________。
答案 n<m&&(n%2==0)
7.设int y;执行表达式(y=4)||(y=5)||(y=6)后，y的值是______。
答案：4
8.设char ch=′A′;则printf(″%c″,(ch>=′A′&&ch<=′Z′)?ch+32:ch);的值是_____。
答案：a
9．设int a, b, c;则执行a=(b=3, c=5, b=10);后变量a的值是__________。
答案：10
10.表达式10＜＜3+1的值是 。
答案：160
11.若定义了int a=1；，则执行printf(″％d\n″,((a=a+4,a+5),a+6))；语句的输出结果是 。
答案：11
12. 设int x=2, y=1；则表达式x+++y的值是__________。
答案：3
变量赋值及表达式计算时的数据类型转换规则
1、表达式计算中数据类型的自动转换规则
2.运算结果存入变量时数据类型的自动转换规则
先将运算结果的数据类型自动转换成左边变量的数据类型，然后再赋予该变量。
3.运算结果的强制性数据类型转换规则
命令格式: (数据类型符)(表达式)
说明：
当被转换的表达式是一个简单表达式时，外面的一对圆括号可以缺省。
强制转换类型得到的是一个所需类型的中间量，原表达式类型并不发生变化。
第四章 顺序结构、选择结构和循环结构的程序设计
字符输入／输出函数
1.字符输入函数getchar
【功能】从键盘读取单个字符。
2.字符输出函数putchar(ch)
【功能】将参数ch对应的字符输出到显示器上。
注意：若程序中用到上面两个函数，则在程序的开头加
“#include “stdio.h””。
格式输入／输出函数
1.格式输入函数
【格式】scanf(输入格式字符串,输入变量地址表)
输入格式字符串
格式字符 | 数据对象的类型 | 输入形式 | 数据输入方法 |
%md | int short unsigned int unsigned short | 十进制整数 | 无m 按实际位数输入 有m 输入m位,不足m位则跟回车换行键 |
%mo | 八进制整数 | ||
%mx | 十六进制整数 | ||
%mld | long unsigned long | 十进制整数 | |
%mlo | 八进制整数 十六进制整数 | ||
%mlx | |||
%mf | float | 十进制实数 十进制指数 | |
%me | |||
%mlf | double | 十进制实数 | |
%mle | 十进制指数 | ||
%mc | char | 单个字符 | 无m 仅取单个字符 有m 输入m位,仅取第一个字符 |
%ms | 字符串 | 字符串 | 无m 取若干字符直到回车或空格为止 有m 仅取前m个字符 |
2.格式输出函数
【格式】printf(输出格式字符串,输出表达式表)
【功能】先按照自右向左的顺序，依次计算“输出表达式表”中诸表达式的值。然后按照“输出格式字符串”中规定的格式顺序，将各个表达式值输出到显示器上显示。
格式字符 | 数据对象的类型 | 输出形式 | 数据输出方法 |
%-md | int short unsigned int unsigned short char | 十进制整数 | 无m 按实际位数输出 有m 输出m位 超过m位,按实际位数输出 不足m位,则用空格补足m位 无-号 右对齐(左补空格) 有-号 左对齐(右补空格) |
%-mo | 八进制整数 | ||
%-mx | 十六进制整数 | ||
%-mu | 无符号整数 | ||
%-mld | long unsigned long | 十进制整数 | |
%-mlo | 八进制整数 | ||
%-mlx | 十六进制整数 | ||
%-mlu | 无符号整数 | ||
%-m.nf | float double | 十进制小数 | 无m.n 按实际位数输出 有m.n 输出n位小数,总宽度为m 超过m位,按实际位数输出 不足m位,用空格补足m位 无-号 右对齐(左补空格) 有-号 左对齐(右补空格) |
%-m.ne | 十进制指数 | ||
%g | 自动选取f或e中 宽度较小的格式 | ||
%-mc | char int short | 单个字符 | 无m 输出单个字符 有m 输出m位, 单个字符和m-1个空格 无-号 右对齐(左补空格) 有-号 左对齐(右补空格) |
%-m.ns | 字符串 | 一串字符 | 无m.n 按实际字符数输出全部字符 有m.n 仅输出前n个字符,补m-n个空格 无-号 右对齐(左补空格) 有-号 左对齐(右补空格) |
输入输出函数真题
1.设int a=7,b=8;则printf(″%d,%d″,(a+b,a),(b,a+b));的输出是( )
A.7，15 B.8，15 C.15，7 D.出错
答案：A
2.若定义了unsigned short a=32768；，则执行printf(″a=％d″，a)；语句的输出结果是 ( )
A. a=-32768 B. a=-1 C. a=32768 D.数据类型不一致，出错
答案：A
3. 使用语句scanf(″a=%f, b=%f″, &a, &b) 输入变量a、b的值(□代表空格)，正确的是 ( )
A. 1.25，2.4 B. 1.25□2.4
C. a=1.25, b=2.4 D. a=1.25□b=2.4
答案：C
4．设int k=-1；执行printf(″%u″,k)；后输出的值是 。
答案：65535
5.写出程序的输出结果
main
{ int a =10,i=1,j=2;
printf(″%d,%o,%x\n″,a,a,a);
printf(″i=%d\n″,i++);
printf(″%c\n″,i==j?′A′:′B′);
}
答案：10，12，A
i=1
A
结构化程序设计方法
结构化程序设计的三种基本结构是：顺序结构、选择结构和循环结构
注意:在设计嵌套的“if语句”和“if-else语句”时，要特别注意else是和其前面出现的哪个if配对。
【例】 if (c>=’0’&&c<=’9’) if (c==’5’) y=0;
else y=1;
多分支结构的switch语句
【格式】switch （表达式）
{ case 常量表达式１： 语句组１；break；
case 常量表达式２： 语句组２；break；
．．．
case 常量表达式ｎ： 语句组ｎ；break；
default： 语句组ｎ+１；
}
说明：
（1）表达式常用的是字符型或整型表达式。
（2）常量表达式是由常量或符号常量组成的表达式，所有常量表达式值必须互不相同。
（3）break在switch语句中的作用是：执行完某个语句组后，将退出该switch语句。如果省略了break语句，则执行完某个语句组后，将连续执行其后的所有语句组。
（4）default及其后的语句组可以省略。省略时，若表达式的值和n个常量表达式值均不相同，则该语句什么也不做。
选择结构真题
1. 与语句if(a>b)if(c>d)x = 1；else x = 2；等价的是( )
A. if(a>b){if(c>d) x = 1；else x = 2；}
B. if(a>b){if(c>d) x = 1；} else x = 2；
C. if((a>b) && (c>d)) x = 1；else x = 2；
D. if(a< =b) x = 2；else if (c>d) x = 1；
答案：A
2.执行下列语句
int a=8,b=7,c=6;
if(a<b)if(b>c){a=c;c=b;}
printf(″%d,%d,%d\n″,a,b,c);
后输出的结果是( )
A.6，7，7 B.6，7，8
C.8，7，6 D.8，7，8
答案：C
3．下列程序段运行后，x的值是（ ）
a=1;b=2;x=0;
if(!(--a))x--;
if(!b)x=7;else ++x;
A.0 B.3 C.6 D.7
答案：A
4．设int x=1,a=9,b=6,c=7,d=8;则执行语句：
if(a>b) if(c>d)x=2;else x=3;后，x的值是（ ）
A.1 B.2 C.3 D.不确定
答案：C
5. 写出程序的运行结果
# include ″stdio.h″
main
{char c；
c = getchar；
if(c> =′a′&&c< =′z′) ‖c> =′X′&&c< =′Z′)c = c - 23；
printf(″﹪c \ n″，c)；
}
设从键盘上输入Next
答案：N
6. 写出程序的运行结果
main ( )
{ int x=16, y=21, z=0;
switch (x%3)
{case 0: z++; break;
case 1: z++;
switch (y%2)
{default: z++;
case 0: z++; break;
}
}
printf (″%d\n″, z);
}
答案：3
7. 输入一字符串(换行为结束标志)统计其中数字(0，1，2，…，9不单独统计)、空白和其它字符出现的次数。
# include ″stdio.h″
main
{ char c；
int ___________________________；
while((c = getchar)! =′\ n′)
{ if(__________________________)digit + + ；
else if(c = =′′‖c = =′\ t′) ++ blank；
else __________________________；
}
printf(″digit =﹪d,blank =﹪d,other =﹪d \ n″,digit,blank,other)；
}
答案： digit,blank,other
c>=0&&c<=9
other++
循环结构
注意：
1．do while 循环至少执行1次。
2．for语句主要用来实现次数型循环结构。
（１）表达式１、2、3都可以是任何类型的，都可以省略。但两个分号不可以省略。
（２）表达式２省略时， 一定是“死循环”。
break语句和continue语句
1. break语句
【功能】强制结束当前的循环，不再执行循环体中break后面的语句。
2.continue语句
【功能】跳过continue之后的语句，重新判断循环控制条件，决定是否继续循环。
多重循环结构的实现
设计多重循环结构时，要注意内层循环语句必须完整地包含在外层循环的循环体中，不得出现内外层循环体交叉现象。但是允许在外层循环体中包含多个并列的循环语句。
1.对于do-while语句，错误的说法是( )
A.先执行循环体后判断循环条件
B.循环体至少要执行一次
C.循环体有可能一次也不执行
D.循环体中可以包含若干条语句
答案：C
2．对do-whie语言错误的说法是（ ）
A.可构成多重循环结构 B.循环次数不可能为0
C.循环次数可能为0 D.先执行后判断
答案：C
3.执行语句for(i=1;i++<4;)；后i的值是( )
A. 3 B. 4 C. 5 D. 不确定
答案：B
4.设int i = 5；则循环语句while (i > = 1) i - -；执行后，i的值为_______________。
答案：0
5.语句for(i=1;i==1;i++);循环的次数是________。
答案：1
6．设for(k=0;k<0;k++)++k;则该循环共执行 次。
答案：0
7.在执行循环结构或switch结构时，能够立即退出该结构的语句是__________。
答案：break
8.写出程序的执行结果
main( )
{
int s=0,i;
for(i=1;;i++)
{
if(s>50)break;
if(i%2==0) s+=i;
}
printf(″i=%d,s=%d\n″,i,s);
}
答案：i=15,s=56
9.下列程序
int x=3;
do{printf(″%d″,--x);}while(!x);
循环执行的次数是______。
答案：1
10.写出程序的执行结果
main( )
｛ int i；
for(i=0；i<5；i++)
switch(i％2)
｛case 0：printf(″1″)；break；
case 1：printf(″0″)；｝
｝
答案：10101
11. /*设从键盘输入：420<回车> */
#include <stdio. h>
main( )
{ char c;
while ((c=getchar( ) )!=′\n′)
switch(c-′0′)
{ case 0:
case 1:putchar(c+2);
case 2:putchar(c+3);break;
case 3:putchar(c+4);
default:putchar(c+1);break;
}
printf(″\n″);
}
答案：5523
12．将一个十进制整数n转变为二进制数。
main( )
{ int i=0,j,n,num[20];
scanf(″%d″, ); /*第一空*/
while(n!=0)
{ num[i++]= ; /*第二空*/
n= ; /*第三空*/
}
for(j=i-1;j>=0;j--)printf(″%d″,num [j]);
}
答案：&n
n%2
n/2
13. 一个三位整数(100～999)，若各位数的立方和等于该数自身，则称其为“水仙花数”(如：153=13+53+33), 找出所有的这种数。
main( )
{int n, a, b, c;/*n、a、b和c分别为三位数自身及其个位、十位和百位 */
for(c=1;c<=9;c++)
for (b=0; b<=9;b++)
for(______;a++) /*第一空*/
{ n=_________; /*第二空*/
if(a*a*a+b*b*b+c*c*c==_________) /*第三空*/
printf(″%d\n″, n);
}
}
答案：a=0;a<=9
c*100+b*10+a
n
第五章 数组
一维数组
一维数组的定义格式：
数据类型符 数组名1[长度1],数组名2[长度2],...;
说明：长度即数组长度，是一个“整型常量表达式”，通常是一个整型常量，表示元素的个数。常量表达式中可以包括常量和符号常量，不能包含变量。
一维数组元素的引用方法： 数组名[下标]
说明：
（1）“下标”是一个整型表达式，其合法值的范围是0～长度-1。
（2）在C语言中，数组作为一个整体，不能参加数据运算，只能对单个的元素进行处理。
（3）当定义了某个一维数组，则要给其所有的元素分配内存单元。单元数目＝数组长度×每个元素占用的字节数，而且，这些内存单元是连续的。并按照元素顺序依次排列。
(4)C语言还规定，数组名是数组的首地址。即a=&a[0]
一维数组
一维数组的初始化
说明：
（1）对数组所有元素赋初值，此时数组定义中数组长度可以省略。
例如：int a[5]={1,2,3,4,5};或int a[]={1,2,3,4,5};
（2）对数组部分元素赋初值，此时数组长度不能省略。
例如：int a[5]={1,2}；
a[0]=1,a[1]=2,其余元素为编译系统指定的默认值0。
例如：char c[5]={‘a’,’b’}；
c[0]=’a’,c[1]=’b’,其余元素为编译系统指定的默认值’\0’。
（3）对数组的所有元素赋初值0。
例如：int a[5]={0}；
注意：如果不进行初始化，如定义int a[5]；那么数组元素的值是随机的，不要指望编译系统为你设置为默认值0。
（4）static int a[5] 不进行初始化，编译系统为你将所有元素设置为默认值0。
static char s[5] 不进行初始化，编译系统为你将所有元素设置为默认值‘\0’。
一维数组真题
1.设char str[100]；int i = 5；则引用数组元素的错误形式是 （ ）
A. str[i + 10] B. *(str + i)
C. *(str + i - 1) D. ((str + + ) + i)
答案：D
2.设int a［10］;则对a数组元素的错误引用是( )
A.a［5］ B.*(a+1)
C.a［10-10］ D.a(5)
答案：D
3．初始化一维数组a正确的语句是（ ）
A.int a[10]=(0,0,0,0,0); B.int a[10]={ };
C.int a[ ]={10}; D.int a[10]={[10*1]};
答案：C
4.在C语言中，数组名除名字的功能之外还代表数组的_______。
答案：数组首地址
5. 写出程序的运行结果
# define N 7
main
{int i，j，temp，a[N]={1，2，3，4，5，6，7}；
for(i = 0；i<N/2；i + + )
{j = N - 1 - i；
temp = a[i]；a[i]=a[j]；a[j]=temp；
}
for(i = 0；i<N；i + + ) printf(″﹪5d″，a[i])；
}
答案： 7 6 5 4 3 2 1
6. 下列程序的功能是：统计从键盘输入的字符（$作为结束）中每个小写英文字母出现的个数，n[0]、n[1]、•••、n[25]分别存放小写字母a、b、•••、z。并输出统计结果。
#include″stdio.h″
main( )
{int n[26]={0},k,char c;
while(( )!= ′$′) /*第一空*/
if(c>=′a′&&c<=′z′)
n[c ]+=1; /*第二空*/
for(k=0; ;k++) /*第三空*/
printf(″％c:％d\n″,k+′a′,n[k] );
}
答案：c=getchar( )
-’a’
k<26
7. 先为数组a输满数据，再为x输入一个数据，在数组a中找出第一个与x相等的元素并将其下标输出，若不存在这样的元素，则输出“Not found!”标志。
main
{int i，x，a[10]；
for(i = 0；i<10；i ++ )scanf(″﹪d″,___________)；
scanf(″﹪d″,&x)；printf(″﹪d″,x)；
for(i = 0；i<10；i ++) if(_________________)break；
if (i _________10)printf(″ position:﹪d \ n″,i)；
else printf(″ Not found! \ n″，x)；
}
答案：&a[i]
a[i]==x
<
8. 将十个整数输入数组，求出其平均值并输出。
main( )
{int i,a[10],sum=0,*p=______; /*第一空*/
for(i=0;i<10;i++)
{ scanf(″%d″,p++);
sum+=______; /*第二空*/
printf(″%8.2f\n″,______); /*第三空*/
}
答案：a
a[i]或p[i]或*(a+i)或*(p+i)
sum/10.0
二维数组
二维数组的定义
【格式】数据类型 数组名[行长度][列长度],...;
二维数组元素的引用
数组名[行下标][列下标]
说明：
(1)二维数组的存放规律是“按行排列”，即先顺序存放第一行的元素，再存放第二行，以此类推。
（2）一个二维数组可以看成若干个一维数组。二维数组a[3][4]理解为：有三个元素a[0]、a[1]、a[2]，每一个元素是一个包含4个元素的数组。
二维数组的初始化
(1)分行给二维数组所有元素赋初值。
例如：int a[2][3]={{1,2,3},{4,5,6}};
(2)不分行给多维数组所有元素赋初值。
例如：int a[2][3]={1,2,3,4,5,6}
(3)只对每行的前若干个元素赋初值，此时所有未赋初值的数组元素均获得零值（对整型数组是0；对实型数组是0.0；对字符型数组是’\0’）。
例如：int a[2][3]={{1},{4,5}};
(4)只对前若干行的前若干个元素赋初值，此时所有未赋初值的数组元素均获得零值。
例如：char a[2][3]={{’1’,’2’}};
（5）若给所有元素赋初值，行长度可以省略。
例如：float a[][3]={{1,2,3},{4,5,6}};
float a[][3]={1,2,3,4,5,6};
注意:允许给出的初值不是列长度的整数倍。此时，行长度＝初值个数整除列长度后再加1。则省略的行长度＝7/3+1=2+1=3。
例如：float a[][3]={1,2,3,4,5,6,7};
（6）若分行给所有行的前若干个元素赋初值，行长度可以省略。
例如：float a[][3]={{1},{2,3}};
结果：自动认为数组a[][3]的行长度是２。
（7）对数组的所有元素赋初值0。
例如：int a[5][6]={0}；
注意：如果不进行初始化，如定义int a[5][6]；那么数组元素的值是随机的，不要指望编译系统为你设置为默认值0。
（8）static int a[5][6]不进行初始化，系统将所有元素设置为0。
static char s[5][6]不进行初始化，系统将所有元素设置为‘\0’。
二维数组真题
1.设int a[][4]={1，2，3，4，5，6，7，8，9}；则数组a的第一维的大小是（ ）
A. 2 B. 3 C. 4 D. 无确定值
答案：B
2. 执行下列程序
int a[3][3]={{1}，{2}，{3}}；
int b[3][3]={1，2，3}；
main
{printf(″﹪d \ n″，a[1][0] + b[0][0])；}
后输出的结果是 ( )
A. 0 B. 1 C. 2 D. 3
答案：D
3.设int a[2][3] = {{2}，{3}}；则数组元素_____________的值为3。
答案：a[1][0]
4. 设int i,x[3][3]={1,2,3,4,5,6,7,8,9}；
则下面语句
for(i=0;i<3;i++)
printf(″%d″,x[i][2-i]);
的输出结果是( )
A.147 B.159 C.357 D.369
答案：C
5.设short a[３][４]；如果数组a首地址为2000，则a+1的地址是 。
答案：2002
6.在C语言中，一个二维数组可以看成若干个______数组。
答案：一维
7. 设int a[2][3]=｛ 1, 2, 3, 4, 5, 6};则数组元素a[1][0]的值是__________。
答案：4
8. main( )
｛int a[3][3]=｛1，4，17，3，6，19，2，5，18｝，i，s=0；
for (i=0；i<=2；i++)
s=s+a[i][2-i]；
printf(″s=％d\n″，s)；
｝
答案：25
字符数组与字符串
字符数组
字符数组的定义： char 数组名[长度]={初值表}
字符数组赋字符串初值
【例】 char s1[4]={”123”};
char s2[]={”123”}; /*省略的数组长度为4*/
char s3[4]=”123”;
char s4[]=”123”;
char s5[4]={‘1’,’2’,’3’,’\0’};
char s6[]={‘1’,’2’,’3’,’\0’};
char s7[4]={‘1’,’2’,’3’ };
以上七种的赋值结果都是：
字符串处理的常用系统函数
1、字符串输出函数 puts(字符数组）
【功能】输出字符数组中存放的字符串，其中结束标记转换成回车换行符输出。
2、字符串输入函数 gets(字符数组）
【功能】从键盘接受一个字符串（仅以回车换行符为结束标记），存入指定的字符数组中。
3、测试字符串长度函数 strlen(字符串）
【功能】测试指定字符串的长度（除字符串结束标记外的所有字符的个数）。
4、字符串复制函数 strcpy(字符数组,字符串,整型表达式）
【功能】将“字符串”的前“整型表达式”个字符组成新的字符串存入“字符数组”中。若省略“整型表达式”，则将整个“字符串”存入字符数组中。
5、字符串比较函数 strcmp(字符串１,字符串２）
【功能】若“字符串１”小于“字符串２”，函数返回值为小于0的整数；
若“字符串１”等于“字符串２”，函数返回值为0；
若“字符串１”大于“字符串２”，函数返回值为大于0的整数。
6、字符串连接函数 strcat(字符数组,字符串)
【功能】把“字符串”连接到“字符数组”中字符串的最后一个有效字符的后面，组成新的字符串存回“字符数组”中。
注意：上述前2个函数，应在程序的开头写上命令“#include <stdio.h>”;后4个函数，应在程序的开头写上命令“#include <string.h>”。
字符数组与字符串
【例】 用二维数组存放多个字符串
char s4[3][4]={”123”,”AB”,”x”};
结果：
0 | 1 | 2 | 3 | |
0 | ‘1’ | ‘2’ | ‘3’ | ‘\0’ |
1 | ‘A’ | ‘B’ | ‘\0’ | ‘\0’ |
2 | ‘X’ | ‘\0’ | ‘\0’ | ‘\0’ |
字符串的输入输出
l 逐个字符I/O： %c
l 整个字符串I/O： %s
1.设char c［5］={′a′,′b′,′\0′,′c′,′\0′};则printf(″%s″,c)的输出是( )
A.′a′′b′ B.ab C.abc D.″ab\0c″
答案：B
2.设static char x[ ]=″12345″,y[ ]={′1′,′2′,′3′,′4′,′5′,′\0′}；那么( )
A.x数组的长度等于y数组的长度
B.x数组的长度大于y数组的长度
C.x数组的长度小于y数组的长度
D.x数组与y数组的存储区域相同
答案：A
3.执行printf(″％d\n″，strlen(″t\″066\xee\n″))；语句的输出结果是( )
A.7
B.12
C.13
D.输出项不合法，无正常输出
答案：A
4.字符数组s不能作为字符串使用的是（ ）
A.char s[ ]=＂happy＂;
B.char s[ ]={＂happy＂};
C.char s[6]={＇h＇,＇a＇,＇p＇,＇p＇,＇y＇};
D.char s[4]={＇h＇,＇a＇,＇p＇,＇p＇,＇y＇};
答案：D
5.连接两个字符串的系统函数名是___________________。
答案：strcat( )
6.设char string[] =″This_is_a_book!″；则数组的长度应是_________。
答案：16
7.# include<stdio.h>
main( )
{ int i=0;
char c,s[]=″SABC″;
while(c=s[i])
{
switch(c)
{
case ′A′:i++;break;
case ′B′:++i;
default:putchar(c);i++;
}
putchar(′*′);
}
}
答案：S**B*
8.从键盘输入一个字符串，判断其是否是回文。若是输出“Yes”，否则输出“No”。回文是指正向、反向的拼写都一样。例如：ABCBA、aaaa等是回文；china、ABC等不是回文。
#include ″stdio.h″
main( )
｛char string［80］；
int i，j，n；
gets (string)；
n= ； /*第一空*/
j=n-1；
for (i=0；i<j；i++，j--)
if (string ［i］!=string［j］) ；/*第二空*/
if( )printf(″Yes\n″)； /*第三空*/
else printf (″No\n″)；
｝
答案：strlen(string)
break
i>=j
第六章 指针
指针和指针变量
指针变量的定义和初始化
格式：数据类型符 *指针变量名1[=初值1],...;
取地址运算符&与指针运算符*
【例】设有数据定义语句：float a,*p=&a;
则：*&a是正确的。相当于“*(&a)”，代表变量a。
*&p是正确的。相当于“*(&p)”，代表p。
&*p是正确的。相当于“&(*p)”，代表a的地址。
&*a是错误的。相当于“&(*a)”，因为a不是指针变量，所以*a不正确。
指向变量的指针变量的使用
1.给指针变量赋值
格式：指针变量＝地址表达式
注意：不能把一个整数赋给pa,也不能把pa的值赋给整型变量。
2.引用所指向的变量
格式： *指针变量
1.设int a,*p；则语句p=&a;中的运算符“&”的含义是( )
A.位与运算 B.逻辑与运算
C.取指针内容 D.取变量地址
答案：D
2.main( )
｛ int x=20，y=40，*p；
p=&x；printf(″％d，″,*p)；
*p=x+10；
p=&y；printf(″％d\n″，*p)；
*p=y+20；
printf(″％d，％d\n″，x，y)；
｝
答案：20，40
30，60
指向一维数组的指针变量的使用
指针变量指向一维数组的方法：
方法一：在数据定义语句中用赋初值的方式 *指针变量=数组名
例：short a[10],*pa=a;
方法二：在程序中用赋值方式 指针变量=数组名
例：short a[10] ,*pa;
pa=a;
指针变量指向某一维数组元素的方法：
方法一：在数据定义语句中用赋初值的方式 *指针变量=&数组名[下标]
例：short a[10],*pa=&a[3];
方法二：在程序中用赋值方式 指针变量=&数组名[下标]
例：short a[10],*pa;
pa=&a[3];
用指向一维数组的指针变量处理数组元素
当指针变量指向一维数组后，对下标为i的数组元素引用一共有下列四种方法： *(指针变量+i) *(数组名+i) 指针变量[i] 数组名[i]
例：short a[10],*p=a;
a[i] p[i] *(p+i) *(a+i)
指向一维数组的指针变量的运算
(1)指针变量和整数的算术运算
运算规则如下：
指针变量+整数 指针变量-整数
++指针变量 --指针变量
指针变量++ 指针变量--
(2)指针变量和指针变量的减法运算
指针变量1－指针变量2 结果为它们所指向的数组元素下标相差的整数
(3)指针变量的关系运算
指针变量1 关系运算符 指针变量2
1.设int x[] = {1，2，3，4，5，6}，*p=x；则值为3的表达式是（ ）
A. p+=2, *++p B. p+=2, *p++
C. p+=3, *p D. p+=2, ++*p
答案：B
2.设int b[ ]={1,2,3,4}，y,*p=b;则执行语句y=*p++；之后，变量y的值为( )
A.1 B.2 C.3 D.4
答案：A
3.设int a[10],*p=a；则对数组元素的正确引用是（ ）
A.a[p] B.p[a] C.*(p+2) D.p+2
答案：C
4.设int x［］={1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, *p=x, k;且0≤k<10, 则对数组元素x［k］的错误引用是( )
A. p+k B. *(x+k) C. x［p-x+k］ D. *(&x［k］)
答案：A
指向字符串的指针变量的使用
1.如何将指针变量指向字符串常量
方法一：在数据定义语句中用赋初值的方式 *指针变量=字符串常量
例如 char *p="abcd";
方法二：在程序中用赋值的方式 指针变量=字符串常量
例如 char *p;
p="abcd";
说明: 不允许将字符串常量用赋值方式赋予字符型数组。
char a[10];
a=”abcd”; /* 这个语句出错 */
2.指向字符串常量的指针变量的使用
(1)处理整个字符串
输出字符串 printf("%s",指针变量);
输入新的字符串代替原字符串 scanf("%s",指针变量);
(2)处理字符串中的单个字符
第i个字符的表示方法 *(指针变量+i)
3.指向存放字符串的字符数组的指针变量的使用
处理方法和前面介绍的处理一维数组元素的方法完全相同，唯一需要注意的是，数组元素的类型是字符型。
1.设char *s=″china″;则printf(″%s,%c,%c\n″,s,*s,s［3］);的输出是( )
A.china, c,n B.china,china,i
C.c,c,n D.china,china,n
答案：A
2.若定义了char ch［］=｛″abc\0def″｝，*p=ch；则执行printf(″%c″,*p+4)；语句的输出结果是( )
A. def B. d C. e D. 0
答案：C
3. 设char s［10］, *p=s;, 下列语句中错误的是( )
A. p=s+5； B. s=p+s；
C. s［2］=p［4］; D. *p=s［0］；
答案：B
4. 下列错误的是( )
A. char s［］=″China″;
B. char s［10］={″China″};
C. char s［10］; s=″China″;
D. char s［10］={′C′,′h′,′i′, n′,′a′};
答案：C
5. 若定义了int a［10］，*p；，将数组元素a［8］的地址赋给指针变量p的赋值语句是 。
答案：p=&a[8]
6. 已知程序段：
char *p=″abcdefgh″;p+=4;
printf(″%c\n″,*p++);
运行结果为 。
答案：e
7. 写出程序的运行结果
main
{ int k; char a［］=″LANGUAGE″,b［］=″PROGRAM″;
char *p=a,*q=b;
for(k=0;k<=5;k++)
if(*(p+k)==*(q+k)) printf(″%c″,*(q+k));
}
答案：GA
指针数组
指针数组的定义
格式:数据类型 *指针数组名 [长度],...
【例】int *p[3];
定义了一个名为p、用来指向整型数据的指针型数组，有3个元素：p[0]、p[1]、p[2]。
指针数组元素的使用
1.对其赋值 指针数组名[下标]＝地址表达式
2.引用所指向的变量或数组元素 *指针数组名[下标]
参加运算 （算术运算） 指针数组名[下标]＋整数
指针数组名[下标]－整数
++指针数组名[下标]
--指针数组名[下标]
指针数组名[下标]++
指针数组名[下标]--
（关系运算） 指针数组名[下标1] 关系运算符 指针数组名[下标2]
1.设double * p［6］;则( )
A.p是指向double型变量的指针
B.p是double型数组
C.p是指针数组，其元素是指向double型变量的指针
D.p是数组指针，指向double型数组
答案：C
2. 执行下列程序段，则结果是（ ）。
int a[]={1,2,3,4,5},*b[2];
b[0]=a+1,b[1]=a+2;
printf(”%d,%d”,*b[0],*b[1]);
A. 语句错误 B. 1,2 C. 1,3 D. 2,3
答案：D
3.阅读下列程序，写出程序运行的输出结果。
void main
{ char *a[6]={”AB”,”CD”,”EF”,”GH”,”IJ”,”KL”};
int i;
for (i=0;i<4;i++) printf(”%s”,a[i]);
printf(”\n”);
}
答案：ABCDEFGH
【说明】puts函数和使用“%s”格式的printf函数都可以输出字符串，但输出时有区别：对于printf函数，“字符串结束标记符”不输出； 对于puts函数，“字符串结束标记符”转换成“回车换行符”输出。
第七章 函数
函数的概念和模块化程序设计方法
函数的概念
函数是一个可以反复使用的程序段，从其它的程序段中均可以通过函数调用语句来执行这段程序，完成既定的功能。
C语言中的函数的分类
(1)从定义的角度来分
l 用户函数：程序设计人员在程序中自己定义的函数。
l 系统函数：Ｃ语言自身定义好的函数。
（2）从形式上来分
l 有参函数：定义函数时有参数的函数。
l 无参函数。定义函数时无参数的函数。
（3）从返回值的角度来分
l 有返回值函数：调用后将回带一个值的函数
l 无返回值函数：调用后不回带值的函数。
（4）从函数起作用的范围来分
l 外部函数：可以被任何编译单位调用的
l 内部函数：只能在本编译单位中被调用
函数的定义
1.函数的一般定义格式
存储类型符 数据类型符 函数名（形式参数表）
{ 数据定义语句序列；
执行语句序列；
}
存储类型符
extern 定义的函数叫做外部函数，它可以被其它编译单位中的函数调用。
static 定义的的函数叫做内部函数，它只能被本编译单位中的函数调用
存储类型说明符可以省略，省略时，默认为外部函数。
数据类型符 规定了本函数返回值的数据类型。
注意：
（1）当函数返回值是整型或字符型时，数据类型符可以省略。
（2）数据类型符是“void”，它表示本函数是无返回值的。
函数的定义
形式参数表
格式： 数据类型符 形式参数1, 数据类型符 形式参数2,...
注意：
（1）max(int x,int y) { …… }不能写成max(int x,y) { …… }
但可以写成：max(x, y)
int x,y;
{ …… }
l（2） 当形式参数是数组时，一维数组的长度、二维数组的行长度可以省略。
1.下面函数定义有错误的是( )
A.f1(x1,x2) B.f1(x1,x2)
int x1,x2; int x1;int x2;
{函数体} {函数体}
C.f1(int x1,x2) D.f1(int x1,int x2)
{函数体} {函数体}
答案：C
函数的调用
1．函数调用的一般格式
（1）表达式方式：函数名(实际参数表) 作为表达式的一部分
只有有返回值的函数才能用这种格式调用。
例：y=x+max3(x1,x2,x3);
（2）语句方式：函数名(实际参数表);
无返回值的函数通常用这种方式调用，但是，有返回值的函数也可以使用这种形式调用，此时，函数仍然有返回值，但没有被使用。
例：printstar( );
注意:
（1）被调函数出现在主调函数之前，声明可以省略。
（2）若被调函数书写顺序调整到主调函数的后面，由于被调函数是有返回值的，并且返回值是整型或字符型，声明也可以省略。
（3）若被调函数在主调函数之后，并且是无返回值或返回植不是的整型或字符型的函数，所以需要声明。
函数调用时的数据传递方法
Ｃ语言规定在函数间传递数据有四种方式：值传递方式、地址传递方式、返回值方式、全局变量传递方式。
1、利用形参与实参传递数据的值传递方式
形式参数：定义函数时函数名后面括号中的变量名
实际参数：调用函数时函数名后面括号中的表达式
说明：
l （1）实参必须有确定的值
l （2）形参必须指定类型
l （3）形参与实参类型一致，个数相同
l （4）若形参与实参类型不一致，自动按形参类型转换———函数调用转换
l （5）形参在函数被调用前不占内存;函数调用时为形参分配内存；调用结束，内存释放
值传递方式的特点：
l （1）函数调用时,为形参分配单元,并将实参的值复制到形参中；调用结束，形参单元被释放，实参单元仍保留并维持原值——单向传递
l （2）形参与实参占用不同的内存单元
2、利用形参与实参传递数据的地址传递方式
地址传递方式特点：
（1）函数调用时，将数据的存储地址作为参数传递给形参
l （2）形参与实参占用同样的存储单元
l （3）“双向”传递，形参和实参的数据实际上并没有传递，其实质是数据的共享
l （4）实参和形参必须是地址常量或变量
当形参是数组时的数据传递方式
数组名做形参，由于数组名代表数组首地址，属于地址传递。
当形参是指针变量时的数据传递方式
形参是指针变量的结论：
（1）形参是指针变量，实参必须是地址表达式。
（2）属于地址传递方式。
（3）在被调函数中，由于形参对应的指针变量已经指向主调函数的某个变量（也可以是数组元素或数组），就可以使用形参对应的指针变量来使用或修改主调函数中的变量或数组元素的值。回到主调函数，可以直接使用“变量”或“数组元素”获得在被调函数中修改的值。
利用参数进行数据传递的方法给出下列总结:
（1）如果要从主调函数将数据传递给被调函数，可以使用形参是变量，实参是表达式的值传递方式。若有n个不相关的数据要传递，则要设置n个形参。
（2）如果要在主调函数和被调函数之间共享一批相关的数据，可以使用形参是数组，实参是地址（数组名、数组元素地址、指向数组的指针变量）的地址传递方式。
（3）如果要在主调函数和被调函数之间共享单个数据，可以使用形参是指针变量，实参是数据地址的传递方式。如果有多个这样的数据要相互传递，需要设置多个指针变量形式的形参。
3、利用返回值的数据传递方式
返回语句
形式：return(表达式)；
或return 表达式;
或return;
功能：使程序控制从被调用函数返回到调用函数中，同时把返回值带给调用函数
说明：
(1)函数中可有多个return语句，但每调用一次该函数，只能执行到一个return语句。
l (2)若无return语句，遇函数的最后一个}时，自动返回调用函数
l (3)若函数类型与return语句中表达式值的类型不一致，按前者为准，自动转换------函数调用转换
函数调用的真题
1.调用函数时，若实参是一个数组名，则向函数对应的形参传送的是( )
A.数组的长度 B.数组的首地址
C. 数组第一个元素的值 D. 整个数组元素的值
答案：B
2.在C语言中，函数返回值的类型是由( )
A.定义的函数类型决定
B.return语句中表达式的类型决定
C.调用该函数的主调函数类型决定
D.调用该函数时系统状态决定
答案：A
3.在C语言中，有值函数的数据类型是指( )
A. 函数形式参数的数据类型
B. 函数返回值的数据类型
C. 调用该函数时的实参的数据类型
D. 任意指定的数据类型
答案：B
1.在C语言中，当定义一个函数的类型为void时，说明执行该函数后 。
答案：无返回值
2.函数调用时，若形参是一个变量，而对应的实参是一个有确定值的表达式，则函数参数的传递方式是__________传递。
答案：值
3.若函数定义为
int data( )
{ float x=9.9;
return(x);
}
则函数返回的值是______。
答案：9
变量的存储类型与作用域
变量的存储类型
存储类型 | 存储类型符 | 存储区域 |
自动型 | auto | 内存的堆栈区 |
寄存器型 | register | CPU的通用寄存器 |
静态型 | static | 内存的数据区 |
外部参照型 | extern |
1.自动型
自动型变量，函数被调用时，给该变量分配内存用于存放变量的值。当函数调用结束时，Ｃ语言就释放该变量
当定义变量时，省略了存储类型符，系统将默认为自动型变量。
2.寄存器型
寄存器型变量是分配在CPU的通用寄存器中,一般以2个左右为宜,且只能定义为整型或字符型。寄存器型变量一般是在函数中定义的，退出该函数后就释放它所占用的寄存器。
3.静态型
静态型变量是在程序开始运行时就分配了固定的内存，在程序运行过程中不释放。只有程序运行结束后，才释放所占用的内存。
4.外部参照型
外部参照型变量是专用于多个编译单位之间传递数据用的。
变量的初始化和变量的存储类型的关系
（1）外部参照型(extern)变量不允许初始化。
（2）自动型(auto)变量和寄存器型(register)变量如果进行初始化，则每次进入所定义的函数或复合语句都随着重新定义而重新初始化。自动型 ( auto) 变量和寄存器型(register)变量如果不进行初始化，变量值将不确定。因此，必须用其它赋值方式为其赋值后方能参与运算。
（３）静态型(static)变量如果进行初始化，只有第一次执行定义语句时随着分配内存赋于初值，当退出所定义的函数或复合语句时，将保留分配给它的内存和其中的值。再次进入所定义的函数或复合语句时，不再重新分配内存，也不进行初始化。此时，该变量值是上次离开时的值。静态型(static)变量如果不进行初始化，Ｃ语言编译系统将自动为其赋予“零值”：对数值型变量赋0，对字符型变量赋空字符’\0’（空字符的ASCII代码值为0）。
变量的生存期与作用域
1、内部变量与外部变量
内部变量:在函数（或某个复合语句）内定义的变量；只在本函数内（或本复合语句内）有效。
外部变量:在函数外定义的变量。它的有效范围是从定义它的地方开始，到整个程序结束的任何地方。
2．变量的生存期
变量从开始分配内存单元（或寄存器）到分配的内存单元（或寄存器）被收回的期间称为变量的生存期。
3．全局变量和局部变量
局部变量：生存期只覆盖某个函数（或某个复合语句）的变量称为具有局部寿命的变量。
说明：
（1） main中定义的变量只在main中有效
（2）不同函数中同名变量，占不同内存单元
（3）形参属于局部变量
（4）可定义在复合语句中有效的变量
（5）局部变量可用存储类型：auto register static （默认为auto）
全局变量：生存期覆盖了定义点到整个程序结束的变量称为具有全局寿命的变量。
说明：
（1）外部变量可用存储类型：缺省 或 static
l （2）若外部变量与局部变量同名，则外部变量被屏蔽
l （3）应尽量少使用全局变量。
关于变量生存期和作用域的总结
变量 | 允许的存储类型 | 生存期 | 作用域 |
外部变量 | 省略(称无存储类型) | 全局变量 | 定义点到程序结束 |
static | |||
内部变量 | 省略(默认为auto) | 局部变量 | 定义该变量的函数或复合语句内部 |
auto | |||
register | |||
static | 全局变量 |
变量的存储类型与作用域的真题
1.在函数内，定义变量时存储类型符可省略的是 ( )
A. auto B. static C. extern D. register
答案：A
2.全局变量的存储类型可以定义为( )
A.auto或static B.extern或register
C.auto或extern D.extern或static
答案：D
3.若函数能被其它编译单位引用，那么函数定义时的存储类型应选用( )
A.auto B.static
C.extern D.register
答案：C
4.自动型变量分配在（ ）
A.内存的数据区中 B.CPU的通用寄存器中
C.内存的程序区中 D.内存的堆栈区中
答案：D
5.若函数中局部变量的值经函数调用后仍保留，则该局部变量定义为（ ）
A.自动变量 B.内部变量
C.外部变量 D.静态变量
答案：D
6.对于程序段
float f1(int a)
{int b；……}
main( )
{ int m,n;
m=f1(n);……}
char f2(int x,int y)
{int a;……}
变量m,n的作用范围是（ ）
A.整个程序段 B.main函数
C.main函数和f2函数 D.mian函数和f1函数
答案：B
7. 静态型外部变量的作用域是__________。
答案：定义点到程序结束
8. 写出程序的运行结果
fun(int x)
{int y=0;
static int z=3;
z++;++y;
return(x+y+z);
}
main( )
{int i,x=2;
for(i=0;i<2;i++)
printf(″%5d″,fun(x++));
}
答案： 7 9
9. 写出程序的执行结果
f( )
{ int x=1;
return x++; }
g( )
{ static int x=1;
return x++; }
main
{ int i,a=0,b=0;
for(i=0;i<5;i++)
{ a+=f;
b+=g; }
printf(″a=%d\nb=%d\n″,a,b);
}
答案：a=5
b=15
10. 写出程序的执行结果
int a = 200；
main
{ int i；
for(i = 1；i< = 5；i + +)
{ a + + ；
printf(″﹪d，″，a)；
s( ); }
}
s( )
{static int a = 20；
a + + ；
printf(″﹪d \ n″，a)；
}
答案：201，21
202，22
203，23
204，24
205，25
11. 写出程序的执行结果
int x=30,y=50;
sub(int x, int y)
{ y=x>y? x:y;
return y;
}
main( )
{
{ int x=100;
printf(″%d\n″,sub(x,y));
}
printf(″%d,%d\n,x,y);
}
答案：100
30，50
12. 写出程序的执行结果
int a1=300,a2=400;
main( )
{int a3=100,a4=200;
sub1(a3,a4);
sub1(a1,a2);
printf(″%d,%d,%d,%d\n″,a1,a2,a3,a4);
}
sub1(int x,int y)
{ a1=x;
x=y;
y=a1;
}
答案：100,400,100,200
13. 写出程序的执行结果,设从键盘输入282
sub(int n)
{int s=1;
do
{ s*=n%10;n/=10;}
while(n);
return s;
}
main( )
{ int n;
scanf (″%d″,&n);
n=sub(n);
printf(″%d\n″,n);
}
答案：32
14. 写出程序的执行结果
int f(int a)
{ int b=4；
static int c=4；
b++；
c++；
return(a+b+c)；
}
main( )
{int a=4,i；
for(i=0;i<3;i++)
printf(″％4d″,f(a))；
}
答案： 14 15 16
15. 写出程序的执行结果
mian( )
{ int i;
for(i=1;i<3;i++)
f(i);
}
f(int j)
{ static int a=100;
int k=1;
++k;
printf(″%d\n″, j+a+k);
a-=2;
}
答案：103
102
16. 写出程序的执行结果
void LE(int*a, int b)
{
int x=*a;
printf(″%d\t%d\n″, *a, b);
*a=b;b=x;
}
main( )
{
int x=10, y=25;
LE(&x, y);
printf(″%d\t%d\n″, x, y);
}
答案：10 25
25 25
17. 填空程序
根据对n的输入，求1+2+3+…+n的和。
float sum(int x)
{ int i;
float s;
________; /* 第一空 */
for (i=1;i<=x;i++)
s+=i;
________; /* 第二空 */
}
main
{int n;
scanf(″%d″,________); /* 第三空 */
printf(″%f\n″,sum(n));
}
答案：s=0
return s
&n
函数的嵌套调用和递归调用
函数的嵌套调用
C规定：函数定义不可嵌套，但可以嵌套调用函数
函数的递归调用
定义：函数直接或间接的调用自身叫函数的递归调用
递归过程必须解决两个问题：一是递归计算的公式，二是递归结束的条件和此时函数返回值。
递归计算公式 p(n)=n*p(n-1)
递归结束条件 p(1)=1
在程序设计实现：
if (递归结束条件) return (递归结束条件中的返回值);
else return (递归计算公式);
函数的嵌套调用和递归调用的真题
1. 写出程序运行的结果
gcd(int m,int n)
{ if(m==n)return m;
else if(m>n) return gcd(m-n,n);
else return gcd(m,n-m);
}
main( )
{
printf(″Gcd=%d\n″,gcd(24,36));
}
答案：12
2. 写出程序运行的结果
sum(int n)
{
if(n= =1) return(1);
else return n+sum(n-1);
}
main( )
{
printf(″%d\n″,sum(10));
}
答案：55
3. 写出程序运行的结果
#include <stdio. h>
long fun(int n)
{ long s;
if(n<=2)s=2;
else s=n+fun(n-1);
printf(″%d\t″, s);
return s;
}
main( )
{ fun(5);
printf(″\n″);
}
答案：14
指针型函数及其调用
所谓指针型函数，是指该函数的返回值是指针型的，也就是说，这类函数的返回值必须是地址值；调用该类函数时，接受返回值的必须是指针变量、指针数组元素等能存放地址值的对象。
指针型函数的定义
定义格式: 存储类型符 数据类型符 *函数名（形式参数表）
指针型函数的调用
指针型函数的调用和一般函数的调用方法完全相同，唯一需要注意的是只能用指针变量或指针型数组元素来接受指针型函数的返回值，不能使用数组名来接受指针型函数的返回值，因为数组名是地址常量，不是地址型变量，不能接受地址型数据。
文件包含命令与多文件程序
文件包含命令
文件包含命令的格式如下。
【格式1】#include <文件名>
【格式2】#include "文件名"
【功能】在编译预处理时，用指定“文件名”中的文本内容替代该语句，使文件的全部内容成为本程序清单的一部分。
【说明】
（1）用格式1，系统仅按规定的路径搜索文件。建议:系统函数的头文件用格式1。
（2）用格式2，系统先在本程序清单文件所在的磁盘和路径下寻找文件；若找不到，再按系统规定的路径搜索文件。建议: 用户函数的头文件用格式1。
多文件程序的处理
多文件程序：若一个大型程序被分散在多个源程序文件中，就称为多文件程序。对这种程序的调试，首先要将多个源程序清单拼接成一个完整的程序清单，然后再对其进行编译和调试。
常用系统函数
常用的数学处理函数
下面是部分常用的数学处理类系统函数，它们均包含在头文件“math.h”中。
1．求整型绝对值函数 abs(int x)
2．求长整型绝对值函数 labs(long x)
3．求实型绝对值函数 fabs(double x)
4．求正平方根函数 sqrt(double x)
5．求指数函数 exp(double x)
6．求10的x次方函数 pow10(int x)
7．求x的y次方函数 pow(double x,double y)
常用的字符处理函数
下面是部分常用的字符类系统函数，它们均包含在头文件“ctype.h”中。
1．判断是否英文小写字母函数 islower(int x)
【返回值】若参数x中存放的字符是英文小写字母，返回非0（真）；否则，返回0（假）。
2．判断是否英文大写字母函数isupper(int x)
【返回值】若参数x中存放的字符是英文大写字母，返回非0（真）；否则，返回0（假）。
3．将大写字母转换为小写字母函数 tolower(int x)
【返回值】若参数x中存放的字符是大写字母，则返回值是对应的小写字母。如果参数x中存放的字符不是大写字母，则返回值等于x的原来值。
4．将小写字母转换为大写字母函数 toupper(int x)
【返回值】若参数x中存放的的字符是小写字母，则返回值是对应的大写字母。如果参数x中存放的字符不是小写字母，则返回值等于x的原来值。
5. 产生一个从0到num-1之间的随机整数random(int num)
第八章 结构型与自定义类型
结构型的定义
结构型是用户在程序中自己定义的一种来存放类型不同的数据的数据类型，又称“结构体型”。
结构型的定义：
【例】定义嵌套结构型的例子。
姓名 | 性别 | 出生日期 | 工资 | ||
年 | 月 | 日 | |||
struct birthday /* 定义含有三个整型成员的birthday结构型 */
{ int year; /* 出生日期中的年份 */
int month; /* 出生日期中的月份 */
int day; /* 出生日期中的日 */
};
struct person1 /* 定义含有4个成员的person1结构型 */
{ char name[10]; /* 姓名 */
char sex; /* 性别 */
struct birthday bir; /* 出生日期，*/
float wage; /* 工资 */
};
注意，名为“birthday”的结构型定义必须在结构型“person1”的定义之前进行定义，否则，结构型“person1”定义时，会出现“birthday结构型未定义”的错误。
结构型定义的真题
1.设
struct
{ short a;
char b;
float c;
}cs;
则sizeof(cs)的值是( )
A. 4 B. 5 C. 6 D. 7
答案：D
2．设
struct student
{ int no;char name[12];
char sex;float score[4];
}stu1;
在程序执行时，系统为stu1分配 个字节的内存空间。
答案：31
结构型变量的定义和成员的引用
结构型变量的定义和初始化
定义结构型变量的方法有三种。
1、先定义结构型，后定义变量（较常用的一种方法）
【例】struct student
{ long number;
char name[10];
char sex;
float score[3];
}; ...
struct student x1,y1;
...
struct student x2={100001L,”zhao1”,’f’,{89,94,86}},
y2={100002L,”zhao2”,’m’,{78,86,92}};
/*在定义结构型的变量x2和y2的同时，对其所有成员赋初值*/
２．定义结构型的同时定义变量
【例】 struct student
{ long number;
char name[10];
char sex;
float score[3];
} x={100001L,”zhao1”,’f’,{89,94,86}};
...
struct student y={100002L,”zhao2”,’m’,{78,86,92}};
３．定义无名称的结构型的同时定义变量
【例】struct /* 定义无名称的结构型 */
{ long number;
char name[10];
char sex;
float score[3];
} x={100001L,”zhao1”,’f’,{89,94,86}},
y={100002L,”zhao2”,’m’,{78,86,92}};
注意：以后将无法使用这种结构型来定义其它变量。
结构型变量成员的引用
1、结构型变量成员的引用方法
结构型变量名.成员名
嵌套型结构型变量的引用方法：
外层结构型变量.外层结构型成员名.内层成员名
注意，这种嵌套结构型数据，外层结构型变量的结构型成员一般是不能单独引用的。
结构型变量成员的引用
2、结构型变量成员地址的引用方法
l成员是变量形式的变量地址： &结构型变量名.成员名
l成员是数组形式的数组首地址： 结构型变量名.成员名
l成员是数组，其数组元素的地址：&结构型变量名.成员数组[下标]
3、结构型变量地址的引用方法
&结构型变量名
1. #include″string.h″
struct worker
{char name[15];
int age;
float pay;
};
main( )
{struct worket x;
char *t=″Lilei″;
int d=20;float f=100;
strcpy(x.name,t);
x.age=d*2;x.pay=f*d;
printf(″％s\t％d\t％.0f\n″,x.name, x.age,x.pay);
}
答案： Lilei 40 2000
结构型数组的定义和数组元素成员的引用
结构型数组的定义和初始化
结构型数组的定义也有三种方法
1、先定义结构型，然后再定义结构型数组并赋初值。
【例】struct student
{ long number;
char name[10];
char sex;
float score[3];
};
...
struct student s[3]={{200001L,”qian2”,’m’,{78,86,92}},
{200002L,”sun3”,’f’,{85,69,82}},
{200003L,”li4”,’m’,{84,88,96}}};
2、定义结构型的同时定义数组并赋初值。
【例】 struct student
{ long number;
char name[10];
char sex;
float score[3];
} s[3]={{200001L,”qian2”,’m’,{78,86,92}},
{200002L,”sun3”,’f’,{85,69,82}},
{200003L,”li4”,’m’,{84,88,96}}};
3、定义无名称的结构型的同时定义数组并赋初值。
【例】 struct
{ long number;
char name[10];
char sex;
float score[3];
} s[3]={{200001L,”qian2”,’m’,{78,86,92}},
{200002L,”sun3”,’f’,{85,69,82}},
{200003L,”li4”,’m’,{84,88,96}}};
注意：以后将无法使用这种结构型来定义其它变量。
结构型数组元素成员的引用
1.结构型数组元素成员的引用方法
结构型数组名[下标]．成员名
2.结构型数组元素成员地址的引用方法
&结构型数组名[下标].成员名
3.结构型数组元素地址的引用方法
&结构型数组名[下标]
4.结构型数组首地址的引用方法
结构型数组名
1.设有定义语句
struct
{int a；float b；} d[3]={{1，4}，{2，5}，{6，7}}；
则printf(″﹪3.1f \ n″，d[2]. a * d[2]. b/d[1]. b)；的输出是( )
A. 2.5 B. 2.0 C. 8.0 D. 8.4
答案：D
2. struct porb
{char * name；
int count；
}x[]={″Li ning″,19,″Lang ping″,21,″Zhu jian hua″,20}；
main
{int i；
for(i = 0；i<3；i + + )
printf(″﹪s: ﹪d \ n″,x[i].name，x[i].count)；
}
答案： Li ning:19
Lang ping:21
Zhu jian hua:20
指向结构型数据的指针变量的定义和使用
指向结构型变量的指针变量
定义指向结构型变量的指针变量和定义结构型变量的方法基本相同，唯一的区别是在结构型指针变量名的前面加一个“*”。
引用该结构型变量的成员的方式：
(*指针变量).成员名 指针变量->成员名 变量.成员名
指向结构型数组的指针变量
1、指针变量指向数组元素对成员的引用
(*指针变量).成员名 指针变量->成员名 数组名[k].成员名。
２、指针变量指向数组对成员的引用
(*(指针变量+k)).成员名 (指针变量+k)->成员名 数组名[k].成员名
1.设有定义struct ru{long x;float y;} time,*timep=&time;则对time中成员x的正确引用是( )
A.ru.time.x B.timep.x
C.(* timep).x D.time->x
答案：C
2.设
struct student
{
int no；
char name[12]；
float score[3]；
} sl，* p = &sl；
用指针法给sl的成员no赋值1234的语句是___________________。
答案：(*p).no=1234 或 p->no=1234
1.设 struct st
{ int i;
int j;
} *p;
main ( )
{
struct st m[ ]={{10, 1}, {20, 2}, {30, 3}};
p=m;
printf (″%d\n″,(*++p). j);
}
则程序的输出结果是（ ）
A．1 B．2 C．3 D．10
答案：B
在函数间传递结构型数据
在函数间传递结构型数据和传递其它类型数据的方法完全相同，可以使用全局外部变量、返回值、形式参数与实际参数结合（又分为值传递和地址传递两种）等方法。
使用全局外部变量传递结构型数据时，只要在程序的开头定义结构型及其变量或数组，就可以在其后定义的函数间传递结构型数据。
使用返回值方式传递结构型数据只能返回1个结构型数据，定义函数时的数据类型符必须是某种已定义的结构型，利用“return(表达式);”语句返回的表达式值也必须是同种结构型的数据。调用函数后的返回值必需用同一种结构型变量或数组元素来接收。
使用形参和实参结合方式传递结构型数据，要注意是值传递，还是地址传递。
1. struct porb
{ char *name;
int age;
} s［］={″LiHua″, 18, ″WangXin″, 25, ″LiuGuo″, 21};
#define N (sizeof(s)/sizeof (s［0］))
void f (struct porb a［］, int n);
main( )
{ f (s, N);
}
void f (struct porb a［］, int n)
{ int i;
for (i=0;i<n;i++)
printf (″%s:%d\n″, a［i］. name, a［i］. age);
}
答案： LiHua: 18
WangXin: 25
LiuGuo: 21
用户自定义类型
用户自定义类型的方法
【格式】typedef 类型符1 类型符2;
【功能】将“类型符1”定义成用户自选的“类型符2”，此后可用“类型符2”来定义相应数据类型的变量、数组、指针变量、结构型、函数。
１．基本数据类型符的自定义
【格式】typedef 基本数据类型符 用户类型符;
【功能】将“基本数据类型符”定义为用户自己的“用户类型符”。
【例】自定义基本数据类型符举例。
typedef float REAL; /* 定义单精度实型为REAL */
２．数组类型的自定义
【格式】typedef 基本数据类型符 用户类型符[数组长度];
【功能】以后可以使用“用户类型符”来定义由“基本数据类型符”组成的数组，其长度为定义时确定的“数组长度”。
【例】自定义数组类型举例。
typedef float F_ARRAY[20]; /* 定义F_ARRAY为单精度型、长度为20数组的用户类型符 */
３．结构型的自定义
【格式】typedef struct
{ 数据类型符 成员名1;
数据类型符 成员名2;
...
数据类型符 成员名n;
} 用户类型符;
【例】自定义结构型举例。
typedef struct
{ long num;
char name[10];
char sex;
} STUDENT; /* 定义STUDENT为含有三个成员num、
name[10]、sex结构型的用户类型符 */
void main
{ STUDENT stu1,stu[10];
}
４．指针型的自定义
【格式】typedef 基本数据类型符 *用户类型符;
【例】自定义指针类型举例。
typedef int *POINT_I; /* 定义POINT_I为整型指针的用户类型符 */
typedef char *POINT_C[6]; /* 定义POINT_C为字符型长度为6的指针数组的用户类型符 */
void main
{ POINT_I p1,p2; /* 该语句相当于int *p1,*p2 */
POINT_C p3,p4; /* 该语句相当于char *p3[6],*p4[6] */
【例】设有定义语句“typedef int *POINT;”，则和定义语句“POINT x[5]; ”作用相同的数据定义语句是__________________________。
答案： int *x[5];
1.设typedef char *POINT;
POINT p,q［3］;,则p和q 分别是字符型的( )
A.变量、指针变量
B.变量、二维数组
C.指针变量、一维数组指针
D.指针变量、一维指针数组
答案： D
2.下列说法中错误的是( )
A. C语言中循环嵌套的层数没有限定
B. C语言中的内部函数只能在本文件中被调用
C. 用typedef语句定义的数据类型名称必须是大写字母
D. C语言中的continue语句，可以通过改变程序的结构而省略
答案： C
第九章 文件
文件概述
文件：由按某个规则集合在一起，保存在外部存储器上的一批数据组成的。
数据文件：文件中存放的都是数据的文件称为数据文件
程序文件：文件中存放的是源程序清单或者是编译连接后生成的可执行程序，这样的文件统称为程序文件。
1.磁盘文件名
盘符:路径\文件主名.扩展名
扩展名是c 表示C语言的源程序文件。
扩展名是obj 表示C语言源程序经编译后生成的中间代码文件。
扩展名是exe 表示C语言中间代码文件经连接后生成的可执行 程序文件。
文件概述
2.磁盘文件的打开与关闭
文件的打开：从磁盘文件中读取数据到内存。
文件的关闭：把内存中的数据存回到磁盘文件。
3.磁盘文件分类
l 二进制文件：文件中的数据都是按其二进制方式存放。
l 文本文件： 文件中数据都是将其转换成对应的ASCII代码字符来存放
4.设备文件
设备文件：把输入／输出设备也看成文件，称为设备文件。
文件型指针
定义方法：FILE *文件型指针名1,*文件型指针名2,...;
1、打开文件函数 FILE *fopen(char *filename,char *mode)
【功能】以mode指定的“使用方式"，打开filename 指定的“文件名”对应的文件，同时自动给该文件分配一个内存缓冲区。
使用方式:
r：读 w：写 ＋：读写 b：二进制 a：追加
文件使用方式 | 含义 |
“r/rb” (只读) | 为输入打开一个文本/二进制文件 |
“w/wb” (只写) | 为输出打开或建立一个文本/二进制文件 |
“a/ab” (追加) | 向文本/二进制文件尾追加数据 |
“r+/rb+” (读写) | 为读/写打开或建立一个文本/二进制文件 |
“w+/wb+” (读写) | 为读/写建立一个文本/二进制文件 |
“a+/ab+” (读追加) | 向文本/二进制文件尾追加数据 |
2、关闭文件函数fclose(FILE *fp)
【功能】关闭fp所指向的文件，同时自动释放分配给文件的内存缓冲区。
标准设备文件的打开与关闭
三种标准输入／输出设备的使用不必事先打开对应的设备文件，因为在系统启动后，已自动打开这三个设备文件，并且为它们各自设置了一个文件型指针。
标准设备名称 | 对应文件型指针名 |
标准输入设备（键盘） | stdin |
标准输出设备（显示器） | stdout |
标准错误输出设备（显示器） | stderr |
三种标准输入／输出设备文件使用后，也不必关闭。因为在退出系统时，将自动关闭。
3、文件尾测试函数 feof(FILE *fp)
【功能】测试fp所指向的文件是否到达文件尾。是文件尾返回非0，否则返回0。
4、写字符函数 fputc(char ch,FILE *fp)
【功能】将ch中的字符写到fp所指向的文件的当前位置。
5、读字符函数 fgetc(FILE *fp)
【功能】从fp所指向的文件当前位置读取单个字符。
6、写字符串函数 fputs(char *str,FILE *fp)
【功能】将str指向的一个字符串，舍去结束标记符’\0’后写入fp所指向的文件中。
7、读字符串函数 *fgets(char *str,int n,FILE *fp)
【功能】从fp所指向的文件当前位置读取n-1个字符，在其后补充一个字符串结束标记符’\0’，组成字符串并存入str指定的内存区。如果读取的前n-1个字符中有“回车符”，则只读到回车符为止，补充结束标记符’\0’组成字符串（包括该回车符）。如果读取前n-1个字符中遇到文件尾，则将读取的字符后面补充结束标记符’\0’组成字符串。
函数名 | 功能 | 说明 |
puts | 将字符串输出到显示器 | 将字符串后的结束标记’\0’转换为“回车换行符”输出 |
fputs | 将字符串输出到显示器 | 输出时舍弃了字符串后的结束标记符’\0’。 |
gets | 从键盘上输入字符串 | 将键盘上输入的“回车换行符”转换为’\0’ |
fgets | 从键盘上输入字符串 | 保留输入的“回车换行符”，然后再补充一个’\0’。 |
8、写数据函数 fwrite(char *buf,unsigned int size,unsigned int n,FILE *fp)
【功能】将buf地址开始的n个数据（每个数据字节数为size）写入fp指向的文件。
9、读数据函数 fread(char *buf,unsigned int size,unsigned int n,FILE *fp)
【功能】从fp所指向的文件当前位置读取n个数据，每个数据的字节数为size，组成n个长度为size个字节的数据存入以buf为首地址的内存区。
10、文件头定位函数 rewind(FILE *fp)
【功能】将文件内部指针置于fp所指向的文件开头。
11、文件随机定位函数 fseek(FILE *fp,long offset,int from)
【功能】将fp所指向的文件内部指针从from指定的起始位置移动offset个字节，指向新的位置。
【参数】offset 长整型表达式，表示从from为起始位置的偏移字节数。可以取正数（向文件尾方向移动）、0（不移动）、负数（向文件头方向移动）。 from 确定起始位置的参数。可以选取下列整数或对应的符号常量：
整数 | 0 | 1 | 2 |
符号常量 | SEEK_SET | SEEK_CUR | SEEK_END |
对应的起始位置 | 文件头 | 内部指针的当前位置 | 文件尾 |
打开文件的常用程序段。
#include <stdio.h>
#include <stdlib.h>
FILE *fp; /* 定义名为fp的文件型指针 */
if ((fp=fopen(”文件名”,”使用方式”))==NULL)
{ printf(”Can not open file!\n”);
exit(0); /* 关闭所有文件，中止程序运行 */
}
测试文件尾的常用程序段。
... /* 设文件型指针fp已经指向一个可读文件 */
while (!feof(fp)) /* 若不是文件尾则继续循环 */
{ ... }
文件的真题
1. 将一个整数10002存到磁盘上，以ASCII码形式存储和以二进制形式存储，占用的字节数分别是 （ ）
A. 2和2 B. 2和5 C. 5和2 D. 5和5
答案：C
2.设FILE*fp;若fp指向的文件未结束，则函数feof(fp)的返回值为( )
A.0 B.true C.非0 D.false
答案：A
3．C语言中，系统自动打开的文件是( )
A.二进制文件 B.随机文件
C.非缓冲文件 D.设备文件
答案：D
4. 数据-35.78在文本文件中占用的字节个数是( )
A.4 B.5 C.6 D.8
答案：C
5. 为了向二进制文件尾部增加数据，打开文件的方式应采用( )
A.″ab″ B.″rb+″ C.″wb″ D.″wb+″
答案：A
6.对于文件操作方式″rb+″，准确的说法是（ ）
A.可读写文本文件 B.只读二进制文件
C.只读文本文件 D.可读写二进制文件
答案：D
7. C语言程序中对文本文件的存取是以________________为单位进行的。
答案：字节
8.设文件file1.c的内容为COMPUTER
#include ″stdio.h″
main( )
{ FILE *fp;
char ch;
if((fp=fopen(″file1.c″,″r″))= =NULL)
{ printf(″Cannot open file \n″);
exit(0); }
while(!feof(fp))
{ch=fgetc(fp);
if(ch>=′A′&&ch<=′Z′)
fputc(ch+32,stdout); }
fclose(fp);
}
答案：computer
9.程序填充题,建立一个磁盘文件，文件名和内容由键盘输入。
#include ″stdio.h″
main
{ char ch, fname ［20］;
_______________; /* 第一空 */
scanf(″%s″,fname);
if ((fp=fopen (________,″w″,))==NULL) /* 第二空 */
exit (0);
ch=getchar ;
while (ch!=′*′)
{
fputc (ch,fp);
putchar (ch);
ch=getchar ;
}
答案：FILE *fp
frame
考情交流
最新考试大纲规定：
本课程考试命题的主要题型有：单项选择题、填空题、阅读程序题、程序填空题。
在命题工作中必须按照本课程大纲中所规定的题型命制，考试试卷使用的题型可以略少，但不能超出规定。”
更多优质自考资料尽在百度贴吧自考乐园俱乐部
（http://tieba.baidu.com/club/5346389）欢迎❤加入...欢迎❤交流...止不住的惊喜等着你........
考试题型及分数分布情况：（我推测的）
1、选择题：共20小题，每小题1分，共20分。
2、填空题：共10小题，每小题2分，共20分。
3、程序阅读题：约6小题，每小题5分，共30分。
4、程序填空题：共5小题，每小题6分，共30分。
近年来出题频率比较高的知识点：
1、转义字符的正确表示。
【2005．10】下列转义字符中错误的是( )
A. ′\000′ B. ′\14′
C. ′\x111′ D. ′\2′
【2006．1】设char a=＇\70＇;则变量a中（ ）
A.包含1个字符 B.包含2个字符
C.包含3个字符 D.是非法表示
2、C语言保留字
【2005．1】C语言的保留字是( )
A. define B. enum
C. main D. include
【2005．10】下列不属于C语言保留字的是( )
A. char B. while
C. typedef D. look
【2006．10】以下属于C语言保留字的是（ ）
A．Fopen B．include
C．get D．unsigned
3、C语言标识符
【2006．1】可以用作C程序标识符的一组是（ ）
A.print oodb aBc B.i\am one-half 3pai
C.Pxq line# His.age D.Cpp pow while
4、C程序构成的特点
【2007．1】一个C语言程序的执行起点是__________。
【2006．10】一个C语言程序的基本组成单位是___________________。
【2005．10】可以将被调函数中获得的值返回给主调函数的语句是__________。
5、Ｃ语言中整型常量的三种形式
6、Ｃ语言中实型常量的两种形式
【2007．1】在C语言中，错误的常数表示是（ ）
A．0L B．-0x6aL
C．′6′ D．1.234E3.5
【2006．10】C语言中，错误的int类型的常数是（ ）
A．1E5 B．0
C．037 D．0xaf
7、字符常量和字符串常量的正确表示，字符串的长度
【2006．10】在C语言中，′a′和″a″存储所占用的字节数分别是（ ）
A．1，1 B．1，2
C．2，1 D．2，2
【2007．1】在C语言中，字符串″\\TOP\t\65\″″的长度是（ ）
A．5 B．7
C．9 D．12
8、Ｃ语言中的各种运算赋，重点掌握：算术、赋值、比较、逻辑、条件、逗号、位运算等运算符的含义，各种运算赋的优先级。（此类每年都考4到5个题目）
【2007．1】设int a,x=2；执行语句a=x>0?3*x(x=10);后，变量x的值是（ ）
A．1 B．2 C．6 D．10
【2007．1】7．逗号表达式a=2*6,a*3,a+5的值是（ ）
A．12 B．17 C．36 D．41
注意，用&&对两个表达式进行计算时，若第一个表达式的值为“假”，则运算结果与第二个表达式的值无关，结果肯定为“假”，所以Ｃ语言规定此时第二个表达式将不再计算。同样用||对两个表达式进行计算时，若第一个表达式的值为“真”，则运算结果与第二个表达式的值无关，结果肯定为“真”，所以Ｃ语言规定此时第二个表达式也不再计算。（这个知识点年年考）
【2007．1】设有以下程序段：
int x=2,y=2,z=0,a;
a=++x||++y&&z++;
printf(″%d,%d,%d\n″,x,y,z);
执行后输出的结果是（ ）
A．2，2，0 B．3，3，1 C．3，2，0 D．3，2，1
【2006．10】设有以下程序段：
int a=1, b=10, c=1, x;
x=a&&b||++c;
printf(″%d, %d\n″,x,c);
执行后输出的结果是（ ）
A．0，0 B．0，1 C．1，0 D．1，1
9、数学表达式和对应C语言表达式的转换。
【2007．1】 C语言表达式3.26*exp(x)+(a+b)/3所表示的数学表达式是（ ）
A．3.26x+ B．3.26xe+
C．3.26ex+ D．3.26lnx+
【2006．10】【2006．1】【2005．10】均有该类题目
10、格式输入函数scanf( )和格式输出函数printf( )的正确使用（年年有该类题目）。
【2007．1】设float x;，由键盘输入：12.45，能正确读入数据的输入语句是（ ）
A．scanf(″%5f″,&x); B．scanf(″%5d″,&x);
C．scanf(″%f″,x); D．scanf(″%s″,&x)
【2006．10】设int x;，则以下语句中错误的输入是（ ）
A．scanf (″%d″,x)； B．scanf (″%d″,&x)；
C．scanf (″%o″,&x)； D．scanf (″%x″,&x)；
11、选择结构的程序设计
注意:在设计嵌套的“if语句”和“if-else语句”时，要特别注意else是和前面出现的哪个if配对。
break在多分支结构switch语句中的作用是：执行完某个语句组后，将退出该switch语句。如果省略了break语句，则执行完某个语句组后，将连续执行其后的所有语句组。
12、循环结构的程序设计、break语句和continue语句在循环结构中的作用
以上两个知识点，肯定是每年必考的，在四种题型中都会出现。
13、一维数组和二维数组的定义和各种初始化方法，数组元素的正确引用。
14、字符数组的定义、初始化和存储字符串的方法
15、指针变量的定义和使用方法
16、指向字符串的指针变量的使用
以上三个知识点，肯定是每年必考的，在四种题型中都会出现。
17、在函数间传递数据有四种方式：值传递方式、地址传递方式、返回值方式、全局变量传递方式。
在“阅读程序”和程序填空中一定会有相关题目。
18、变量的存储类型与作用域，尤其注意静态变量和全局变量的使用。
每年必考，尤其在“阅读程序”和程序填空中一定有相关题目。
19、函数的递归调用
在“阅读程序”和程序填空中一定有相关题目。
20、结构型的定义，结构型变量站用的内存空间大小。
21、结构型变量成员的引用，结构型数组的定义和数组元素成员的引用
22、指向结构型数据的指针变量对成员的引用，指向结构型数组元素的指针变量对成员的引用，指向结构型数组的指针变量对成员的引用
以上三个知识点，肯定是每年必考的，在四种题型中都会出现。
应考建议：
1、认真完成教材课后习题中的选择题、填空题、程序阅读题和程序填空题,。对于课后的程序设计题，最好能找到题目的答案，认真研究，此类题目也可能以程序阅读或程序填空的方式出题，通过做题来理解知识点。
2、认真研究历年真题。串讲和最新真题讲解中包含从2001年至今的所有真题，通过研究这些真题来复习相关知识点并了解出题的方式。
3、认真做好三套模拟试题，这三套模拟试题的题目是我认真研究历年自考真题的基础上编写的，题目全部来自国家正式考试试题。
4、要重点掌握基础知识，不要过多研究难题和怪题
