考情分析及复习介绍（１）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第一章 Ｃ语言概述（１４）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第二章 算法（１９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第三章 数据类型、运算符与表达式（３３）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第四章 单的Ｃ程序设计（４９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第五章 择结构程序设计（６０）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第六章 循环控制（６９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第七章 数组（８０）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第八章 函数（９９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第九章 预处理命令（１３０）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第十章 指针（１３９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第十一章 结构体与共同体（１７２）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第十二章 位运算（２０１）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
第十三章 文件（２０９）G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21 G21
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１
考情分析及章节介绍
考情分析、复习方法
◆课程特点
知识点众多，不利于记忆，难于掌握
算法的概念及其表示；
数据类型、运算符与表达式；
程序设计结构；
数组；
函数；
指针；
预处理命令；
结构体、共同体、枚举类型；
位运算、位段；
文件。
书写形式类似、功能相近，容易混淆
给定以下几组定义，说明其含义：
１．ｉｎｔｐ；ｉｎｔｐ；
２．ｉｎｔｐ［ｎ］；ｉｎｔｐ［ｎ］；ｉｎｔ（ｐ）［ｎ］；
３．ｉｎｔｐ（ ）；ｉｎｔｐ（ ）；ｉｎｔ（ｐ）（ ）；
关于ｔｙｐｅｄｅｆ与＃ｄｅｆｉｎｅ的相似之处
ｔｙｐｅｄｅｆｉｎｔＣＯＵＮＴ；
＃ｄｅｆｉｎｅＣＯＵＮＴｉｎｔ
作用：都是用ＣＯＵＮＴ代表ｉｎｔ。但事实上，二者是不同的。＃ｄｅｆｉｎｅ是在预编译时处理的，只能作
简单的字符串替换，而ｔｙｐｅｄｅｆ是在编译时处理的，并不是作简单的字符串替换，而是声明一个类型。
知识点综合运用，难于理解
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｓｔｒｕｃｔｓｔｕ｛ｉｎｔｘ；ｉｎｔｙ；｝ｐ；
ｉｎｔｄｔ［４］＝｛１０，２０，３０，４０｝；
ｓｔｒｕｃｔｓｔｕ
ａ［４］＝｛５０，＆ｄｔ［０］，６０，＆ｄｔ［１］，７０，＆ｄｔ［２］，８０，＆ｄｔ［３］｝；
２
ｍａｉｎ（）
｛
ｐ＝ａ；
ｐｒｉｎｔｆ（＂％ｄ，＂，＋＋ｐ－＞ｘ）；
ｐｒｉｎｔｆ（＂％ｄ，＂，（＋＋ｐ）－＞ｘ）；
ｐｒｉｎｔｆ（＂％ｄ＼ｎ＂，＋＋（ｐ－＞ｙ））；
Ｃ．是任意的 Ｄ．由所用机器的机器字长所决
｝
运行情况输出：
５１，６０，２１
◆出题思路：按内容分布、按题型分布探讨
按内容分布
按知识点的基础内容出题
例如：针对数据类型、运算符与表达式；
在Ｃ语言中，ｉｎｔ、ｃｈａｒ和ｓｈｏｒｔ种类型数据在内存中所占用的字节数（Ｄ）。
Ａ．由用户自己定义 Ｂ．均为２个字节
定
例如：针对函数；
在Ｃ语言程序中，在一个源程序中，ｍａｉｎ函数的位置（Ｃ）。
Ａ．Ｃ语言程序总是从第一个定义的函数开始执行
Ｂ．在Ｃ语言程序中，要调用的函数必须在ｍａｉｎ函数中定义
Ｃ．Ｃ语言程序总是从ｍａｉｎ函数开始执行
Ｄ．Ｃ语言程序中的ｍａｉｎ函数必须放在程序的开始部分
例如：针对循环结构；
写出下面程序的输出结果（Ａ）
ｍａｉｎ（ ）
｛
Ｉｎｔｎ［２］＝｛０｝，ｉ，ｊ，ｋ＝２；
ｆｏｒ（ｉ＝０；ｉ＜ｋ；ｉ＋＋）
ｆｏｒ（ｊ＝０；ｊ＜ｋ；ｊ＋＋）ｎ［ｊ］＝ｎ［ｉ］＋１；
Ｐｒｉｎｔｆ（“％ｄ＼ｎ”，ｎ［ｋ］）；
｝
Ａ．不确定的值
Ｂ．３
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
３
Ｃ．２
Ｄ．１
例如：综合选择结构、自增运算符；
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｍａｉｎ（）
｛
ｉｎｔ ｘ，ｙ；
ｓｃａｎｆ（“％ｄ”， ＆ｘ）；
ｉｆ（ｘ＋＋＜０）ｙ＝－１；
ｅｌｓｅｉｆ（ｘ＝＝０）ｙ＝０；
ｅｌｓｅｙ＝１；
ｐｒｉｎｔｆ（“％ｄ”，ｙ）；
｝
如果从键盘上输入－１，则程序的输出是（Ａ）。
Ａ．－１ Ｂ．０ Ｃ．１ Ｄ．不确定的值
例如：综合选择分支结构、自增运算符；
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｍａｉｎ（）
｛
ｉｎｔ ｘ＝１，ｙ＝０，ａ＝０，ｂ＝０；
ｓｗｉｔｃｈ（ｘ）
｛
ｃａｓｅ１：
ｓｗｉｔｃｈ（ｙ）
｛
ｃａｓｅ０：ａ＋＋；ｂｒｅａｋ；
ｃａｓｅ１：ｂ＋＋；ｂｒｅａｋ；
｝
ｃａｓｅ２：
ａ＋＋；ｂ＋＋；ｂｒｅａｋ；
｝
ｐｒｉｎｔｆ（“ａ＝％ｄ，ｂ＝％ｄ＼ｎ”， ａ，ｂ）；
｝
４
Ａ．ａ＝２，ｂ＝１ Ｂ．ａ＝１，ｂ＝１ Ｃ．ａ＝１，ｂ＝０ Ｄ．ａ＝２，ｂ＝２
出题思路
◆按题型角度：填空题、选择题、程序补充、程序阅读、程序改错、程序设计
填空题：
描述“一个整数ｎ能被３或７整除”的Ｃ语言逻辑表达式（ ）。
（ｎ％３＝＝０）｜｜（ｎ％７＝＝０）
以下程序的运行结果是（１１）。
＃ｄｅｆｉｎｅＡＤＤ（ｘ，ｙ）ｘ＋ｙ
ｖｏｉｄｍａｉｎ（）
｛
ｐｒｉｎｔｆ（“％ｄ＼ｎ”，ＡＤＤ（１，２）ＡＤＤ（３，４））；
｝
按题型角度：知识点的基本内容及综合
选择题：单项
下列标识符中，（Ｂ）是合法的用户定义的标识符。
Ａ．Ａ＃Ｃ Ｂ．ｇｅｔｃｈ Ｃ．ｖｏｉｄ Ｄ．ａｂ
以下程序的运行结果是（Ｂ）
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ＝０，ｊ＝０，ｋ＝６；
ｉｆ（（＋＋ｉ）｜｜（＋＋ｊ＞０））ｋ＋＋；
ｐｒｉｎｔｆ（“％ｄ，％ｄ，％ｄ＼ｎ”，ｉ，ｊ，ｋ）；
｝
Ａ．０，０，６
Ｂ．１，０，７
Ｃ．１，１，７
Ｄ．０，１，７
选择题：多项
下面关于枚举类型的说法正确的是（Ｂ、Ｃ、Ｄ）。
Ａ．可以为枚举元素赋值
Ｂ．枚举元素可以进行比较
Ｃ．枚举元素的值可以在类型定义时指定
Ｄ．枚举元素可以作为常量使用
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
５
程序补充：
从键盘上输入１０个数，求其平均值。
ｍａｉｎ（）
｛
ｆｏｒ（ｉ＝１，ｓｕｍ＝０．０；ｉ＜１１；ｉ＋＋） ｓｃａｎｆ（＂％ｆ＂，＆ｆ）
｛ｓｕｍ＝ｓｕｍ＋ｆ
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿；
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿；
｝
Ｐｒｉｎｔｆ（“ａｖｅｒａｇｅ＝％ｆ＼ｎ”，ｓｕｍ／１０）；
｝ｓｃａｎｆ（＂％ｆ＂，＆ｆ）｛ｓｕｍ＝ｓｕｍ＋ｆ
以下函数的功能是：把字符串ｓｔｒ２接在字符串ｓｔｒ１的后面。
ｖｏｉｄｆｕｎ（ｃｈａｒｓｔｒ１，ｃｈａｒｓｔｒ２）
｛
（ｐ１＋ｉ）！＝‘＼０’
（ｐ２＋＋）ｉｎｔｉ＝０；
ｃｈａｒｐ１＝ｓｔｒ１，ｐ２＝ｓｔｒ２；
ｗｈｉｌｅ（＿＿＿＿＿＿＿＿＿＿＿＿）ｉ＋＋； （ｐ１＋ｉ）＝＼‘０’
ｆｏｒ（；ｐ２；ｉ＋＋）（ｐ２＋＋）
（ｐ１＋ｉ）＝＿＿＿＿＿＿＿＿＿＿＿；
（ｐ１＋ｉ）＝‘＼０’；
｝
（ｐ１＋ｉ）＝＼‘０’
（ｐ２＋＋）
程序阅读：
写出程序的输出结果。
ｍａｉｎ（）
｛
４ｉｎｔａ＝３；
ａ
＋
＝（ａ＜１）？ａ：１；
ｐｒｉｎｔｆ（“％ｄ”，ａ）；
｝ ４
程序阅读：
６
写出程序的输出结果。
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ，ｂ，ｋ＝０；
ｆｏｒ（ｉ＝１；ｉ＜＝５；ｉ＋＋）
｛
ｂ＝ｉ％２；
ｗｈｉｌｅ（ｂ－－＞＝０）ｋ＋＋；
｝
ｐｒｉｎｔｆ（＂％ｄ，％ｄ＼ｎ＂，ｋ，ｂ）；
｝ ８，－２
程序改错：
下面程序用以计算整数阶乘。
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ，ｎ；
ｌｏｎｇｎｐｐ；
ｓｃａｎｆ（＂％ｄ＂，＆ｎ）；
ｎｐｐ＝１；ｉ＝２；
ｗｈｉｌｅ（ｉ＋＋＜＝ｎ） ｗｈｉｌｅ（ｉ＜＝ｎ）
ｎｐｐ＝ｎｐｐｉ；ｎｐｐ＝ｎｐｐ
（ｉ－１）；
ｐｒｉｎｔｆ（＂ｎ＝％ｄ，ｎ！＝％ｄ＼ｎ＂，ｎ，ｎｐｐ）；
｝
ｗｈｉｌｅ（ｉ＜＝ｎ）
ｎｐｐ（ｉ－１）；
程序改错：
输入一个三位数，分别求这个数的个、十、百位输出。
ｖｏｉｄｍａｉｎ（ ）
｛
ｉｎｔｔ，ｘ，ｙ，ｚ；
ｓｃａｎｆ（＂％ｄ＂，ｔ）； ｓｃａｎｆ（“％ｄ”，＆ｔ）；
ｘ＝ｔ／１００；
ｙ＝（ｔ－ｘ１００）／１０；ｙ＝（ｔ－ｘ１００）％１０；
ｚ＝ｔ％１０；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
７
ｐｒｉｎｔｆ（＂ｘ＝％ｄ，ｙ＝％ｄ，ｚ＝％ｄ＼ｎ＂，ｘ，ｙ，ｚ）；
｝
ｓｃａｎｆ（“％ｄ”，＆ｔ）；
ｙ＝（ｔ－ｘ１００）％１０；
◆按题型角度：算法及知识点的综合
程序设计：课后习题、综合性弱
编程输出１０至１００之间的所有素数。
编程输出１００至９９９之间的所有水仙花数。
（水仙花数定义，如：１５３＝１３＋５３＋３３，则１５３为水仙花数）
设任意含有１０个元素的一维数组Ａ和指针变量ｐ，请用指针与数组关系编程输出该数组元素
内容。
◆程序设计：综合性强
假设一个文本文件中保存着１００个整数，请将这１００个整数从大到小的顺序写到另一个文件中
去，并且在新文件中每１０个整数占一行。源文件名和目标文件名通过命令行参数获取。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（ｉｎｔａｒｇｃ，ｃｈａｒａｒｇｖ［］）
｛
ＦＩＬＥｆｉｎ，ｆｏｕｔ；
ｉｎｔａ［１００］，ｉ，ｊ，ｔ；
Ｉｆ（ａｒｇｃ！＝３）
｛
ｐｒｉｎｔｆ（“Ｙｏｕｆｏｒｇｏｔｔｏｅｎｔｅｒａｆｉｌｅｎａｍｅ．＼ｎ”）；
ｒｅｔｕｒｎ；
｝
ｆｉｎ＝ｆｏｐｅｎ（ａｒｇｖ［１］，”ｒ”）；
ｆｏｕｔ＝ｆｏｐｅｎ（ａｒｇｖ［２］，”ｗ”）；
ｆｏｒ（ｉ＝０；ｉ＜１００；ｉ＋＋）
ｆｓｃａｎｆ（ｆｉｎ，”％ｄ”，＆ａ［ｉ］）；
ｆｏｒ（ｉ＝０；ｉ＜９９；ｉ＋＋）
ｆｏｒ（ｊ＝０；ｊ＜９９－ｉ；ｉ＋＋）
ｉｆ（ａ［ｊ］＞ａ［ｊ＋１］
｛ｔ＝ａ［ｊ］；ａ［ｊ］＝ａ［ｊ＋１］；ａ［ｊ＋１］＝ｔ；｝
８
◆复习思路
从教材的角度（按章节顺序，较全面）（第一阶段）
从考题的角度（抓重点，找遗漏）（第二阶段）
从教材的角度（按章节顺序，较全面）（第一阶段）
认真复习每个知识点，掌握Ｃ语言规则。
例如：针对字符数组和字符指针变量
字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字符串
第１个字符的地址），决不是将字符串放到字符指针变量中。
对字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值。
ｃｈａｒ ｓｔｒ［１４］；
ｓｔｒ＝″ＩｌｏｖｅＣｈｉｎａ！″；
而对字符指针变量，可以采用下面方法赋值：
ｃｈａｒａ；
ａ＝″ＩｌｏｖｅＣｈｉｎａ！″；
对于容易混淆的知识点，善于归纳和总结
有关整型的数据类型
定义含义
ｉｎｔ ｐ；定义整型变量ｐ
ｉｎｔ ｐ；ｐ为指向整型数据的指针变量
ｉｎｔ ｐ［ｎ］；定义整型数组ｐ，它有ｎ个元素
ｉｎｔｐ［ｎ］；定义指针数组ｐ，它由ｎ个指向整型数据的指针元素组成
ｉｎｔ （ｐ）［ｎ］；ｐ为指向含ｎ个元素的一维数组的指针变量
ｉｎｔ ｐ（）；ｐ为带回整型函数值的函数
ｉｎｔ ｐ（）；ｐ为带回一个指针的函数，该指针指向整型数据
ｉｎｔ （ｐ）（）；ｐ为指向函数的指针，该函数返回一个整型值
ｉｎｔ ｐ；ｐ是一个指针变量，它指向一个指向整型数据的指针变量
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
９
培养认真分析的习惯，建立地址分配模型。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｓｔｒｕｃｔｓｔｕ｛ｉｎｔｘ；ｉｎｔｙ；｝ｐ；
ｉｎｔｄｔ［４］＝｛１０，２０，３０，４０｝；
ｓｔｒｕｃｔｓｔｕ
ａ［４］＝｛５０，＆ｄｔ［０］，６０，＆ｄｔ［１］，７０，＆ｄｔ［２］，８０，＆ｄｔ［３］｝；
ｍａｉｎ（）
｛
ｐ＝ａ；
ｐｒｉｎｔｆ（＂％ｄ，＂，＋＋ｐ－＞ｘ）；
ｐｒｉｎｔｆ（＂％ｄ，＂，（＋＋ｐ）－＞ｘ）；
ｐｒｉｎｔｆ（＂％ｄ＼ｎ＂，＋＋（ｐ－＞ｙ））；
｝
运行情况输出：
５１，６０，２１
１０
从考题的角度（抓重点，有遗漏）（第二阶段）
主要是出题几率小的知识点。
例如：下面符合要求的位段定义是（Ｂ）。
要求：１）ａ有两位；２）ｂ有两位；３）ｃ有两位；４）ｄ有四位。
Ａ．ｓｔｒｕｃｔｂｉｔｆｉｅｌｄｓ
｛
ｕｎｓｉｇｎｅｄａ，ｂ，ｃ：２；
ｕｎｓｉｇｎｅｄｄ：４；
｝；
Ｂ．ｓｔｒｕｃｔｂｉｔｆｉｅｌｄｓ
｛
ｕｎｓｉｇｎｅｄａ：２，ｂ：２；
ｕｎｓｉｇｎｅｄｃ：２，ｄ：４；
｝；
Ｃ．ｓｔｒｕｃｔｂｉｔｆｉｅｌｄｓ
｛
ｕｎｓｉｇｎｅｄａ，ｂ，ｃ：６；
ｕｎｓｉｇｎｅｄｄ：４；
｝；
Ｄ．ｓｔｒｕｃｔｂｉｔｆｉｅｌｄｓ
｛
ｕｎｓｉｇｎｅｄａ，ｂ：４；
ｕｎｓｉｇｎｅｄｃ，ｄ：６；
｝；
●按章节介绍知识点分布
重点内容必考；
数据类型、运算符与表达式、结构化程序设计、数组、函数、结构体、指针、文件；
主要内容
●算法
算法的概念、算法的特性、算法的表示
用自然语言表示算法
用流程图表示算法：基本程序设计结构
用Ｎ－Ｓ流程图表示算法
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１
用伪代码表示算法
●数据类型、运算符与表达式
整型数据：整型常量的表示方法、整型变量、整型常量
浮点型数据：浮点型常量的表示方法、浮点型变量、浮点型常量
字符型数据：字符常量、字符变量、字符串常量
各类数值型数据间的混合运算
算术运算符和算术表达式
赋值运算符和赋值表达式
逗号运算符和逗号表达式
●Ｃ语言程序设计
赋值语句
数据输入输出
字符数据输入输出
格式输入与输出
●选择结构
关系运算符和关系表达式
逻辑运算符和逻辑表达式
ｉｆ语句：Ｉｆ语句的基本形式、Ｉｆ语句的嵌套、条件运算符
ｓｗｉｔｃｈ语句
●循环控制
ｇｏｔｏ语句以及用ｇｏｔｏ语句构成循环
用ｗｈｉｌｅ语句实现循环
用ｄｏ－ｗｈｉｌｅ语句实现循环
用ｆｏｒ语句实现循环
循环的嵌套
ｂｒｅａｋ语句ｃｏｎｔｉｎｕｅ和语句
●数组
一维数组的定、引用、初始化
二维数组的定义、引用、初始化
字符数组的定义、引用、初始化
字符串和字符串结束标志
字符数组的输入输出
字符串处理函数
１２
●函数
函数定义的一般形式、函数参数和函数的返回值
函数的调用、函数原型、嵌套调用、递归调用
数组作为函数参数
局部变量和全局变量
变量的存储类别：动态存储方式与静态存储方式
ａｕｔｏ变量、用ｓｔａｔｉｃ声明局部变量、ｒｅｇｉｓｔｅｒ变量
用ｅｘｔｅｒｎ声明外部变量、用ｓｔａｔｉｃ声明外部变量
●预处理命令
宏定义：不带参数的宏定义、带参数的宏定义、带参数的宏和函数的区别
“文件包含”处理
条件编译
●指针
地址和指针
变量的指针和指向变量的指针变量
数组与指针
字符串与指针
指向函数的指针、返回指针值的函数
指针数组和指向指针的指针
ｖｏｉｄ指针类型
●结构体与共同体
结构体变量的定义、引用、初始化
结构体数组
指向结构体类型数据的指针
用指针处理链表
共用体
枚举类型
用ｔｙｐｅｄｅｆ定义类型
●位运算
位运算符和位运算
位段
●文件
文件类型指针
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１３
文件的打开与关闭
文件的读写
文件的定位
出错的检测
文件输入输出
复习思路
知识点较多、知识点之间可以综合应用，复习难度大；
按章节顺序、全面掌握知识点，培养综合分析考题的能力；
从考题的角度、有重点地针对性地复习。
１４
第一章 Ｃ语言概述
本章考点
考点１ Ｃ语言出现的历史背景
Ｃ语言是国际上广泛流行的高级语言，Ｃ语言是在Ｂ语言的基础上发展起来的。
Ｂ（ＢＣＰＬ）语言是１９７０年由美国贝尔实验室设计的，并用于编写了第一个ＵＮＩＸ操作系统，优点：
精练，接近硬件；缺点：过于简单，数据无类型。
１９７５年ＵＮＩＸ第６版发布，Ｃ优点突出引起关注。
１９７７年出现《可移植Ｃ语言编译程序》，推动ＵＮＩＸ在各种机器上实现，Ｃ语言得到推广，其发展
相辅相成
１９７３年贝尔实验室的Ｄ．Ｍ．Ｒｉｔｃｈｉｅ在Ｂ语言的基础上设计出Ｃ语言，对Ｂ取长补短，并用之改写
原来用汇编编写的ＵＮＩＸ，但仅在贝尔实验室使用。
。
１９７８年影响深远的名著《ＴｈｅＣＰｒｏｇｒａｍｍｉｎｇＬａｎｇｕａｇｅ》由ＢｒｉａｎＷ．Ｋｅｒｎｉｇｈａｎ和ＤｅｎｎｉｓＭ．Ｒｉｔｃｈｉｅ
合著，被称为标准Ｃ。
１９８３年，美国国家标准化协会（ＡＮＳＩ）根据Ｃ语言各种版本对Ｃ的发展和扩充，制定了新的标准
ＡＮＳＩＣ，比标准Ｃ有了很大的发展。
１９８８年，Ｋ＆Ｒ按照ＡＮＳＩＣ修改了他们的《ＴｈｅＣＰｒｏｇｒａｍｍｉｎｇＬａｎｇｕａｇｅ》。
１９８７年，ＡＮＳＩ公布新标准———８７ＡＮＳＩＣ。
１９９０年，国际标准化组织接受了８７ＡＮＳＩＣ为ＩＳＯＣ的标准（ＩＳＯ９８９９—１９９０）。
１９９４年，ＩＳＯ又修订了Ｃ语言标准。
目前，流行的Ｃ语言编译系统大多是以ＡＮＳＩＣ为基础进行开发的。
说明：不同版本的Ｃ编译系统所实现的语言功能和语法规则略有差别，因此了解所用的Ｃ语言编
译系统的特点。
考点２ Ｃ语言的特点
（１）语言简洁、紧凑，使用方便、灵活。３２个关键字、９种控制语句，程序形式自由。
（２）运算符丰富。３４种运算符。
（３）数据类型丰富，具有现代语言的各种数据结构。
（４）具有结构化的控制语句，是完全模块化和结构化的语言。
（５）语法限制不太严格，程序设计自由度大。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１５
（６）允许直接访问物理地址，能进行位操作，能实现汇编语言的大部分功能，可直接对硬件进行
操作。
（７）目标代码质量高，程序执行效率高。只比汇编程序生成的目标代码效率低１０％－２０％。
（８）程序可移植性好。基本上不做修改就能用于各种型号的计算机和各种操作系统。
考点３ 简单的Ｃ语言程序介绍
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞ ／文件包含／
ｖｏｉｄ ｍａｉｎ（） ／主函数／
｛ ／函数体开始／
ｐｒｉｎｔｆ（＂ＴｈｉｓｉｓａＣｐｒｏｇｒａｍ．＼ｎ＂）； ／输出语句／
｝ ／函数体结束／
说明：ｍａｉｎ－主函数名，ｖｏｉｄ－函数类型
每个Ｃ程序必须有一个主函数ｍａｉｎ
｛｝是函数开始和结束的标志，不可省
每个Ｃ语句以分号结束
使用标准库函数时应在程序开头添加：＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
例：求３个数中较大者。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（） ／主函数／
｛
ｉｎｔｍａｘ（ｉｎｔｘ，ｉｎｔｙ）； ／对被调用函数ｍａｘ的声明／
ｉｎｔａ，ｂ，ｃ； ／定义变量ａ、ｂ、ｃ／
ｓｃａｎｆ（″％ｄ，％ｄ″，＆ａ，＆ｂ）； ／输入变量ａ和ｂ的值／
ｃ＝ｍａｘ（ａ，ｂ）； ／调用ｍａｘ函数，将得到的值赋给ｃ／
ｐｒｉｎｔｆ（″ｍａｘ＝％ｄ＼＼ｎ″，ｃ）； ／输出ｃ的值／
｝
ｉｎｔ ｍａｘ（ｉｎｔｘ，ｉｎｔｙ）
｛
ｉｎｔｚ；
ｉｆ （ｘ＞ｙ） ｚ＝ｘ；
ｅｌｓｅｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
例：求两数之和
１６
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（） ／求两数之和／
｛
ｉｎｔａ，ｂ，ｓｕｍ； ／声明，定义变量为整型／
／以下３行为Ｃ语句／
ａ＝１２３；ｂ＝４５６；
ｓｕｍ＝ａ＋ｂ；
ｐｒｉｎｔｆ（″ｓｕｍｉｓ％ｄ＼ｎ″，ｓｕｍ）；
｝
说明：／……／表示注释。注释对编译和运行不起作用，可以用汉字或英文字符表示，可以出
现在一行中的最右侧，也可以单独成为一行。
Ｃ程序：
（１）Ｃ程序是由函数构成的，使程序容易实现模块化。
（２）一个函数由两部分组成：
函数的首部：例３中的ｍａｘ函数首部
ｉｎｔｍａｘ（ｉｎｔｘ，ｉｎｔｙ）
函数体：花括号内的部分。若一个函数有多个花括号，则最外层的一对花括号为函数体的范围。
函数体包括两部分：
声明部分：ｉｎｔａ，ｂ，ｃ；可缺省
执行部分：由若干个语句组成，可缺省
注意：
函数的声明部分和执行部分都可缺省，例如：
ｖｏｉｄｄｕｍｐ（）
｛
｝
这是一个空函数，什么也不做，但是合法的函数。
总结：
（１）Ｃ程序总是从ｍａｉｎ函数开始执行的，与ｍａｉｎ函数的位置无关。
（２）Ｃ程序书写格式自由，一行内可以写几个语句，一个语句可以分写在多行上，Ｃ程序没有
行号。
（３）每个语句和数据声明的最后必须有一个分号。
（４）Ｃ语言本身没有输入输出语句。输入和输出的操作是由库函数ｓｃａｎｆ和ｐｒｉｎｔｆ等函数来完成
的。Ｃ对输入输出实行“函数化”。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１７
考点４ 运行Ｃ程序的步骤
一、运行Ｃ程序的步骤
（１）上机输入与编辑源程序
（２）对源程序进行编译
（３）与库函数连接
（４）运行可执行目标程序
二、上机运行Ｃ程序的方法
（１）目前使用的大多数Ｃ编译系统都是集成环境（ＩＤＥ）的。可用不同的编译系统对Ｃ程序进行
操作。
（２）常用的有ＴｕｒｂｏＣ２．０、ＴｕｒｂｏＣ＋＋３．０、ＶｉｓｕａｌＣ＋＋等。
（３）ＴｕｒｂｏＣ＋＋３．０：是一个集成环境，具有方便、直观和易用的界面，虽然是ＤＯＳ环境下的集成
环境，但是可以把启动ＴｕｒｂｏＣ＋＋３．０集成环境的ＤＯＳ执行文件ｔｃ．ｅｘｅ生成快捷方式，也可以用鼠
标操作。
（４）ＶｉｓｕａｌＣ＋＋：可以用ＶｉｓｕａｌＣ＋＋对Ｃ程序进行编译。
１８
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
殏
殏
殏
殏
本章小结
主要知识点：
Ｃ语言的特点：运算符丰富、模块化和结构化、允许直接访问物理地址、进行位操作、可移植
性好等
简单的Ｃ语言程序：函数、函数的首部、函数体等
运行Ｃ程序的步骤：输入与编辑源程序、编译、连接、运行等
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１９
第二章 算法
本章考点
考点１ 算法的概念
一个程序应包括两个方面的内容：
对数据的描述：数据结构（ｄａｔａｓｔｒｕｃｔｕｒｅ）
对操作的描述：算法（ａｌｇｏｒｉｔｈｍ）
著名计算机科学家沃思提出一个公式：
数据结构＋算法＝程序
完整的程序设计应该是：
数据结构＋算法＋程序设计方法＋语言工具
广义地说，为解决一个问题而采取的方法和步骤，就称为“算法”。
对同一个问题，可有不同的解题方法和步骤。
例如求：
∑
１００
ｎ＝１
ｎ
方法１：１＋２，＋３，＋４，一直加到１００，加９９次
方法２：１００＋（１＋９９）＋（２＋９８）＋…＋（４９＋５１）＋５０
＝１００＋４９×１００＋５０ 加５１次
为了有效地进行解题，不仅需要保证算法正确，还要考虑算法的质量，选择合适的算法。希望方
法简单，运算步骤少。
计算机算法可分为两大类别：
数值运算算法：求数值解，例如求方程的根、求函数的定积分等。
非数值运算：包括的面十分广泛，最常见的是用于事务管理领域，例如图书检索、人事管理、行车
调度管理等。
例１ 求１×２×３×４×５
步骤１：先求１×２，得到结果２
步骤２：将步骤１得到的乘积２再乘以３，得到结果６
步骤３：将６再乘以４，得２４
步骤４：将２４再乘以５，得１２０
如果要求１×２×…×１０００，则要写９９９个步骤
２０
可以设两个变量：一个变量代表被乘数，一个变量代表乘数。不另设变量存放乘积结果，而直接
将每一步骤的乘积放在被乘数变量中。设ｐ为被乘数，ｉ为乘数。用循环算法来求结果，算法可改写：
Ｓ１：使ｐ＝１
Ｓ２：使ｉ＝２
Ｓ３：使ｐ×ｉ，乘积仍放在变量ｐ中，可表示为：ｐ×ｉ－＞ｐ
Ｓ４：使ｉ的值加１，即ｉ＋１－＞ｉ。
Ｓ５：如果ｉ不大于５，返回重新执行步骤Ｓ３以及其后的步骤Ｓ４和Ｓ５；否则，算法结束。最后得到ｐ
的值就是５！的值。
用这种方法表示的算法具有通用性、灵活性。Ｓ３到Ｓ５组成一个循环，在实现算法时，要反复多次
执行Ｓ３，Ｓ４，Ｓ５等步骤，直到某一时刻，执行Ｓ５步骤时经过判断，乘数ｉ已超过规定的数值而不返回
Ｓ３步骤为止。此时算法结束，变量ｐ的值就是所求结果。
例题
例２ 有５０个学生，要求将成绩在８０分以上者打印出来。设ｎ表示学号，ｎ１代表第一个学生学
号，ｎｉ代表第ｉ个学生学号。用ｇ代表学生成绩，ｇｉ代表第ｉ个学生成绩，算法表示如下：
Ｓ１：１－＞ｉ
Ｓ２：如果ｇｉ≥８０，则打印ｎｉ和ｇｉ，否则不打印。
Ｓ３：ｉ＋１－＞ｉ
Ｓ４：如果ｉ≤５０，返回Ｓ２，继续执行。否则算法结束。
变量ｉ作为下标，用来控制序号（第几个学生，第几个成绩）。当ｉ超过５０时，表示已对５０个学生
的成绩处理完毕，算法结束。
例３ 判定２０００～２５００年中的每一年是否闰年，将结果输出。
分析：闰年的条件是：（１）能被４整除，但不能被１００整除的年份都是闰年，如１９９６，２００４年是闰
年；（２）能被１００整除，又能被４００整除的年份是闰年。如１６００，２０００年是闰年。不符合这两个条件
的年份不是闰年。
设ｙ为被检测的年份，算法可表示如下：
Ｓ１：２０００－＞ｙ
Ｓ２：若ｙ不能被４整除，则输出ｙ“不是闰年”。然后转到Ｓ６。
Ｓ３：若ｙ能被４整除，不能被１００整除，则输出ｙ“是闰年”。然后转到Ｓ６。
Ｓ４：若ｙ能被１００整除，又能被４００整除，输出ｙ“是闰年”，否则输出“不是闰年”。然后转到Ｓ６。
Ｓ５：输出ｙ“不是闰年”。
Ｓ６：ｙ＋１－＞ｙ
Ｓ７：当ｙ≤２５００时，转Ｓ２继续执行，如ｙ＞２５００，算法停止。
例４ 求１－
１
２
＋
１
３
－
１
４
＋……－
１
９９
＋
１
１００
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２１
算法如下：
Ｓ１：ｓｉｇｎ＝１
Ｓ２：ｓｕｍ＝１
Ｓ３：ｄｅｎｏ＝２
Ｓ４：ｓｉｇｎ＝（－１）×ｓｉｇｎ
Ｓ５：ｔｅｒｍ＝ｓｉｇｎ×（１／ｄｅｎｏ）
Ｓ６：ｓｕｍ＝ｓｕｍ＋ｔｅｒｍ
Ｓ７：ｄｅｎｏ＝ｄｅｎｏ＋１
Ｓ８：若ｄｅｎｏ≤１００返回Ｓ４，否则算法结束。
反复执行Ｓ４到Ｓ８步骤，直到分母大于１００为止。一共执行了９９次循环，向ｓｕｍ累加入了９９个
分数。ｓｕｍ最后的值就是多项式的值。
例５ 对一个大于或等于３的正整数，判断它是不是一个素数。
概念：所谓素数，是指除了１和该数本身之外，不能被其它任何整数整除的数。例如，１３是素数。
因为它不能被２，３，４，…，１２整除。
分析：判断一个数ｎ（ｎ≥３）是否素数的方法：将ｎ作为被除数，将２到（ｎ－１）各个整数轮流作为
除数，如果都不能被整除，则ｎ为素数。
算法如下：
Ｓ１：输入ｎ的值
Ｓ２：ｉ＝２（ｉ作为除数）
Ｓ３：ｎ被ｉ除，得余数ｒ
Ｓ４：如果ｒ＝０，表示ｎ能被ｉ整除，则打印ｎ“不是素数”，算法结束。否则执行Ｓ５
Ｓ５：ｉ＋１－＞ｉ
Ｓ６：如果ｉ≤ｎ－１，返回Ｓ３。否则打印ｎ“是素数”，然后结束。
实际上，ｎ不必被２到（ｎ－１）的整数除，只需被２到ｎ／２间整数除，甚至只需被２到 之间的整数
除即可。
考点２ 算法的特性
一个算法应该具有以下特点：
有穷性：包含有限的操作步骤。
确定性：算法中的每一个步骤都应当是确定的。
有零个或多个输入：输入是指在执行算法时需要从外界取得必要的信息。
有一个或多个输出：算法的目的是为了求解，“解”就是输出。
有效性：算法中的每一个步骤都应当能有效地执行，并得到确定的结果。
考点３ 算法的表示
２２
可以用不同的方法表示算法，常用的有：
自然语言
传统流程图
结构化流程图
伪代码
ＰＡＤ图
一、用自然语言表示算法
自然语言就是人们日常使用的语言，可以是汉语或英语或其它语言。用自然语言表示通俗易懂，
但文字冗长，容易出现“歧义性”。自然语言表示的含义往往不大严格，要根据上下文才能判断其正确
含义，描述包含分支和循环的算法时也不很方便。因此，除了那些很简单的问题外，一般不用自然语
言描述算法。
二、用流程图表示算法
美国国家标准化协会ＡＮＳＩ规定了一些常用的流程图符号：
例６图
例６ 将求５！的算法用流程图表示
例７ 将例２的算法用流程图表示。打印５０名学生中成绩在８０分以上者
的学号和成绩。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２３
例８ 将例３判定闰年的算法用流程图表示
２４
例９ 将例４的算法用流程图表示
例１０ 将例５判断素数的算法用流程图表示
（图见视频）
用流程图表示算法
总结：流程图是表示算法的较好的工具。一个流程图包括以下几部分：
（１）表示相应操作的框；
（２）带箭头的流程线；
（３）框内外必要的文字说明。
优点：用流程图表示算法要比用文字描述算法逻辑清晰、易于理解。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２５
三、三种基本结构和改进的流程图
１．传统流程图的弊端
传统流程图用流程线指出各框的执行顺序，对流程线的使用没有严格限制。因此，使用者可以毫
不受限制地使流程随意地转向，使流程图变得毫无规律，阅读者要花很大精力去追踪流程，使人难以
理解算法的逻辑。如图：
缺点：难以阅读、修改，使算法的可靠性和可维护性难以保证。
解决办法：必须限制箭头的滥用，即不允许无规律地使流程随意转向，只能顺序地进行下去。
这种如同乱麻一样的算法称为ＢＳ型算法，意为一碗面条（ＡＢｏｗｌｏｆＳｐａｇｈｅｔｔｉ），乱无头绪。
２．三种基本结构
Ｂｏｈｒａ和Ｊａｃｏｐｉｎｉ提出了以下三种基本结构：
顺序结构、选择结构、循环结构
用这三种基本结构作为表示一个良好算法的基本单元。
循环结构
２６
３．三种基本结构的共同特点：
（１）只有一个入口；
（２）只有一个出口；（请注意：一个菱形判断框有两个出口，而一个选择结构只有一个出口。不要
将菱形框的出口和选择结构的出口混淆。）
（３）结构内的每一部分都有机会被执行到；
（４）结构内不存在“死循环”（无终止的循环）。
不正确的流程表示：
总结：
由三种基本结构顺序组成的算法结构，可以解决任何复杂的问题。由基本结构所构成的算法属
于“结构化”的算法，它不存在无规律的转向，只在本基本结构内才允许存在分支和向前或向后的
跳转。
只要具有上述四个特点的都可以作为基本结构。可以自己定义基本结构，并由这些基本结构组
成结构化程序。下图符合基本结构的特点：
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２７
如下是一个多分支选择结构。虚线框内的结构是一个入口一个出口，并且有上述全部的四个特
点。由此构成的算法结构也是结构化的算法。可以认为这是由三种基本结构所派生出来的。
（图见视频）
四、用Ｎ－Ｓ流程图表示算法
１９７３年，美国学者Ｉ．Ｎａｓｓｉ和Ｂ．Ｓｈｎｅｉｄｅｒｍａｎ提出一种新的流程图形式，完全去掉了带箭头的流
程线。全部算法写在一个矩形框内，在该框内还可以包含其它的从属于它的框。这种流程图又称Ｎ
－－Ｓ结构化流程图。
用三种Ｎ－Ｓ流程图中的基本框，可以组成复杂的Ｎ－Ｓ流程图。图中的Ａ框或Ｂ框，可以是一
个简单的操作，也可以是三个基本结构之一。如下图：Ａ框可以是一个选择结构，Ｂ框可以是一个循
环结构。
２８
例１１ 将例１的求５！算法用Ｎ－Ｓ图表示
例１２ 将例２的算法用Ｎ－Ｓ图表示。（打印５０名学生中成绩高于８０分的学号和成绩）
例１３ 将例３判定闰年的算法用Ｎ－Ｓ图表示
例１４ 将例４的算法用Ｎ－Ｓ图表示
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２９
例１５ 将例５判别素数的算法用Ｎ－Ｓ流程图表示
流程图不符合基本结构特点！不能分解为三种基本结构，无法直接用Ｎ－Ｓ流程图的三种基本结
构的符号来表示。因此，应当先作必要的变换。
（图见视频）
用Ｎ－Ｓ流程图表示算法
总结：一个结构化的算法是由一些基本结构顺序组成的。在基本结构之间不存在向前或向后的
跳转，流程的转移只存在于一个基本结构范围之内（如循环中流程的跳转）；一个非结构化的算法可
以用一个等价的结构化算法代替，其功能不变。如果一个算法不能分解为若干个基本结构，则它必然
不是一个结构化的算法。
优点：比文字描述直观、形象、易于理解；比传统流程图紧凑易画。尤其是它废除了流程线，整个
算法结构是由各个基本结构按顺序组成的，Ｎ－－Ｓ流程图中的上下顺序就是执行时的顺序。用Ｎ－
－Ｓ图表示的算法都是结构化的算法，因为它不可能出现流程无规律的跳转，而只能自上而下地顺序
执行。
五、用伪代码表示算法
概念：伪代码是用介于自然语言和计算机语言之间的文字和符号来描述算法。
特点：如同一篇文章一样，自上而下地写下来。每一行（或几行）表示一个基本操作。不用图形
符号，书写方便、格式紧凑，比较好懂，便于向计算机语言算法（即程序）过渡。
用处：适用于设计过程中需要反复修改时的流程描述。
例：“打印ｘ的绝对值”的算法可以用伪代码表示为：
３０
ＩＦｘｉｓｐｏｓｉｔｉｖｅＴＨＥＮ
ｐｒｉｎｔｘ
ＥＬＳＥ
ｐｒｉｎｔ－ｘ
可以用汉字伪代码表示：
若ｘ为正
打印ｘ
否则
打印－ｘ
也可以中英文混用。
例１６ 求５！。用伪代码表示算法
开始
置ｔ的初值为１
置ｉ的初值为２
当ｉ＜＝５，执行下面操作：
使ｔ＝ｔ×ｉ
使ｉ＝ｉ＋１
｛循环体到此结束｝
输出ｔ的值
结束
例１７ 输出５０个学生中成绩高于８０分者的学号和成绩。用伪代码表示算法：
ＢＥＧＩＮ｛算法开始｝
１－＞ｉ
ｗｈｉｌｅｉ≤５０
｛ｉｎｐｕｔ ａｎｄ
ｉ＋１－＞ｉ｝
１－＞ｉ
ｗｈｉｌｅｉ≤５０
｛ｉｆ≥８０ｐｒｉｎｔ ａｎｄ ｉ＋１－＞ｉ｝
ＥＮＤ｛算法结束｝
六、用计算机语言表示算法
概念：用计算机实现算法。计算机是无法识别流程图和伪代码的。只有用计算机语言编写的程
序才能被计算机执行。因此在用流程图或伪代码描述出一个算法后，还要将它转换成计算机语言
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
３１
程序。
特点：用计算机语言表示算法必须严格遵循所用的语言的语法规则，这是和伪代码不同的。
用处：要完成一件工作，包括设计算法和实现算法两个部分。设计算法的目的是为了实现算法。
例２０ 将例１６表示的算法（求５！）用Ｃ语言表示。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｉｎｔｉ，ｔ；
ｔ＝１；
ｉ＝２；
ｗｈｉｌｅ（ｉ＜＝５）
｛ｔ＝ｔＩ；
ｉ＝ｉ＋１；
｝
ｐｒｉｎｔｆ（“％ｄ＼ｎ”，ｔ）；
｝
应当强调说明：
写出了Ｃ程序，仍然只是描述了算法，并未实现算法。只有运行程序才是实现算法。应该说，用
计算机语言表示的算法是计算机能够执行的算法。
考点４ 结构化程序设计方法
一个结构化程序：就是用高级语言表示的结构化算法。用三种基本结构组成的程序必然是结构
化的程序，这种程序便于编写、便于阅读、便于修改和维护。
结构化程序设计强调程序设计风格和程序结构的规范化，提倡清晰的结构。
结构化程序设计方法的基本思路是：把一个复杂问题的求解过程分阶段进行，每个阶段处理的问
题都控制在人们容易理解和处理的范围内。
采取以下方法来保证得到结构化的程序：
自顶向下；
逐步细化；
模块化设计；
结构化编码。
两种不同的方法：
自顶向下，逐步细化；
自下而上，逐步积累。
（图见视频）
３２
用这种方法逐步分解，直到作者认为可以直接将各小段表达为文字语句为止。这种方法就叫做
“自顶向下，逐步细化”。
自顶向下，逐步细化方法的优点：
考虑周全，结构清晰，层次分明，作者容易写，读者容易看。如果发现某一部分中有一段内容不
妥，需要修改，只需找出该部分修改有关段落即可，与其它部分无关。
模块设计的方法：
（１）模块化设计的思想实际上是一种“分而治之”的思想，把一个大任务分为若干个子任务，每一
个子任务就相对简单。
（２）在拿到一个程序模块以后，根据程序模块的功能将它划分为若干个子模块，如果这些子模块
的规模还嫌大，还再可以划分为更小的模块。这个过程采用自顶向下方法来实现。
（３）子模块一般不超过５０行。
（４）划分子模块时应注意模块的独立性，即：使一个模块完成一项功能，耦合性愈少愈好
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
殏
殏
殏
殏
。
本章小结
主要知识点：
程序、算法的概念：运算掌握简单的算法举例
算法的特性：有穷性、确定性、有效性等
算法的表示：用自然语言表示、流程图、Ｎ－Ｓ流程图、伪代码、三种基本结构的流程图及Ｎ－
Ｓ流程图等
结构化程序设计方法：自顶向下、模块化设计等
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
３３
第三章 数据类型、运算符与表达式
本章考点
考点１ Ｃ的数据类型
Ｃ语言提供的数据类型：
指针类型
考点２ 常量与变量
一、常量和符号常量
在程序运行过程中，其值不能被改变的量称为常量。
常量区分为不同的类型：
例１ 符号常量的使用
＃ｄｅｆｉｎｅ
ＰＲＩＣＥ ３０
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
８０
第七章 数组
本章考点
考点１ 一维数组的定义和引用
数组：是一组具有相同数据类型的数据的有序集合。
一、一维数组的定义
１．定义格式为：
类型说明符 数组名［常量表达式］；
例如：ｉｎｔａ［１０］；
表示定义了一个整形数组，数组名为ａ，此数组有１０个元素。
２．说明：
（１）数组名定名规则和变量名相同，遵循标识符定名规则。
（２）在定义数组时，要指定数组中元素的个数，方括弧中的常量表达式用来表示元素的个数，即数
组长度。
例：ａ［１０］，表示ａ数组有１０个元素，注意下标是从０开始的，这１０个元素是ａ［０］，ａ［１］，ａ［２］，ａ
［３］，ａ［４］，ａ［５］，ａ［６］，ａ［７］，ａ［８］，ａ［９］。注意：按上面的定义，不存在数组元素ａ［１０］。
（３）常量表达式中可以包括常量和符号常量，但不能包含变量。即，Ｃ语言不允许对数组的大小
作动态定义，即数组的大小不依赖于程序运行过程中变量的值。例如，下面这样定义数组是不行的：
ｉｎｔｎ；
ｓｃａｎｆ（“％ｄ″，＆ｎ）； ／在程序中临时输入数组的大小／
ｉｎｔａ［ｎ］；
数组说明中其他常见的错误
①ｆｌｏａｔａ［０］；／数组大小为０没有意义／
②ｉｎｔｂ（２）（３）； ／不能使用圆括号／
③ｉｎｔｋ，ａ［ｋ］； ／不能用变量说明数组大小／
３．一维数组在内存中的存放
一维数组：ｆｌｏａｔｍａｒｋ［１００］；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
８１
每个数据元素占用的字节数，就是基类型的字节数。
一个元素占４个字节。
二、一维数组元素的引用
１．数组元素的引用方式：
数组名［下标］
下标可以是整型常量或整型表达式。
例如：ａ［０］＝ａ［５］＋ａ［７］－ａ［２３］
注意：定义数组时用到的“数组名［常量表达式］”和引用数组元素时用到的“数组名［下标］”是
有区别的。
例如∶ｉｎｔａ［１０］； ／定义数组长度为１０／
ｔ＝ａ［６］； ／引用ａ数组中序号为６的元素。此时６不代表数组长度／
２．一维数组元素引用的程序实例
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ，ａ［１０］；
ｆｏｒ（ｉ＝０；ｉ＜＝９；ｉ＋＋）
ａ［ｉ］＝ｉ；
ｆｏｒ（ｉ＝９；ｉ＞＝０；ｉ－－）
ｐｒｉｎｔｆ（＂％ｄ″，ａ［ｉ］）；
ｐｒｉｎｔｆ（＂＼ｎ″）；
｝
运行结果如下：
９８７６５４３２１０
三、一维数组的初始化
１．对数组元素初始化的实现方法：
８２
（１）在定义数组时对数组元素赋以初值。例如：
ｉｎｔａ［１０］＝｛０，１，２，３，４，５，６，７，８，９｝；
将数组元素的初值依次放在一对花括弧内。经过上面的定义和初始化之后：
ａ［０］＝０，ａ［１］＝１，ａ［２］＝２，ａ［３］＝３，ａ［４］＝４，
ａ［５］＝５，ａ［６］＝６，ａ［７］＝７，ａ［８］＝８，ａ［９］＝９
（２）可以只给一部分元素赋值。例如：
ｉｎｔａ［１０］＝｛０，１，２，３，４｝；
定义ａ数组有１０个元素，但花括弧内只提供５个初值，这表示只给前面５个元素赋初值，后５个
元素值为０。
（３）如果想使一个数组中全部元素值为０，可以写成
ｉｎｔ ａ［１０］＝｛０，０，０，０，０，０，０，０，０，０｝；或
ｉｎｔ ａ［１０］＝｛０｝；
不能写成：ｉｎｔａ［１０］＝｛０１０｝；
这是与ＦＯＲＴＲＡＮ语言不同的，不能给数组整体赋初值。
（４）在对全部数组元素赋初值时，由于数据的个数已经确定，因此可以不指定数组长度。例如：
ｉｎｔａ［５］＝｛１，２，３，４，５｝；
或 ｉｎｔａ［］＝｛１，２，３，４，５｝；
在第二种写法中，花括弧中有５个数，系统就会据此自动定义ａ数组的长度为５。但若数组长度
与提供初值的个数不相同，则数组长度不能省略。例如，想定义数组长度为１０，就不能省略数组长度
的定义，而必须写成
ｉｎｔａ［１０］＝｛１，２，３，４，５｝；
只初始化前５个元素，后５个元素为０。
四、一维数组程序举例
举例１：用数组来处理，求解Ｆｉｂｏｎａｃｃｉ数列。
Ｆｉｂｏｎａｃｃｉ数列公式：ａ１＝ａ２＝１，ａｎ＝ａｎ－１＋ａｎ－２
程序实例：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ； ｉｎｔｆ［２０］＝｛１，１｝；
ｆｏｒ（ｉ＝２；ｉ＜２０；ｉ＋＋）
ｆ［ｉ］＝ｆ［ｉ－２］＋ｆ［ｉ－１］；
ｆｏｒ（ｉ＝０；ｉ＜２０；ｉ＋＋）
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
８３
｛
ｉｆ（ｉ％５＝＝０）ｐｒｉｎｔｆ（″＼ｎ″）；
ｐｒｉｎｔｆ（″％１２ｄ″，ｆ［ｉ］）
｝／Ｆｏｒ循环结束／
｝ ／程序结束／
举例２：用起泡法对１０个数排序（由小到大）。
起泡法的思路是：将相邻两个数比较，将小的调到前头
注意：经过第一趟（共５次比较与交换）后，最大的数９已“沉底”。然后进行对余下的前面５个
数第二趟比较。
注意：经过第二趟（共４次比较与交换）后，得到次大的数８。
如果有ｎ个数，则要进行ｎ－１趟比较。在第１趟比较中要进行ｎ－１次两两比较，在第ｊ趟比较
中要进行ｎ－ｊ次两两比较。
程序流程图如下：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
８４
ｉｎｔａ［１０］；
ｉｎｔｉ，ｊ，ｔ；
ｐｒｉｎｔｆ（″ｉｎｐｕｔ１０ｎｕｍｂｅｒｓ：＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
ｓｃａｎｆ（＂％ｄ＂，＆ａ［ｉ］）；
ｐｒｉｎｔｆ（＂＼ｎ＂）；
ｆｏｒ（ｊ＝０；ｊ＜９；ｊ＋＋）
ｆｏｒ（ｉ＝０；ｉ＜９－ｊ；ｉ＋＋）
ｉｆ（ａ［ｉ］＞ａ［ｉ＋１］）
｛
ｔ＝ａ［ｉ］；ａ［ｉ］＝ａ［ｉ＋１］；
ａ［ｉ＋１］＝ｔ；
｝
ｐｒｉｎｔｆ（″ｔｈｅｓｏｒｔｅｄｎｕｍｂｅｒｓ：＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｄ″，ａ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
程序运行结果如下：
ｉｎｐｕｔ１０ｎｕｍｂｅｒｓ：
１０４８１２６５－７６１００－４５１２３G21
ｔｈｅｓｏｒｔｅｄｎｕｍｂｅｒｓ：
－７６－４５０１４８１２６５１００１２３
考点２ 二维数组的定义和引用
一、二维数组的定义
二维数组定义的一般形式为
类型说明符数组名［常量表达式］［常量表达式］；
例：定义ａ为３×４（３行４列）的数组，ｂ为５×１０（５行１０列）的数组。如下：
ｆｌｏａｔａ［３］［４］，ｂ［５］［１０］；
不能写成
ｆｌｏａｔａ［３，４］，ｂ［５，１０］；
注意：可以把二维数组看作是一种特殊的一维数组：它的元素又是一个一维数组。
例如：可以把ａ看作是一个一维数组，它有３个元素：ａ［０］、ａ［１］、ａ［２］，每个元素又是一个包含４
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
８５
个元素的一维数组。
二维数组在内存中的存放
二维数组中的元素在内存中的排列顺序是：按行存放，即先顺序存放第一行的元素，再存放第二
行的元素…
下图表示对ａ［３］［４］数组存放的顺序
例：整型数组ｂ［３］［３］＝｛｛１，２，３｝，｛４，５，６｝，｛７，８，９｝｝；
问题：有了二维数组的基础，那么多维数组如何定义呢？
定义三维数组： ｆｌｏａｔａ［２］［３］［４］；
多维数组元素在内存中的排列顺序：第一维的下标变化最慢，最右边的下标变化最快。
二、二维数组的引用
二维数组元素的表示形式为：
数组名［下标］［下标］
８６
例如：ａ［２］［３］
下标可以是整型表达式，如ａ［２－１］［２２－１］
注意：不要写成ａ［２，３］，ａ［２－１，２２－１］形式
数组元素可以出现在表达式中，也可以被赋值，例如：ｂ［１］［２］＝ａ［２］［３］／２
在使用数组元素时，应该注意下标值应在已定义的数组大小的范围内。
常出现的错误有：
ｉｎｔａ［３］［４］； ／定义ａ为３×４的数组／
┆
ａ［３］［４］＝３；
三、二维数组的初始化
数据类型数组名［常量表达式１］［常量表达式２］＝｛初始化数据｝；
可以用下面４种方法对二维数组初始化
（１）分行给二维数组赋初值。如：
ｉｎｔａ［３］［４］＝｛｛１，２，３，４｝，｛５，６，７，８｝，｛９，１０，１１，１２｝｝；
（２）可以将所有数据写在一个花括弧内，按数组排列的顺序对各元素赋初值。如：
ｉｎｔａ［３］［４］＝｛１，２，３，４，５，６，７，８，９，１０，１１，１２｝；
（３）可以对部分元素赋初值。如
ｉｎｔａ［３］［４］＝｛｛１｝，｛５｝，｛９｝｝；
１ ０ ０ ０
５ ０ ０ ０
９ ０ ０ ０
也可以对各行中的某一元素赋初值，如
ｉｎｔａ［３］［４］＝｛｛１｝，｛０，６｝，｛０，０，０，１１｝｝；
１ ０ ０ ０
０ ６ ０ ０
０ ０ ０ １１
也可以只对某几行元素赋初值。如
ｉｎｔａ［３］［４］＝｛｛１｝，｛５，６｝｝；
１ ０ ０ ０
５ ６ ０ ０
０ ０ ０ ０
（４）如果对全部元素都赋初值，则定义数组时对第一维的长度可以不指定，但第二维的长度不能
省。如：
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
８７
ｉｎｔａ［３］［４］＝｛１，２，３，４，５，６，７，８，９，１０，１１，１２｝；
等价于：
ｉｎｔａ［］［４］＝｛１，２，３，４，５，６，７，８，９，１０，１１，１２｝；
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。如：
ｉｎｔａ［］［４］＝｛｛０，０，３｝，｛｝，｛０，１０｝｝；
０ ０ ３ ０
０ ０ ０ ０
０ １０ ０ ０
四、二维数组程序举例
例４ 将一个二维数组行和列元素互换，存到另一个二维数组中。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔａ［２］［３］＝｛｛１，２，３｝，｛４，５，６｝｝；
ｉｎｔｂ［３］［２］，ｉ，ｊ；
ｐｒｉｎｔｆ（″ａｒｒａｙａ：＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜＝１；ｉ＋＋）
｛
ｆｏｒ（ｊ＝０；ｊ＜＝２；ｊ＋＋）
｛ ｐｒｉｎｔｆ（″％５ｄ″，ａ［ｉ］［ｊ］）；
ｂ［ｊ］［ｉ］＝ａ［ｉ］［ｊ］；
｝
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
ｐｒｉｎｔｆ（″ａｒｒａｙｂ：＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜＝２；ｉ＋＋）
｛
ｆｏｒ（ｊ＝０；ｊ＜＝１；ｊ＋＋）
ｐｒｉｎｔｆ（＂％５ｄ″，ｂ［ｉ］［ｊ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
｝／程序结束／
运行结果如下：
８８
ａｒｒａｙａ：
１ ２ ３
４ ５ ６
ａｒｒａｙｂ：
１ ４
２ ５
３ ６
例５ 有一个３×４的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号和
列号。
用Ｎ－Ｓ流程图表示算法，如下：
程序如下：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｉｎｔｉ，ｊ，ｒｏｗ＝０，ｃｏｌｕｍ＝０，ｍａｘ；
ｉｎｔａ［３］［４］＝｛｛１，２，３，４｝，｛９，８，７，６｝，
｛－１０，１０，－５，２｝｝；
ｍａｘ＝ａ［０］［０］；
ｆｏｒ（ｉ＝０；ｉ＜＝２；ｉ＋＋）
ｆｏｒ（ｊ＝０；ｊ＜＝３；ｊ＋＋）
ｉｆ（ａ［ｉ］［ｊ］＞ｍａｘ）
｛ｍａｘ＝ａ［ｉ］［ｊ］；
ｒｏｗ＝ｉ；
ｃｏｌｕｍ＝ｊ；
｝
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
８９
ｐｒｉｎｔｆ（″ｍａｘ＝％ｄ，ｒｏｗ＝％ｄ，ｃｏｌｕｍ＝％ｄ＼ｎ″，
ｍａｘ，ｒｏｗ，ｃｏｌｕｍ）；
｝／程序结束／
考点３ 字符数组
一、字符数组的定义
定义方法与前面介绍的类似。例如：
ｃｈａｒｃ［１０］；
ｃ［０］＝′Ｉ′；ｃ［１］＝′′；ｃ［２］＝′ａ′；
ｃ［３］＝′ｍ′；ｃ［４］＝′′；ｃ［５］＝′ｈ′；ｃ［６］＝′ａ′；
ｃ［７］＝′ｐ′；ｃ［８］＝′ｐ′；ｃ［９］＝′ｙ′；
用来存放字符数据的数组是字符数组。字符数组中的一个元素存放一个字符。
二、字符数组的初始化
对字符数组初始化，最容易理解的方式是逐个字符赋给数组中各元素。如：
ｃｈａｒｃ［１０］＝｛’Ｉ′，’′，’ａ′，’ｍ′，’’，′ｈ′，′ａ′，′ｐ′，′ｐ′，′ｙ′｝；
如果在定义字符数组时不进行初始化，则数组中各元素的值是不可预料的。
如果花括弧中提供的初值个数（即字符个数）大于数组长度，则按语法错误处理。
如果初值个数小于数组长度，则只将这些字符赋给数组中前面那些元素，其余的元素自动定为空
字符（即′＼０′）。
例如：
ｃｈａｒｃ［１０］＝｛′ｃ′，′′，′ｐ′，′ｒ′，′ｏ′，′ｇ′，′ｒ′，′ａ′，′ｍ′｝；
（图见视频）
如果提供的初值个数与预定的数组长度相同，在定义时可以省略数组长度，系统会自动根据初值
个数确定数组长度。
例如：
ｃｈａｒｃ［］＝｛′Ｉ′，′′，′ａ′，′ｍ′，′′，′ｈ′，′ａ′，′ｐ′，′ｐ′，′ｙ′｝；数组ｃ的长度自动定为１０。
也可以定义和初始化一个二维字符数组。
例如：
１０６
二、函数调用的方式
按函数在程序中出现的位置来分，可以有以下三种函数调用方式：
１．函数语句
把函数调用作为一个语句。如例１中的ｐｒｉｎｔｓｔａｒ（），这时不要求函数带回值，只要求函数完成一
定的操作。
２．函数表达式
函数出现在一个表达式中，这种表达式称为函数表达式。这时要求函数带回一个确定的值以参
加表达式的运算。例如：ｃ＝２ｍａｘ（ａ，ｂ）；
３．函数参数
函数调用作为一个函数的实参。例如：
ｍ＝ｍａｘ（ａ，ｍａｘ（ｂ，ｃ））；
其中ｍａｘ（ｂ，ｃ）是一次函数调用，它的值作为ｍａｘ另一次调用的实参。ｍ的值是ａ、ｂ、ｃ三者中
的最大者。又如： ｐｒｉｎｔｆ（＂％ｄ＂，ｍａｘ（ａ，ｂ））；也是把ｍａｘ（ａ，ｂ）作为ｐｒｉｎｔｆ函数的一个参数。
函数调用作为函数的参数，实质上也是函数表达式形式调用的一种，因为函数的参数本来就要求
是表达式形式。
三、对被调用函数的声明和函数原型
在一个函数中调用另一函数（即被调用函数）需要具备哪些条件呢 ？
（１）首先被调用的函数必须是已经存在的函数（是库函数或用户自己定义的函数）。但光有这一
条件还不够。
（２）如果使用库函数，还应该在本文件开头用＃ｉｎｃｌｕｄｅ命令将调用有关库函数时所需用到的信息
“包含”到本文件中来。
（３）如果使用用户自己定义的函数，而该函数的位置在调用它的函数（即主调函数）的后面（在同
一个文件中），应该在主调函数中对被调用的函数作声明。
函数原型的一般形式为
（１）函数类型函数名（参数类型１，参数类型２……）；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１０７
（２）函数类型函数名（参数类型１参数名１，参数类型２参数名２，……）；
声明的作用是把函数名、函数参数的个数和参数类型等信息通知编译系统，以便在遇到函数调用
时，编译系统能正确识别函数并检查调用是否合法。（例如函数名是否正确，实参与形参的类型和个
数是否一致）。
注意：函数的“定义”和“声明”不是一回事。函数的定义是指对函数功能的确立，包括指定函数
名，函数值类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。而函数的声明的作用
则是把函数的名字、函数类型以及形参的类型、个数和顺序通知编译系统，以便在调用该函数时系统
按此进行对照检查。
例５ 对被调用的函数作声明
ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ ｆｌｏａｔ ａｄｄ（ｆｌｏａｔｘ，ｆｌｏａｔｙ）；
／对被调用函数ａｄｄ的声明／
ｆｌｏａｔ ａ，ｂ，ｃ；
ｓｃａｎｆ（＂％ｆ，％ｆ＂，＆ａ，＆ｂ）；
ｃ＝ａｄｄ（ａ，ｂ）；
ｐｒｉｎｔｆ（＂ｓｕｍｉｓ％ｆ ＼ｎ＂，ｃ）；
｝
ｆｌｏａｔａｄｄ（ｆｌｏａｔｘ，ｆｌｏａｔｙ） ／函数首部／
｛ ｆｌｏａｔｚ； ／ 函数体／
ｚ＝ｘ＋ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
如果被调用函数的定义出现在主调函数之前，可以不必加以声明。因为编译系统已经先知道了
已定义函数的有关情况，会根据函数首部提供的信息对函数的调用作正确性检查。
改写例５
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｆｌｏａｔａｄｄ（ｆｌｏａｔｘ，ｆｌｏａｔｙ）
／函数首部／
｛ ｆｌｏａｔ ｚ； ／ 函数体／
ｚ＝ｘ＋ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
１０８
ｖｏｉｄｍａｉｎ（）
｛
ｆｌｏａｔ ａ，ｂ，ｃ；
ｓｃａｎｆ（＂％ｆ，％ｆ＂，＆ａ，＆ｂ）；
ｃ＝ａｄｄ（ａ，ｂ）；
ｐｒｉｎｔｆ（＂ｓｕｍｉｓ％ｆ ＼ｎ＂，ｃ）；
｝
考点５ 函数的嵌套调用
嵌套定义就是在定义一个函数时，其函数体内又包含另一个函数的完整定义。
Ｃ语言不能嵌套定义函数，但可以嵌套调用函数，也就是说，在调用一个函数的过程中，又调用另
一个函数。
例６ 用弦截法求方程ｆ（ｘ）＝ｘ３－５ｘ２＋１６ｘ－８０＝０的根
方法：
（１）取两个不同点ｘ１，ｘ２，如果ｆ（ｘ１）和ｆ（ｘ２）符号相反，则（ｘ１，ｘ２）区间内必有一个根。如果ｆ
（ｘ１）与ｆ（ｘ２）同符号，则应改变ｘ１，ｘ２，直到ｆ（ｘ１）、ｆ（ｘ２）异号为止。注意ｘ１、ｘ２的值不应差太大，以
保证（ｘ１，ｘ２）区间内只有一个根。
（２）连接（ｘ１，ｆ（ｘ１））和（ｘ２，ｆ（ｘ２））两点，此线（即弦）交ｘ轴于ｘ。
（３）若ｆ（ｘ）与ｆ（ｘ１）同符号，则根必在（ｘ，ｘ２）区间内，此时将ｘ作为新的ｘ１。如果ｆ（ｘ）与ｆ（ｘ２）
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１０９
同符号，则表示根在（ｘ１，ｘ）区间内，将ｘ作为新的ｘ２。
（４）重复步骤（２）和（３），直到｜ｆ（ｘ）｜＜ε为止，ε为一个很小的数，例如１０－６．此时认为ｆ
（ｘ）≈０
Ｎ－Ｓ流程图
（图见视频）
分别用几个函数来实现各部分功能：
（１）用函数ｆ（ｘ）代表ｘ的函数：ｘ３－５ｘ２＋１６ｘ－８０．
（２）用函数调用ｘｐｏｉｎｔ（ｘ１，ｘ２）来求（ｘ１，ｆ（ｘ１））和（ｘ２，ｆ（ｘ２））的连线与ｘ轴的交点ｘ的坐标。
（３）用函数调用ｒｏｏｔ（ｘ１，ｘ２）来求（ｘ１，ｘ２）区间的那个实根。显然，执行ｒｏｏｔ函数过程中要用到函
数ｘｐｏｉｎｔ，而执行ｘｐｏｉｎｔ函数过程中要用到ｆ函数。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｉｎｃｌｕｄｅ＜ｍａｔｈ．ｈ＞
ｆｌｏａｔｆ（ｆｌｏａｔｘ）
／定义ｆ函数，以实现ｆ（ｘ）＝ｘ３－５ｘ２＋１６ｘ－８０／
｛
ｆｌｏａｔｙ；
ｙ＝（（ｘ－５．０）ｘ＋１６．０）ｘ－８０．０；
ｒｅｔｕｒｎ（ｙ）；
｝
ｆｌｏａｔｘｐｏｉｎｔ（ｆｌｏａｔｘ１，ｆｌｏａｔｘ２）
／定义ｘｐｏｉｎｔ函数，求出弦与ｘ轴交点／
｛
ｆｌｏａｔｙ；
ｙ＝（ｘ１ｆ（ｘ２）－ｘ２ｆ（ｘ１））／
（ｆ（ｘ２）－ｆ（ｘ１））；
ｒｅｔｕｒｎ（ｙ）；
｝
ｆｌｏａｔｒｏｏｔ（ｆｌｏａｔｘ１，ｆｌｏａｔｘ２）
／定义ｒｏｏｔ函数，求近似根／
｛
ｆｌｏａｔｘ，ｙ，ｙ１；
ｙ１＝ｆ（ｘ１）；
ｄｏ｛
１１０
ｘ＝ｘｐｏｉｎｔ（ｘ１，ｘ２）；
ｙ＝ｆ（ｘ）；
ｉｆ（ｙｙ１＞０）
｛ｙ１＝ｙ；ｘ１＝ｘ；｝
ｅｌｓｅ｛ｙ２＝ｙ；ｘ２＝ｘ；｝
｝ｗｈｉｌｅ（ｆａｂｓ（ｙ）＞＝０．０００１）；
ｒｅｔｕｒｎ（ｘ）；
｝
ｖｏｉｄｍａｉｎ（）／主函数／
｛
ｆｌｏａｔ ｘ１，ｘ２，ｆ１，ｆ２，ｘ；
ｄｏ｛
ｐｒｉｎｔｆ（＂ｉｎｐｕｔｘ１，ｘ２：＼ｎ＂）；
ｓｃａｎｆ（＂％ｆ，％ｆ＂，＆ｘ１，＆ｘ２）；
ｆ１＝ｆ（ｘ１）；
ｆ２＝ｆ（ｘ２）；
｝ｗｈｉｌｅ（ｆ１ｆ２＞＝０）；
ｘ＝ｒｏｏｔ（ｘ１，ｘ２）；
ｐｒｉｎｔｆ（＂Ａｒｏｏｔｏｆｅｑｕａｔｉｏｎｉｓ ％８．４ｆ＼ｎ＂，ｘ）；
｝
考点６ 函数的递归调用
在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。Ｃ语言
的特点之一就在于允许函数的递归调用。例如：
ｉｎｔｆ（ｉｎｔｘ）
｛
ｉｎｔｙ，ｚ；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１１
ｚ＝ｆ（ｙ）；
ｒｅｔｕｒｎ（２ｚ）；
｝
例７ 有５个人坐在一起，问第５个人多少岁？他说比第４个人大２岁。问第４个人岁数，他说
比第３个人大２岁。问第３个人，又说比第２个人大２岁。问第２个人，说比第１个人大２岁。最后
问第１个人，他说是１０岁。请问第５个人多大。
ａｇｅ（５）＝ａｇｅ（４）＋２
ａｇｅ（４）＝ａｇｅ（３）＋２
ａｇｅ（３）＝ａｇｅ（２）＋２
ａｇｅ（２）＝ａｇｅ（１）＋２
ａｇｅ（１）＝１０
可以用数学公式表述如下：
ａｇｅ（ｎ）＝１０ （ｎ＝１）
ａｇｅ（ｎ－１）＋２ （ｎ＞１）
可以用一个函数来描述上述递归过程：
ｉｎｔａｇｅ（ｉｎｔｎ） ／求年龄的递归函数／
｛ ｉｎｔｃ；／ｃ用作存放函数的返回值的变量／
ｉｆ（ｎ＝＝１）ｃ＝１０；
ｅｌｓｅｃ＝ａｇｅ（ｎ－１）＋２；
ｒｅｔｕｒｎ（ｃ）；
｝
用一个主函数调用ａｇｅ函数，求得第５人的年龄。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｐｒｉｎｔｆ（″％ｄ″，ａｇｅ（５））；
｝
例８ 用递归方法求ｎ！
求ｎ！也可以用递归方法，即５！等于４！×５，而４！＝３！×４…１！＝１。
可用下面的递归公式表示：
ｎ！＝１ （ｎ＝０，１）
ｎ·（ｎ－１）！ （ｎ＞１）
例９ Ｈａｎｏｉ（汉诺）塔问题。这是一个古典的数学问题，是一个用递归方法解题的典型例子。问
１１２
题是这样的：古代有一个梵塔，塔内有３个座Ａ、Ｂ、Ｃ，开始时Ａ座上有６４个盘子，盘子大小不等，大的
在下，小的在上。现在想把这６４个盘子从Ａ座移到Ｃ座，但每次只允许移动一个盘，且在移动过程中
在３个座上都始终保持大盘在下，小盘在上。在移动过程中可以利用Ｂ座，要求编程序打印出移动的
步骤。
为便于理解，先分析将Ａ座上３个盘子移到Ｃ座上的过程：
（１）将Ａ座上２个盘子移到Ｂ座上（借助Ｃ）；
（２）将Ａ座上１个盘子移到Ｃ座上；
（３）将Ｂ座上２个盘子移到Ｃ座上（借助Ａ）。
其中第（２）步可以直接实现。第１步又可用递归方法分解为：
１．１将Ａ上１个盘子从Ａ移到Ｃ；
１．２将Ａ上１个盘子从Ａ移到Ｂ；
１．３将Ｃ上１个盘子从Ｃ移到Ｂ。
由上面的分析可知：将ｎ个盘子从Ａ座移到Ｃ座可以分解为以下３个步骤：
（１）将Ａ上ｎ－１个盘借助Ｃ座先移到Ｂ座上。
（２）把Ａ座上剩下的一个盘移到Ｃ座上。
（３）将ｎ－１个盘从Ｂ座借助于Ａ座移到Ｃ座上。
程序如下：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛
ｖｏｉｄｈａｎｏｉ（ｉｎｔｎ，ｃｈａｒｏｎｅ，ｃｈａｒｔｗｏ，ｃｈａｒｔｈｒｅｅ）；
／对ｈａｎｏｉ函数的声明／
ｉｎｔｍ；
ｐｒｉｎｔｆ（＂ｉｎｐｕｔｔｈｅｎｕｍｂｅｒｏｆｄｉｓｋｅｓ：＂）；
ｓｃａｎｆ（“％ｄ”，＆ｍ）；
ｐｒｉｎｔｆ（＂Ｔｈｅｓｔｅｐｔｏｍｏｖｅｉｎｇ％ｄｄｉｓｋｅｓ：＼ｎ＂，ｍ）；
ｈａｎｏｉ（ｍ，＇Ａ＇，＇Ｂ＇，＇Ｃ＇）；
｝
ｖｏｉｄｈａｎｏｉ（ｉｎｔｎ，ｃｈａｒｏｎｅ，ｃｈａｒｔｗｏ，ｃｈａｒｔｈｒｅｅ）
／定义ｈａｎｏｉ函数，将ｎ个盘从ｏｎｅ座借助ｔｗｏ座，移到ｔｈｒｅｅ座／
｛
ｖｏｉｄｍｏｖｅ（ｃｈａｒｘ，ｃｈａｒｙ）； ／对ｍｏｖｅ函数的声明／
ｉｆ（ｎ＝＝１）ｍｏｖｅ（ｏｎｅ，ｔｈｒｅｅ）；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１３
ｅｌｓｅ
｛ ｈａｎｏｉ（ｎ－１，ｏｎｅ，ｔｈｒｅｅ，ｔｗｏ）；
ｍｏｖｅ（ｏｎｅ，ｔｈｒｅｅ）；
ｈａｎｏｉ（ｎ－１，ｔｗｏ，ｏｎｅ，ｔｈｒｅｅ）；
｝
｝
ｖｏｉｄｍｏｖｅ（ｃｈａｒｘ，ｃｈａｒｙ） ／定义ｍｏｖｅ函数／
｛
ｐｒｉｎｔｆ（“％ｃ－－＞％ｃ＼ｎ＂，ｘ，ｙ）；
｝
运行情况如下：
ｉｎｐｕｔｔｈｅｎｕｍｂｅｒｏｆｄｉｓｋｅｓ：３G21
Ｔｈｅｓｔｅｐｓｔｏｎｏｖｉｎｇ３ｄｉｓｋｅｓ：
Ａ－－＞Ｃ
Ａ－－＞Ｂ
Ｃ－－＞Ｂ
Ａ－－＞Ｃ
Ｂ－－＞Ａ
Ｂ－－＞Ｃ
Ａ－－＞Ｃ
考点７ 数组作为函数参数
一、数组元素作函数实参
由于实参可以是表达式，而数组元素可以是表达式的组成部分，因此数组元素当然可以作为函数
的实参，与用变量作实参一样，是单向传递，即“值传送”方式。
例１０有两个数组ａ和ｂ，各有１０个元素，将它们对应地逐个相比（即ａ［０］与ｂ［０］比，ａ［１］与ｂ
［１］比等）。如果ａ数组中的元素大于ｂ数组中的相应元素的数目多于ｂ数组中元素大于ａ数组中相
应元素的数目（例如ａ［ｉ］＞ｂ［ｉ］６次，ｂ［ｉ］＞ａ［ｉ］３次，其中ｉ每次为不同的值），则认为ａ数组大于ｂ
数组，并分别统计出两个数组相应元素大于、等于、小于的次数。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ ｉｎｔｌａｒｇｅ（ｉｎｔｘ，ｉｎｔｙ）； ／ 函数声明／
ｉｎｔａ［１０］，ｂ［１０］，ｉ，ｎ＝０，ｍ＝０，ｋ＝０；
ｐｒｉｎｔｆ（″ｅｎｔｅｒａｒｒａｙａ∶＼ｎ″）；
１１４
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋＝）
ｓｃａｎｆ（″％ｄ″，＆ａ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
ｐｒｉｎｔｆ（″ｅｎｔｅｒａｒｒａｙｂ∶＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋＝）
ｓｃａｎｆ（″％ｄ″，＆ｂ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
｛ ｉｆ（ｌａｒｇｅ（ａ［ｉ］，ｂ［ｉ］）＝＝１） ｎ＝ｎ＋１；
ｅｌｓｅｉｆ（ｌａｒｇｅ（ａ［ｉ］，ｂ［ｉ］）＝＝０）ｍ＝ｍ＋１；
ｅｌｓｅｋ＝ｋ＋１；
｝
ｐｒｉｎｔｆ（＂ａ［ｉ］＞ｂ［ｉ］％ｄｔｉｍｅｓ＼ｎａ［ｉ］＝ｂ［ｉ］％ｄ
ｔｉｍｅｓ＼ｎａ［ｉ］＜ｂ［ｉ］％ｄｔｉｍｅｓ＼ｎ＂，ｎ，ｍ，ｋ）；
ｉｆ（ｎ＞ｋ）ｐｒｉｎｔｆ（＂ａｒｒａｙａｉｓｌａｒｇｅｒｔｈａｎａｒｒａｙｂ＼ｎ＂）；
ｅｌｓｅｉｆ（ｎ＜ｋ）ｐｒｉｎｔｆ（＂ａｒｒａｙａｉｓｓｍａｌｌｅｒｔｈａｎａｒｒａｙｂ＼ｎ＂）；
ｅｌｓｅ ｐｒｉｎｔｆ（＂ａｒｒａｙａｉｓｅｑｕａｌｔｏａｒｒａｙｂ＼ｎ＂）；
｝
ｌａｒｇｅ（ｉｎｔｘ，ｉｎｔｙ）
｛ ｉｎｔｆｌａｇ；
ｉｆ（ｘ＞ｙ）ｆｌａｇｅ＝１；
ｅｌｓｅｉｆ（ｘ＜ｙ）ｆｌａｇ＝－１；
ｅｌｓｅｆｌａｇ＝０；
ｒｅｔｕｒｎ（ｆｌａｇ）；
｝
运行情况如下：
ｅｎｔｅｒａｒｒａｙａ：
１３５７９８６４２０G21
ｅｎｔｅｒａｒｒａｙｂ：
５ ３ ８ ９G22１G22３ ５ ６ ０ ４G21
ａ［ｉ］＞ｂ［ｉ］４ｔｉｍｅｓ
ａ［ｉ］＝ｂ［ｉ］１ｔｉｍｅｓ
ａ［ｉ］＜ｂ［ｉ］５ｔｉｍｅｓ
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１５
ａｒｒａｙａｉｓｓｍａｌｌｅｒｔｈａｎｎａｒｒａｙｂ
二、数组名作函数参数
可以用数组名作函数参数，此时形参应当用数组名或用指针变量。
例１１有一维数组ｓｃｏｒｅ，内放１０个学生成绩，求平均成绩。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｆｌｏａｔ ａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［１０］）；
／函数声明／
ｆｌｏａｔｓｃｏｒｅ［１０］，ａｖｅｒ；
ｉｎｔｉ；
ｐｒｉｎｔｆ（″ｉｎｐｕｔ１０ｓｃｏｒｅｓ：＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋＝
ｓｃａｎｆ（″％ｆ″，＆ｓｃｏｒｅ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
ａｖｅｒ＝ａｖｅｒａｇｅ（ｓｃｏｒｅ）；
ｐｒｉｎｔｆ（″ａｖｅｒａｇｅｓｃｏｒｅｉｓ％５．２ｆ＼ｎ″，ａｖｅｒ）；
｝
ｆｌｏａｔ ａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［１０］）
｛ｉｎｔｉ；
ｆｌｏａｔ ａｖｅｒ，ｓｕｍ＝ａｒｒａｙ［０］；
ｆｏｒ （ｉ＝１；ｉ＜１０；ｉ＋＋）
ｓｕｍ＝ｓｕｍ＋ａｒｒａｙ［ｉ］；
ａｖｅｒ＝ｓｕｍ／１０；
ｒｅｔｕｒｎ（ａｖｅｒ）；
｝
运行情况如下：
ｉｎｐｕｔ１０ｓｃｏｒｅｓ：
１００５６７８９８．５７６８７９９６７．５７５９７G21
ａｖｅｒａｇｅｓｃｏｒｅｉｓ８３．４０
例１２ 形参数组不定义长度
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ ｆｌｏａｔ ａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［］，ｉｎｔｎ）
１１６
ｆｌｏａｔ ｓｃｏｒｅ＿１［５］＝｛９８．５，９７，９１．５，６０，５５｝；
ｆｌｏａｔｓｃｏｒｅ＿２［１０］＝｛６７．５，８９．５，９９，６９．５，
７７，８９．５，７６．５，５４，６０，９９．５｝；
ｐｒｉｎｔｆ（“ｔｈｅａｖｅｒａｇｅｏｆｃｌａｓｓＡｉｓ％６．２ｆ＼ｎ”，
ａｖｅｒａｇｅ（ｓｃｏｒｅ＿１，５））；
ｐｒｉｎｔｆ（“ｔｈｅａｖｅｒａｇｅｏｆｃｌａｓｓＢｉｓ％６．２ｆ＼ｎ”，
ａｖｅｒａｇｅ（ｓｃｏｒｅ＿２，１０））；
｝
ｆｌｏａｔ ａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［］，ｉｎｔｎ）
｛ ｉｎｔｉ；
ｆｌｏａｔ ａｖｅｒ，ｓｕｍ＝ａｒｒａｙ［０］；
ｆｏｒ（ｉ＝１；ｉ＜ｎ；ｉ＋＋＝
ｓｕｍ＝ｓｕｍ＋ａｒｒａｙ［ｉ］；
ａｖｅｒ＝ｓｕｍ／ｎ；
ｒｅｔｕｒｎ（ａｖｅｒ）；
｝
运行结果如下：
ｔｈｅａｖｅｒａｇｅｏｆｃｌａｓｓＡｉｓ８０．４０
ＴｈｅａｖｅｒａｇｅｏｆｃｌａｓｓＢｉｓ ７８．２０
例１３ 用选择法对数组中１０个整数按由小到大排序。所谓选择法就是先将１０个数中最小的数
与ａ［０］对换；再将ａ［１］到ａ［９］中最小的数与ａ［１］对换……每比较一轮，找出一个未经排序的数中
最小的一个。共比较９轮。
ａ［０］ ａ［１］ ａ［２］ ａ［３］ ａ［４］
３ ６ １ ９ ４未排序时的情况
１ ６ ３ ９ ４
将５个数中最小的数１与ａ［０］对换
１ ３ ６ ９ ４
将余下的４个数中最小的数３与ａ［１］对换
１ ３ ４ ９ ６
将余下的３个数中最小的数４与ａ［２］对换
１ ３ ４ ６ ９
将余下的２个数中最小的数６与ａ［３］对换，
至此完成排序
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１７
程序实例
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ ｖｏｉｄ ｓｏｒｔ（ｉｎｔａｒｒａｙ［］，ｉｎｔｎ）；
ｉｎｔａ［１０］，ｉ；
ｐｒｉｎｔｆ（″ｅｎｔｅｒ ｔｈｅ ａｒｒａｙ＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
ｓｃａｎｆ（″％ｄ″，＆ａ［ｉ］）；
ｓｏｒｔ（ａ，１０）；
ｐｒｉｎｔｆ（″ｔｈｅ ｓｏｒｔｅｄａｒｒａｙ∶＼ｎ″）；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｄ″，ａ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
ｖｏｉｄ ｓｏｒｔ（ｉｎｔａｒｒａｙ［］，ｉｎｔｎ）
｛ ｉｎｔｉ，ｊ，ｋ，ｔ；
ｆｏｒ（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋）
｛ ｋ＝ｉ；
ｆｏｒ（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋）
ｉｆ（ａｒｒａｙ［ｊ］＜ａｒｒａｙ［ｋ］）ｋ＝ｊ；
ｔ＝ａｒｒａｙ［ｋ］；
ａｒｒａｙ［ｋ］＝ａｒｒａｙ［ｉ］；ａｒｒａｙ［ｉ］＝ｔ；
｝
｝
三、多维数组名作函数参数
１４．程序如下：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｍａｘ＿ｖａｌｕｅ（ｉｎｔａｒｒａｙ［］［４］）；
ｉｎｔａ［３］［４］＝｛｛１，３，５，７｝，｛２，４，６，８｝，｛１５，１７，３４，１２｝｝；
ｐｒｉｎｔｆ（″ｍａｘｖａｌｕｅｉｓ％ｄ＼ｎ″，
ｍａｘ＿ｖａｌｕｅ（ａ））；
｝
１１８
ｍａｘ＿ｖａｌｕｅ（ ｉｎｔａｒｒａｙ［］［４］）
｛ ｉｎｔｉ，ｊ，ｋ，ｍａｘ；
ｍａｘ＝ａｒｒａｙ［０］［０］；
ｆｏｒ（ｉ＝０；ｉ＜３；ｉ＋＋）
ｆｏｒ（ｊ＝０；ｊ＜４；ｊ＋＋＝
ｉｆ（ａｒｒａｙ［ｉ］［ｊ］＞ｍａｘ）
ｍａｘ＝ａｒｒａｙ［ｉ］［ｊ］；
ｒｅｔｕｒｎ（ｍａｘ）；
｝
运行结果如下：
Ｍａｘｖａｌｕｅｉｓ３４
考点８ 局部变量和全局变量
一、局部变量
在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才
能使用它们，在此函数以外是不能使用这些变量的。这称为“局部变量”。
ｆｌｏａｔｆ１（ｉｎｔａ） ／函数ｆ１／
｛ｉｎｔｂ，ｃ；
… ａ、ｂ、ｃ有效
｝
ｃｈａｒｆ２（ｉｎｔｘ，ｉｎｔｙ） ／函数ｆ２／
｛ｉｎｔｉ，ｊ； ｘ、ｙ、ｉ、ｊ有效
｝
ｖｏｉｄｍａｉｎ（） ／主函数／
｛ｉｎｔｍ，ｎ；
… ｍ、ｎ有效
｝
说明：
（１）主函数中定义的变量（ｍ，ｎ）也只在主函数中有效，而不因为在主函数中定义而在整个文件或
程序中有效。主函数也不能使用其他函数中定义的变量。
（２）不同函数中可以使用相同名字的变量，它们代表不同的对象，互不干扰。例如，上面在ｆ１函
数中定义了变量ｂ和ｃ，倘若在ｆ２函数中也定义变量ｂ和ｃ，它们在内存中占不同的单元，互不混淆。
（３）形式参数也是局部变量。例如上面ｆ１函数中的形参ａ，也只在ｆ１函数中有效。其他函数可
以调用ｆ１函数，但不能引用ｆ１函数的形参ａ。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１１９
（４）在一个函数内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效，这种复合语
句也称为“分程序”或“程序块”。
ｖｏｉｄｍａｉｎ（）
｛ｉｎｔａ，ｂ；
…
｛ｉｎｔｃ；
ｃ＝ａ＋ｂ； ｃ在此范围内有效 ａ，ｂ在此范围内有效
…
｝
…
｝
ｉｎｔｐ＝１，ｑ＝５； ／外部变量／
ｆｌｏａｔｆ１（ｉｎｔａ） ／定义函数ｆ１
二、全局变量
在函数内定义的变量是局部变量，而在函数之外定义的变量称为外部变量，外部变量是全局变量
（称全程变量）。全局变量可以为本文件中其他函数所共用。它的有效范围为从定义变量的位置开始
到本源文件结束。
／
｛ｉｎｔｂ，ｃ；
…
｝
ｃｈａｒｃ１，ｃ２； ／外部变量／
ｃｈａｒｆ２（ｉｎｔｘ，ｉｎｔｙ） ／定义函数ｆ２／
｛ｉｎｔｉ，ｊ；全局变量ｐ，ｑ的作用范围
… 全局变量ｃ１，ｃ２的作用范围
｝
ｖｏｉｄｍａｉｎ（） ／主函数／
｛ｉｎｔｍ，ｎ；
…
｝
例１５ 有一个一维数组，内放１０个学生成绩，写一个函数，求出平均分、最高分和最低分。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｆｌｏａｔ Ｍａｘ＝０，Ｍｉｎ＝０； ／全局变量／
ｖｏｉｄ ｍａｉｎ（）
１２０
｛ ｆｌｏａｔ ａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［］，ｉｎｔｎ）；
ｆｌｏａｔ ａｖｅ，ｓｃｏｒｅ［１０］；
ｉｎｔｉ；
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＋）
ｓｃａｎｆ（″％ｆ″，＆ｓｃｏｒｅ［ｉ］）；
ａｖｅ＝ａｖｅｒａｇｅ（ｓｃｏｒｅ，１０）；
ｐｒｉｎｔｆ（“ｍａｘ＝％６．２ｆ＼ｎｍｉｎ＝％６．２ｆ＼ｎ
ａｖｅｒａｇｅ＝％６．２ｆ＼ｎ“，Ｍａｘ，Ｍｉｎ，ａｖｅ）；
｝
ｆｌｏａｔａｖｅｒａｇｅ（ｆｌｏａｔａｒｒａｙ［］，ｉｎｔｎ）
／定义函数，形参为数组／
｛ｉｎｔｉ；
ｆｌｏａｔ ａｖｅｒ，ｓｕｍ＝ａｒｒａｙ［０］；
Ｍａｘ＝Ｍｉｎ＝ａｒｒａｙ［０］；
ｆｏｒ（ｉ＝１；ｉ＜ｎ；ｉ＋＋）
｛ ｉｆ（ａｒｒａｙ［ｉ］＞Ｍａｘ）
Ｍａｘ＝ａｒｒａｙ［ｉ］；
ｅｌｓｅ ｉｆ（ａｒｒａｙ［ｉ］＜Ｍｉｎ）
Ｍｉｎ＝ａｒｒａｙ［ｉ］；
ｓｕｍ＝ｓｕｍ＋ａｒｒａｙ［ｉ］；
｝
ａｖｅｒ＝ｓｕｍ／ｎ；
ｒｅｔｕｒｎ（ａｖｅｒ）；
｝
建议不在必要时不要使用全局变量，原因如下：
①全局变量在程序的全部执行过程中都占用存储单元，而不是仅在需要时才开辟单元。
②使用全局变量过多，会降低程序的清晰性，人们往往难以清楚地判断出每个瞬时各个外部变量
的值。在各个函数执行时都可能改变外部变量的值，程序容易出错。因此，要限制使用全局变量。
③它使函数的通用性降低，因为函数在执行时要依赖于其所在的外部变量。如果将一个函数移
到另一个文件中，还要将有关的外部变量及其值一起移过去。但若该外部变量与其他文件的变量同
名时，就会出现问题，降低了程序的可靠性和通用性。一般要求把Ｃ程序中的函数做成一个封闭体，
除了可以通过“实参———形参”的渠道与外界发生联系外，没有其他渠道。
例１６外部变量与局部变量同名
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１２１
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｉｎｔａ＝３，ｂ＝５； ／ａ，ｂ为外部变量／ ａ，ｂ作用范围
ｖｏｉｄｍａｉｎ（）
｛ ｉｎｔａ＝８； ／ａ为局部变量／ 局部变量ａ作用范围
ｐｒｉｎｔｆ（″％ｄ″，ｍａｘ（ａ，ｂ））； 全局变量ｂ的作用范围
｝
ｍａｘ（ｉｎｔａ，ｉｎｔｂ） ／ａ，ｂ为局部变量／
｛ ｉｎｔｃ；
ｃ＝ａ＞ｂ？ａ∶ｂ； 形参ａ、ｂ作用范围
ｒｅｔｕｒｎ（ｃ）；
｝
运行结果为８
考点９ 变量的存储类别
一、动态存储方式与静态存储方式
前面已介绍了从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。那么从变
量值存在的时间（即生存期）角度来分，又可以分为静态存储方式和动态存储方式。
所谓静态存储方式是指在程序运行期间由系统分配固定的存储空间的方式。而动态存储方式则
是在程序运行期间根据需要进行动态的分配存储空间的方式。这个存储空间可以分为三部分：
程序区
静态存储区
动态存储区
在Ｃ语言中每一个变量和函数有两个属性：数据类型和数据的存储类别。对数据类型，读者已熟
悉（如整型、字符型等）。存储类别指的是数据在内存中存储的方式。存储方式分为两大类：静态存储
类和动态存储类。具体包含四种：自动的（ａｕｔｏ），静态的（ｓｔａｔｉｃ），寄存器的（ｒｅｇｉｓｔｅｒ），外部的（ｅｘｔｅｒｎ）。
根据变量的存储类别，可以知道变量的作用域和生存期。
二、ａｕｔｏ变量
函数中的局部变量，如不专门声明为ｓｔａｔｉｃ存储类别，都是动态地分配存储空间的，数据存储在动
态存储区中。函数中的形参和在函数中定义的变量（包括在复合语句中定义的变量），都属此类，在调
用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。因此这类局
部变量称为自动变量。自动变量用关键字ａｕｔｏ作存储类别的声明。例如：
ｉｎｔｆ（ｉｎｔａ） ／定义ｆ函数，ａ为形参／
｛ａｕｔｏ ｉｎｔｂ，ｃ＝３； ／定义ｂ、ｃ为自动变量／
１２２
…
｝
三、用ｓｔａｔｉｃ声明局部变量
有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不
释放，在下一次该函数调用时，该变量已有值，就是上一次函数调用结束时的值。这时就应该指定该
局部变量为“静态局部变量”，用关键字ｓｔａｔｉｃ进行声明。通过下面简单的例子可以了解它的特点。
例１７ 考察静态局部变量的值。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｉｎｔｆ（ｉｎｔ）；
ｉｎｔａ＝２，ｉ；
ｆｏｒ（ｉ＝０；ｉ＜３；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｄ″，ｆ（ａ））；
｝
ｉｎｔｆ（ｉｎｔａ）
｛ ａｕｔｏｉｎｔｂ＝０；
ｓｔａｔｉｃｉｎｔｃ＝３；
ｂ＝ｂ＋１；
ｃ＝ｃ＋１；
ｒｅｔｕｒｎ（ａ＋ｂ＋ｃ）；
｝
对静态局部变量的说明：
（１）静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不
释放。而自动变量（即动态局部变量）属于动态存储类别，占动态存储区空间而不占静态存储区空间，
函数调用结束后即释放。
（２）对静态局部变量是在编译时赋初值的，即只赋初值一次，在程序运行时它已有初值。以后每
次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。而对自动变量赋初值，不是在
编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。
（３）如在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值０（对数值型
变量）或空字符（对字符变量）。而对自动变量来说，如果不赋初值则它的值是一个不确定的值。这是
由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的
值是不确定的。
（４）虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的。
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１２３
例１８ 输出１到５的阶乘值。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｉｎｔ ｆａｃ（ｉｎｔｎ）；
ｉｎｔｉ；
ｆｏｒ（ｉ＝１；ｉ＜＝５；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｄ！＝％ｄ＼ｎ″，ｉ，ｆａｃ（ｉ））；
｝
Ｉｎｔｆａｃ（ｉｎｔｎ）
｛ ｓｔａｔｉｃ ｉｎｔｆ＝１；
ｆ＝ｆｎ；
ｒｅｔｕｒｎ（ｆ）；
｝
四、ｒｅｇｉｓｔｅｒ变量
一般情况下，变量（包括静态存储方式和动态存储方式）的值是存放在内存中的。当程序中用到
哪一个变量的值时，由控制器发出指令将内存中该变量的值送到运算器中。经过运算器进行运算，如
果需要存数，再从运算器将数据送到内存存放。
如果有一些变量使用频繁（例如在一个函数中执行１００００次循环，每次循环中都要引用某局部变
量），则为存取变量的值要花费不少时间。为提高执行效率，Ｃ语言允许将局部变量的值放在ＣＰＵ中
的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。由于对寄存器的存取速
度远高于对内存的存取速度，因此这样做可以提高执行效率。这种变量叫做寄存器变量，用关键字
ｒｅｇｉｓｔｅｒ作声明。例如，例１９中的程序是输出１到ｎ的阶乘的值。
例１９ 使用寄存器变量
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｌｏｎｇｆａｃ（ｌｏｎｇ）；
ｌｏｎｇｉ，ｎ；
ｓｃａｎｆ（＂％ｌｄ＂，＆ｎ）；
１２４
ｆｏｒ（ｉ＝１；ｉ＜＝ｎ；ｉ＋＋）
ｐｒｉｎｔｆ（＂％ｌｄ！＝％ｌｄ＼ｎ＂，ｉ，ｆａｃ（ｉ））；
｝
ｌｏｎｇｆａｃ（ｌｏｎｇｎ）
｛ｒｅｇｉｓｔｅｒｌｏｎｇｉ，ｆ＝１； ／定义寄存器变量／
ｆｏｒ（ｉ＝１；ｉ＜＝ｎ；ｉ＋＋）
ｆ＝ｆｉ；
ｒｅｔｕｒｎ（ｆ）；
｝
五、用ｅｘｔｅｒｎ声明外部变量
外部变量是在函数的外部定义的全局变量，它的作用域是从变量的定义处开始，到本程序文件的
末尾。在此作用域内，全局变量可以为程序中各个函数所引用。编译时将外部变量分配在静态存
储区。
有时需要用ｅｘｔｅｒｎ来声明外部变量，以扩展外部变量的作用城。
１．在一个文件内声明外部变量
例２０用ｅｘｔｅｒｎ声明外部变量，扩展它在程序文件中的作用域。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｉｎｔｍａｘ（ｉｎｔ，ｉｎｔ）；／外部变量声明／
ｅｘｔｅｒｎ Ａ，Ｂ；
ｐｒｉｎｔｆ（＂％ｄ＼ｎ＂，ｍａｘ（Ａ，Ｂ））；
｝
ｉｎｔＡ＝１３，Ｂ＝－８；／定义外部变量／
ｉｎｔｍａｘ（ｉｎｔｘ，ｉｎｔｙ）／定义ｍａｘ函数／
｛ｉｎｔｚ；
ｚ＝ｘ＞ｙ？ｘ：ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
２．在多文件的程序中声明外部变量
例２１ 用ｅｘｔｅｒｎ将外部变量的作用域扩展到其他文件。本程序的作用是给定ｂ的值，输入ａ和
ｍ，求ａ×ｂ和ａｍ的值。
文件ｆｉｌｅ１．ｃ中的内容为：
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１２５
ｉｎｔＡ； ／定义外部变量／
ｖｏｉｄｍａｉｎ（）
｛ｉｎｔｐｏｗｅｒ（ｉｎｔ）； ／函数声明／
ｉｎｔｂ＝３，ｃ，ｄ，ｍ；
ｐｒｉｎｔｆ（″ｅｎｔｅｒｔｈｅｎｕｍｂｅｒａａｎｄｉｔｓｐｏｗｅｒｍ：＼ｎ″）；
ｓｃａｎｆ（″％ｄ，％ｄ″，＆Ａ，＆ｍ）；
ｃ＝Ａｂ；
ｐｒｉｎｔｆ（″％ｄ％ｄ＝％ｄ＼ｎ″，Ａ，ｂ，ｃ）；
ｄ＝ｐｏｗｅｒ（ｍ）；
ｐｒｉｎｔｆ（″％ｄ％ｄ＝％ｄ＼ｎ″，Ａ，ｍ，ｄ）；
｝
文件ｆｉｌｅ２．ｃ中的内容为：
ｅｘｔｅｒｎ Ａ；
／声明Ａ为一个已定义的外部变量／
ｉｎｔｐｏｗｅｒ（ｉｎｔｎ）；
｛
ｉｎｔｉ，ｙ＝１；
ｆｏｒ（ｉ＝１；ｉ＜＝ｎ；ｉ＋＋）
ｙ＝Ａ；
ｒｅｔｕｒｎ（ｙ）；
｝
六、用ｓｔａｔｉｃ声明外部变量
有时在程序设计中希望某些外部变量只限于被本文件引用，而不能被其他文件引用。这时可以
在定义外部变量时加一个ｓｔａｔｉｃ声明。
例如：
ｆｉｌｅ１．ｃ ｆｉｌｅ２．ｃ
ｓｔａｔｉｃｉｎｔＡ； ｅｘｔｅｒｎｉｎｔＡ；
ｖｏｉｄｍａｉｎ（） ｖｏｉｄｆｕｎ（ｉｎｔｎ）
｛ ｛…
… Ａ＝Ａｎ；
｝
七、关于变量的声明和定义
对变量而言，声明与定义的关系稍微复杂一些。在声明部分出现的变量有两种情况：一种是需要
１２６
建立存储空间的（如：ｉｎｔａ；），另一种是不需要建立存储空间的（如：ｅｘｔｅｒｎａ；）。
前者称为“定义性声明”（ｄｅｆｉｎｉｎｇｄｅｃｌａｒａｔｉｏｎ），或简称定义（ｄｅｆｉｎｉｔｉｏｎ）。后者称为“引用性声明”
（ｒｅｆｅｒｅｎｃｉｎｇｄｅｃｌａｒａｔｉｏｎ）。广义地说，声明包括定义，但并非所有的声明都是定义。对“ｉｎｔａ；”而言，
它既是声明，又是定义。而对“ｅｘｔｅｒｎａ；”而言，它是声明而不是定义。
一般为了叙述方便，把建立存储空间的声明称定义，而把不需要建立存储空间的声明称为声明。
显然这里指的声明是狭义的，即非定义性声明。
例如：
ｖｏｉｄｍａｉｎ（）
｛ｅｘｔｅｒｎＡ； ／是声明不是定义。声明Ａ是一个已定义的外部变量／
…
｝
ｉｎｔＡ；
存储类别小结
（１）从作用域角度分，有局部变量和全局变量。它们采用的存储类别如下：
局部变量 ｜自动变量，即动态局部变量
（离开函数，值就消失）
｜静态局部变量（离开函数，值仍保留）
｜寄存器变量（离开函数，值就消失）
｜（形式参数可以定义为自动变量或寄存器变量）
全局变量 ｜静态外部变量（只限本文件引用）
｜外部变量
（即非静态的外部变量，允许其他文件引用）
（２）从变量存在的时间（生存期）来区分，有动态存储和静态存储两种类型。静态存储是程序整
个运行时间都存在，而动态存储则是在调用函数时临时分配单元。
动态存储 ｜自动变量（本函数内有效）
｜寄存器变量（本函数内有效）
｜形式参数（本函数内有效）
静态存储 ｜静态局部变量（函数内有效）
｜静态外部变量（本文件内有效）
｜外部变量（其他文件可引用）
（３）从变量值存放的位置来区分，可分为：
内存中静态存储区 ｜静态局部变量
｜静态外部变量（函数外部静态变量）
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１２７
｜外部变量（可为其他文件引用）
内存中动态存储区：自动变量和形式参数
ＣＰＵ中的寄存器：寄存器变量
（４）关于作用域和生存期的概念。从前面叙述可以知道，对一个变量的性质可以从两个方面分
析，一是变量的作用域，一是变量值存在时间的长短，即生存期。前者是从空间的角度，后者是从时间
的角度。二者有联系但不是同一回事。
（５）ｓｔａｔｉｃ对局部变量和全局变量的作用不同。对局部变量来说，它使变量由动态存储方式改变
为静态存储方式。而对全局变量来说，它使变量局部化（局部于本文件），但仍为静态存储方式。从作
用域角度看，凡有ｓｔａｔｉｃ声明的，其作用域都是局限的，或者是局限于本函数内（静态局部变量），或者
局限于本文件内（静态外部变量）。
考点１０ 内部函数和外部函数
函数本质上是全局的，因为一个函数要被另外的函数调用，但是，也可以指定函数不能被其他文
件调用。根据函数能否被其他源文件调用，将函数区分为内部函数和外部函数。
一、内部函数
如果一个函数只能被本文件中其他函数所调用，它称为内部函数。在定义内部函数时，在函数名
和函数类型的前面加ｓｔａｔｉｃ。即
ｓｔａｔｉｃ类型标识符函数名（形参表）
如 ｓｔａｔｉｃｉｎｔｆｕｎ（ｉｎｔａ，ｉｎｔｂ）
二、外部函数
（１）在定义函数时，如果在函数首部的最左端加关键字ｅｘｔｅｒｎ，则表示此函数是外部函数，可供其
他文件调用。如函数首部可以写为ｅｘｔｅｒｎｉｎｔｆｕｎ（ｉｎｔａ，ｉｎｔｂ）
这样，函数ｆｕｎ就可以为其他文件调用。Ｃ语言规定，如果在定义函数时省略ｅｘｔｅｒｎ，则隐含为外
部函数。
（２）在需要调用此函数的文件中，用ｅｘｔｅｒｎ对函数作声明，表示该函数是在其他文件中定义的外
部函数
例２２有一个字符串，内有若干个字符，今输入一个字符，要求程序将字符串中该字符删去。用外
部函数实现
Ｆｉｌｅ．ｃ（文件１）
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｅｘｔｅｒｎｖｏｉｄｅｎｔｅｒ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［］）；
ｅｘｔｅｒｎｖｏｉｄｄｅｔｅｌｅ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［］，ｃｈａｒｃｈ）；
１２８
ｅｘｔｅｒｎｖｏｉｄｐｒｉｎｔ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［］）；／以上３行声明在本函数中将要调用的在其他文件中定
义的３个函数／
ｃｈａｒｃ；
ｃｈａｒｓｔｒ［８０］；
ｓｃａｎｆ（＂％ｃ＂，＆ｃ）；
ｄｅｔｅｌｅ＿ｓｔｒｉｎｇ（ｓｔｒ，ｃ）；
ｐｒｉｎｔ＿ｓｔｒｉｎｇ（ｓｔｒ）；
｝
ｆｉｌｅ２．ｃ（文件２）
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｅｎｔｅｒ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［８０］）／定义外部函数
ｅｎｔｅｒ－ｓｔｒｉｎｇ／
｛ ｇｅｔｓ（ｓｔｒ）；／向字符数组输入字符串／
｝
ｆｉｌｅ３．ｃ（文件３）
ｖｏｉｄｄｅｌｅｔｅ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［］，ｃｈａｒｃｈ） ／定义外部函数ｄｅｌｅｔｅ＿ｓｔｒｉｎｇ／
｛ ｉｎｔｉ，ｊ；
ｆｏｒ（ｉ＝ｊ＝０；ｓｔｒ［ｉ］！＝＇＼０＇；ｉ＋＋）
ｉｆ（ｓｔｒ［ｉ］！＝ｃｈ）
ｓｔｒ［ｊ＋＋］＝ｓｔｒ［ｉ］；
ｓｔｒ［ｉ］＝＇＼０＇；
｝
ｆｉｌｅ４．ｃ（文件４）
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｐｒｉｎｔ＿ｓｔｒｉｎｇ（ｃｈａｒｓｔｒ［］）
｛
ｐｒｉｎｔｆ（＂％ｓ＼ｎ＂，ｓｔｒ）；
｝
运行情况如下：
ａｂｃｄｅｆｇｃG21 （输入ｓｔｒ）
ｃG21 （输入要删去的字符）
ａｂｄｅｆｇ （输出已删去指定字符的字符串）
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１２９
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
殏
殏
殏
殏
本章小结
主要知识点：
函数的概念
函数的定义与调用
函数的递归调用
变量的作用域
函数的作用域
１３０
第九章 预处理命令
本章考点
ＡＮＳＩＣ标准规定可以在Ｃ源程序中加入一些“预处理命令”，以改进程序设计环境，提高编程
效率。
这些预处理命令是由ＡＮＳＩＣ统一规定的，但是它不是Ｃ语言本身的组成部分，不能直接对它们
进行编译（因为编译程序不能识别它们）。必须在对程序进行通常的编译之前，先对程序中这些特殊
的命令进行“预处理”
经过预处理后程序可由编译程序对预处理后的源程序进行通常的编译处理，得到可供执行的目
标代码。
Ｃ语言与其他高级语言的一个重要区别是可以使用预处理命令和具有预处理的功能。
Ｃ提供的预处理功能主要有以下三种：
１．宏定义
２．文件包含
３．条件编译
这些功能分别用宏定义命令、文件包含命令、条件编译命令来实现。为了与一般Ｃ语句相区别，
这些命令以符号“＃”开头。例如：
＃ｄｅｆｉｎｅ
＃ｉｎｃｌｕｄｅ
考点１ 宏定义
一、不带参数的宏定义
宏定义一般形式为：＃ｄｅｆｉｎｅ 标识符 字符串
例如：＃ｄｅｆｉｎｅ ＰＩ ３．１４１５９２６
宏定义的作用是在本程序文件中用指定的标识符ＰＩ来代替“３．１４１５９２６”这个字符串，在编译预
处理时，将程序中在该命令以后出现的所有的ＰＩ都用“３．１４１５９２６”代替。这种方法使用户能以一个
简单的名字代替一个长的字符串．
这个标识符（名字）称为“宏名”
在预编译时将宏名替换成字符串的过程称为“宏展开”。＃ｄｅｆｉｎｅ是宏定义命令。
例１使用不带参数的宏定义
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１３１
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＰＩ３．１４１５９２６
ｖｏｉｄｍａｉｎ（）
｛ｆｌｏａｔｌ，ｓ，ｒ，ｖ；
ｐｒｉｎｔｆ（＂ｉｎｐｕｔｒａｄｉｕｓ：＂）；
ｓｃａｎｆ（＂％ｆ＂，＆ｒ）；
ｌ＝２．０ＰＩｒ；
ｓ＝ＰＩｒｒ；
ｖ＝４．０／３ＰＩｒｒｒ；
ｐｒｉｎｔｆ（＂ｌ＝％１０．４ｆ＼ｎｓ＝％１０．４ｆ＼ｎｖ＝％１０．４ｆ＼ｎ＂，ｌ，ｓ，ｖ）；
｝
运行情况如下：
ｉｎｐｕｔｒａｄｉｕｓ：４G21
１＝２５．１３２８
ｓ＝５０．２６５５
ｖ＝１５０．７９６６
说明：
（１）宏名一般习惯用大写字母表示，以便与变量名相区别。但这并非规定，也可用小写字母。
（２）使用宏名代替一个字符串，可以减少程序中重复书写某些字符串的工作量。
（３）宏定义是用宏名代替一个字符串，只作简单置换，不作正确性检查。只有在编译已被宏展开
后的源程序时才会发现语法错误并报错。
（４）宏定义不是Ｃ语句，不必在行末加分号。如果加了分号则会连分号一起进行置换。
（５）＃ｄｅｆｉｎｅ命令出现在程序中函数的外面，宏名的有效范围为定义命令之后到本源文件结束。
通常，＃ｄｅｆｉｎｅ命令写在文件开头，函数之前，作为文件一部分，在此文件范围内有效。
（６）可以用＃ｕｎｄｅｆ命令终止宏定义的作用域。
例２：
＃ｄｅｆｉｎｅＧ ９．８ ＿＿＿＿＿＿＿
ｖｏｉｄｍａｉｎ（） ↑
｛Ｇ的有效范围
…
｝ －－－－－↓－－－－
＃ｕｎｄｅｆＧ
ｆ１（）
１３２
｛
…
｝
在ｆ１函数中，Ｇ不再代表９．８。这样可以灵活控制宏定义的作用范围。
（７）在进行宏定义时，可以引用已定义的宏名，可以层层置换。
例９．２在宏定义中引用已定义的宏名
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＲ３．０
＃ｄｅｆｉｎｅＰＩ３．１４１５９２６
＃ｄｅｆｉｎｅＬ２ＰＩＲ
＃ｄｅｆｉｎｅＳＰＩＲＲ
ｖｏｉｄ ｍａｉｎ（ ）
｛
ｐｒｉｎｔｆ（＂Ｌ＝％ｆ＼ｎＳ＝％ｆ＼ｎ＂，Ｌ，Ｓ）；
｝
运行情况如下：
Ｌ＝１８．８４９５５６
Ｓ＝２８．２７４３３３
经过宏展开后，ｐｒｉｎｔｆ函数中的输出项Ｌ被展开为：
２３．１４１５９２６３．０
Ｓ展开为
３．１４１５９２６３．０３．０
ｐｒｉｎｔｆ函数调用语句展开为：
ｐｒｉｎｔｆ（“Ｌ＝％Ｆ＼ＮＳ＝％ｆ＼ｎ”，
２３．１４１５９２６３．０，３．１４１５９２６３．０３．０）；
（８）对程序中用双撇号括起来的字符串内的字符，即使与宏名相同，也不进行置换。
（９）宏定义是专门用于预处理命令的一个专用名词，它与定义变量的含义不同，只作字符替换，不
分配内存空间。
二、带参数的宏定义
作用：不是进行简单的字符串替换，还要进行参数替换。
带参数的宏定义一般形式为：
＃ｄｅｆｉｎｅ宏名（参数表） 字符串
字符串中包含在括弧中所指定的参数
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１３３
＃ｄｅｆｉｎｅ Ｓ（ａ，ｂ）ａｂ
：
ａｒｅａ＝Ｓ（３，２）；
程序中用３和２分别代替宏定义中的形式参数ａ和ｂ，用３２代替Ｓ（３，２）。因此赋值语句展开
为：ａｒｅａ＝３２
对带参的宏定义是这样展开置换的：
对带实参的宏（如Ｓ（３，２），则按＃ｄｅｆｉｎｅ命令行中指定的字符串从左到右进行置换。若串中包含
宏中的形参（如ａ、ｂ），则将程序中相应的实参（可以是常量、变量或表达式）代替形参。如果宏定义中
的字符串中的字符不是参数字符（如ａｂ中的号），则保留。这样就形成了置换的字符串。
例３ 使用带参的宏
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＰＩ３．１４１５９２６
＃ｄｅｆｉｎｅＳ（ｒ）ＰＩｒｒ
ｖｏｉｄｍａｉｎ（ ）
｛ｆｌｏａｔａ，ａｒｅａ；
ａ＝３．６；
ａｒｅａ＝Ｓ（ａ）； ｐｒｉｎｔｆ（＂ｒ＝％ｆ＼ｎａｒｅａ＝％ｆ＼ｎ＂，ａ，ａｒｅａ）；
｝
赋值语句“ａｒｅａ＝Ｓ（ａ）；”经宏展开后为：
ａｒｅａ＝３．１４１５９２６ａａ；
运行情况如下：
ｒ＝３．６０００００
ａｒｅａ＝４０．７１５０３８
说明：
（１）对带参数的宏展开只是将语句中的宏名后面括号内的实参字符串代替＃ｄｅｆｉｎｅ命令行中的
形参。
（２）在宏定义时，在宏名与带参数的括弧之间不应加空格，否则将空格以后的字符都作为替代字
符串的一部分。
带参数的宏和函数的区别：
（１）函数调用时，先求出实参表达式的值，然后代入形参。而使用带参的宏只是进行简单的字符
１３４
替换。
（２）函数调用是在程序运行时处理的，为形参分配临时的内存单元。而宏展开则是在编译前进行
的，在展开时并不分配内存单元，不进行值的传递处理，也没有“返回值”的概念。
（３）对函数中的实参和形参类型要求一致。而宏名无类型，它的参数也无类型，只是一个符号代
表，展开时代入指定的字符串即可。宏定义时，字符串可以是任何类型的数据。
（４）调用函数只可得到一个返回值，而用宏可以设法得到几个结果。
例４ 通过宏展开得到若干个结果
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＰＩ３．１４１５９２６
＃ｄｅｆｉｎｅＣＩＲＣＬＥ（Ｒ，Ｌ，Ｓ，Ｖ）Ｌ＝２ＰＩＲ；Ｓ＝ＰＩＲＲ；Ｖ＝４．０／３．０ＰＩＲＲＲ
ｖｏｉｄｍａｉｎ（）
｛ｆｌｏａｔｒ，ｌ，ｓ，ｖ；
ｓｃａｎｆ（＂％ｆ＂，＆ｒ）；
ＣＩＲＣＬＥ（ｒ，ｌ，ｓ，ｖ）； ｐｒｉｎｔｆ（＂ｒ＝％６．２ｆ，ｌ＝％６．２ｆ，ｓ＝％６．２ｆ，ｖ＝％６．２ｆ＼ｎ＂，ｒ，ｌ，ｓ，
ｖ）；
｝
对宏进行预编译，展开后的ｍａｉｎ函数如下：
ｖｏｉｄｍａｉｎ（）
｛ｆｌｏａｔｒ，ｌ，ｓ，ｖ；
ｓｃａｎｆ（＂％ｆ＂，＆ｒ）；
ｌ＝２３．１４１５９２６ｒ；
ｓ＝３．１５１５９２６ｒｒ；
ｖ＝４．０／３／０３．１４１５９２６ｒｒｒ； ｐｒｉｎｔｆ（”ｒ＝％６．２ｆ，ｌ＝％６．２ｆ，ｓ＝％６．２ｆ，ｖ＝％６．２ｆ＼
ｎ”，ｒ，ｌ，ｓ，ｖ）；
｝
运行情况如下：
３．５G21
ｒ＝３．５０，ｌ＝２１．９９，ｓ＝３８．４８，ｖ＝１７９．５９
（５）使用宏次数多时，宏展开后源程序长，因为每展开一次都使程序增长，而函数调用不会使源
程序变长。
（６）宏替换不占运行时间，只占编译时间。而函数调用则占运行时间（分配单元、保留现场、值传
递、返回）。
如果善于利用宏定义，可以实现程序的简化，如事先将程序中的“输出格式”定义好，以减少在输
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１３５
出语句中每次都要写出具体的输出格式的麻烦。
例５ 通过宏展开得到若干个结果
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅ ＰＲｐｒｉｎｔｆ
＃ｄｅｆｉｎｅ ＮＬ＂＼ｎ＂
＃ｄｅｆｉｎｅ Ｄ＂％ｄ＂
＃ｄｅｆｉｎｅ Ｄ１ＤＮＬ
＃ｄｅｆｉｎｅ Ｄ２ＤＤＮＬ
＃ｄｅｆｉｎｅ Ｄ３ＤＤＤＮＬ
＃ｄｅｆｉｎｅ Ｄ４ＤＤＤＤＮＬ
＃ｄｅｆｉｎｅ Ｓ＂％ｓ＂
ｖｏｉｄｍａｉｎ（ ）
｛ｉｎｔａ，ｂ，ｃ，ｄ；
ｃｈａｒｓｔｒｉｎｇ［］＝＂ＣＨＩＮＡ＂；
ａ＝１；ｂ＝２；ｃ＝３；ｄ＝４；
ＰＲ（Ｄ１，ａ）；
ＰＲ（Ｄ２，ａ，ｂ）；
ＰＲ（Ｄ３，ａ，ｂ，ｃ）；
ＰＲ（Ｄ４，ａ，ｂ，ｃ，ｄ）；
ＰＲ（Ｓ，ｓｔｒｉｎｇ）；
｝
运行时输出结果：
１
１２
１２３
１２３４
ＣＨＩＮＡ
考点２ “文件包含”处理
所谓“文件包含”处理是指一个源文件可以将另外一个源文件的全部内容包含进来。Ｃ语言提供
了＃ｉｎｃｌｕｄｅ命令用来实现“文件包含”的操作。
其一般形式为：
＃ｉｎｃｌｕｄｅ＂文件名＂
或＃ｉｎｃｌｕｄｅ＜文件名＞
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１５７
可以不定义字符数组，而定义一个字符指针。用字符指针指向字符串中的字符。
例１６ 定义字符指针
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｃｈａｒｓｔｒｉｎｇ＝″ＩｌｏｖｅＣｈｉｎａ！″；
ｐｒｉｎｔｆ（″％ｓ＼ｎ″，ｓｔｒｉｎｇ）；
｝
对字符串中字符的存取，可以用下标方法，也可以用指针方法
例１７ 将字符串ａ复制为字符串ｂ
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｃｈａｒ ａ［］＝″Ｉ ａｍ ａ ｂｏｙ．″，ｂ［２０］；
ｉｎｔｉ；
ｆｏｒ（ｉ＝０；（ａ＋ｉ）！＝′＼０′；ｉ＋＋）
（ｂ＋ｉ）＝（ａ＋ｉ）；
（ｂ＋ｉ）＝′＼０′；
ｐｒｉｎｔｆ（″ｓｔｒｉｎｇ ａ ｉｓ：％ｓ＼ｎ″，ａ）；
ｐｒｉｎｔｆ（″ｓｔｒｉｎｇｂｉｓ：″）；
ｆｏｒ（ｉ＝０；ｂ［ｉ］！＝′＼０′；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｃ″，ｂ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
也可以设指针变量，用它的值的改变来指向字符串中的不同的字符。
例１８ 用指针变量来处理例１７问题。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｃｈａｒａ［］＝″Ｉａｍａｂｏｙ．″，ｂ［２０］，ｐ１，ｐ２；
ｉｎｔｉ；
ｐ１＝ａ；ｐ２＝ｂ；
ｆｏｒ（；ｐ１！＝′＼０′；ｐ１＋＋，ｐ２＋＋）
ｐ２＝ｐ１；
ｐ２＝′＼０′；
ｐｒｉｎｔｆ（″ｓｔｒｉｎｇａｉｓ：％ｓ＼ｎ″，ａ）；
１５８
ｐｒｉｎｔｆ（″ｓｔｒｉｎｇｂｉｓ：″）；
ｆｏｒ（ｉ＝０；ｂ［ｉ］！＝′＼０′；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｃ″，ｂ［ｉ］）；
ｐｒｉｎｔｆ（″＼ｎ″）；
｝
二、字符指针作函数参数
例１９ 用函数调用实现字符串的复制
（１）用字符数组作参数
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｖｏｉｄ ｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ［］，ｃｈａｒｔｏ［］）；
ｃｈａｒａ［］＝″Ｉａｍａｔｅａｃｈｅｒ．″；
ｃｈａｒｂ［］＝″ｙｏｕａｒｅａｓｔｕｄｅｎｔ．″；
ｐｒｉｎｔｆ（“ｓｔｒｉｎｇａ＝％ｓ＼ｎｓｔｒｉｎｇｂ＝％ｓ＼ｎ″，
ａ，ｂ）；
ｐｒｉｎｔｆ（＂ｃｏｐｙｓｔｒｉｎｇａｔｏｓｔｒｉｎｇｂ：＼ｎ＂）；
ｃｏｐｙ＿ｓｔｒｉｎｇ（ａ，ｂ）；
ｐｒｉｎｔｆ（＂＼ｎｓｔｒｉｎｇａ＝％ｓ＼ｎｓｔｒｉｎｇｂ＝％ｓ＼ｎ＂，ａ，ｂ）；
｝
ｖｏｉｄ ｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ［］，ｃｈａｒｔｏ［］）
｛ｉｎｔ ｉ＝０；
ｗｈｉｌｅ（ｆｒｏｍ［ｉ］！＝′＼０′）
｛ｔｏ［ｉ］＝ｆｒｏｍ［ｉ］；ｉ＋＋；｝
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１５９
ｔｏ［ｉ］＝′＼０′；
｝
程序运行结果如下：
Ｓｔｒｉｎｇ ａ＝ｌ ａｍ ａ ｔｅａｃｈｅｒ．
Ｓｔｒｉｎｇａ ｂ＝ｙｏｕ ａ ｒｅａｓｔｕｄｅｎｔ．
ｃｏｐｙｓｔｒｉｎｇａｔｏｓｔｒｉｎｇｂ：
Ｓｔｒｉｎｇ ａ＝ｌ ａｍ ａ ｔｅａｃｈｅｒ．
Ｓｔｒｉｎｇａ ｂ＝ｌ ａｍ ａ ｔｅａｃｈｅｒ．
（２）形参用字符指针变量
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｖｏｉｄｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ，ｃｈａｒｔｏ）；
ｃｈａｒａ＝″Ｉａｍ ａ ｔｅａｃｈｅｒ．″；
ｃｈａｒｂ＝″ｙｏｕａｒｅａｓｔｕｄｅｎｔ．″；
ｐｒｉｎｔｆ（＂ｓｔｒｉｎｇａ＝％ｓ＼ｎｓｔｒｉｎｇｂ＝％ｓ＼ｎ″，ａ，ｂ）；
ｐｒｉｎｔｆ（＂ｃｏｐｙｓｔｒｉｎｇａｔｏｓｔｒｉｎｇｂ：＼ｎ＂）；
ｃｏｐｙ＿ｓｔｒｉｎｇ（ａ，ｂ）；
ｐｒｉｎｔｆ（＂＼ｎｓｔｒｉｎｇａ＝％ｓ＼ｎｓｔｒｉｎｇｂ＝％ｓ＼ｎ＂，ａ，ｂ）；
｝
ｖｏｉｄ ｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ，ｃｈａｒｔｏ）
｛ｆｏｒ（；ｆｒｏｍ！＝′＼０′；ｆｒｏｍ＋＋，ｔｏ＋＋）
ｔｏ＝ｆｒｏｍ；
ｔｏ＝′＼０′；
｝
（３）对ｃｏｐｙ＿ｓｔｒｉｎｇ函数还可作简化
１．将ｃｏｐｙ＿ｓｔｒｉｎｇ函数改写为
ｖｏｉｄ ｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ，ｃｈａｒｔｏ）
｛ｗｈｉｌｅ（（ｔｏ＝ｆｒｏｍ）！＝′＼０′）
｛ｔｏ＋＋；ｆｒｏｍ＋＋；｝
｝
２．ｃｏｐｙ＿ｓｔｒｉｎｇ函数的函数体还可改为
｛
ｗｈｉｌｅ（（ｔｏ＋＋＝ｆｒｏｍ＋＋）！＝′＼０′）；
１６０
｝
３．ｃｏｐｙ＿ｓｔｒｉｎｇ函数的函数体还可写成
｛
ｗｈｉｌｅ（ｆｒｏｍ！＝′＼０′）
ｔｏ＋＋＝ｆｒｏｍ＋＋；
ｔｏ＝′＼０′；
｝
４．上面的ｗｈｉｌｅ语句还可以进一步简化为下面的ｗｈｉｌｅ语句：
ｗｈｉｌｅ（ｔｏ＋＋＝ｆｒｏｍ＋＋）；
它与下面语句等价：
ｗｈｉｌｅ（（ｔｏ＋＋＝ｆｒｏｍ＋＋）！＝′＼０′）；
将ｆｒｏｍ赋给ｔｏ，如果赋值后的ｔｏ值等于′＼０′，则循环终止（′＼０′已赋给ｔｏ）
５．函数体中ｗｈｉｌｅ语句也可以改用ｆｏｒ语句：
ｆｏｒ（；（ｔｏ＋＋＝ｆｒｏｍ＋＋）！＝０；）；
或
ｆｏｒ（；ｔｏ＋＋＝ｆｒｏｍ＋＋；）；
６．也可用指针变量，函数ｃｏｐｙ＿ｓｔｒｉｎｇ可写为
ｖｏｉｄ ｃｏｐｙ＿ｓｔｒｉｎｇ（ｃｈａｒｆｒｏｍ［］，ｃｈａｒｔｏ［］）
｛ｃｈａｒｐ１，ｐ２；
ｐ１＝ｆｒｏｍ；ｐ２＝ｔｏ；
ｗｈｉｌｅ（（ｐ２＋＋＝ｐ１＋＋）！＝′＼０′）；
｝
三、对使用字符指针变量和字符数组的讨论
虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们二者之间是有区别的，不
应混为一谈，主要有以下几点：
（１）字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字
符串第１个字符的地址），决不是将字符串放到字符指针变量中。
（２）赋值方式。对字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值。
ｃｈａｒ ｓｔｒ［１４］；
ｓｔｒ＝″ＩｌｏｖｅＣｈｉｎａ！″；
而对字符指针变量，可以采用下面方法赋值：
ｃｈａｒａ；
ａ＝″ＩｌｏｖｅＣｈｉｎａ！″；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１６１
但注意赋给ａ的不是字符，而是字符串第一个元素的地址。
（３）对字符指针变量赋初值：
ｃｈａｒａ＝″ＩｌｏｖｅＣｈｉｎａ！″；等价于
ｃｈａｒａ；
ａ＝″ＩｌｏｖｅＣｈｉｎａ！″；
而对数组的初始化：
ｃｈａｒ ｓｔｒ［１４］＝｛″Ｉｌｏｖｅ Ｃｈｉｎａ！″｝；
不能等价于
ｃｈａｒｓｔｒ［１４］；
ｓｔｒ［］＝″ＩｌｏｖｅＣｈｉｎａ！″；
（４）如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符
指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址也就是说，该指针变量可
以指向一个字符型数据，但如果未对它赋予一个地址值，则它并未具体指向一个确定的字符数据。
｛ｃｈａｒａ＝″ＩｌｏｖｅＣｈｉｎａ！″
如： ｃｈａｒｓｔｒ［１０］；
ｓｃａｎｆ（″％ｓ″，ｓｔｒ）；是可以的。
而常有人用下面的方法，目的是想输入一个字符串，虽然一般也能运行，但这种方法是危险的：
ｃｈａｒａ；
ｓｃａｎｆ（″％ｓ″，ａ）；
应当这样：
ｃｈａｒａ，ｓｔｒ［１０］；
ａ＝ｓｔｒ；
ｓｃａｎｆ（″％ｓ″，ａ）；
（５）指针变量的值是可以改变的，如：
例２０ 改变指针变量的值
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
；
ａ＝ａ＋７；
ｐｒｉｎｔｆ（″％ｓ″，ａ）；
｝
需要说明，若定义了一个指针变量，并使它指向一个字符串，就可以用下标形式引用指针变量所
指的字符串中的字符。
例２１
１６２
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｃｈａｒａ＝″ＩｌｏｖｅＣｈｉｎａ！″；
ｉｎｔｉ；
ｐｒｉｎｔｆ（“Ｔｈｅｓｉｘｔｈｃｈａｒａｃｔｅｒｉｓ％ｃ＼ｎ＂，ａ［５］）；
ｆｏｒ（ｉ＝０；ａ［ｉ］！＝′＼０′；ｉ＋＋）
ｐｒｉｎｔｆ（″％ｃ″，ａ［ｉ］）；
｝
考点５ 指向函数的指针
一、用函数指针变量调用函数
可以用指针变量指向整型变量、字符串、数组，也可以指向一个函数。一个函数在编译时被分配
给一个入口地址。这个函数的入口地址就称为函数的指针。
例２２ 求ａ和ｂ中的大者。先列出按一般方法的程序。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ｉｎｔ ｍａｘ（ｉｎｔ，ｉｎｔ）；
ｉｎｔａ，ｂ，ｃ；
ｓｃａｎｆ（″％ｄ，％ｄ″，＆ａ，＆ｂ）；
ｃ＝ｍａｘ（ａ，ｂ）；
ｐｒｉｎｔｆ（″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％ｄ
″，ａ，ｂ，ｃ）；
｝
ｉｎｔ ｍａｘ（ｉｎｔｘ，ｉｎｔｙ）
｛ｉｎｔｚ；
ｉｆ（ｘ＞ｙ）ｚ＝ｘ；
ｅｌｓｅ ｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
将ｍａｉｎ函数改写为
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（）
｛ ｉｎｔ ｍａｘ（ｉｎｔ，ｉｎｔ）；
ｉｎｔ（ｐ）（）；
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
１６３
ｉｎｔａ，ｂ，ｃ；
ｐ＝ｍａｘ；
ｓｃａｎｆ（″％ｄ，％ｄ″，＆ａ，＆ｂ）；
ｃ＝（ｐ）（ａ，ｂ）；
ｐｒｉｎｔｆ（″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％ｄ″，ａ，ｂ，ｃ）；
｝
二、用指向函数的指针作函数参数
函数指针变量常用的用途之一是把指针作为参数传递到其他函数。前面介绍过，函数的参数可
以是变量、指向变量的指针变量、数组名、指向数组的指针变量等。现在介绍指向函数的指针也可以
作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。
它的原理可以简述如下：有一个函数（假设函数名为ｓｕｂ），它有两个形参（ｘ１和ｘ２），定义ｘ１和
ｘ２为指向函数的指针变量。在调用函数ｓｕｂ时，实参为两个函数名ｆ１和ｆ２，给形参传递的是函数ｆ１
和ｆ２的地址。这样在函数ｓｕｂ中就可以调用ｆ１和ｆ２函数了。
实参函数名 ｆ１ ｆ２
↓ ↓
ｖｏｉｄｓｕｂ（ｉｎｔ（ｘ１）（ｉｎｔ），ｉｎｔ（ｘ２）（ｉｎｔ，ｉｎｔ））
｛ ｉｎｔａ，ｂ，ｉ，ｊ；
ａ＝（ｘ１）（ｉ）；／调用ｆ１函数／
ｂ＝（ｘ２）（ｉ，ｊ）；／调用ｆ２函数／
…
｝
例２３ 设一个函数ｐｒｏｃｅｓｓ，在调用它的时候，每次实现不同的功能。输入ａ和ｂ两个数，第一次
调用ｐｒｏｃｅｓｓ时找出ａ和ｂ中大者，第二次找出其中小者，第三次求ａ与ｂ之和。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄｍａｉｎ（）
｛ｉｎｔｍａｘ（ｉｎｔ，ｉｎｔ）； ／函数声明／
ｉｎｔｍｉｎ（ｉｎｔ，ｉｎｔ）； ／函数声明／
ｉｎｔａｄｄ（ｉｎｔ，ｉｎｔ）； ／函数声明／
ｖｏｉｄｐｒｏｃｅｓｓ（ｉｎｔ，ｉｎｔ，ｉｎｔ（ｆｕｎ）（））； ／函数声明／
ｉｎｔａ，ｂ；
ｐｒｉｎｔｆ（″ｅｎｔｅｒａａｎｄｂ：″）；
ｓｃａｎｆ（″％ｄ，％ｄ″，＆ａ，＆ｂ）；
ｐｒｉｎｔｆ（″ｍａｘ＝″）；
１６４
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍａｘ）；
ｐｒｉｎｔｆ（″ｍｉｎ＝″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍｉｎ）；
ｐｒｉｎｔｆ（″ｓｕｂ＝″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ａｄｄ）；
｝
ｉｎｔｍａｘ（ｉｎｔｘ，ｉｎｔｙ） ／函数定义／
｛ｉｎｔｚ；
ｉｆ（ｘ＞ｙ）ｚ＝ｘ；
ｅｌｓｅｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
ｉｎｔｍｉｎ（ｉｎｔｘ，ｉｎｔｙ） ／函数定义／
｛ｉｎｔｚ；
ｉｆ（ｘ＜ｙ）ｚ＝ｘ；
ｅｌｓｅｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
ｉｎｔａｄｄ（ｉｎｔｘ，ｉｎｔｙ） ／函数定义／
｛ｉｎｔｚ；
ｚ＝ｘ＋ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
ｖｏｉｄ ｐｒｏｃｅｓｓ（ｉｎｔｘ，ｉｎｔｙ，ｉｎｔ（ｆｕｎ）（ｉｎｔ，ｉｎｔ））
｛ｉｎｔｒｅｓｕｌｔ；
ｒｅｓｕｌｔ＝（ｆｕｎ）（ｘ，ｙ）；
ｐｒｉｎｔｆ（″％ｄ＼ｎ″，ｒｅｓｕｌｔ）；
｝
考点６ 返回指针值的函数
一个函数可以带回一个整型值、字符值、实型值等，也可以带回指针型的数据，即地址。其概念与
以前类似，只是带回的值的类型是指针类型而已。
这种带回指针值的函数，一般定义形式为
类型名函数名（参数表列）；
２１２
关闭成功返回值为０；否则返回ＥＯＦ（－１）
考点４：文件的读写
一、字符输入输出函数（ｆｐｕｔｃ（ ）和ｆｇｅｔｃ（ ））
ｆｐｕｔｓ函数
函数调用：
ｆｐｕｔｃ（ｃｈ，ｆｐ）；
函数功能：
将字符（ｃｈ的值）输出到ｆｐ所指向的文件中去。
返回值：
如果输出成功，则返回值就是输出的字符；
如果输出失败，则返回一个ＥＯＦ．
ｆｇｅｔｃ函数
函数调用：
ｃｈ＝ｆｇｅｔｃ（ｆｐ）；
函数功能：
从指定的文件读入一个字符，该文件必须是以读或读写方式打开的。
返回值：
读取成功一个字符，赋给ｃｈ。
如果遇到文件结束符，返回一个文件结束标志ＥＯＦ。
常见的读取字符操作
从一个文本文件顺序读入字符并在屏幕上显示出来：
ｃｈ＝ｆｇｅｔｃ（ｆｐ）；
ｗｈｉｌｅ（ｃｈ！＝ＥＯＦ）
｛
ｐｕｔｃｈａｒ（ｃｈ）；
ｃｈ＝ｆｇｅｔｃ（ｆｐ）；
｝
注意：ＥＯＦ不是可输出字符，因此不能在屏幕上显示。由于字符的ＡＳＣＩＩ码不可能出现－１，因此
ＥＯＦ定义为－１是合适的。当读入的字符值等于－１时，表示读入的已不是正常的字符而是文件结
束符。
常见的读取字符操作
从一个二进制文件顺序读入字符：
ｗｈｉｌｅ（！ｆｅｏｆ（ｆｐ））
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２１３
｛
ｃｈ＝ｆｇｅｔｃ（ｆｐ）；
｝
注意：ＡＮＳＩＣ提供一个ｆｅｏｆ（）函数来判断文件是否真的结束。如果是文件结束，函数ｆｅｏｆ（ｆｐ）的
值为１（真）；否则为０（假）。以上也适用于文本文件的读取。
ｆｐｕｔｃ和ｆｇｅｔｃ函数使用举例：
例１从键盘输入一些字符，逐个把它们送到磁盘上去，直到输入一个“＃”为止。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｌｉｂ．ｈ＞
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｖｏｉｄ ｍａｉｎ（ｖｏｉｄ）
｛ ＦＩＬＥｆｐ；
ｃｈａｒｃｈ，ｆｉｌｅｎａｍｅ［１０］；
ｓｃａｎｆ（＂％ｓ＂，ｆｉｌｅｎａｍｅ）；
ｉｆ（（ｆｐ＝ｆｏｐｅｎ（ｆｉｌｅｎａｍｅ，＂ｗ＂））＝＝ＮＵＬＬ）｛
ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）； ／终止程序／｝
ｃｈ＝ｇｅｔｃｈａｒ（）； ／接收执行ｓｃａｎｆ语句时最后输入的回车符／
ｃｈ＝ｇｅｔｃｈａｒ（）； ／接收输入的第一个字符／
ｗｈｉｌｅ（ｃｈ！＝‘＃’）｛
ｆｐｕｔｃ（ｃｈ，ｆｐ）；ｐｕｔｃｈａｒ（ｃｈ）；
ｃｈ＝ｇｅｔｃｈａｒ（）；｝
ｆｃｌｏｓｅ（ｆｐ）；
｝
运行情况如下：
Ｆｉｌｅ１．ｃ（输入磁盘文件名）
Ｃｏｍｐｕｔｅｒａｎｄｃ＃（输入一个字符串）
ｃｏｍｐｕｔｅｒａｎｄｃ（输出一个字符串）
ｆｐｕｔｃ和ｆｇｅｔｃ函数使用举例：
例２将一个磁盘文件中的信息复制到另一个磁盘文件中。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｌｉｂ．ｈ＞
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｍａｉｎ（）
２１４
｛ＦＩＬＥｉｎ，ｏｕｔ；
ｃｈａｒｃｈ，ｉｎｆｉｌｅ［１０］，ｏｕｔｆｉｌｅ［１０］；
ｐｒｉｎｔｆ（＂Ｅｎｔｅｒｔｈｅｉｎｆｉｌｅｎａｍｅ：＼ｎ＂）；
ｓｃａｎｆ（＂％ｓ＂，ｉｎｆｉｌｅ）；
ｐｒｉｎｔｆ（＂Ｅｎｔｅｒｔｈｅｏｕｔｆｉｌｅｎａｍｅ：＼ｎ＂）；
ｓｃａｎｆ（＂％ｓ＂，ｏｕｔｆｉｌｅ）；
ｉｆ（（ｉｎ＝ｆｏｐｅｎ（ｉｎｆｉｌｅ，＂ｒ＂））＝＝ＮＵＬＬ）
｛ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｉｎｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｉｆ（（ｏｕｔ＝ｆｏｐｅｎ（ｏｕｔｆｉｌｅ，＂ｗ＂））＝＝ＮＵＬＬ）
｛ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｏｕｔｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｗｈｉｌｅ（！ｆｅｏｆ（ｉｎ））
ｆｐｕｔｃ（ｆｇｅｔｃ（ｉｎ），ｏｕｔ）；
ｆｃｌｏｓｅ（ｉｎ）；
ｆｃｌｏｓｅ（ｏｕｔ）；｝
运行情况如下：
Ｅｎｔｅｒ ｔｈｅｉｎｆｉｌｅ ｎａｍｅ：
ｆｉｌｅ１．ｃ（输入原有磁盘文件名）
Ｅｎｔｅｒ ｔｈｅ ｏｕｔ ｆｉｌｅ１ ｎａｍｅ：
Ｆｉｌｅ２．ｃ（输入新复制的磁盘文件名）
程序运行结果是将ｆｉｌｅ１．ｃ文件中的内容复制到Ｆｉｌｅ２．ｃ中去。
ｆｐｕｔｃ和ｆｇｅｔｃ函数使用举例：
例２的改进：复制一个二进制文件，利用ｍａｉｎ参数，在输入命令行是将两个文件名输入。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｌｉｂ．ｈ＞
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｍａｉｎ（ｉｎｔａｒｇｃ，ｃｈａｒａｒｇｖ［］）
｛ＦＩＬＥｉｎ，ｏｕｔ；
ｃｈａｒｃｈ；
ｉｆ（ａｒｇｃ！＝３）
｛ ｐｒｉｎｔｆ（＂Ｙｏｕｆｏｒｇｏｔｔｏｅｎｔｅｒａｆｉｌｅｎａｍｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｉｆ（（ｉｎ＝ｆｏｐｅｎ（ａｒｇｖ［１］，＂ｒｂ＂））＝＝ＮＵＬＬ）
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２１５
｛ ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｉｎｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｉｆ（（ｏｕｔ＝ｆｏｐｅｎ（ａｒｇｖ［２］，＂ｗｂ＂））＝＝ＮＵＬＬ）
｛ ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｏｕｔｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｗｈｉｌｅ（！ｆｅｏｆ（ｉｎ））ｆｐｕｔｃ（ｆｇｅｔｃ（ｉｎ），ｏｕｔ）；
ｆｃｌｏｓｅ（ｉｎ）；
ｆｃｌｏｓｅ（ｏｕｔ）；｝
运行方法：
设经编译连接后得到的可执行文件名为ａ．ｅｘｅ，则在ＤＯＳ命令工作方式下，可以输入以下的命
令行：
Ｃ＞ａ ｆｉｌｅ１．ｃ ｆｉｌｅ２．ｃ
ｆｉｌｅ１．ｃ和ｆｉｌｅ２．ｃ，分别输入到ａｒｇｖ［１］和ａｒｇｖ［２］中，ａｒｇｖ［０］的内容为ａ，ａｒｇｃ的值等于３。
二、数据块读写函数（ｆｒｅａｄ（ ）和ｆｗｒｉｔｅ（ ））
函数调用：
ｆｒｅａｄ（ｂｕｆｆｅｒ，ｓｉｚｅ，ｃｏｕｎｔ，ｆｐ）；
ｆｗｒｉｔｅ（ｂｕｆｆｅｒ，ｓｉｚｅ，ｃｏｕｎｔ，ｆｐ）；
参数说明：
ｂｕｆｆｅｒ：是一个指针。
对ｆｒｅａｄ来说，它是读入数据的存放地址。
对ｆｗｒｉｔｅ来说，是要输出数据的地址（均指起始地址）。
ｓｉｚｅ：要读写的字节数。
ｃｏｕｎｔ：要进行读写多少个ｓｉｚｅ字节的数据项。
ｆｐ：文件型指针。
使用举例：
若文件以二进制形式打开：
ｆｒｅａｄ（ｆ，４，２，ｆｐ）；
此函数从ｆｐ所指向的文件中读入２个４个字节的数据，存储到数组ｆ中。
使用举例：
若有如下结构类型：
ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ
｛ｃｈａｒｎａｍｅ［１０］；
ｉｎｔｎｕｍ；
２１６
ｉｎｔａｇｅ；
ｃｈａｒａｄｄｒ［３０］；｝ｓｔｕｄ［４０］；
可以用ｆｒｅａｄ和ｆｗｒｉｔｅ来进行数据的操作：
ｆｏｒ（ｉ＝０；ｉ＜４０；ｉ＋＋）
ｆｒｅａｄ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ－ｔｙｐｅ），１，ｆｐ）；
ｆｏｒ（ｉ＝０；ｉ＜４０，ｉ＋＋）
ｆｗｒｉｔｅ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ－ｔｙｐｅ），１，ｆｐ）；
使用举例：
例３从键盘输入４个学生的有关数据，然后把它们转存到磁盘文件上去。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＳＩＺＥ４
ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ
｛ｃｈａｒｎａｍｅ［１０］；
ｉｎｔｎｕｍ；
ｉｎｔａｇｅ；
ｃｈａｒａｄｄｒ［１５］；
｝ｓｔｕｄ［ＳＩＺＥ］；／定义结构／
ｖｏｉｄｓａｖｅ（）
｛ＦＩＬＥｆｐ；
ｉｎｔｉ；
ｉｆ（（ｆｐ＝ｆｏｐｅｎ（＂ｓｔｕ－ｌｉｓｔ＂，＂ｗｂ＂））＝＝ＮＵＬＬ）
｛ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｆｉｌｅ＼ｎ＂）；
ｒｅｔｕｒｎ；｝
ｆｏｒ（ｉ＝０；ｉ＜ＳＩＺＥ；ｉ＋＋） ／二进制写／
ｉｆ（ｆｗｒｉｔｅ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ），１，ｆｐ）！＝１）
ｐｒｉｎｔｆ（“ｆｉｌｅｗｒｉｔｅｅｒｒｏｒ＼ｎ”）； ／出错处理／
ｆｃｌｏｓｅ（ｆｐ）；｝ ／关闭文件／
ｍａｉｎ（）
｛ｉｎｔｉ；
ｆｏｒ（ｉ＝０；ｉ＜ＳＩＺＥ；ｉ＋＋） ／从键盘读入学生信息／
ｓｃａｎｆ（＂％ｓ％ｄ％ｄ％ｓ＂，ｓｔｕｄ［ｉ］．ｎａｍｅ，＆ｓｔｕｄ［ｉ］．ｎｕｍ，
＆ｓｔｕｄ［ｉ］．ａｇｅ，ｓｔｕｄ［ｉ］．ａｄｄｒ）；
ｓａｖｅ（）；｝ ／调用ｓａｖｅ（）保存学生信息／
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２１７
运行情况如下：
输入４个学生的姓名、学号、年龄和地址：
Ｚｈａｎｇ １００１ １９ ｒｏｏｍ－１０１
Ｆｕｎ １００２ ２０ ｒｏｏｍ－１０２
Ｔａｎ １００３ ２１ ｒｏｏｍ－１０３
Ｌｉｎｇ １００４ ２１ ｒｏｏｍ－１０４
验证在磁盘文件“ｓｔｕ－ｌｉｓｔ”中是否已存在此数据，用以下程序从“ｓｔｕ－ｌｉｓｔ”文件中读入数据，然后
在屏幕上输出。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
＃ｄｅｆｉｎｅＳＩＺＥ４
ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ
｛ ｃｈａｒｎａｍｅ［１０］；
ｉｎｔｎｕｍ；
ｉｎｔａｇｅ；
ｃｈａｒａｄｄｒ［１５］；
｝ｓｔｕｄ［ＳＩＺＥ］；
ｍａｉｎ（）
｛ ｉｎｔｉ；
ＦＩＬＥｆｐ；
ｆｐ＝ｆｏｐｅｎ（＂ｓｔｕ－ｌｉｓｔ＂，＂ｒｂ＂）；
ｆｏｒ（ｉ＝０；ｉ＜ＳＩＺＥ；ｉ＋＋）
｛ｆｒｅａｄ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ），１，ｆｐ）；
ｐｒｉｎｔｆ（＂％＼－１０ｓ％４ｄ ％４ｄ ％＼－１５ｓ＼ｎ＂，ｓｔｕｄ［ｉ］．ｎａｍｅ，
ｓｔｕｄ［ｉ］．ｎｕｍ，ｓｔｕｄ［ｉ］．ａｇｅ，ｓｔｕｄ［ｉ］．ａｄｄｒ）；｝
ｆｃｌｏｓｅ（ｆｐ）；｝
屏幕上显示出以下信息：
Ｚｈａｎｇ １００１ １９ ｒｏｏｍ－１０１
Ｆｕｎ １００２ ２０ ｒｏｏｍ－１０２
Ｔａｎ １００３ ２１ ｒｏｏｍ－１０３
Ｌｉｎｇ １００４ ２１ ｒｏｏｍ－１０４
如果已有的数据已经以二进制形式存储在一个磁盘文件“ｓｔｕ－ｄａｔ“中，要求从其中读入数据并
输出到“ｓｔｕ－ｄａｔ”文件中，可以编写一个ｌｏａｄ函数，从磁盘文件中读二进制数据．
ｖｏｉｄｌｏａｄ（）
２１８
｛ＦＩＬＥｆｐ；ｉｎｔｉ；
ｉｆ（（ｆｐ＝ｆｏｐｅｎ（＂ｓｔｕ－ｄａｔ＂，＂ｒｂ＂））＝＝ＮＵＬＬ）
｛ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｉｎｆｉｌｅ＼ｎ＂）；
ｒｅｔｕｒｎ；｝
ｆｏｒ（ｉ＝０；ｉ＜ＳＩＺＥ；ｉ＋＋）
ｉｆ（ｆｒｅａｄ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ），１，ｆｐ）！＝１）
｛ｉｆ（ｆｅｏｆ（ｆｐ））｛ｆｃｌｏｓｅ（ｆｐ）；ｒｅｔｕｒｎ；｝
ｐｒｉｎｔｆ（＂ｆｉｌｅｒｅａｄｅｒｒｏｒ＼ｎ＂）；｝
ｆｃｌｏｓｅ（ｆｐ）；｝
三、格式化读写函数（ｆｐｒｉｎｔｆ（）和ｆｓｃａｎｆ（））
函数调用：
ｆｐｒｉｎｔｆ（文件指针，格式字符串，输出表列）；
ｆｓｃａｎｆ （文件指针，格式字符串，输入表列）；
函数功能：
从磁盘文件中读入或输出字符。
例：
ｆｐｒｉｎｔｆ（ｆｐ，”％ｄ，％６．２ｆ”，ｉ，ｔ）；
ｆｓｃａｎｆ（ｆｐ，”％ｄ，％ｆ”，＆ｉ，＆ｔ）；
注意：
用ｆｐｒｉｎｔｆ和ｆｓｃａｎｆ函数对磁盘文件读写，使用方便，容易理解，但由于在输入时要将ＡＳＣＩＩ码转换
为二进制形式，在输出时又要将二进制形式转换成字符，花费时间比较多。因此，在内存与磁盘频繁
交换数据的情况下，最好不用ｆｐｒｉｎｔｆ和ｆｓｃａｎｆ函数，而用ｆｒｅａｄ和ｆｗｒｉｔｅ函数。
三、其他读写函数
ｐｕｔｗ（）和ｇｅｔｗ（）
ｐｕｔｗ函数定义如下：
ｐｕｔｗ（ｉｎｔＩ，ＦＩＬＥｆｐ）
｛
ｃｈａｒｓ；
ｓ＝＆Ｉ；
ｐｕｔｃ（ｓ［０］，ｆｐ）；
ｐｕｔｃ（ｓ［１］，ｆｐ）；
ｒｅｔｕｒｎｉ；
｝
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２１９
ｇｕｔｗ函数定义如下：
ｇｕｔｗ（ＦＩＬＥｆｐ）
｛
ｃｈａｒｓ；
ｓ＝ｃｈａｒ＆ｉ；
ｓ［０］＝ｇｅｔｃ（ｆｐ）；
ｓ［１］＝ｇｅｔｃ（ｆｐ）；
ｒｅｔｕｒｎｉ；
｝
函数调用：
ｐｕｔｗ（ｉｎｔｉ，ＦＩＬＥｆｐ）；
ｉｎｔｉ＝ｇｅｔｗ（ＦＩＬＥｆｐ）；
函数功能：
对磁盘文件中读写一个字（整数）。
例：
ｐｕｔｗ（１０，ｆｐ）；
ｉ＝ｇｅｔｗ（ｆｐ）；
用户自定义读取其他类型数据的函数
向磁盘文件写一个实数（用二进制方式）的函数ｐｕｔｆｌｏａｔ：
ｐｕｔｆｌｏａｔ（ｆｌｏａｔｎｕｍ，ＦＩＬＥｆｐ）
｛
ｃｈａｒｓ；
ｉｎｔｃｏｕｎｔ；
ｓ＝（ｃｈａｒ）＆ｎｕｍ；
ｆｏｒ（ｃｏｕｎｔ＝０；ｃｏｕｎｔ＜４；ｃｏｕｎｔ＋＋）
ｐｕｔｃ（ｓ［ｃｏｕｎｔ］，ｆｐ）；
｝
ｆｇｅｔｓ函数
函数作用：
从指定文件读入一个字符串。
函数调用：
ｆｇｅｔｓ（ｓｔｒ，ｎ，ｆｐ）；
从ｆｐ指向的文件输入ｎ－１个字符，在最后加一个’＼０’
２２０
返回值：
ｓｔｒ的首地址
ｆｐｕｔｓ函数
函数作用：
向指定的文件输出一个字符串。
函数调用：
ｆｐｕｔｓ（“ｃｈｉｎａ”，ｆｐ）；
第一个参数可以是字符串常量、字符数组名或字符型指针。字符串末尾的′＼０′不输出。
返回值：
输入成功，返回值为０；
输入失败，返回ＥＯＦ．
考点５：文件的定位
ｒｅｗｉｎｄ函数
函数作用：
使位置指针重新返回文件的开头，无返回值。
应用举例：
例４ 有一个磁盘文件，第一次将它的内容显示在屏幕上，第二次把它复制到另一文件上。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｍａｉｎ（）
｛ＦＩＬＥｆｐ１，ｆｐ２；
ｆｐ１＝ｆｏｐｅｎ（＂ｆｉｌｅ１．ｃ＂，＂ｒ＂）；
ｆｐ２＝ｆｏｐｅｎ（＂ｆｉｌｅ２．ｃ＂，＂ｗ＂）；
ｗｈｉｌｅ（！ｆｅｏｆ（ｆｐ１））ｐｕｔｃｈａｒ（ｇｅｔｃ（ｆｐ１））；
ｒｅｗｉｎｄ（ｆｐ１）；
ｗｈｉｌｅ（！ｆｅｏｆ（ｆｐ１））
ｐｕｔｃ（ｇｅｔｃ（ｆｐ１），ｆｐ２）；
ｆｃｌｏｓｅ（ｆｐ１）；ｆｃｌｏｓｅ（ｆｐ２）；
｝
顺序读写和随机读写
顺序读写：
位置指针按字节位置顺序移动。
随机读写：
读写完上一个字符（字节）后，并不一定要读写其后续的字符（字节），而可以读些文件中任意位
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２２１
置上所需要的字符（字节）。
ｆｓｅｅｋ函数（一般用于二进制文件）
函数功能：
改变文件的位置指针
函数调用形式：
ｆｓｅｅｋ（文件类型指针，位移量，起始点）
起始点：文件开头 ＳＥＥＫ＿ＳＥＴ ０
文件当前位置 ＳＥＥＫ＿ＣＵＲ １
文件末尾 ＳＥＥＫ＿ＥＮＤ ２
位移量：以起始点为基点，向前移动的字节数。一般要求为ｌｏｎｇ型
ｆｓｅｅｋ函数应用举例
ｆｓｅｅｋ（ｆｐ，１００Ｌ，０）；
将位置指针移到离文件头１００个字节处
ｆｓｅｅｋ（ｆｐ，５０Ｌ，１）；
将位置指针移到离当前位置５０个字节处
ｆｓｅｅｋ（ｆｐ，５０Ｌ，２）；
将位置指针从文件末尾处向后退５０个字节
例５ 在磁盘文件上存有１０个学生的数据。要求将第１、３、５、７、９个学生数据输入计算机，并在
屏幕上显示出来。
＃ｉｎｃｌｕｄｅ＜ｓｔｄｌｉｂ．ｈ＞
＃ｉｎｃｌｕｄｅ＜ｓｔｄｉｏ．ｈ＞
ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ
｛ ｃｈａｒｎａｍｅ［１０］；
ｉｎｔｎｕｍ；
ｉｎｔａｇｅ；
ｃｈａｒｓｅｘ；
｝ｓｔｕｄ［１０］； ｍａｉｎ（）
｛ ｉｎｔｉ；
ＦＩＬＥ ｆｐ；
ｉｆ（（ｆｐ＝ｆｏｐｅｎ（＂ｓｔｕｄ－ｄａｔ＂，＂ｒｂ＂））＝＝ＮＵＬＬ）
｛ｐｒｉｎｔｆ（＂ｃａｎｎｏｔｏｐｅｎｆｉｌｅ＼ｎ＂）；
ｅｘｉｔ（０）；｝
ｆｏｒ（ｉ＝０；ｉ＜１０；ｉ＋＝２）
２２２
｛ｆｓｅｅｋ（ｆｐ，ｉｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ），０）；
ｆｒｅａｄ（＆ｓｔｕｄ［ｉ］，ｓｉｚｅｏｆ（ｓｔｒｕｃｔｓｔｕｄｅｎｔ＿ｔｙｐｅ），１，ｆｐ）；
ｐｒｉｎｔｆ（“％ｓ％ｄ％ｄ％ｃ＼ｎ”，ｓｔｕｄ［ｉ］．ｎａｍｅ，
ｓｔｕｄ［ｉ］．ｎｕｍ，ｓｔｕｄ［ｉ］．ａｇｅ，ｓｔｕｄ［ｉ］．ｓｅｘ）；｝
ｆｃｌｏｓｅ（ｆｐ）｝
ｆｔｅｌｌ函数
函数作用：
得到流式文件中的当前位置，用相对于文件开头的位移量来表示。
返回值：
返回当前位置，出错时返回－１Ｌ。
应用举例：
ｉ＝ｆｔｅｌｌ（ｆｐ）；
ｉｆ（ｉ＝＝－１Ｌ）ｐｒｉｎｔｆ（“ｅｒｒｏｒ＼ｎ”）；
考点６：出错的检测
ｆｅｒｒｏｒ函数
调用形式：
ｆｅｒｒｏｒ（ｆｐ）；
返回值：
返回０，表示未出错；返回非０，表示出错。
在调用一个输入输出函数后立即检查ｆｅｒｒｏｒ函数的值，否则信息会丢失。在执行ｆｏｐｅｎ函数时，
ｆｅｒｒｏｒ函数的初始值自动置为０。
ｃｌｅａｒｅｒｒ函数
调用形式：
ｃｌｅａｒｅｒｒ（ｆｐ）；
函数作用：
使文件错误标志和文件结束标志置为０。
只要出现错误标志，就一直保留，直到对同一文件调用ｃｌｅａｒｅｒｒ函数或ｒｅｗｉｎｄ函数，或任何其他一
个输入输出函数。
考点７：文件输入和输出小结
分类 函数名 功能
打开文件 ｆｏｐｅｎ（） 打开文件
关闭文件 ｆｃｌｏｓｅ（） 关闭文件
文件定位 ｆｓｅｅｋ（） 改变文件位置指针的位置
谭浩强《Ｃ语言程序设计》考点精讲及复习思路
２２３
ｒｅｗｉｎｄ（） 使文件位置指针重新至于文件开头
ｆｔｅｌｌ（） 返回文件位置指针的当前值
文件状态 ｆｅｏｆ（） 若到文件末尾，函数值为真
ｆｅｒｒｏｒ（） 若对文件操作出错，函数值为真
ｃｌｅａｒｅｒｒ（） 使ｆｅｒｒｏｒ和ｆｅｏｆ（）函数值置零
文件读写 ｆｇｅｔｃ（） 从指定文件取得一个字符
ｆｐｕｔｃ（） 把字符输出到指定文件
ｆｇｅｔｓ（）从指定文件读取字符串
ｆｐｕｔｓ（） 把字符串输出到指定文件
ｇｅｔｗ（） 从指定文件读取一个字（ｉｎｔ型）
ｐｕｔｗ（）
ｆｒｅａｄ（）
把一个字输出到指定文件
从指定文件中读取数据项
ｆｗｒｉｔｅ（） 把数据项写到指定文件中
ｆｓｃａｎｆ（）
ｆｐｒｉｎｔｆ（）
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
殏
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪殏
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
檪
殏
从指定文件按格式输入数据
按指定格式将数据写到指定文件中
檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪檪殏
本章小结
主要知识点：
文件类型指针
文件的打开与关闭
文件的读写
文件的定位
文件输入输出
|
|
