c语言

一、C语言的产生与发展
C语言是1972年由美国的Dennis Ritchie设计发明的,并首次在UNIX操作系统的 DEC PDP-11 计算机上使用。它由早期的编程语言BCPL (Basic Combind Programming Language)发展演变而来。在1970年,AT&T贝尔实验室的Ken hompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。
随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准, 使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。

二、C语言的特点
C语言发展如此迅速, 而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件, 如PC-DOS,DBASE Ⅳ都是由C语言编写的。用C语言加上一些汇编语言子程序, 就更能显示C语言的优势了。归纳起来C语言具有下列特点:
1. C是中级语言
它把高级语言的基本结构和语句与低级语言的实用性结合起来。C语言可以象汇编语言一样对位、字节和地址进行操作,而这三者是计算机最基本的工作单元。
2. C是结构式语言
结构式语言的显著特点是代码及数据的分隔化,即程序的各个部分除了必要的信息交流外彼此独立。这种结构化方式可使程序层次清晰,便于使用、维护以及调试。C 语言是以函数形式提供给用户的,这些函数可方便的调用,并具有多种循环、条件语句控制程序流向,从而使程序完全结构化。
3. C语言功能齐全
C语言具有各种各样的数据类型,并引入了指针概念,可使程序效率更高。另外C语言也具有强大的图形功能,支持多种显示器和驱动器。而且计算功能、逻辑判断功能也比较强大,可以实现决策目的。
4. C语言适用范围大
C语言还有一个突出的优点就是适合于多种操作系统,如DOS、UNIX,也适用于多种机型。

三、Turbo C的产生与发展
我们平常用的大部分都是Turbo C。Turbo C是美国Borland公司的产品,Borland公司是一家专门从事软件开发、研制的公司。该公司相继推出了一套Turbo系列软件,如Turbo BASIC,Turbo Pascal,Turbo Prolog,这些软件很受用户欢迎。该公司在1987年首次推出Turbo C 1.0产品,其中使用了全然一新的集成开发环境,即使用了一系列下拉式菜单,将文本编辑、程序编译、连接以及程序运行一体化, 大大方便了程序的开发。1988年,Borland公司又推出Turbo C 1.5版本,增加了图形库和文本窗口函数库等,而Turbo C 2.0 则是该公司1989年出版的。Turbo C2.0在原来集成开发环境的基础上增加了查错功能,并可以在Tiny模式下直接生成.COM (数据、代码、堆栈处在同一64K中)文件。还可对数学协处理器(支持8087/80287/80387等)进行仿真。我们目前经常使用的集成环境就是Turbo C 2.0。
Borland 公司后来又推出了面向对象的程序软件包Turbo C++,它继承发展Turbo C 2.0的集成开发环境, 并包含了面向对象的基本思想和设计方法。习惯上我们也叫它Turbo C 3.0。
1991年为了适用Microsoft公司的Windows 3.0版本,Borland公司又将Turbo C++作了更新,即Turbo C的新一代产品Borlandc C++也已经问世了。
四、Turbo C 2.0集成开发环境的使用
下载完以后，解压缩，双击TC.EXE,进入Turbo C 2.0集成开发环境中后, 屏幕上显示:
─────────────────────────────---
File Edit Run Compile Project Options Debug Break/watch
┌────────────Edit──────────────┐
│ Line 1 Col 1 Insert Indent Tab File Unindent c:NONAME.C│
│ │
│ │
│ │
│ │
│ │
│ │
│ │
│─────────Message─────────────── |
│ │
│ │
└──────────────────────────--─┘
F1-Help F5-Zoom F6-Switch F7-Trace F8-Step F9-Make F10-Menu
───────────────────────────────
其中顶上一行为Turbo C 2.0 主菜单, 中间窗口为编辑区, 接下来是信息窗口, 最底下一行为参考行。这四个窗口构成了Turbo C 2.0的主屏幕, 以后的编程、编译、调试以及运行都将在这个主屏幕中进行。
下面详细介绍主菜单的内容：
(一)、主菜单 在Turbo C 2.0主屏幕顶上一行, 显示下列内容:
File Edit Run Compile Project Options Debug Break/watch
除Edit外, 其它各项均有子菜单, 只要用Alt加上某项中第一个字母(即大写字母), 就可进入该项的子菜单中。
1、File(文件)菜单
按Alt+F可进入File菜单, 该菜单包括以下内容:
.Load(加载)
装入一个文件, 可用类似DOS的通配符(如*.C)来进行列表选择。也可装入其它扩展名的文件, 只要给出文件名(或只给路径)即可。该项的热键为F3, 即只要在主菜单中按F3即可进入该项, 而不需要先进入File菜单再选此项。
.Pick(选择)
将最近装入编辑窗口的8个文件列成一个表让用户选择, 选择后将该程序装入编辑区，并将光标置在上次修改过的地方。其热健为Alt+F3。
.New(新文件)
说明文件是新的, 缺省文件名为NONAME.C, 存盘时可改名。
.Save(存盘)
将编辑区中的文件存盘, 若文件名是NONAME.C时, 将询问是否更改文件名, 其热键为F2。
.Write to(存盘)
可由用户给出文件名将编辑区中的文件存盘, 若该文件已存在, 则询问要不要覆盖。
.Directory(目录)
显示目录及目录中的文件, 并可由用户选择。
.Change dir(改变目录)
显示当前目录, 用户可以改变显示的目录。
.Os shell(暂时退出)
暂时退出Turbo C 2.0到DOS提示符下, 此时可以运行DOS 命令, 若想回到Turbo C 2.0中,只要在DOS状态下键入EXIT即可。
.Quit(退出)
退出Turbo C 2.0, 返回到DOS操作系统中, 其热键为Alt+X。
说明: 以上各项可用光标键移动色棒进行选择, 回车则执行。也可用每一项的第一个大写字母直接选择。若要退到主菜单或从它的下一级菜单列表框退回均可用Esc键,Turbo C 2.0所有菜单均采用这种方法进行操作, 以下不再说明。
2、Edit(编辑)菜单
按Alt+E可进入编辑菜单, 若再回车, 则光标出现在编辑窗口,此时用户可以进行文本编辑。
编辑方法基本与wordstar相同, 可用F1键获得有关编辑方法的帮助信息。
与编辑有关的功能键如下:
F1 获得Turbo C 2.0编辑命令的帮助信息
F5 扩大编辑窗口到整个屏幕
F6 在编辑窗口与信息窗口之间进行切换
F10 从编辑窗口转到主菜单
编辑命令简介:
PageUp 向前翻页
PageDn 向后翻页
Home 将光标移到所在行的开始
End 将光标移到所在行的结尾
Ctrl+Y 删除光标所在的一行
Ctrl+T 删除光标所在处的一个词
Ctrl+KB 设置块开始
Ctrl+KK 设置块结尾
Ctrl+KV 块移动
Ctrl+KC 块拷贝
Ctrl+KY 块删除
Ctrl+KR 读文件
Ctrl+KW 存文件
Ctrl+KP 块文件打印
Ctrl+F1 如果光标所在处为Turbo C 2.0库函数,则获得有关该函数的帮助信息
Ctrl+Q[ 查找Turbo C 2.0双界符的后匹配符
Ctrl+Q] 查找Turbo C 2.0双界符的前匹配符
说明:
(1). Turbo C 2.0的双界符包括以下几种符号:
花括符 {和}
尖括符 <和>
圆括符 (和)
方括符 [和]
注释符 /*和*/
双引号
单引号 '
(2). Turbo C
2.0在编辑文件时还有一种功能,就是能够自动缩进,即光标定位和上一个非空字符对齐。在编辑窗口中,Ctrl+OL为自动缩进开关的控制键。
3、Run(运行)菜单
按Alt+R可进入Run菜单, 该菜单有以下各项:
.Run(运行程序)
运行由Project/Project name项指定的文件名或当前编辑区的文件。如果对上次编译后的源代码未做过修改,则直接运行到下一个断点(没有断点则运行到结束)。否则先进行编译、连接后才运行,其热键为Ctrl+F9。
.Program reset(程序重启)
中止当前的调试, 释放分给程序的空间, 其热键为Ctrl+F2。
.Go to cursor(运行到光标处)
调试程序时使用, 选择该项可使程序运行到光标所在行。光标所在行必须为一条可执行语句, 否则提示错误。其热键为F4。
.Trace into(跟踪进入)
在执行一条调用其它用户定义的子函数时,若用Trace into项,则执行长条将跟踪到该子函数内部去执行,其热键为F7。
.Step over(单步执行)
执行当前函数的下一条语句,即使用户函数调用,执行长条也不会跟踪进函数内部,其热键为F8。
.User screen(用户屏幕)
显示程序运行时在屏幕上显示的结果。其热键为Alt+F5。
4、Compile(编译)菜单
按Alt+C可进入Compile菜单,该菜单有以下几个内容:
.Compile to OBJ(编译生成目标码)
将一个C源文件编译生成.OBJ目标文件,同时显示生成的文件名。其热键为Alt+F9。
.Make EXE file(生成执行文件)
此命令生成一个.EXE的文件,并显示生成的.EXE文件名。其中.EXE文件名是下面几项之一。
(1). 由Project/Project name说明的项目文件名。
(2). 若没有项目文件名,则由Primary C file说明的源文件。
(3). 若以上两项都没有文件名,则为当前窗口的文件名。
.Link EXE file(连接生成执行文件)
把当前.OBJ文件及库文件连接在一起生成.EXE文件。
.Build all(建立所有文件)
重新编译项目里的所有文件,并进行装配生成.EXE文件。该命令不作过时检查(上面的几条命令要作过时检查,即如果目前项目里源文件的日期和时间与目标文件相同或更早, 则拒绝对源文件进行编译)。
.Primary C file(主C文件)
当在该项中指定了主文件后,在以后的编译中,如没有项目文件名则编译此项中规定的主C文件,如果编译中有错误,则将此文件调入编辑窗口,不管目前窗口中是不是主C文件。
.Get info(获得有关当前路径、源文件名、源文件字节大小、编译中的错误数目、可用空间等信息。
5、Project(项目)菜单
按Alt+P可进入Project菜单,该菜单包括以下内容:
.Project name(项目名)
项目名具有.PRJ的扩展名,其中包括将要编译、连接的文件名。例如有一个程序由file1.c, file2.c, file3.c组成,要将这3个文件编译装配成一个file.exe的执行文件,可以先建立一个file.prj的项目文件,其内容如下:
file1.c
file2.c
file3.c
此时将file.prj放入Project name项中,以后进行编译时将自动对项目文件中规定的三个源文件分别进行编译。然后连接成file.exe文件。如果其中有些文件已经编译成.OBJ文件,而又没有修改过,可直接写上.OBJ扩展名。此时将不再编译而只进行连接。
例如: file1.obj
file2.c
file3.c
将不对file1.c进行编译,而直接连接。
说明: 当项目文件中的每个文件无扩展名时,均按源文件对待,另外,其中的文件也可以是库文件, 但必须写上扩展名.LIB。
.Break make on(中止编译)
由用户选择是否在有Warining(警告)、Errors(错误)、Fatal Errors( 致命错误)时或Link(连接)之前退出Make编译。
.Auto dependencies(自动依赖)
当开关置为on, 编译时将检查源文件与对应的.OBJ文件日期和时间,否则不进行检查。
.Clear project(清除项目文件)
清除Project/Project name中的项目文件名。
.Remove messages(删除信息)
把错误信息从信息窗口中清除掉。
6、Options(选择菜单)
按Alt+O可进入Options菜单, 该菜单对初学者来说要谨慎使用。
.Compiler(编译器)
本项选择又有许多子菜单, 可以让用户选择硬件配置、存储模型、调试技术、代码优化、对话信息控制和宏定义。这些子菜单如下:
Model
共有Tiny, small, medium, compact, large, huge 六种不同模式可由同户选择。
Define
打开一个宏定义框,同户可输入宏定义。多重定义可同分号,赋值可用等号。
Code generation
它又有许多任选项,这些任选项告诉编译器产生什么样的目标代码。
Calling convention 可选择C或Pascal方式传递参数。
Instruction set 可选择8088/8086或80186/80286指令系列。
Floating point 可选择仿真浮点、数学协处理器浮点或无浮点运算。
Default char type 规定char的类型。
Alignonent 规定地址对准原则。
Merge duplicate strings 作优化用,将重复的字符串合并在一起。
Standard stack frame 产生一个标准的栈结构。
Test stack overflow 产生一段程序运行时检测堆栈溢出的代码。
Line number 在.OBJ文件中放进行号以供调试时用。
OBJ debug information 在.OBJ文件中产生调试信息。
Optimization
Optimize for 选择是对程序小型化还是对程序速度进行优 化处理。
Use register variable 用来选择是否允许使用寄存器变量。
Register optimization 尽可能使用寄存器变量以减少过多的取数操作。
Jump optimization 　　　通过去除多余的跳转和调整循环与开关语句的办法,压缩代码。
Source
Indentifier length 说明标识符有效字符的个数,默认为32个。
Nested comments 是否允许嵌套注释。
ANSI keywords only　　　是只允许ANSI关键字还是也允许Turbo C 2.0关键字。
Error
Error stop after 多少个错误时停止编译,默认为25个。
Warning stop after　多少个警告错误时停止编译, 默认为100个。
Display warning
Portability warning 移植性警告错误。
ANSI Violations 侵犯了ANSI关键字的警告错误。
Common error　　　 常见的警告错误。
Less common error 少见的警告错误。
Names 用于改变段(segment)、组(group)和类(class)的名字,默认值为CODE,DATA,BSS。
.Linker(连接器)
本菜单设置有关连接的选择项,它有以下内容:
Map file menu 选择是否产生.MAP文件。
Initialize segments　　是否在连接时初始化没有初始化的段。
Devault libraries 是否在连接其它编译程序产生的目标文件时去寻找其缺省库。
Graphics library 是否连接graphics库中的函数。
Warn duplicate symbols 当有重复符号时产生警告信息。
Stack warinig 是否让连接程序产生No stack的警告信息。
Case-sensitive link 是否区分大、小写字。
.Environment(环境)
本菜单规定是否对某些文件自动存盘及制表键和屏幕大小的设置
Message tracking
Current file 跟踪在编辑窗口中的文件错误。
All files 跟踪所有文件错误。
Off 不跟踪。
Keep message 编译前是否清除Message窗口中的信息。
Config auto save 选on时,在Run,Shell或退出集成开发环境之前,如果Turbo C
2.0的配置被改过,则所做的改动将存入配置文件中。选off时不存。
Edit auto save 是否在Run或Shell之前, 自动存储编辑的源文件。
Backup file 是否在源文件存盘时产生后备文件(.BAK文件)。
Tab size 设置制表键大小,默认为8。
Zoomed windows 将现行活动窗口放大到整个屏幕, 其热键为F5。
Screen size 设置屏幕文本大小。
.Directories(路径)
规定编译、连接所需文件的路径,有下列各项:
Include directories 包含文件的路径,多个子目录用;分开。
Library directories 库文件路径,多个子目录用;分开。
Output directoried 输出文件(.OBJ,.EXE,.MAP文件)的目录。
Turbo C directoried Turbo C 所在的目录。
Pick file name 定义加载的pick文件名,如不定义则从current pick file中取。
.Arguments(命令行参数)
允许用户使用命令行参数。
.Save options(存储配置)
保存所有选择的编译、连接、调试和项目到配置文件中,缺省的配置文件为TCCONFIG.TC。
.Retrive options
装入一个配置文件到TC中,TC将使用该文件的选择项。
7、Debug(调试)菜单
按Alt+D可选择Debug菜单,该菜单主要用于查错,它包括以下内容:
.Evaluate(Ctrl+F4)
Expression 要计算结果的表达式。
Result 显示表达式的计算结果。
New value 赋给新值。
.Call stack(Ctrl+F3) 该项不可接触。而在Turbo C debuger时用于检查堆栈情况。
.Find function 在运行Turbo C debugger时用于显示规定的函数。
.Refresh display 如果编辑窗口偶然被用户窗口重写了可用此恢复编辑窗口的内容。
8、Break/watch(断点及监视表达式)
按Alt+B可进入Break/watch菜单, 该菜单有以下内容:
.Add watch(Ctrl+F7) 向监视窗口插入一监视表达式。
.Delete watch 从监视窗口中删除当前的监视表达式。
.Edit watch 在监视窗口中编辑一个监视表达式。
.Remove all watches 从监视窗口中删除所有的监视表达式。
.Toggle breakpoint(Ctrl+F8) 对光标所在的行设置或清除断点。
.Clear all breakpoints 清除所有断点。
.View next breakpoint 将光标移动到下一个断点处。
(二)、编辑区 所有的程序代码都在这个区域编写，修改。用ALT+E进入编辑区。在编辑区的最上面还显示光标所数在行和所在列数。
(三)、信息窗口 在编译过程中显示程序的错误和警告；在单步调试过程中，显示所添加监视表达式的值。
(四)、参考行 包括以下内容
F1-Help 显示帮助信息
F5-Zoom 让编辑区最大，即屏蔽信息窗口；再按一次，返回。
F6-Switch 在编辑区和信息窗口之间切换。
F7-Trace 单步运行程序，并跟踪到函数体内部
F8-Step 单步运行程序，不跟踪到函数体内部
F9-Make 编译链接
F10-Menu 回到主菜单
编译环境设置好以后，就可以正式学习C语言了。
一、变量
(一)、变量类型和表示方法
1.什么是变量？一句话，变量是存储数据的值的空间。由于数值的类型有多种，有整数、小数（浮点数）、字符等等，那么对应的变量就有整型变量、浮点型变量、字符型变量。变量还有其他的具体分类。整型变量还可具体分为无符号型、长整型和短整型。浮点型也可分为单精度型、双精度型和长双精度型。此外还可以分为静态变量、外部变量、寄存器变量和自动存储变量。这些数据类型我们在本节和后面的章节中都会陆陆续续介绍。
那么变量我们总要给它取个名字吧，这个名字我们叫做标识符。
标识符的命名有一定的规则：
(1).标识符只能由字母、数字和下划线三类字符组成
(2).第一个字符必须是字母（第一个字符也可以是下划线，但被视作系统自定义的标识符）
(3).大写字母和小写字母被认为是两个不同的字符，如A和a是两个不同的标识符
(4).标识符可以任意长，但只有前32位有效。有些旧的C版本对外部标识符的限制为6位。这是由于链接程序的限制所总成的，而不是C语言本身的局限性
(5).标识符不能是C的关键字
2.从上面的规则中，有个关键字的概念。那么什么叫关键字呢？
从表面字意上也可以看出，关键字是C语言本身某些特性的一个表示，是唯一的代表某一个意思的。
下面列出ANSI标准定义的32个C语言的关键字，这些关键字在以后的学习中基本上都会用到，到时再说它们的各自用法。
auto break case char const continue default
do double else enum extern float for
goto if int long register return short
signed sizeof static struct switch typedef
union unsigned void volatile while
C语言还包括一些不能用做标识符的扩展关键字。
asm cdecl _cs _ds _es far
huge interrupt near pascal _ss
所以在以后的学习中，在给变量命名时要避开这些关键字。
3. Turbo C2.0规定所有变量在使用前都必须加以说明。一条变量说明语句由数据类型和其后的一个或多个变量名组成。变量说明的形式如下:
类型 <变量表>;
这里类型是指Turbo C2.0的有效数据类型。变量表是一个或多个标识符名,每个标识符之间用,分隔。
(二)、整型变量
整型变量是用来存储整数的。
整型变量又可具体分为好几种，最基本的整型变量是用类型说明符int声明的符号整型，形式如下：
int Counter;
这里int是类型说明符，Counter是变量的名字。
整型变量可以是有符号型、无符号型、长型、短型或象上面定义的普通符号整型。
整型是16位的，长整型是32位，短整型等价于整型。
以下是几种整型变量的声明示例：
long int Amount; /*长整型*/
long Amount; /*长整型，等价于上面*/
signed int Total; /*有符号整型*/
signed Total; /*有符号整型，等价于上面*/
unsigned int Offset; /*无符号整型*/
unsigned Offset; /*无符号整型，等价于上面*/
short int SmallAmt; /*短整型*/
short SmallAmt; /*短整型，等价于上面*/
unsigned short int Month; /*无符号短整型*/
unsigned short Month; /*无符号短整型，等价于上面*/
从上面的示例可以看出，当定义长整型、短整型、符号整型或无符号整型时，可以省略关键字int。
注明：
1.用signed对整型变量进行有符号指定是多余的，因为除非用unsigned指定为无符号型，否则整型都是有符号的。
2.当一个变量有几重特性时，声明关键字的顺序可以任意。以下几种声明是等价的：
unsigned long T1;
long unsigned T2;
unsigned long int T3;
unsigned int long T4;
long unsigned int T5;
long int unsigned T6;
int unsigned long T7;
int long unsigned T8;
(三)、浮点类型变量
顾名思义，浮点类型变量是用来存储带有小数的实数的。
C语言中有三种不同的浮点类型，以下是对这三种不同类型的声明示例：
float Amount; /*单精度型*/
double BigAmount; /*双精度型*/
long double ReallyBigAmount; /*长双精度型*/
这里Amount,BigAmount,ReallyBigAmount都是变量名。
浮点型都是有符号的。
(四)、字符型变量
字符型变量中所存放的字符是计算机字符集中的字符。对于PC机上运行的C系统，字符型数据用8位单字节的ASCII码表示。程序用类型说明符char来声明字符型变量：
char ch;
这条声明语句声明了一个字符型变量，标识符为ch。当以这种形式声明变量之后，程序可以在表达式中引用这个变量，关于语句和表达式的知识在后面将会介绍。
字符数据类型事实上是8位的整型数据类型，可以用于数值表达式中，与其他的整型数据同样使用。在这种情况下，字符型变量可以是有符号的，也可以是无符号的。对于无符号的字符型变量可以声明为：
unsigned char ch;
除非声明为无符号型，否则在算术运算和比较运算中，字符型变量一般作为8位有符号整型变量处理。
还有其他的如指针型变量，void型变量，以后再介绍。

二、常量
常量的意思就是不可改变的量，是一个常数。同变量一样，常量也分为整型常量、浮点型常量、字符型常量，还有字符串常量、转义字符常量和地址常量。
(一)、整型常量
整型常量可以是长整型、短整型、有符号型、无符号型。在Tubbo C 2.0里有符号整型常量的范围从-32768到32767，无符号整型的为0到65535；有符号长整型的范围为-2147483648到2147483647。无符号长整型的范围为0到4294967295。短整型同字符型。
可以指定一个整型常量为二进制、八进制或十六进制，如以下语句：
-129, 0x12fe, 0177
常量的前面有符号0x，这个符号表示该常量是十六进制表示。如果前面的符号只有一个字母0，那么表示该常量是八进制。
有时我们在常量的后面加上符号L或者U，来表示该常量是长整型或者无符号整型：
22388L, 0x4efb2L, 40000U
后缀可以是大写，也可以是小写。
(二)、浮点型常量
一个浮点型常量由整数和小数两部分构成，中间用十进制的小数点隔开。有些浮点树非常大或者非常小，用普通方法不容易表示，可以用科学计数法或者指数方法表示。下面是一个实例：
3.1416, 1.234E-30, 2.47E201
注意在C语言中，数的大小也有一定的限制。对于float型浮点数，数的表示范围为-3.402823E38到3.402823E38，其中-1.401298E-45到1.401298E-45不可见。double型浮点型常数的表示范围为-1.79E308到1.79E308，其中-4.94E-324到4.94E-324不可见。
在浮点型常量里我们也可以加上后缀。
FloatNumber=1.6E10F; /*有符号浮点型*/
LongDoubleNumber=3.45L; /*长双精度型*/
后缀可大写也可小写。
说明:
1. 浮点常数只有一种进制(十进制)。
2. 所有浮点常数都被默认为double。
3. 绝对值小于1的浮点数, 其小数点前面的零可以省略。如:0.22可写为.22, -0.0015E-3可写为-.0015E-3。
4. Turbo C默认格式输出浮点数时, 最多只保留小数点后六位
(三)、字符型常量
字符型常量所表示的值是字符型变量所能包含的值。我们可以用ASCII表达式来表示一个字符型常量，或者用单引号内加反斜杠表示转义字符。
'A', '\x2f', '\013';
其中：\x表示后面的字符是十六进制数，\0表示后面的字符是八进制数。
注意：在Turbo C 2.0中，字符型常量表示数的范围是-128到127，除非你把它声明为unsigned，这样就是0到255。
(四)、字符串常量
字符串常量就是一串字符,用双引号括起来表示。
Hello,World!
\nEnter selection:
\aError!!!
(五)、转义字符
上面我们见到的\x,\n,\a等等都是叫转义字符，它告诉编译器需要用特殊的方式进行处理。下面给出所有的转义字符和所对应的意义：
转义字符 描述
\' 单引号
\ 双引号
\\ 反斜杠
\0 空字符
\0nnn 八进制数
\a 声音符
\b 退格符
\f 换页符
\n 换行符
\r 回车符
\t 水平制表符
\v 垂直制表符
\x 十六进制符
它们的具体用法我们到讲输出语句时再介绍。
(六)、地址常量
我们前面说的变量是存储数据的空间，它们在内存里都有对应的地址。在C语言里可以用地址常量来引用这些地址，如下：
&Counter, ∑
&是取地址符，作用是取出变量(或者函数)的地址。在后面的输入语句和指针里还会说明。
这一节所讲到的变量和常量知识可以说是在一切程序中都要用到，特别是变量的声明和命名规则。

无论是加减乘除还是大于小于，都需要用到运算符，在C语言中的运算符和我们平时用的基本上都差不多。
运算符包括赋值运算符、算术运算符、逻辑运算符、位逻辑运算符、位移运算符、关系运算符、自增自减运算符。大多数运算符都是二目运算符，即运算符位于两个表达式之间。单目运算符的意思是运算符作用于单个表达式。(具体什么是表达式下一节再说)

一、赋值运算符
赋值语句的作用是把某个常量或变量或表达式的值赋值给另一个变量。符号为‘=’。这里并不是等于的意思，只是赋值，等于用‘==’表示。
注意：赋值语句左边的变量在程序的其他地方必须要声明。
得已赋值的变量我们称为左值，因为它们出现在赋值语句的左边；产生值的表达式我们称为右值，因为她它们出现在赋值语句的右边。常数只能作为右值。
例如：
count=5;
total1=total2=0;
第一个赋值语句大家都能理解。
第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。这样它先total2=0;然后total1=total2;那么我们这样行不行呢？
(total1=total2)=0;
这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表达式，而赋值语句的左边是不允许表达式存在的。

二、算术运算符
在C语言中有两个单目和五个双目运算符。
符号 功能
+ 单目正
- 单目负
* 乘法
/ 除法
% 取模
+ 加法
- 减法
下面是一些赋值语句的例子， 在赋值运算符右侧的表达式中就使用了上面的算术运算符：
Area=Height*Width;
num=num1+num2/num3-num4;
运算符也有个运算顺序问题，先算乘除再算加减。单目正和单目负最先运算。
取模运算符(%)用于计算两个整数相除所得的余数。例如：
a=7%4;
最终a的结果是3，因为7%4的余数是3。
那么有人要问了，我要想求它们的商怎么办呢？
b=7/4;
这样b就是它们的商了，应该是1。
也许有人就不明白了，7/4应该是1.75，怎么会是1呢？这里需要说明的是，当两个整数相除时，所得到的结果仍然是整数，没有小数部分。要想也得到小数部分，可以这样写7.0/4或者7/4.0，也即把其中一个数变为非整数。
那么怎样由一个实数得到它的整数部分呢？这就需要用强制类型转换了。例如：
a=(int) (7.0/4);
因为7.0/4的值为1.75，如果在前面加上(int)就表示把结果强制转换成整型，这就得到了1。那么思考一下a=(float) (7/4);最终a的结果是多少？
单目减运算符相当于取相反值，若是正值就变为负值，若是负数就变为正值。
单目加运算符没有意义，纯粹是和单目减构成一对用的。

三、逻辑运算符
逻辑运算符是根据表达式的值来返回真值或是假值。其实在C语言中没有所谓的真值和假值，只是认为非0为真值，0为假值。
符号 功能
&& 逻辑与
|| 逻辑或
! 逻辑非
例如：
5!3;
0||-2&&5;
!4;

当表达式进行&&运算时，只要有一个为假，总的表达式就为假，只有当所有都为真时，总的式子才为真。当表达式进行||运算时，只要有一个为真，总的值就为真，只有当所有的都为假时，总的式子才为假。逻辑非(!)运算是把相应的变量数据转换为相应的真/假值。若原先为假，则逻辑非以后为真，若原先为真，则逻辑非以后为假。
还有一点很重要，当一个逻辑表达式的后一部分的取值不会影响整个表达式的值时，后一部分就不会进行运算了。例如：
a=2,b=1;
a||b-1;
因为a=2，为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。

四、关系运算符
关系运算符是对两个表达式进行比较，返回一个真/假值。
符号 功能
> 大于
< 小于
>= 大于等于
<= 小于等于
== 等于
!= 不等于
这些运算符大家都能明白，主要问题就是等于==和赋值=的区别了。
一些刚开始学习C语言的人总是对这两个运算符弄不明白，经常在一些简单问题上出错，自己检查时还找不出来。看下面的代码：
if(Amount=123) ……
很多新人都理解为如果Amount等于123，就怎么样。其实这行代码的意思是先赋值Amount=123，然后判断这个表达式是不是真值，因为结果为123，是真值，那么就做后面的。如果想让当Amount等于123才运行时，应该if(Amount==123) ……

五、自增自减运算符
这是一类特殊的运算符，自增运算符++和自减运算符--对变量的操作结果是增加1和减少1。例如：
--Couter;
Couter--;
++Amount;
Amount++;

看这些例子里，运算符在前面还是在后面对本身的影响都是一样的，都是加1或者减1，但是当把他们作为其他表达式的一部分，两者就有区别了。运算符放在变量前面，那么在运算之前，变量先完成自增或自减运算；如果运算符放在后面，那么自增自减运算是在变量参加表达式的运算后再运算。这样讲可能不太清楚，看下面的例子：
num1=4;
num2=8;
a=++num1;
b=num2++;

a=++num1;这总的来看是一个赋值，把++num1的值赋给a，因为自增运算符在变量的前面，所以num1先自增加1变为5，然后赋值给a，最终a也为5。b=num2++;这是把num2++的值赋给b，因为自增运算符在变量的后面，所以先把num2赋值给b，b应该为8，然后num2自增加1变为9。
那么如果出现这样的情况我们怎么处理呢？
c=num1+++num2;
到底是c=(num1++)+num2;还是c=num1+(++num2);这要根据编译器来决定，不同的编译器可能有不同的结果。所以我们在以后的编程当中，应该尽量避免出现上面复杂的情况。

六、复合赋值运算符
在赋值运算符当中，还有一类C/C++独有的复合赋值运算符。它们实际上是一种缩写形式，使得对变量的改变更为简洁。
Total=Total+3;
乍一看这行代码，似乎有问题，这是不可能成立的。其实还是老样子，'='是赋值不是等于。它的意思是本身的值加3，然后在赋值给本身。为了简化，上面的代码也可以写成：
Total+=3;
复合赋值运算符有下列这些：
符号 功能
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 模运算赋值
<<= 左移赋值
>>= 右移赋值
&= 位逻辑与赋值
|= 位逻辑或赋值
^= 位逻辑异或赋值
上面的十个复合赋值运算符中，后面五个我们到以后位运算时再说明。
那么看了上面的复合赋值运算符，有人就会问，到底Total=Total+3;与Total+=3;有没有区别？答案是有的，对于A=A+1，表达式A被计算了两次，对于复合运算符A+=1，表达式A仅计算了一次。一般的来说，这种区别对于程序的运行没有多大影响，但是当表达式作为函数的返回值时，函数就被调用了两次(以后再说明)，而且如果使用普通的赋值运算符，也会加大程序的开销，使效率降低。

七、条件运算符
条件运算符(?:)是C语言中唯一的一个三目运算符，它是对第一个表达式作真/假检测，然后根据结果返回两外两个表达式中的一个。
<表达式1>?<表达式2>:<表达式3>
在运算中，首先对第一个表达式进行检验，如果为真，则返回表达式2的值；如果为假，则返回表达式3的值。
例如：
a=(b>0)?b:-b;
当b>0时，a=b；当b不大于0时，a=-b；这就是条件表达式。其实上面的意思就是把b的绝对值赋值给a。

八、逗号运算符
在C语言中，多个表达式可以用逗号分开，其中用逗号分开的表达式的值分别结算，但整个表达式的值是最后一个表达式的值。
假设b=2,c=7,d=5,
a1=(++b,c--,d+3);
a2=++b,c--,d+3;
对于第一行代码，有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3，为8，所以a=8。对于第二行代码，那么也是有三个表达式，这时的三个表达式为a2=++b、c--、d+3,(这是因为赋值运算符比逗号运算符优先级高)所以最终表达式的值虽然也为8，但a2=3。

还有其他的如位逻辑运算符，位移运算符等等，我们等到讲位运算时再说明。

九、优先级和结合性
从上面的逗号运算符那个例子可以看出，这些运算符计算时都有一定的顺序，就好象先要算乘除后算加减一样。优先级和结合性是运算符两个重要的特性，结合性又称为计算顺序，它决定组成表达式的各个部分是否参与计算以及什么时候计算。
下面是C语言中所使用的运算符的优先级和结合性：
优先级 运算符 结合性
(最高) () [] -> . 自左向右
! ~ ++ -- + - * & sizeof 自右向左
* / % 自左向右
+ - 自左向右
<< >> 自左向右
< <= > >= 自左向右
== != 自左向右
& 自左向右
^ 自左向右
| 自左向右
&& 自左向右
|| 自左向右
: 自右向左
= += -= *= /= %= &= ^= |= <<= >>= 自右向左
(最低) , 自左向右
在该表中，还有一些运算符我们没有介绍，如指针运算符、sizeof运算符、数组运算符[]等等，这些在以后的学习中会陆续说明的。
                前面几节介绍了常量和变量、运算符、表达式和语句的概念，对它们的使用有了一个大概的了解。也许刚学程序的人会觉得有些枯燥，下面我们就来编写第一个C语言程序。

#define PI 3.1416
main()
{
float Radius,Area;
scanf(%f,&Radius); /*输入半径的值*/
Area=PI*Radius*Radius;
printf(%f\n,Area); /*输出圆的面积*/
}

1.一个C语言程序，通常由带有#号的编译预处理语句开始。关于预处理我们在以后介绍，这里的#define PI 3.1415926相当于PI代表3.1416，下面在程序中遇到PI，我们就用3.1416替代一下。在以后的程序中，在学习预处理之前，我们都将不使用预处理语句。
2.main() 任何一个完整的程序都需要main()，这是一个函数，具体什么是函数，以后再讲，这儿你就要记住就行。后面有一对{}把所有的语句都括在里面，表明那些语句都属于main()里面。程序运行时从这个左大括号开始。
3.{}里面的4行语句大家应该都能明白，先定义两个变量，一个代表半径，一个代表面积，然后输入半径的值，然后求面积，最后在屏幕上输出面积。程序到main()的那对{}的右大括号结束。求面积的语句Area=PI*Radius*Radius;相当于Area=3.1416*Radius*Radius;(完全用3.1416替代PI)。

具体程序从编写到运行得到结果的步骤为：
1.双击tc.exe，进入Turbo C 2.0编译界面
2.ALT+E 进入编辑模式
3.书写程序
4.F2 存储程序(也可进入File菜单，选择save),第一次存储需要写上程序名称(*.C)，回车
5.ALT+F9 编译，如果有错误和警告，光标停留在错误行，回车进行修改，修改后，回到4;没有错，下一步
6.CTRL+F9 连接和运行程序
7.用ALT+F5查看程序运行结果，任意键返回程序

如何打开一个已有的C文件：
1.双击tc.exe，进入Turbo C 2.0编译界面
2.F3 进入load状态，找到所要打开文件的目录，找到文件，回车;后面都一样。

具体的有哪些快捷键及其它们的作用，请查看第一节概述。

说明：
1.必须在程序的最开始部分定义所有用到的变量，例如这里的Area,Radius。
2.变量的命名要尽量有意义，如用代表该意思的英文单词、或者是汉语拼音，例如这里的Radius,Area，绝对禁止用毫无干系的字母，如a,b,c。例如下面的程序，虽然意思和上面的一样，但是看上去意思不明朗，时间长了，很可能忘记程序本身的意思。对于仅仅是控制程序运行，不代表实际意思时，可以用一些简单字母。
main()
{
float a,b;
scanf(%f,&a);
b=3.1416*a*a;
printf(%f\n,b);
}
3.采用层次书写程序的格式，要有合理的缩进，必要的时候要有空行，一行只书写一个语句。所有语句尽量不分行，除非太长(分行时变量、运算符，格式字符等等不能拆开)，例如下面两个程序看起来就不好看了，虽然它们的功能和前面是一样的。
main()
{float Radius,Area;scanf(%f,&Radius);
Area=3.1416*Radius*Radius;printf(%f\n,Area);}

main()
{
float Radius,Area;
scanf(%f,
%Radius);
Area=3.1416*Radius
*Radius;
printf(%f\n,
Area);
}
4.程序在适当的地方要用/*……*/注释，它的意思表示在/* */里面的所有字符都不参加编译。因为一个较大的程序，经过一段时间，有些地方可能连编程者都忘记了，增加注释可以帮助恢复记忆，调试程序时，也容易找出错误。注释也可以分行写。
5.在书写{}时要对齐。虽然不对应也不影响程序运行，但对齐后方便以后检查程序，也是为了美观，特别是后面学到流程控制时，{}一定要对齐。

程序设计方法：
1.从问题的全局出发，写出一个概括性的抽象的描述。
2.定义变量，选取函数，确定算法。算法这个东西不好说，遇到的问题多了，自然就会形成自己一整套的算法。
3.按照解决问题的顺序把语句和函数在main()里面堆砌起来。

一个好的C程序员应该做到：
1.在运行程序之前存盘
2.所有在程序中用到的常量都用预处理语句在程序开头定义
3.所有在程序中用到的函数都在程序开头声明
4.头文件的#ifndef
5.变量名和函数名使用有意思的英文单词或汉语拼音
6.尽量少用全局变量或不用全局变量
7.采用层次的书写程序格式，对for,while,if_else,do_while,switch_case等控制语句或他们的多重嵌套，采用缩格结构
8.所有对应的{}都对齐
9.尽量用for，而不用while做记数循环
10.尽量不用goto语句
11.一个函数不宜处理太多的功能，保持函数的小型化，功能单一化
12.一个函数要保持自己的独立性，如同黑匣子一样，单进单出
13.函数的返回类型不要省略
14.用malloc()分配内存空间时，以后一定要用free()释放
15.打开文件后，记住在退出程序前要关闭
16.出错情况的处理
17.写上必要的注释
这里说的是一些基本的，经常遇到的情况，还有其他很多要注意的地方，在实际编程中都会遇到.
一个表达式的返回值都可以用来判断真假，除非没有任何返回值的void型和返回无法判断真假的结构。当表达式的值不等于0时，它就是“真”，否则就是假。一样个表达式可以包含其他表达式和运算符，并且基于整个表达式的运算结果可以得到一个真/假的条件值。因此，当一个表达式在程序中被用于检验其真/假的值时，就称为一个条件。

一、if语句
if(表达式) 语句1;
如果表达式的值为非0，则执行语句1，否则跳过语句继续执行下面的语句。
如果语句1有多于一条语句要执行时, 必须使用{和} 把这些语句包括在其中, 此时条件语句形式为:
if(表达式)
{
语句体1;
}
例如：
if(x>=0) y=x;
if(a||b&&c)
{
z=a+b;
c+=z;
}

二、if--else语句
除了可以指定在条件为真时执行某些语句外，还可以在条件为假时执行另外一段代码。在C语句中利用else语句来达到这个木的。
if(表达式) 语句1;
else 语句2;
同样，当语句1或语句2是多于一个语句时，需要用{}把语句括起来。
例如：
if(x>=0) y=x;
else y=-x;

三、if--else if--else结构。
if(表达式1)
语句1;
else if(表达式2)
语句2;
else if(表达式3)
语句3;
.
.
.
else
语句n;
这种结构是从上到下逐个对条件进行判断,一旦发现条件满点足就执行与它有关的语句, 并跳过其它剩余阶梯;若没有一个条件满足,则执行最后一个else 语句n。最后这个else常起着缺省条件的作用。同样,如果每一个条件中有多于一条语句要执行时,必须使用{和}把这些语句包括在其中。
条件语句可以嵌套,这种情况经常碰到,但条件嵌套语句容易出错,其原因主要是不知道哪个if对应哪个else。
例如:
if(x>20||x<-10)
if(y<=100&&y>x)
printf(Good);
else
printf(Bad);
对于上述情况, Turbo C2.0规定: else语句与最近的一个if语句匹配, 上例中的else与if(y<=100&&y>x)相匹配。为了使else与if(x>20||x<-10)相匹配, 必须用花括号。如下所示:
if(x>20||x<-10)
{
if(y<=100&&y>x)
printf(Good);
}
else
printf(Bad);

下面举几个例子：
1.输入一个数,如果大于0，输出plus;如果是负数，输出negative;如果正好是0，则输出zero。
main()
{
float num;
scanf(%f,&f);
if(num>0)
printf(plus\n);
else if(num<0)
printf(negative\n);
else
printf(zero\n);
}
先定义两个变量，然后输入一个数，然后判断这个数的范围，输出对应的字符串。

2.输入一个数x,输出y。其中y是x的绝对值。
main()
{
float x,y;
scanf(%f,&x);
if(x>=0) y=x;
else y=-x;
printf(%f\n,y);
}
程序比较简单，这儿就不分析了。
其实Trubo C 2.0把一些常用的功能都写好了，我们只需要使用就可。例如求绝对值的功能在C的库里面就有。看下面的：
#include math.h
main()
{
float x,y;
scanf(%f,&x);
y=fabs(x); /*求x的绝对值，然后赋值给y*/
printf(%f\n,y);
}

这个程序和上面的程序完成的功能是一模一样的，都是求绝对值。可以看出，用下面这个方法比上面就要好一些。由于fabs()是一个函数，系统自带的，所以在使用它的时候，我们必须把它所在的库文件math.h包含都程序中，即程序最前面一行。类似的还有求开方sqrt()，求指数幂exp()等等，这些与数学方面有关的函数都在math.h里面。具体哪些有哪些没有，在什么库里面，可以查看一些手册。

3.输入x，输出y，x和y满足关系：
x<-5 y=x;
-5<=x<1 y=2*x+5;
1<=x<4 y=x+6;
x>=4 y=3*x-2;
程序如下：
main()
{
float x,y;
scanf(%f,&x);
if(x<-5)
y=x;
else if(-5<=x&&x<1)
y=2*x+5;
else if(1<=x&&x<4)
y=x+6;
else
y=3*x-2;
printf(%f\n,y);
}

这里要说明两点：
(1).-5<=x&&x<1不能写成-5<=x<1;1<=x&&x<4也不能写成1<=x<4;在C语言中，不能认识连续不等式。
(2).y=2*x+5不能写成y=2x+5;y=3*x-2也不能写成y=3x-2;这与我们平时所写的方法不一样。

4.输入三个数x,y,z,然后按从大到小输出。
main()
{
float x,y,z;
scanf(%f%f%f,&x,&y,&z);
if(x>=y&&x>=z)
{
printf(%f\t,x);
if(y>=z) printf(%f\t%f\n,y,z);
else printf(%f\t%f\n,z,y);
}
else if(y>=x&&y>=z)
{
printf(%f\t,y);
if(x>=z) printf(%f\t%f\n,x,z);
else printf(%f\t%f\n,z,x);
}
else
{
printf(%f\t,z);
if(x>=y) printf(%f\t%f\n,x,y);
else printf(%f\t%f\n,y,x);
}
}
说明：这是一个典型的if语句嵌套结构，如果不使用括号，那么if和else的对应关系就乱了。

四、switch--case语句
在编写程序时, 经常会碰到按不同情况分转的多路问题, 这时可用嵌套if -else-if语句来实现, 但if-else-if语句使用不方便, 并且容易出错。对这种情况, Turbo C2.0提供了一个开关语句。开关语句格式为:
switch(变量)
{
case 常量1:
语句1或空;
case 常量2:
语句2或空;
.
.
.
case 常量n:
语句n或空;
default:
语句n+1或空;
}

执行switch开关语句时,将变量逐个与case后的常量进行比较,若与其中一个相等,则执行该常量下的语句,若不与任何一个常量相等,则执行default后面的语句。
注意:
1.switch中变量可以是数值，也可以是字符，但必须是整数。
2.可以省略一些case和default。
3.每个case或default后的语句可以是语句体,但不需要使用{和}括起来。
例如：
main()
{
int x,y;
scanf(%d,&x);
witch(x)
{
case 1:
y=x+1;
break; /*退出开关语句,遇到break才退出*/
case 4:
y=2*x+1;
break;
default:
y=x--;
break;
}
printf(%d\n,y);
}

从上面的例子可以看出，用开关语句编的程序一定可以用if语句做。那么在什么情况下需要用switch语句呢？一般在出现比较整的情况下或者能转化成比较整数的情况下使用。看下面的例子：

例子：一个学生的成绩分成五等，超过90分的为'A'，80-89的为'B'，70-79为'C'，60-69为'D'，60分以下为'E'。现在输入一个学生的成绩，输出他的等级。

(1).用if语句
main()
{
float num;
char grade;
scanf(%d,&num);
if(num>=90) grade='A';
else if(num>=80&&num<89) grade='B';
else if(num>=70&&num<79) grade='C';
else if(num>=60&&num<69) grade='D';
else grade='E';
printf(%c,grade);
}

(2).用switch语句
main()
{
int num;
char grade;
scanf(%d,&num);
num/=10;
switch(num)
{
case 10:
case 9:
grade='A';
break;
case 8:
grade='B';
break;
case 7:
grade='C';
break;
case 6:
grade='D';
break;
default:
grade='E';
break;
}
printf(%c,grade);
}

说明一点，并不是每个case里面有都语句，有时侯里面是空的，就好象这一题。switch语句执行的顺序是从第一case判断，如果正确就往下执行，直到break；如果不正确，就执行下一个case。所以在这里，当成绩是100分时，执行case 10:然后往下执行，grade='A';break;退出。
想想看，这里为什么要用num/=10;？
假设当程序中有浮点数时怎么办呢？
Turbo C 2.0提供三种基本的循环语句: for语句、while语句和do-while语句。

一、循环语句
(一)、for循环 它的一般形式为:
for(<初始化>;<条件表过式>;<增量>)
语句;
初始化总是一个赋值语句，它用来给循环控制变量赋初值；条件表达式是一个关系表达式，它决定什么时候退出循环；增量定义循环控制变量每循环一次后按什么方式变化。这三个部分之间用;分开。
例如:
for(i=1;i<=10;i++)
语句;
上例中先给i赋初值1，判断i是否小于等于10，若是则执行语句，之后值增加1。再重新判断，直到条件为假，即i>10时，结束循环。
注意:
(1).for循环中语句可以为语句体,但要用{和}将参加循环的语句括起来。
(2).for循环中的初始化、条件表达式和增量都是选择项，即可以缺省，但;不能缺省。省略了初始化，表示不对循环控制变量赋初值。省略了条件表达式，则不做其它处理时便成为死循环。省略了增量，则不对循环控制变量进行操作，这时可在语句体中加入修改循环控制变量的语句。
(3).for循环可以有多层嵌套。
例如：
for(;;) 语句;
for(i=1;;i+=2) 语句;
for(j=5;;) 语句;
这些for循环语句都是正确的。
main()
{
int i,j;
printf(i j\n);
for(i=0;i<2;i++)
for(j=0;j<3;j++)
printf(%d %d\n,i,j);
}
输出结果为:
i j
0 0
0 1
0 2
1 0
1 1
1 2

用for循环求1+2+……+100的和：
main()
{
int sn=0,i;
for(i=1;i<=100;i++)
sn+=i; /*1+2+……+100*/
printf(%d\n,sn);
}
从程序可以看出，使用循环语句可以大大简化代码。
(二)、while循环 它的一般形式为:
while(条件)
语句;
while循环表示当条件为真时，便执行语句。直到条件为假才结束循环。并继续执行循环程序外的后续语句。
例如：
#include stdio.h
main()
{
char c;
c='\0'; /*初始化c*/
while(c!='\n') /*回车结束循环*/
c=getche(); /*带回显的从键盘接收字符*/
}

上例中，while循环是以检查c是否为回车符开始，因其事先被初始化为空，所以条件为真，进入循环等待键盘输入字符；一旦输入回车，则c='\n'，条件为假，循环便告结束。与for循环一样，while循环总是在循环的头部检验条件，这就意味着循环可能什么也不执行就退出。
注意:
(1).在while循环体内也允许空语句。
例如:
while((c=getche())!='\n');
这个循环直到键入回车为止。
(2).可以有多层循环嵌套。
(3).语句可以是语句体, 此时必须用{和}括起来。
用while循环求1+2+……+100的和：
main()
{
int sn=0,i=0;
while(++i<=100)
sn+=i; /*求1+2+……+100*/
printf(%d\n,sn);
}
(三)、do--while循环 它的一般格式为:
do
{
语句块;
}
while(条件);
这个循环与while循环的不同在于:它先执行循环中的语句,然后再判断条件是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while循环至少要执行一次循环语句。
同样当有许多语句参加循环时，要用{和}把它们括起来。

用do--while循环求1+2+……+100的和：
main()
{
int sn=0,i=1;
do
sn+=i; /*求1+2+……+100*/
while(++i<=100);
printf(%d\n,sn);
}
从上面三个程序看出，使用for，while和do--while求解同样的问题，基本思路都差不多，只是在第一次计算时，注意初值。

二、循环控制
(一)、break语句
break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则将成为一个死循环而无法退出。break在switch中的用法已在前面介绍开关语句时的例子中碰到，这里不再举例。
当break语句用于do-while、for、while循环语句中时，可使程序终止循环而执行循环后面的语句，通常break语句总是与if语句联在一起。即满足条件时便跳出循环。
例如：
main()
{
int sn=0,i;
for(i=1;i<=100;i++)
{
if(i==51) break; /*如果i等于51，则跳出循环*/
sn+=i; /*1+2+……+50*/
}
printf(%d\n,sn);
}

可以看出，最终的结果是1+2+……+50。因为在i等于51的时候，就跳出循环了。自己写写怎样在while和do--while循环中增加break语句。
注意:
1. break语句对if-else的条件语句不起作用。
2. 在多层循环中，一个break语句只向外跳一层。
例如：
main()
{
int i,j;
printf(i j\n);
for(i=0;i<2;i++)
for(j=0;j<3;j++)
{
if(j==2) break;
printf(%d %d\n,i,j);
}
}
输出结果为:
i j
0 0
0 1
1 0
1 1
当i==0,j==2时，执行break语句，跳出到外层的循环，i变为1。
(二)、continue语句
continue语句的作用是跳过循环本中剩余的语句而强行执行下一次循环。
continue语句只用在for、while、do-while等循环体中, 常与if条件语句一起使用，用来加速循环。
例如：
main()
{
int sn=0,i;
for(i=1;i<=100;i++)
{
if(i==51) continue; /*如果i等于51，则结束本次循环*/
sn+=i; /*1+2+……+50+52+……+100*/
}
printf(%d\n,sn);
}
从程序中可以看出，continue语句只是当前的值没有执行，也就是说当前的值跳过去了，接着执行下次循环。
main()
{
int i,j;
printf(i j\n);
for(i=0;i<2;i++)
for(j=0;j<3;j++)
{
if(j==1) continue;
printf(%d %d\n,i,j);
}
}
输出结果为:
i j
0 0
0 2
1 0
1 2
(三)、goto语句
goto语句是一种无条件转移语句，与BASIC中的goto语句相似。goto语句的使用格式为:
goto 标号;
其中标号是Turbo C 2.0中一个有效的标识符，这个标识符加上一个:一起出现在函数内某处，执行goto语句后，程序将跳转到该标号处并执行其后的语句。标号既然是一个标识符，也就要满足标识符的命名规则。另外标号必须与goto语句同处于一个函数中，但可以不在一个循环层中。通常goto语句与if条件语句连用，当满足某一条件时，程序跳到标号处运行。goto语句通常不用，主要因为它将使程序层次不清，且不易读，但在多层嵌套退出时，用goto语句则比较合理。
main()
{
int sn=0,i;
for(i=1;i<=100;i++)
{
if(i==51) goto loop; /*如果i等于51，则跳出循环*/
sn+=i; /*1+2+……+50*/
}
loop: ;
printf(%d\n,sn);
}
可以看出，这儿的goto语句和break作用很类似。
这儿的loop: ;
printf(%d\n,sn);
也可以写成loop: printf(%d\n,sn);
main()
{
int sn=0,i;
for(i=1;i<=100;i++)
{
if(i==51) goto loop; /*如果i等于51，则跳出本次循环*/
sn+=i; /*1+2+……+50+52+……+100*/
loop: ;
}
printf(%d\n,sn);
}
可以看出这儿的loop语句和continue的作用类似。
但是某些情况下又必须使用goto语句，否则会让程序大大臃肿。如：
main()
{
int i,j,k;
printf(i j k\n);
for(i=0;i<2;i++)
for(j=0;j<3;j++)
for(k=0;k<3;k++)
{
if(k==2) goto loop;
printf(%d %d %d\n,i,j,k);
}
loop: ;
}
输出结果为:
i j k
0 0 0
0 0 1
如果不使用goto语句，而使用break,continue语句，应该这样
main()
{
int i,j,k;
printf(i j\n);
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
for(k=0;k<3;k++)
{
if(k==2) break;
printf(%d %d %d\n,i,j,k);
}
if(k==2) break;
}
if(k==2) break;
}
}
输出结果为:
i j k
0 0 0
0 0 1
所以在同时跳出多层循环时，应该使用goto语句。记住，所有的goto语句其实都是可以用break,continue代替的。

下面举几个例子：
1.求两个整数的最大公约数。例如10和15的最大公约数是5。
分析：最大公约数一定小于等于最小的那个数一半，同时能被两数整除。
main()
{
int num1,num2,i,min;
scanf(%d%d,&num1,&num2);
min=num1
for(i=min/2;i>0;i--)
if(num1%i==0&&num2%i==0) break;
printf(最大公约数为%d\n,i);
}

2.求1!+2!+……+n!(n<10)
main()
{
int n,i;
long temp=1,sn=0; /*从9!以后,所得的值就超过了int范围*/
scanf(%d,&n);
for(i=1;i<=n;i++)
{
temp*=i;
sn+=temp; /*如果没有这一步，求的就是n!*/
}
printf(%ld\n,sn);
}
那么想想，如果求1!+3!+5!+……+n!应该怎么办？

3.判断一个整数是不是素数(素数就是只能被本身和1整除的数)。
#include math.h
main()
{
int num,i,flag=0;
scanf(%d,&num);
for(i=2;i
{
flag=0; /*标志变量复位*/
if(num%i==0)
{
flag=1;
break;
}
}
if(flag==0) printf(是素数\n);
else printf(不是素数\n);
}
可以说，在所有的C语言书上，都有判断素数的例题。它的编程思想是：把一个变量作为标志变量，用来标志是不是素数；循环体是从2到sqrt(num)，因为如果一个数不是素数的话，一定能分解成num=num1*num2，它们中的最小值一定小于sqrt(num)，所以循环的时候只要到sqrt(num)就可以了。同时要注意变量复位的问题。

数组，顾名思义就是一组同类型的数。

一、数组的声明
声明数组的语法为在数组名后加上用方括号括起来的维数说明。本接仅介绍一维数组。下面是一个整型数组的例子：
int array[10];
这条语句定义了一个具有10个整型元素的名为array的数组。这些整数在内存中是连续存储的。数组的大小等于每个元素的大小乘上数组元素的个数。方括号中的维数表达式可以包含运算符，但其计算结果必须是一个长整型值。这个数组是一维的。
下面这些声明是合法的：
int offset[5+3];
float count[5*2+3];
下面是不合法的：
int n=10;
int offset[n]; /*在声明时，变量不能作为数组的维数*/

二、用下标访问数组元素
int offset[10];
表明该数组是一维数组，里面有10个数，它们分别为offset[0],offset[1],……offset[9]；千万注意，数组的第一个元素下标从0开始。一些刚学编程的人员经常在这儿犯一些错误。
offset[3]=25;
上面的例子是把25赋值给整型数组offset的第四个元素。
在赋值的时候，可以使用变量作为数组下标。
main()
{
int i,offset[10];
for(i=0;i<10;i++) scanf(%d,&offset[i]);
for(i=9;i>=0;i--) printf(%d ,offset[i]);
printf(\n);
}
题目的意思是先输入10个整数，存入到数组中，然后反序输出。

三、数组的初始化
前面说了，变量可以在定义的时候初始化，数组也可以。
int array[5]={1,2,3,4,5};
在定义数组时，可以用放在一对大括号中的初始化表对其进行初始化。初始化值的个数可以和数组元素个数一样多。
如果初始化的个数多于元素个数，将产生编译错误；如果少于元素个数，其余的元素被初始化为0。
如果维数表达式为空时，那么将用初始化值的个数来隐式地指定数组元素的个数，如下所式：
int array[]={1,2,3,4,5};
这也表明数组array元素个数为5。
main()
{
int i,array[]={1,3,5,7,9,11};
for(i=0;i<5;i++) printf(%d ,array[i]);
printf(\n);
}
最终结果为1 3 5 7 9

四、字符数组
整数和浮点数数组很好理解，在一维数组中，还有一类字符型数组。
char array[5]={'H','E','L','L','O'};
对于单个字符，必须要用单引号括起来。又由于字符和整型是等价的，所以上面的字符型数组也可以这样表示：
char array[5]={72,69,76,76,79}; /*用对应的ASCII码*/
举一个例子：
main()
{
int i;
char array[5]={'H','E','L','L','O'};
for(i=0;i<5;i++) printf(%d ,array[i]);
printf(\n);
}
最终的输出结果为72 69 76 76 79
但是字符型数组和整型数组也有不同的地方，看下面的：
char array[]=HELLO;
如果我们能看到内部的话，实际上编译器是这样处理的：
char array[]={'H','E','L','L','O','\0'};
看上面最后一个字符'\0'，它是一个字符常量，Turbo C编译器总是给字符型数组的最后自动加上一个\0，这是字符的结束标志。所以虽然HELLO只有5个字符，但存入到数组的个数却是6个。但是，数组的长度仍然是5。
int i;
i=strlen(array); /*求字符串的长度，在string.h里面*/
可以看出i仍然是5，表明最后的'\0'没有算。
#include string.h
main()
{
int i,j;
char array[]=094387fdhgkdladhladaskdh;
j=strlen(array);
for(i=0;i
printf(\n);
}
其实我们可以根据判断'\0'来输出字符串，看下面的：
main()
{
int i;
char array[]=094387fdhgkdladhladaskdh;
for(i=0;array[i]!='\0';i++) printf(%c,array[i]);
printf(\n);
}

举几个例子：
1.输入10个整数存入数组中，然后把它们从小到大排列并放在同一数组中。(思路：先找出最小的，放在第一个位置，为了防止把原先的数覆盖掉，可以把原先的第一个数和最小数的位置互换)。
main()
{
int array[10];
int i,j,min,stmp;
for(i=0;i<10;i++) scanf(%d,&array[i]);
for(i=0;i<9;i++)
{
min=array[i];
for(j=i+1;j<10;j++)
if(min>array[j]) /*里面的4行语句很重要*/
{
min=array[j];
stmp=array[i];
array[i]=array[j];
array[j]=stmp;
}
}
for(i=0;i<10;i++) printf(%d ,array[i]);
printf(\n);
}

分析：先让第一个值作为基准，如果后面有比它小的，那么就把这两个数互换一下，同时把基准换成小的值。两个数互换应该这样(stmp=a;a=b;b=stmp;)，而不是(a=b;b=a;)，想想这是为什么？必须要用一个变量作为桥梁。这种一个一个的把最小的放在前面的排序方法，我们形象的叫做冒泡法。

2.输入一行字符存入数组，然后把他们反序存入到同一数组中。
#include stdio.h
main()
{
char c,stmp,array[80];
int i=0,j;
while((c=getchar())!='\n') /*注意这儿的用法*/
array[i++]=c;
array[i]='\0'; /*为什么要加'\0'？是否可以不加？*/
for(j=i-1;j>=i/2;j--)
{
stmp=array[j];
array[j]=array[i-1-j];
array[i-1-j]=stmp;
}
for(i=0;array[i]!='\0';i++) printf(%c,array[i]);
printf(\n);
}

3.一个已经排好序的数组，输入一个数，利用二分法把这个数从原数组中删除，数组顺序保持不变。如原数组为1,3,5,7,9,11,13,15,17,19，待删除的数为13，则输出为1,3,5,7,9,11,15,17,19。
二分法：每次都是判断中间的数是否满足要求，若满足则删除，若不满足，则把该数当作边界，然后再找中点。例如这一题，第一次的是10个数的中点，为11，发现11<13，则找11-19的中点15，发现15>13，再找11-15的中点13，正好，则删除。
main()
{
int array[10]={1,2,3,5,8,15,20,30,100,200};
int first=0,end=9,middle=(first+end)/2,num,i;
scanf(%d,&num);
while(array[middle]!=num) /*注意这里面的三行代码*/
{
if(array[middle]>num) end=middle;
else first=middle;
middle=(first+end)/2;
}
for(i=0;i<9;i++)
{
if(i>=middle) array[i]=array[i+1];
printf(%d ,array[i]);
}
printf(\n);
}
程序没有考虑当输入的数在原先数组中没有时怎么处理。如果要考虑这个问题，程序该怎么改动呢？
  一、高维数组

有时，数组的维数并不止一维，例如一个记录消费中心在第一季度里各个月的收入数据就可以用二维数组来表示。定义二维数组的方法是在一维数组定义的后面再加上一个用方括号括起来的维数说明。例如：
float array[3][8];
实际上，这个数组可以看成3个连续的一维数组，每个一维数组具有8个元素。该数组在内存中的存储格式为最左边的维数相同的元素连续存储，也即按行存储的。首先存储第一行8个元素，其次是第二行，最后是第三行。
main()
{
int array[3][3]={1,2,3,4,5,6,7,8,9};
int i,j;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++) printf(%3d);
printf(\n);
}
}
它的输出结果为：
1 2 3
4 5 6
7 8 9
可以看出，二维数组元素是按行存储的。

我们也可以对数组进行赋值，而不是初始化。
main()
{
int array[3][3];
int i,j;
for(j=0;j<3;j++)
for(i=0;i<3;i++) scanf(%d,&array[i][j]);
for(i=0;i<3;i++)
{
for(j=0;j<3;j++) printf(%3d);
printf(\n);
}
}
当输入1 2 3 4 5 6 7 8 9<回车>
输出为：
1 4 7
2 5 8
3 6 9

数组可以是二维、三维甚至是更高维数的，虽然C语言对维数的处理没有上限，但是处理高维数组是很头疼的事。一般尽量避免处理四维和四维以上的数组。下面看一个三维数组的例子：
main()
{
int array[2][3][4];
int i,j,k;
for(i=0;i<2;i++)
for(j=0;j<3;j++)
for(k=0;k<4;k++) array[i][j][k]=i*12+j*4+k;
}
这个三维数组可以看成2个二维数组，每个二维数组又可以看成3个一维数组。可以在头脑里想象成两个平行平面，每个平面内有3*4个点。所以共有24个元素。

二、字符串数组
上面讲的都是存放数值的，有一类数组，用来处理字符串的，我们叫字符串数组。其实字符串数组也是二维数组，只是它的特殊性，才单独拿出来说的。
main()
{
char s[10][10];
int i;
for(i=0;i<10;i++) scanf(%s,s[i]);
}

先看它的输入特性，前面在说输入语句的时候说过，遇到字符串输入，可以不加'&'，现在只要记住这个特性就可以，以后说指针的时候再讲为什么。但是这儿为什么用s[i]，可能很多人不太明白。我们定义的是二维数组，而输入的时候，却使用一维数组的形式。这是因为字符串在内存里地址可以用它的名字表示，就好象这种形式：
main()
{
char s[10];
scanf(%s,s);
}
定义的是一维数组，输入语句用变量形式表示一样。通过前面的'%s'形式可以看出，s[i]是一个数组，所以s就是二维数组了。
这里要注意一点，scanf()函数在输入字符串时候不能支持空格，看下面的例子：
main()
{
char s[3][10];
int i;
for(i=0;i<10;i++)
scanf(%s,s[i]);
for(i=0;i<3;i++)
printf(%s\n,s[i]);
}
我们输入：1111
2222 3333
4444
我们是想把1111赋值给s[0],2222 3333赋值给s[1],4444赋值给s[2]。可实际上编译器是这样做的，把1111赋值给s[0]，把2222赋值给[1]，把3333赋值给s[2]。
实际输出：1111
2222
3333
在输入字符串的时候，如果使用scanf()，就把空格当作下一个输入了。那么我们怎么解决这个问题呢？毕竟很多情况下，一行字符串肯定有空格出现的。我们使用新的函数gets()。这个函数是专门接受字符串输入的，它跳过了空格的影响。把上面的输入语言修改为gets(s[i])即可。
我们定义了char s[3][10]，超过10个字符肯定不行，如果少于10个字符，电脑怎么处理呢？电脑是在每个字符串的后面自动补上'\0'，作为字符串的结束标志。
我们经常在填写一些可选择的内容时经常发现，待选的字符串都是按字母排列好的，我们怎么用C语言实现这个功能？在C语言里，字符串的排序是按照字符的ASCII码来的，如果第一个字符一样，则比较第二个，依次类推。
main()
{
char s1[6]=addfgh,s2[5]=asdlg;
int i;
for(i=0;s1[i]!='\0'&&s2[i]!='\0';i++)
{
if(s1[i]<>
{
printf(s1<>
exit(1);
}
else if(s1[i]>s2[i])
{
printf(s1>s2\n);
exit(1);
}
else ;
}
if(s1[i]=='\0' && s2[i]!='\0') printf(s1<>
else if(s2[i]=='\0' && s1[i]!='\0') printf(s1>s2\n);
else printf(s1==s2\n);
}

上面的例子就是比较两个字符串大小的，先比较第一个，如果相同，接着比较第二个，如果不相同，则分出大小。一直往后比较，直到其中某一个到'\0'，你也可以先用strlen()函数找出最小的长度。
exit()函数的作用是退出程序，具体它的用法可以看看相关资料。

其实C语言把我们经常需要的字符串处理函数都做好了，我们只需要调用它即可。如strcmp()用来比较、strcpy()用来拷贝等等。看看它们的用法：
#include string.h
main()
{
char s1[10],s2[10],s2[10];
int k;
gets(s1);
gets(s2);
k=strcmp(s1,s2); /*比较s1和s2大小*/
if(k==0) printf(s1==s2\n);
else if(k>0) printf(s1>s2\n);
else printf(s1<>
strcpy(s3,s1); /*把s1拷贝到s3*/
printf(%s\n,s3);
}

可以看出，比较大小时，如果k<0，则s10，则s1>s2;如果k=0，则s1=s2。实际上这是一个函数，具体什么是函数，以及为什么写成那种形式，我们下节再说。这些函数都包含在string.h头文件中，所以在程序的开头，都要写上#include string.h。
字符串处理有很多函数，你们可以看看相关的书，也可以看看Turbo C的帮助。

本节介绍C程序的基本单元--函数。函数中包含了程序的可执行代码。每个C程序的入口和出口都位于函数main()之中。main()函数可以调用其他函数，这些函数执行完毕后程序的控制又返回到main()函数中，main()函数不能被别的函数所调用。通常我们把这些被调用的函数称为下层(lower-level)函数。函数调用发生时，立即执行被调用的函数，而调用者则进入等待状态，直到被调用函数执行完毕。函数可以有参数和返回值。

程序员一般把函数当作“黑箱”处理，并不关心它内部的实现细节。当然程序员也可以自己开发函数库。
说明一点，函数这一节很重要，可以说一个程序的优劣集中体现在函数上。如果函数使用的恰当，可以让程序看起来有条理，容易看懂。如果函数使用的乱七八糟，或者是没有使用函数，程序就会显得很乱，不仅让别人无法查看，就连自己也容易晕头转向。可以这样说，如果超过100行的程序中没有使用函数，那么这个程序一定很罗嗦(有些绝对，但也是事实)。

一、函数的定义
一个函数包括函数头和语句体两部分。
函数头由下列三不分组成：
函数返回值类型
函数名
参数表
一个完整的函数应该是这样的：
函数返回值类型 函数名(参数表)
{
语句体；
}
函数返回值类型可以是前面说到的某个数据类型、或者是某个数据类型的指针、指向结构的指针、指向数组的指针。指针概念到以后再介绍。
函数名在程序中必须是唯一的，它也遵循标识符命名规则。
参数表可以没有也可以有多个，在函数调用的时候，实际参数将被拷贝到这些变量中。语句体包括局部变量的声明和可执行代码。
我们在前面其实已经接触过函数了，如abs(),sqrt()，我们并不知道它的内部是什么，我们只要会使用它即可。
这一节主要讲解无参数无返回值的函数调用。

二、函数的声明和调用
为了调用一个函数，必须事先声明该函数的返回值类型和参数类型，这和使用变量的道理是一样的(有一种可以例外，就是函数的定义在调用之前，下面再讲述)。
看一个简单的例子：
void a(); /*函数声明*/

main()
{
a(); /*函数调用*/
}

void a() /*函数定义*/
{
int num;
scanf(%d,&num);
printf(%d\n,num);
}

在main()的前面声明了一个函数，函数类型是void型，函数名为a，无参数。然后在main()函数里面调用这个函数，该函数的作用很简单，就是输入一个整数然后再显示它。在调用函数之前声明了该函数其实它和下面这个程序的功能是一样的：
main()
{
int num;
scanf(%d,&num);
printf(%d\n,num);
}
可以看出，实际上就是把a()函数里面的所有内容直接搬到main()函数里面(注意，这句话不是绝对的。)
我们前面已经说了，当定义在调用之前时，可以不声明函数。所以上面的程序和下面这个也是等价的：
void a()
{
int num;
scanf(%d,&num);
printf(%d\n,num);
}

main()
{
a();
}
因为定义在调用之前，所以可以不声明函数，这是因为编译器在编译的时候，已经发现a是一个函数名，是无返回值类型无参数的函数了。

那么很多人也许就会想，那我们何必还要声明这一步呢？我们只要把所有的函数的定义都放在前面不就可以了吗？这种想法是不可取的，一个好的程序员总是在程序的开头声明所有用到的函数和变量，这是为了以后好检查。
前面说了，在调用之前，必须先声明函数，所以下面的做法也是正确的(但在这里我个人并不提倡)。
main()
{
void a();
a();
}

void a()
{
int num;
scanf(%d,&num);
printf(%d\n,num);
}

一般来说，比较好的程序书写顺序是，先声明函数，然后写主函数，然后再写那些自定义的函数。
既然main()函数可以调用别的函数，那么我们自己定义的函数能不能再调用其他函数呢？答案是可以的。看下面的例子：

void a();
void b();

main()
{
a();
}

void a()
{
b();
}

void b()
{
int num;
scanf(%d,&num);
printf(%d\n,num);
}

main()函数先调用a()函数，而a()函数又调用b()函数。在C语言里，对调用函数的层数没有严格的限制，我们可以往下调用100层、1000层，但是在这里我们并不提倡调用的层数太多(除非是递归)，因为层数太多，对以后的检查有一些干扰，函数调过来调过去，容易让自己都晕头转向。
某些人可能就不明白了，看上面的例子，好象使用函数后，程序变的更长了，更不让人理解。当然，我举的这个例子的确没有必要用函数来实现，但是对于某些实际问题，如果不使用函数，会让程序变的很乱，这涉及到参数问题，我们下一节再说。
前面我们说的都是无参数无返回值的函数，实际程序中，我们经常使用到带参数有返回值的函数。

一、函数参数传递
1.形式参数和实际参数
函数的调用值把一些表达式作为参数传递给函数。函数定义中的参数是形式参数，函数的调用者提供给函数的参数叫实际参数。在函数调用之前，实际参数的值将被拷贝到这些形式参数中。
2.参数传递
先看一个例子：
void a(int); /*注意函数声明的形式*/

main()
{
int num;
scanf(%d,&num);
a(num); /*注意调用形式*/
}

void a(int num_back) /*注意定义形式*/
{
printf(%d\n,num_back);
}

在主函数中，先定义一个变量，然后输入一个值，在a()这个函数中输出。当程序运行a(num);这一步时，把num的值赋值给num_back，在运行程序过程中，把实际参数的值传给形式参数，这就是函数参数的传递。
形参和实参可能不只一个，如果多于一个时，函数声明、调用、定义的形式都要一一对应，不仅个数要对应，参数的数据类型也要对应。

void a(int,float);

main()
{
int num1;
float num2;
scanf(%d,&num1);
scanf(%f,&num2);
a(num1,num2);
}

void a(int num1_back,float num2_back)
{
printf(%d,%f\n,num1_back,num2_back);
}

上面的例子中，函数有两个参数，一个是整型，一个是浮点型，那么在声明、调用、定义的时候，不仅个数要一样，类型也要对应。如果不对应，有可能使的编译错误，即使没错误，也有可能让数据传递过程中出现错误。
再看一个例子：

void a(int);

main()
{
int num;
scanf(%d,&num);
a(num);
}

void a(int num)
{
printf(%d\n,num);
}

看上面的例子，形式参数和实际参数的标识符都是num，程序把实际参数num的值传递给形式参数num。有些人可能就不明白了，既然两个都是num，为什么还要传递呢？干脆这样不就行了吗：

void a();

main()
{
int num;
scanf(%d,&num);
a();
}

void a()
{
printf(%d\n,num);
}

其实不然，这就要涉及到标识符作用域的问题。作用域的意思就是说，哪些变量在哪些范围内有效。一个标识符在一个语句块中声明，那么这个标识符仅在当前和更低的语句块中可见，在函数外部的其实地方不可见，其他地方同名的标识符不受影响，后面我们会系统讲解作用域的问题。在这儿你就要知道两个同名的变量在不同的函数中是互不干扰的。
前面将的都是变量与变量之间的值传递，其实函数也可以传递数组之间的值。看下面的例子：

void a(int []);

main()
{
int array[5],i;
for(i=0;i<5;i++) scanf(%d,&array[i]);
a(array);
}

void a(int array[])
{
int i;
for(i=0;i<5;i++) printf(%d\t,array[i]);
printf(\n);
}

这就是数组之间的值传递。注意他们的声明和定义形式，和变量参数传递有什么区别？有了后面的[]就表明传递的是一个数组。其中在定义的时候，也可以写成void a(int array[5]);想想，如果我们写成了int array[4]会有什么情况发生？
目前我们只学了数组和变量，以后还会知道指针、结构，到那是，函数也可以传递它们之间的值。

二、函数值的返回
其实我们也可以把函数当作一个变量来看，既然是变量，那一定也可以有类型。还举最前面的例子，现在要求在main()函数里输入一个整数作为正方形的边长，在子函数里求正方形的面积，然后再在主函数里输出这个面积。
我们前面的程序都是在子函数里输出的，现在要求在主函数里输出，这就需要把算好的值返回回来。先看例子：

int a(int); /*声明函数*/

main()
{
int num,area;
scanf(%d,&num);
area=a(num); /*调用时的形式*/
printf(%d,area);
}

int a(int num)
{
int area_back;
area_back=num*num;
return area_back; /*返回一个值*/
}
和前面的程序有几点不同：
(1).声明函数类型时，不是void，而是int。这是由于最后要求的面积是整型的，所以声明函数的返回值类型是整型。
(2).return语句 它的意思就是返回一个值。在C语言中，return一定是在函数的最后一行。
(3).调用函数的时候,由于函数有一个返回值，所以必须要用变量接受这个返回值(不是绝对的)，如果我们不用一个变量接受这个值，函数还照样返回，但是返回的这个值没有使用。

上面的例子运行过程是这样的，先把实参的值传递给形参，然后在子函数里计算面积得到area_back，然后返回这个面积到主函数，也就是把area_back赋值给area，最后输出。
前面说了，返回值有时不一定非要用一个变量来接受，我们可以把上面的程序简化为：

int a(int);

main()
{
int num;
scanf(%d,&num);
printf(%d,a(num)); /*函数调用放在这儿*/
}

int a(int num)
{
int area_back;
area_back=num*num;
return area_back;
}
这样函数返回的值就可以直接放到输出缓冲区直接输出了。
还可以再简化为：

int a(int);

main()
{
int num;
scanf(%d,&num);
printf(%d,a(num));
}

int a(int num)
{
return num*num; /*直接在这儿返回*/
}

对于函数而言，一个函数只能返回一个值，如果想返回一组数值，就要使用数组或者结构或者指针。其实对于这些，还是返回一个值，只是这个值是一个地址而已。但是对于数组的返回有和变量不同，因为数组和地址是联系在一起的。看一个例子：

void a(int []);

main()
{
int array[5]={1,2,3,4,5},i;
a(array);
for(i=0;i<5;i++) printf(%d,array[i]);
}

void a(int array[])
{
int i;
for(i=0;i<5;i++) array[i]++;
}

看看这个程序，好象函数没有返回值，但是函数的功能的确实现了，在主函数当中输出的值的确都各加了1上来。这就是因为数组和变量不同的缘故，在后面讲指针的时候再详细说明。
下面看一个实际例子，加深对函数的理解：

用函数实现，判断一个整数是不是素数？在主函数里输入输出，子函数里判断。

#include math.h
int judge(int);

main()
{
int num,result;
scanf(%d,&num);
result=judge(num);
if(result==1) printf(yes\n);
else printf(no\n);
}

judge(int num)
{
int i,flag=1;
for(i=2;i<=sqrt(num);i++)
if(num%i==0)
{
flag=0;
break;
}
return flag;
}

可以看出，函数的功能就是为了让程序看起来有条理，一个函数实现一个特定的功能。如果我们还和以前那样，把所有代码都放在main()函数，好象程序就显的臃肿了。而且函数有一个显著的好处就是很方便的使用。这里面的judge()函数判断一个数是不是素数，如果我们以后还有判断某个数是不是素数，就可以直接使用这个函数了。我们这样，把下面的代码：

judge(int num)
{
int i,flag=1;
for(i=2;i<=sqrt(num);i++)
if(num%i==0)
{
flag=0;
break;
}
return flag;
}
保存为judge.h文件，放到include目录里面。

以后就可以直接使用这个函数了，就好象直接使用abs(),sqrt()这些函数一样方便。

#include math.h /*必须要有它*/
#include judge.h

main()
{
int num,result;
scanf(%d,&num);
result=judge(num);
if(result==1) printf(yes\n);
else printf(no\n);
}

看上面的例子，我们在程序中直接使用了函数judge()，这就是我们自己编写的第一个所谓的库函数。但是程序的第一行要包含math.h文件，这是因为在judge.h里面使用了sqrt()函数，所以为了方便，我们可以把math.h放到judge.h里面，也就是在judge.h文件的第一行加上include math.h,这样，我们的主程序中就不需要包含它了，但是这样做也有副作用，具体有什么副作用，我们以后接触到时再介绍。
我们实际用到的一些程序，也许代码有很长，上千行，甚至上万行，这些代码不可能放在一个*.c文件中，所以我们经常把一些功能做成*.h,*c的文件形式，然后在主程序中包含这些文件，这样就把一个大程序分割成几个小块，不仅浏览方便，对以后的修改也有很多好处。
我们在平时就应该有这样的好习惯，把一些经常使用的功能做成库函数的形式保存下来，也许刚开始你会觉得很烦琐，可到了后来，也许几年过去了，你会发现，一个好几千行上万行的程序，有一大半的功能你都有，直接调用就可，这会大大缩短你的程序开发周期的。就好象这里的判断素数一样，如果以后还需要判断一个数是不是素数，就没必要再写那些代码了，直接调用judge()函数就可。
一、作用域和生存期
C程序的标识符作用域有三种：局部、全局、文件。标识符的作用域决定了程序中的哪些语句可以使用它，换句话说，就是标识符在程序其他部分的可见性。通常，标识符的作用域都是通过它在程序中的位置隐式说明的。
1.局部作用域
前面各个例子中的变量都是局部作用域，他们都是声明在函数内部，无法被其他函数的代码所访问。函数的形式参数的作用域也是局部的，它们的作用范围仅限于函数内部所用的语句块。

void add(int);

main()
{
int num=5;
add(num);
printf(%d\n,num); /*输出5*/
}

void add(int num)
{
num++;
printf(%d\n,num); /*输出6*/
}


上面例子里的两个num变量都是局部变量，只在本身函数里可见。前面我们说了，在两个函数出现同名的变量不会互相干扰，就是这个道理。所以上面的两个输出，在主函数里仍然是5，在add()函数里输出是6。

2.全局作用域
对于具有全局作用域的变量，我们可以在程序的任何位置访问它们。当一个变量是在所有函数的外部声明，也就是在程序的开头声明，那么这个变量就是全局变量。

void add(int);
int num;

main()
{
int n=5;
add(n);
printf(%d\n,num); /*输出6*/
}

void add(num) /*形式参数没有指定类型*/
{
num++;
printf(%d\n,num); /*输出6*/
}

上面的main()和add()里面，并没有声明num，但是在最后输出的时候却要求输出num，这是由于在程序的开始声明了num是全局变量，也就是在所有函数里都可以使用这个变量。这时候一个函数里改变了变量的值，其他函数里的值也会出现影响。上面的例子输出都是6，因为在add()函数里改变了num的值，由于num是全局变量，就好象它们两个函数共用一个变量，所以在main()函数里的num也随之改变了。

3.文件作用域
在很多C语言书上，都没有说明文件作用域，或者只是略微的提到，其实文件作用域在较大程序中很有作用(在多文件系统中)。文件作用域是指外部标识符仅在声明它的同一个转换单元内的函数汇总可见。所谓转换单元是指定义这些变量和函数的源代码文件(包括任何通过#include指令包含的源代码文件)。static存储类型修饰符指定了变量具有文件作用域。

static int num;
static void add(int);

main()
{
scanf(%d,&num);
add(num)
printf(%d\n,num);
}

void add(num)
{
num++;
}

上面的程序中变量num和函数add()在声明是采用了static存储类型修饰符，这使得它们具有文件作用域，仅爱定义它们的文件内可见。
由于我们提到的大多数程序都只有一个编译文件组成，所以这种写法没有实际意义。但是实际工程上的文件有很多，它们不是由一个人写成的，由很多人共同完成，这些文件都是各自编译的，这难免使得某些人使用了一样的全局变量名，那么为了以后程序中各自的变量和函数不互相干扰，就可以使用static修饰符，这样在连接到同一个程序的其他代码文件而言就是不可见的。

二、变量存储类型
前面我们说了，声明变量时用如下类似的形式：
int num;
float total;

它们都没有存储类型修饰符，我们在声明时也可以通过存储类型修饰符来告诉编译器将要处理什么类型的变量。存储类型有以下四种：自动(auto)、静态(static)、外部(extern)、寄存器(regiser)。
1.自动存储类型
自动存储类型修饰符指定了一个局部变量为自动的，这意味着，每次执行到定义该变量的语句块时，都将会为该变量在内存中产生一个新的拷贝，并对其进行初始化。实际上，如果不特别指明，局部变量的存储类型就默认为自动的，因此，加不加auto都可以。
main()
{
auto int num=5;
printf(%d\n,num);
}
在这个例子中，不论变量num的声明是否包含关键字auto，代码的执行效果都是一样的。函数的形式参数存储类型默认也是自动的。

2.静态存储变量
前面已经使用了static关键字，但是对于局部变量，静态存储类型的意义是不一样的，这时，它是和自动存储类型相对而言的。静态局部变量的作用域仍然近局限于声明它的语句块中，但是在语句块执行期间，变量将始终保持它的值。而且，初始化值只在语句块第一次执行是起作用。在随后的运行过程中，变量将保持语句块上一次执行时的值。看下面两个对应的程序：

/*1.C*/ /*2.C*/
int add(); int add();

main() main()
{ {
int result; int result;
result=add() result=add();
printf(%d ,result); printf(%d ,result);
result=add(); result=add();
printf(%d ,result); printf(%d ,result);
result=add(); result=add();
printf(%d,result); printf(%d,result);
} }

int add() int add()
{ {
int num=50; static int num=50;
num++; num++;
return num; return num;
} }

上面两个源文件，只有函数add()里的变量声明有所不同，一个是自动存储类型，一个是静态存储类型。
对于1.C文件，输出结果为51 51 51；这很好理解，每次初始值都是50，然后加1上来。
对于2.C文件，输出结果为51 52 53；这是由于变量是静态的，只在第一次初始化了50，以后都是使用上次的结果值。当第一次调用add()时，初始化为50，然后加1，输出为51；当第二次调用时，就不初始化了，这时num的值为上次的51，然后加1，输出52；当第三次调用时，num为52，加1就是53了。
比较就会发现它们的不同之处了。静态变量在下一节要说的递归函数中经常使用到。
当第一次不指明静态变量的初始值时，默认为0。

下面举一个例子，把我们说到的静态变量理解一下。
求1+2+……+100的值

void add();
int result;

main()
{
int i;
result=0;
for(i=0;i<100;i++) add();
printf(%d\n,result);
}

void add()
{
static int num=0;
num++;
result+=num;
}

add()函数被调用了100次，num的值从1一直变到100，这样就可以求出它们的和了。如果写成int num=0;那就是求1+1+……+1这100个1的值了。
实际上类似的这类问题我们可以通过递归函数来解决，什么是递归，我们下一节介绍。
3.外部存储类型
外部存储类型声明了程序将要用到的、但尚未定义的外部变量。通常，外部存储类型都是用于声明在另一个转换单元中定义的变量。下面举一个例子，这个例子包括两个文件。

/*1.C*/
void a();

main()
{
extern int num;
a();
printf(%d\n,num);
}

/*2.C*/
int num;

void a()
{
num=5;
}


这两个程序是分别编译的，然后连接成一个执行文件。具体如何操作，可以查看一些手册，这儿我简单说了一下。把上面两个文件都编译好后，再制作一个.prj文件，里面的内容是：
1.c
2.c
只有这两行，这可在编辑状态下写成，存盘，取名为1.prj。
然后选择project选项，选择project name，填入1.prj文件名，按F9后，即可生成1.exe文件。

main()函数中变量num是在另一个文件中定义的。因此，当编译器编译1.c时，无法确定该变量的地址。这时，外部存储类型声明告诉编译器，把所有对num的引用当作暂且无法确定的引用，等到所有便宜好的目标代码连接成一个可执行程序模块时，再来处理对变量num的引用。
外部变量的声明既可以在引用它的函数的内部，也可以在外部。如果变量声明在函数外部，那么同一转换单元内的所有函数都可以使用这个外部变量。反之，如果在函数内部，那么只有这一个函数可以使用该变量。

前面说了文件作用域的问题，如果在声明全局变量时，加上static修饰符，那么该变量只在当前文件内可见，而extern又可以引用其它文件里的变量。所以在一个大型程序中，每个程序员只是完成其中的一小块，为了让自己的变量不让其他程序员使用，保持一定的独立性，经常在全局变量前加static。我们可以这样来说明一下：
还是上面的两个文件，现在再增加一个文件3.c，内容为：

static int num;

void a()
{
num=6;
}

把1.prj文件后面加上3.c 这样，我们生成的1.exe文件，执行时输出是5，而不是6。因为3.c文件的num变量增加了文件作用域，在其他文件中是无法使用它的。
4.寄存器存储类型
被声明为寄存器存储类型的变量，除了程序无法得到其地址外，其余都和自动变量一样。至于什么是变量地址，以后说指针时会详细介绍。

main()
{
register int num;
num=100;
printf(%d,num);
}

使用寄存器存储类型的目的是让程序员指定某个局部变量存放在计算机的某个硬件寄存器里而不是内存中，以提高程序的运行速度。不过，这只是反映了程序员的主观意愿，编译器可以忽略寄存器存储类型修饰符。
寄存器变量的地址是无法取得的，因为绝大多数计算机的硬件寄存器都不占用内存地址。而且，即使编译器忽略寄存器类型修饰符把变量放在可设定地址的内存中，我们也无法取地址的限制仍然存在。
要想有效的利用寄存器存储类型，必须象汇编语言程序员那样了解处理器的内部构造，知道可用于存放变量的寄存器的数量和种类，以及他们是如何工作的。但是，不同计算机在这些细节上未必是一样的，因此对于一个可移植的程序来说，寄存器存储类型的作用不大。特别是现在很多编译器都能提供很好的优化效果，远比程序员来选择有效的多。不过，寄存器存储类型还是可以为优化器提供重要的参考。
一、栈
在说函数递归的时候，顺便说一下栈的概念。
栈是一个后进先出的压入(push)和弹出(pop)式数据结构。在程序运行时，系统每次向栈中压入一个对象，然后栈指针向下移动一个位置。当系统从栈中弹出一个对象时，最近进栈的对象将被弹出。然后栈指针向上移动一个位置。程序员经常利用栈这种数据结构来处理那些最适合用后进先出逻辑来描述的编程问题。这里讨论的程序中的栈在每个程序中都是存在的，它不需要程序员编写代码去维护，而是由运行是系统自动处理。所谓的系统自动维护，实际上就是编译器所产生的程序代码。尽管在源代码中看不到它们，但程序员应该对此有所了解。
再来看看程序中的栈是如何工作的。当一个函数(调用者)调用另一个函数(被调用者)时，运行时系统将把调用者的所有实参和返回地址压入到栈中，栈指针将移到合适的位置来容纳这些数据。最后进栈的是调用者的返回地址。当被调用者开始执行时，系统把被调用者的自变量压入到栈中，并把栈指针再向下移，以保证有足够的空间存储被调用者声明的所有自变量。当调用者把实参压入栈后，被调用者就在栈中以自变量的形式建立了形参。被调用者内部的其他自变量也是存放在栈中的。由于这些进栈操作，栈指针已经移动所有这些局部变量之下。但是被调用者记录了它刚开始执行时的初始栈指针，以他为参考，用正或负的偏移值来访问栈中的变量。当被调用者准备返回时，系统弹出栈中所有的自变量，这时栈指针移动了被调用者刚开始执行时的位置。接着被调用者返回，系统从栈中弹出返回地址，调用者就可以继续执行了。当调用者继续执行时，系统还将从栈中弹出调用者的实参，于是栈指针回到了调用发生前的位置。
可能刚开始学的人看不太懂上面的讲解，栈涉及到指针问题，具体可以看看一些数据结构的书。要想学好编程语言，数据结构是一定要学的。

二、递归
递归，是函数实现的一个很重要的环节，很多程序中都或多或少的使用了递归函数。递归的意思就是函数自己调用自己本身，或者在自己函数调用的下级函数中调用自己。
递归之所以能实现，是因为函数的每个执行过程都在栈中有自己的形参和局部变量的拷贝，这些拷贝和函数的其他执行过程毫不相干。这种机制是当代大多数程序设计语言实现子程序结构的基础，是使得递归成为可能。假定某个调用函数调用了一个被调用函数，再假定被调用函数又反过来调用了调用函数。这第二个调用就被称为调用函数的递归，因为它发生在调用函数的当前执行过程运行完毕之前。而且，因为这个原先的调用函数、现在的被调用函数在栈中较低的位置有它独立的一组参数和自变量，原先的参数和变量将不受影响，所以递归能正常工作。程序遍历执行这些函数的过程就被称为递归下降。
程序员需保证递归函数不会随意改变静态变量和全局变量的值，以避免在递归下降过程中的上层函数出错。程序员还必须确保有一个终止条件来结束递归下降过程，并且返回到顶层。
例如这样的程序就是递归：

void a(int);

main()
{
int num=5;
a(num);
}

void a(int num)
{
if(num==0) return;
printf(%d,num);
a(--num);
}

在函数a()里面又调用了自己，也就是自己调用本身，这样就是递归。那么有些人可能要想，这不是死循环吗？所以在递归函数中，一定要有return语句，没有return语句的递归函数是死循环。
我们分析上面的例子，先调用a(5)，然后输出5，再在函数中调用本身a(4)，接着回到函数起点，输出4，……，一直到调用a(0)，这时发现已经满足if条件，不在调用而是返回了，所以这个递归一共进行了5次。如果没有这个return，肯定是死循环的。
虽然递归不难理解，但是很多在在使用递归函数的时候，问题多多。这里面一般有两个原因：一是如何往下递归，也就是不知道怎么取一个变量递归下去；二是不知道怎么终止递归，经常弄个死循环出来。
下面看几个例子：
1.求1+2+……+100的和
先分析一下。第一递归变量的问题，从题目上看应该取1,2,……,100这些变量的值作为递归的条件；第二就是如何终止的问题，从题目上看应该是当数为100的时候就不能往下加了。那么我们试着写一下程序。

int add(int);

main()
{
int num=1,sn;
sn=add(num);
printf(%d\n,sn);
getch();
}

int add(int num)
{
static int sn;
sn+=num;
if(num==100) return sn;
add(++num);
}

分析一下程序：前调用add(1)，然后在子函数中把这个1加到sn上面。接着调用add(2)，再把sn加2上来。这样一直到100，到了100的时候，先加上来，然后发现满足了if条件，这时返回sn的值，也就是1+2+……+100的值了。
这里有一个问题一定要注意，就是static int sn;
有些人就不明白，为什么要使用static类型修饰符，为什么不使用int sn=0;？如果使用int sn=0;这样的语句，在每次调用函数add()的时候，sn的值都是赋值为0,也就是第一步虽然加了1上来，可是第二次调用的时候，sn又回到了0。我们前面说了，static能保证本次初始化的值是上次执行后的值，这样也就保证了前面想加的结果不会丢失。如果你修改为int sn=0，最后结果一定是最后的100这个值而不是5050。

2.求数列s(n)=s(n-1)+s(n-2)的第n项。其中s(1)=s(2)=1。
可以看出，终止条件一定是s(1)=s(2)=1。递归下降的参数一定是n。

int a(int);

main()
{
int n,s;
scanf(%d,&n);
s=a(n);
printf(%d\n,s);
getch();
}

int a(int n)
{
if(n<3) return 1;
return a(n-1)+a(n-2);
}

这个题目主要说明的是，在函数中，不一定只有一个return语句，可以有很多，但是每次对归的时候只有一个起作用。题目不难理解，这儿不分析了。
说了这些递归，其实它和函数的调用没有大的区别，主要就是一个终止条件要选好。递归函数很多时候都能用循环来处理。

main()
{
int n=20,array[20];
int i;
for(i=0;i<>
{
if(i<2) array[i]=1;
else array[i]=array[i-1]+array[i-2];
}
printf(%d\n,array[19]);
getch();
}

上面的程序就是实现一模一样的功能的。但是它有一个缺陷，就是n的值不是通过键盘输入来得到。如果想通过键盘来得到n，可以这样：

main()
{
int n,i;
int s1=1,s2=1,temp
scanf(%d,&n);
for(i=3;i<=n;i++)
{
temp=s2;
s2+=s1;
s1=temp;
}
printf(%d\n,s2);
getch();
}

但是在某些场合，使用递归比使用循环要简单的多。而且有些题目，一看就知道应该使用递归而不是循环来处理。
   预处理过程扫描源代码，对其进行初步的转换，产生新的源代码提供给编译器。可见预处理过程先于编译器对源代码进行处理。
在C语言中，并没有任何内在的机制来完成如下一些功能：在编译时包含其他源文件、定义宏、根据条件决定编译时是否包含某些代码。要完成这些工作，就需要使用预处理程序。尽管在目前绝大多数编译器都包含了预处理程序，但通常认为它们是独立于编译器的。预处理过程读入源代码，检查包含预处理指令的语句和宏定义，并对源代码进行响应的转换。预处理过程还会删除程序中的注释和多余的空白字符。
预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令：

指令 用途
# 空指令，无任何效果
#include 包含一个源代码文件
#define 定义宏
#undef 取消已定义的宏
#if 如果给定条件为真，则编译下面代码
#ifdef 如果宏已经定义，则编译下面代码
#ifndef 如果宏没有定义，则编译下面代码
#elif 如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
#endif 结束一个#if……#else条件编译块
#error 停止编译并显示错误信息

一、文件包含
#include预处理指令的作用是在指令处展开被包含的文件。包含可以是多重的，也就是说一个被包含的文件中还可以包含其他文件。标准C编译器至少支持八重嵌套包含。
预处理过程不检查在转换单元中是否已经包含了某个文件并阻止对它的多次包含。这样就可以在多次包含同一个头文件时，通过给定编译时的条件来达到不同的效果。例如：

#define AAA
#include t.c
#undef AAA
#include t.c

为了避免那些只能包含一次的头文件被多次包含，可以在头文件中用编译时条件来进行控制。例如：
/*my.h*/
#ifndef MY_H
#define MY_H
……
#endif

在程序中包含头文件有两种格式：
#include
#include my.h
第一种方法是用尖括号把头文件括起来。这种格式告诉预处理程序在编译器自带的或外部库的头文件中搜索被包含的头文件。第二种方法是用双引号把头文件括起来。这种格式告诉预处理程序在当前被编译的应用程序的源代码文件中搜索被包含的头文件，如果找不到，再搜索编译器自带的头文件。
采用两种不同包含格式的理由在于，编译器是安装在公共子目录下的，而被编译的应用程序是在它们自己的私有子目录下的。一个应用程序既包含编译器提供的公共头文件，也包含自定义的私有头文件。采用两种不同的包含格式使得编译器能够在很多头文件中区别出一组公共的头文件。

二、宏
宏定义了一个代表特定内容的标识符。预处理过程会把源代码中出现的宏标识符替换成宏定义时的值。宏最常见的用法是定义代表某个值的全局符号。宏的第二种用法是定义带参数的宏，这样的宏可以象函数一样被调用，但它是在调用语句处展开宏，并用调用时的实际参数来代替定义中的形式参数。
1.#define指令
#define预处理指令是用来定义宏的。该指令最简单的格式是：首先神明一个标识符，然后给出这个标识符代表的代码。在后面的源代码中，就用这些代码来替代该标识符。这种宏把程序中要用到的一些全局值提取出来，赋给一些记忆标识符。
#define MAX_NUM 10
int array[MAX_NUM];
for(i=0;i

在这个例子中，对于阅读该程序的人来说，符号MAX_NUM就有特定的含义，它代表的值给出了数组所能容纳的最大元素数目。程序中可以多次使用这个值。作为一种约定，习惯上总是全部用大写字母来定义宏，这样易于把程序红的宏标识符和一般变量标识符区别开来。如果想要改变数组的大小，只需要更改宏定义并重新编译程序即可。
宏表示的值可以是一个常量表达式，其中允许包括前面已经定义的宏标识符。例如：
#define ONE 1
#define TWO 2
#define THREE (ONE+TWO)
注意上面的宏定义使用了括号。尽管它们并不是必须的。但出于谨慎考虑，还是应该加上括号的。例如：
six=THREE*TWO;
预处理过程把上面的一行代码转换成：
six=(ONE+TWO)*TWO;
如果没有那个括号，就转换成six=ONE+TWO*TWO;了。
宏还可以代表一个字符串常量，例如：
#define VERSION Version 1.0 Copyright(c) 2003
2.带参数的#define指令
带参数的宏和函数调用看起来有些相似。看一个例子：
#define Cube(x) (x)*(x)*(x)
可以时任何数字表达式甚至函数调用来代替参数x。这里再次提醒大家注意括号的使用。宏展开后完全包含在一对括号中，而且参数也包含在括号中，这样就保证了宏和参数的完整性。看一个用法：
int num=8+2;
volume=Cube(num);
展开后为(8+2)*(8+2)*(8+2);
如果没有那些括号就变为8+2*8+2*8+2了。
下面的用法是不安全的：
volume=Cube(num++);
如果Cube是一个函数，上面的写法是可以理解的。但是，因为Cube是一个宏，所以会产生副作用。这里的擦书不是简单的表达式，它们将产生意想不到的结果。它们展开后是这样的：
volume=(num++)*(num++)*(num++);
很显然，结果是10*11*12,而不是10*10*10;
那么怎样安全的使用Cube宏呢？必须把可能产生副作用的操作移到宏调用的外面进行：
int num=8+2;
volume=Cube(num);
num++;
3.#运算符
出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算符。例如：

#define PASTE(n) adhfkj#n

main()
{
printf(%s\n,PASTE(15));
}
宏定义中的#运算符告诉预处理程序，把源代码中任何传递给该宏的参数转换成一个字符串。所以输出应该是adhfkj15。
4.##运算符
##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号。看下面的例子：

#define NUM(a,b,c) a##b##c
#define STR(a,b,c) a##b##c

main()
{
printf(%d\n,NUM(1,2,3));
printf(%s\n,STR(aa,bb,cc));
}

最后程序的输出为:
123
aabbcc
千万别担心，除非需要或者宏的用法恰好和手头的工作相关，否则很少有程序员会知道##运算符。绝大多数程序员从来没用过它。

三、条件编译指令
条件编译指令将决定那些代码被编译，而哪些是不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。
1.#if指令
#if指令检测跟在制造另关键字后的常量表达式。如果表达式为真，则编译后面的代码，知道出现#else、#elif或#endif为止；否则就不编译。
2.#endif指令
#endif用于终止#if预处理指令。

#define DEBUG 0
main()
{
#if DEBUG
printf(Debugging\n);
#endif
printf(Running\n);
}

由于程序定义DEBUG宏代表0，所以#if条件为假，不编译后面的代码直到#endif，所以程序直接输出Running。
如果去掉#define语句，效果是一样的。
3.#ifdef和#ifndef
#define DEBUG

main()
{
#ifdef DEBUG
printf(yes\n);
#endif
#ifndef DEBUG
printf(no\n);
#endif
}
#if defined等价于#ifdef; #if !defined等价于#ifndef
4.#else指令
#else指令用于某个#if指令之后，当前面的#if指令的条件不为真时，就编译#else后面的代码。#endif指令将中指上面的条件块。

#define DEBUG

main()
{
#ifdef DEBUG
printf(Debugging\n);
#else
printf(Not debugging\n);
#endif
printf(Running\n);
}

5.#elif指令
#elif预处理指令综合了#else和#if指令的作用。

#define TWO

main()
{
#ifdef ONE
printf(1\n);
#elif defined TWO
printf(2\n);
#else
printf(3\n);
#endif
}
程序很好理解，最后输出结果是2。

6.其他一些标准指令
#error指令将使编译器显示一条错误信息，然后停止编译。
#line指令可以改变编译器用来指出警告和错误信息的文件号和行号。
#pragma指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信息。

学习Turbo C语言,如果你不能用指针编写有效、正确和灵活的程序,可以认为你没有学好C语言。指针、地址、数组及其相互关系是C语言中最有特色的部分。规范地使用指针,可以使程序达到简单明了,因此,我们不但要学会如何正确地使用指针,而且要学会在各种情况下正确地使用指针变量。

一、指针基本概念及其指针变量的定义
我们知道变量在计算机内是占有一块存贮区域的,变量的值就存放在这块区域之中, 在计算机内部, 通过访问或修改这块区域的内容来访问或修改相应的变量。Turbo C语言中, 对于变量的访问形式之一,就是先求出变量的地址,然后再通过地址对它进行访问,这就是这里所要论述的指针及其指针变量。
所谓变量的指针, 实际上指变量的地址。变量的地址虽然在形式上好象类似于整数, 但在概念上不同于以前介绍过的整数, 它属于一种新的数据类型, 即指针类型。Turbo C中,
一般用指针来指明这样一个表达式&x的类型,而用地址作为它的值,也就是说, 若x为一整型变量, 则表达式&x的类型是指向整数的指针,而它的值是变量x的地址。同样, 若double d;则&d的类型是指向以精度数d的指针,而&d的值是双精度变量d的地址。所以,
指针和地址是用来叙述一个对象的两个方面。虽然&x、&d的值分别是整型变量x和双精度变量d的地址, 但&x、&d的类型是不同的, 一个是指向整型变量x的指针, 而另一个则是指向双精度变量d的指针。在习惯上,很多情况下指针和地址这两个术语混用了。
我们可以用下述方法来定义一个指针类型的变量。
int *ip;
首先说明了它是一指针类型的变量,注意在定义中不要漏写符号*,否则它为一般的整型变量了。另外,在定义中的int 表示该指针变量为指向整型数的指针类型的变量, 有时也可称ip为指向整数的指针。ip是一个变量, 它专门存放整型变量的地址。
指针变量的一般定义为:
类型标识符 *标识符;
其中标识符是指针变量的名字, 标识符前加了*号,表示该变量是指针变量, 而最前面的类型标识符表示该指针变量所指向的变量的类型。一个指针变量只能指向同一种类型的变量, 也就是讲, 我们不能定义一个指针变量, 既能指向一整型变量又能指向双精度变量。
指针变量在定义中允许带初始化项。如:
int i, *ip=&i;
注意, 这里是用&i对ip初始化, 而不是对*ip初始化。和一般变量一样,对于外部或静态指针变量在定义中若不带初始化项, 指针变量被初始化为NULL, 它的值为0。Turbo C中规定, 当指针值为零时, 指针不指向任何有效数据, 有时也称指针为空指针。因此, 当调用一个要返回指针的函数时(以后会讲到), 常使用返回值为NULL来指示函数调用中某些错误情况的发生。
既然在指针变量中只能存放地址,因此,在使用中不要将一个整数赋给一指针变量。下面的赋值是不合法的:
int *ip;
ip=100;
假设
int i=200, x;
int *ip;
我们定义了两个整型变量i,x,还定义了一个指向整型数的指针变量ip。i,x中可存放整数,而ip中只能存放整型变量的地址。我们可以把i的地址赋给ip:
ip=&i;
此时指针变量ip指向整型变量i,假设变量i的地址为1800, 这个赋值可形象理解为下图所示的联系。
ip i
________ _______
| | | |
| 1800 | ---- | 200 |
|________| |_______|

图1. 给指针变量赋值
以后我们便可以通过指针变量ip间接访问变量i,例如:
x=*ip;
运算符*访问以ip为地址的存贮区域,而ip中存放的是变量i的地址,因此,*ip访问的是地址为1800的存贮区域(因为是整数, 实际上是从1800开始的两个字节),它就是i所占用的存贮区域,所以上面的赋值表达式等价于x=i;
另外,指针变量和一般变量一样,存放在它们之中的值是可以改变的,也就是说可以改变它们的指向, 假设
int i, j, *p1, *p2;
i='a';
j='b';
p1=&i;
p2=&j;
则建立如下图所示的联系:

p1 i
________ _______
| | | |
| | ---- | 'a' |
|________| |_______|

p2 j
________ _______
| | | |
| | ---- | 'b' |
|________| |_______|

图2. 赋值运算结果
这时赋值表达式:
p2=p1;
就使p2与p1指向同一对象i,此时*p2就等价于i,而不是j,图2.就变成图3.所示:


p1 i
________ _______
| | ____ | |
| | __ | 'a' |
|________| | |_______|
|
p2 | j
________ | _______
| | | | |
| | ___| | 'b' |
|________| |_______|

图3. p2=p1时的情形
如果执行如下表达式:
*p2=*p1;
则表示把p1指向的内容赋给p2所指的区域, 此时图2.就变成图4.所示

p1 i
________ _______
| | | |
| | ---- | 'a' |
|________| |_______|

p2 j
________ _______
| | | |
| | ---- | 'a' |
|________| |_______|

图4. *p2=*p1时的情形

通过指针访问它所指向的一个变量是以间接访问的形式进行的,所以比直接访问一个变量要费时间,而且不直观,因为通过指针要访问哪一个变量,取决于指针的值(即指向),
例如*p2=*p1;实际上就是j=i;,前者不仅速度慢而且目的不明。但由于指针是变量,我们可以通过改变它们的指向, 以间接访问不同的变量,这给程序员带来灵活性,也使程序代码编写得更为简洁和有效。
指针变量可出现在表达式中, 设
int x, y *px=&x;
指针变量px指向整数x, 则*px可出现在x能出现的任何地方。例如:
y=*px+5; /*表示把x的内容加5并赋给y*/
y=++*px; /*px的内容加上1之后赋给y [++*px相当于++(*px)]*/
y=*px++; /*相当于y=*px; px++*/

二、地址运算
指针允许的运算方式有:
(1). 指针在一定条件下,可进行比较,这里所说的一定条件, 是指两个指针指向同一个对象才有意义, 例如两个指针变量p, q指向同一数组, 则<, >, >=,<=, ==等关系运算符都能正常进行。若p==q为真, 则表示p, q指向数组的同一元素; 若p
(2). 指针和整数可进行加、减运算。设p是指向某一数组元素的指针,开始时指向数组的第0号元素, 设n为一整数, 则p+n就表示指向数组的第n号元素(下标为n的元素)。不论指针变量指向何种数据类型, 指针和整数进行加、减运算时,编译程序总根据所指对象的数据长度对n放大, 在一般微机上, char放大因子为1, int、short放大因子为2, long和float放大因子为4, double放大因子为8。对于下面讲述到的结构或联合, 也仍然遵守这一原则。
(3). 两个指针变量在一定条件下,可进行减法运算。设p, q指向同一数组,则p-q的绝对值表示p所指对象与q所指对象之间的元素个数。其相减的结果遵守对象类型的字节长度进行缩小的规则。

对于初学者而言，指针和地址以及指针和数组之间的关系都是非常让人头疼的概念。我说了上面那么多，可能很多人还是一头雾水。这就需要多看看一些书了。毕竟自己理解的东西永远比别人讲解的要深刻。
下面举一个例子，来看看指针的应用：

main()
{
char c='A';
int i=123;
float f=3.45;

char *cp;
int *ip;
float *fp;

cp=&c;
ip=&i;
fp=&f;

printf(%c\n,*cp);
printf(%d\n,*ip);
printf(%f\n,*fp);
}

如果你们还对指针有不理解，可以再接着输出cp,ip,fp的值看看，看它们到底是什么。
  指针和数组有着密切的关系,任何能由数组下标完成的操作也都可用指针来实现,但程序中使用指针可使代码更紧凑、更灵活。

一、指向数组元素的指针
我们定义一个整型数组和一个指向整型的指针变量:
int a[10], *p;
和前面介绍过的方法相同,可以使整型指针p指向数组中任何一个元素,假定给出赋值运算
p=&a[0];
此时,p指向数组中的第0号元素,即a[0],指针变量p中包含了数组元素a[0]的地址,由于数组元素在内存中是连续存放的,因此,我们就可以通过指针变量p及其有关运算间接访问数组中的任何一个元素。
Turbo C中,数组名是数组的第0号元素的地址,因此下面两个语句是等价的
p=&a[0];
p=a;
根据地址运算规则,a+1为a[1]的地址,a+i就为a[i]的地址。
下面我们用指针给出数组元素的地址和内容的几种表示形式：
(1). p+i和a+i均表示a[i]的地址, 或者讲,它们均指向数组第i号元素, 即指向a[i]。
(2). *(p+i)和*(a+i)都表示p+i和a+i所指对象的内容,即为a[i]。
(3). 指向数组元素的指针, 也可以表示成数组的形式,也就是说,它允许指针变量带下标, 如p[i]与*(p+i)等价。
假若: p=a+5;
则p[2]就相当于*(p+2), 由于p指向a[5], 所以p[2]就相当于a[7]。而p[-3]就相当于*(p-3), 它表示a[2]。

二、指向二维数组的指针
1.二维数组元素的地址
为了说明问题, 我们定义以下二维数组:
int a[3][4]={{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};
a为二维数组名,此数组有3行4列, 共12个元素。但也可这样来理解,数组a由三个元素组成:a[0],a[1],a[2]。而每个元素又是一个一维数组, 且都含有4个元素(相当于4列),例如,a[0]所代表的一维数组所包含的 4 个元素为a[0][0], a[0][1], a[0][2], a[0][3]。如图所示:
______ _______________
a---| a[0] | ____ | 0 | 1 | 2 | 3 |
|______| |___|___|___|___|
| a[1] | ____ | 4 | 5 | 6 | 7 |
|______| |___|___|___|___|
| a[2] | ____ | 8 | 9 | 10| 11|
|______| |___|___|___|___|


但从二维数组的角度来看,a代表二维数组的首地址,当然也可看成是二维数组第0行的首地址。a+1就代表第1行的首地址,a+2就代表第2行的首地址。如果此二维数组的首地址为1000,由于第0行有4个整型元素,所以a+1为1008,a+2也就为1016。如图所示
_______________
(1000) ____ | 0 | 1 | 2 | 3 |
|___|___|___|___|
(1008) ____ | 4 | 5 | 6 | 7 |
|___|___|___|___|
(1016) ____ | 8 | 9 | 10| 11|
|___|___|___|___|

既然我们把a[0],a[1],a[2]看成是一维数组名,可以认为它们分别代表它们所对应的数组的首地址,也就是讲,a[0]代表第 0 行中第 0 列元素的地址,即&a[0][0], a[1]是第1行中第0列元素的地址,即&a[1][0],根据地址运算规则,a[0]+1即代表第0行第1列元素的地址,即&a[0][1],一般而言,a[i]+j即代表第i行第j列元素的地址, 即&a[i][j]。
另外,在二维数组中,我们还可用指针的形式来表示各元素的地址。如前所述,a[0]与*(a+0)等价,a[1]与*(a+1)等价,因此a[i]+j就与*(a+i)+j等价,它表示数组元素a[i][j]的地址。
因此,二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j),它们都与a[i][j]等价,或者还可写成(*(a+i))[j]。

另外, 要补充说明一下, 果你编写一个程序输出打印a和*a,你可发现它们的值是相同的,这是为什么呢? 我们可这样来理解:
首先,为了说明问题,我们把二维数组人为地看成由三个数组元素a[0],a[1],a[2]组成,将a[0],a[1],a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此,a表示数组第0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址,它就是数组第0 行第0 列元素的地址。
2.指向一个由n个元素所组成的数组指针
在Turbo C中, 可定义如下的指针变量:
int (*p)[3];
指针p为指向一个由3个元素所组成的整型数组指针。在定义中,圆括号是不能少的, 否则它是指针数组, 这将在后面介绍。这种数组的指针不同于前面介绍的整型指针,当整型指针指向一个整型数组的元素时,进行指针(地址)加1运算,表示指向数组的下一个元素,此时地址值增加了2(因为放大因子为2),而如上所定义的指向一个由3个元素组成的数组指针,进行地址加1运算时,其地址值增加了6(放大因子为2x3=6),
这种数组指针在Turbo C中用得较少,但在处理二维数组时, 还是很方便的。例如:
int a[3][4], (*p)[4];
p=a;
开始时p指向二维数组第0行,当进行p+1运算时,根据地址运算规则,此时放大因子为4x2=8,所以此时正好指向二维数组的第1行。和二维数组元素地址计算的规则一样,*p+1指向a[0][1],*(p+i)+j则指向数组元素a[i][j]。
例：
int a[3][4]={
{1,3,5,7},
{9,11,13,15},
{17,19,21,23}
};

main()
{
int i,(*b)[4];
b=a+1; /* b指向二维数组的第1行, 此时*b[0]是a[1][0] */
for(i=1;i<=4;b=b[0]+2,i++) /* 修改b的指向, 每次增加2 */
printf(%d\t,*b[0]);
printf(\n);
for(i=0; i<3; i++)
{
b=a+i; /* 修改b的指向,每次跳过二维数组的一行 */
printf(%d\t,*(b[i]+1));
}
printf (\n);
}
程序运行结果如下:
9 13 17 21
3 11 19

三、字符指针
我们已经知道,字符串常量是由双引号括起来的字符序列,例如:
a string
就是一个字符串常量,该字符串中因为字符a后面还有一个空格字符,所以它由8个字符序列组成。在程序中如出现字符串常量C编译程序就给字符串常量按排一存贮区域,这个区域是静态的,在整个程序运行的过程中始终占用, 平时所讲的字符串常量的长度是指该字符串的字符个数, 但在按排存贮区域时, C 编译程序还自动给该字符串序列的末尾加上一个空字符'\0',用来标志字符串的结束,因此一个字符串常量所占的存贮区域的字节数总比它的字符个数多一个字节。
Turbo C中操作一个字符串常量的方法有:
(1).把字符串常量存放在一个字符数组之中, 例如:
char s[]=a string;
数组s共有9个元素所组成,其中s[8]中的内容是'\0'。实际上,在字符数组定义的过程中,编译程序直接把字符串复写到数组中,即对数组s初始化。
(2).用字符指针指向字符串,然后通过字符指针来访问字符串存贮区域。当字符串常量在表达式中出现时,
根据数组的类型转换规则,它被转换成字符指针。因此,若我们定义了一字符指针cp:
char *cp;
于是可用:
cp=a string;
使cp指向字符串常量中的第0号字符a, 如图所示。

___________________________________
CP ----- | a | | s | t | r | i | n | g | \0|
|___|___|___|___|___|___|___|___|___|

以后我们可通过cp来访问这一存贮区域, 如*cp或cp[0]就是字符a,而cp[i]或*(cp+i)就相当于字符串的第i号字符,但企图通过指针来修改字符串常量的行为是没有意义的。

四、指针数组
因为指针是变量,因此可设想用指向同一数据类型的指针来构成一个数组, 这就是指针数组。数组中的每个元素都是指针变量,根据数组的定义,指针数组中每个元素都为指向同一数据类型的指针。指针数组的定义格式为:
类型标识 *数组名[整型常量表达式];
例如:
int *a[10];
定义了一个指针数组,数组中的每个元素都是指向整型量的指针,该数组由10个元素组成,即a[0],a[1],a[2], ..., a[9],它们均为指针变量。a为该指针数组名,和数组一样，a是常量,不能对它进行增量运算。a为指针数组元素a[0]的地址,a+i为a[i]的地址,*a就是a[0],*(a+i)就是a[i]。
为什么要定义和使用指针数组呢?主要是由于指针数组对处理字符串提供了更大的方便和灵活,使用二维数组对处理长度不等的正文效率低，而指针数组由于其中每个元素都为指针变量,因此通过地址运算来操作正文行是十分方便的。
指针数组和一般数组一样,允许指针数组在定义时初始化，但由于指针数组的每个元素是指针变量,它只能存放地址,所以对指向字符串的指针数组在说明赋初值时,是把存放字符串的首地址赋给指针数组的对应元素,
例如下面是一个书写函数month_name(n),函数返回一个指向包含第n月名字的字符指针(关于函数指针和指针函数,下一节将专门介绍)。

例: 打印1月至12月的月名:
char *month_name(int n)
{
static char *name[]={
Illegal month,
January,
February,
March,
April,
May,
June,
July,
August,
September,
October,
November,
December
};
return((n<1||n>12)?name[0]:name[n]);
}

main()
{
int i;
for(i=0; i<13; i++)
printf(%s\n, month_name(i));
}
对于指针这一节，一定要多练习一些题。指针是一个很重要的概念，必须多接触实际的问题才能掌握它。

一、指针函数
当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。
格式：
类型说明符 * 函数名(参数)
当然了，由于返回的是一个地址，所以类型说明符一般都是int。
例如：int *GetDate();
int * aaa(int,int);
函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。

int * GetDate(int wk,int dy);

main()
{
int wk,dy;
do
{
printf(Enter week(1-5)day(1-7)\n);
scanf(%d%d,&wk,&dy);
}
while(wk<1||wk>5||dy<1||dy>7);
printf(%d\n,*GetDate(wk,dy));
}

int * GetDate(int wk,int dy)
{
static int calendar[5][7]=
{
{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,-1}
};
return &calendar[wk-1][dy-1];
}
程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。

二、函数指针
指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：
类型说明符 (*函数名)(参数)
其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。
例如：
void (*fptr)();
把函数的地址赋值给函数指针，可以采用下面两种形式：
fptr=&Function;
fptr=Function;
取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
可以采用如下两种方式来通过指针调用函数：
x=(*fptr)();
x=fptr();
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：

void (*funcp)();
void FileFunc(),EditFunc();

main()
{
funcp=FileFunc;
(*funcp)();
funcp=EditFunc;
(*funcp)();
}

void FileFunc()
{
printf(FileFunc\n);
}

void EditFunc()
{
printf(EditFunc\n);
}

程序输出为：
FileFunc
EditFunc

三、指针的指针
指针的指针看上去有些令人费解。它们的声明有两个星号。例如：
char ** cp;
如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。
指针的指针需要用到指针的地址。
char c='A';
char *p=&c;
char **cp=&p;
通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：
char *p1=*cp;
char c1=**cp;
你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。

void FindCredit(int **);

main()
{
int vals[]={7,6,5,-4,3,2,1,0};
int *fp=vals;
FindCredit(&fp);
printf(%d\n,*fp);
}

void FindCredit(int ** fpp)
{
while(**fpp!=0)
if(**fpp<0) break;
else (*fpp)++;
}

首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。

四、指向指针数组的指针
指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。

char *Names[]=
{
Bill,
Sam,
Jim,
Paul,
Charles,
0
};

main()
{
char **nm=Names;
while(*nm!=0) printf(%s\n,*nm++);
}

先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。
注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。


 结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。结构中可以使用不同的数据类型。

一、结构说明和结构变量定义
在Turbo C中,结构也是一种数据类型,可以使用结构变量,因此,象其它类型的变量一样, 在使用结构变量时要先对其定义。
定义结构变量的一般格式为:
struct 结构名
{
类型 变量名;
类型 变量名;
...
} 结构变量;
结构名是结构的标识符不是变量名。
类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和无值型)。
构成结构的每一个类型变量称为结构成员,它象数组的元素一样,但数组中元素是以下标来访问的,而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。

struct string
{
char name[8];
int age;
char sex[4];
char depart[20];
float wage1,wage2,wage3;
}person;

这个例子定义了一个结构名为string的结构变量person,如果省略变量名person,则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义时上例变成:

struct string
{
char name[8];
int age;
char sex[4];
char depart[20];
float wage1,wage2,wage3;
};
struct string person;
如果需要定义多个具有相同形式的结构变量时用这种方法比较方便,它先作结构说明,再用结构名来定义变量。
例如:
struct string Tianyr, Liuqi, ...;
如果省略结构名,则称之为无名结构,这种情况常常出现在函数内部,用这种结构时前面的例子变成:

struct
{
char name[8];
int age;
char sex[4];
char depart[20];
float wage1,wage2,wage3;
} Tianyr, Liuqi;

二、结构变量的使用
结构是一个新的数据类型,因此结构变量也可以象其它类型的变量一样赋值、运算,不同的是结构变量以成员作为基本变量。
结构成员的表示方式为:
结构变量.成员名
如果将结构变量.成员名看成一个整体,则这个整体的数据类型与结构中该成员的数据类型相同,这样就可象前面所讲的变量那样使用。
下面这个例子定义了一个结构变量,其中每个成员都从键盘接收数据,然后对结构中的浮点数求和,并显示运算结果。请注意这个例子中不同结构成员的访问。

#include
main()
{
struct
{ /*定义一个结构变量*/
char name[8];
int age;
char sex[4];
char depart[20];
float wage1,wage2,wage3;
}a;
float wage;
char c='Y';
while(c=='Y'||c=='y') /*判断是否继续循环*/
{
printf(\nName:);
scanf(%s, a.name); /*输入姓名*/
printf(Age:);
scanf(%d, &a.wage); /*输入年龄*/
printf(Sex:);
scanf(%s, a.sex);
printf(Dept:);
scanf(%s, a.depart);
printf(Wage1:);
scanf(%f, &a.wage1); /*输入工资*/
printf(Wage2:);
scanf(%f, &a.wage2);
printf(Wage3:);
scanf(%f, &a.wage3);
wage=a.wage1+a.wage2+a.wage3;
printf(The sum of wage is %6.2f\n, wage);
printf(Continue?);
c=getche();
}
}

三、结构数组和结构指针
结构是一种新的数据类型, 同样可以有结构数组和结构指针。
1.结构数组
结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示:
struct
{
char name[8];
char sex[4];
int age;
char addr[40];
}student[40];
也可定义为:
struct string
{
char name[8];
char sex[4];
int age;
char addr[40];
};
struct string student[40];
需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为:
结构数组元素.成员名
例如:
student[0].name
student[30].age
实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是一个结构变量, 第二维是结构成员。
注意:
结构数组的成员也可以是数组变量。
例如:
struct a
{
int m[3][5];
float f;
char s[20];
}y[4];
为了访问结构a中结构变量y[2]的这个变量, 可写成y[2].m[1][4]
2.结构指针
结构指针是指向结构的指针。它由一个加在结构变量名前的* 操作符来定义, 例如用前面已说明的结构定义一个结构指针如下:
struct string
{
char name[8];
char sex[4];
int age;
char addr[40];
}*student;
也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。
struct string *student;
使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为:
结构指针名->结构成员
其中->是两个符号-和>的组合,好象一个箭头指向结构成员。例如要给上面定义的结构中name和age赋值,可以用下面语句:
strcpy(student->name, Lu G.C);
student->age=18;
实际上, student->name就是(*student).name的缩写形式。
需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间,这可用下面函数完成, 仍以上例来说明如下:
student=(struct string*)malloc(size of (struct string));
size of (struct string)自动求取string结构的字节长度,malloc()函数定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。

注意:
1. 结构作为一种数据类型,因此定义的结构变量或结构指针变量同样有局部变量和全程变量, 视定义的位置而定。
2. 结构变量名不是指向该结构的地址,这与数组名的含义不同,因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。
3. 结构的复杂形式：嵌套结构
嵌套结构是指在一个结构成员中可以包括其它一个结构,Turbo C允许这种嵌套。
例如: 下面是一个有嵌套的结构
struct string
{
char name[8];
int age;
struct addr address;
} student;
其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即
struct addr
{
char city[20];
unsigned lon zipcode;
char tel[14];
}
如果要给student结构中成员address结构中的zipcode赋值, 则可写成:
student.address.zipcode=200001;
每个结构成员名从最外层直到最内层逐个被列出,即嵌套式结构成员的表达方式是:
结构变量名.嵌套结构变量名.结构成员名
其中: 嵌套结构可以有很多,结构成员名为最内层结构中不是结构的成员名。

联合(union)：
一、联合说明和联合变量定义
联合也是一种新的数据类型, 它是一种特殊形式的变量。
联合说明和联合变量定义与结构十分相似。其形式为:
union 联合名
{
数据类型 成员名;
数据类型 成员名;
...
}联合变量名;
联合表示几个变量公用一个内存位置,在不同的时间保存不同的数据类型和不同长度的变量。
下例表示说明一个联合a_bc:
union a_bc
{
int i;
char mm;
};
再用已说明的联合可定义联合变量。
例如用上面说明的联合定义一个名为lgc的联合变量,可写成:
union a_bc lgc;
在联合变量lgc中, 整型量i和字符mm公用同一内存位置。
当一个联合被说明时, 编译程序自动地产生一个变量,其长度为联合中最大的变量长度。
联合访问其成员的方法与结构相同。同样联合变量也可以定义成数组或指针,但定义为指针时,也要用->符号, 此时联合访问成员可表示成:
联合名->成员名
另外, 联合既可以出现在结构内, 它的成员也可以是结构。
例如:
struct
{
int age;
char *addr;
union
{
int i;
char *ch;
}x;
}y[10];
若要访问结构变量y[1]中联合x的成员i, 可以写成:
y[1].x.i;
若要访问结构变量y[2]中联合x的字符串指针ch的第一个字符可写成:
*y[2].x.ch;
若写成y[2].x.*ch;是错误的。

二、结构和联合的区别
1. 结构和联合都是由多个不同的数据类型成员组成,但在任何同一时刻,联合中只存放了一个被选中的成员, 而结构的所有成员都存在。
2. 对于联合的不同成员赋值,将会对其它成员重写,原来成员的值就不存在了,而对于结构的不同成员赋值互不影响的。
下面举一个例了来加深对联合的理解。

main()
{
union
{ /*定义一个联合*/
int i;
struct
{ /*在联合中定义一个结构*/
char first;
char second;
}half;
}number;
number.i=0x4241; /*联合成员赋值*/
printf(%c%c\n, number.half.first, mumber.half.second);
number.half.first='a'; /*联合中结构成员赋值*/
number.half.second='b';
printf(%x\n, number.i);
getch();
}
输出结果为:
AB
6261
从上例结果可以看出: 当给i赋值后, 其低八位也就是first和second的值;当给first和second赋字符后,这两个字符的ASCII码也将作为i 的低八位和高八位。
简单的说，就是联合里面的所有变量共用一个内存区域，区域大小是所有变量中最大的那个。改动某一个变量的值，其他的值也会随之改变。

枚举(enum)
枚举是一个被命名的整型常数的集合,枚举在日常生活中很常见。

例如表示星期的SUNDAY,MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,就是一个枚举。
枚举的说明与结构和联合相似, 其形式为:
enum 枚举名
{
标识符[=整型常数],
标识符[=整型常数],
...
标识符[=整型常数],
}枚举变量;
如果枚举没有初始化,即省掉=整型常数时,则从第一个标识符开始,顺次赋给标识符0,1,2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次加1的规则确定其值。
例如下列枚举说明后,x1, x2, x3, x4的值分别为0, 1, 2, 3。
enum string{x1, x2, x3, x4}x;
当定义改变成:
enum string
{
x1,
x2=0,
x3=50,
x4,
}x;
则x1=0, x2=0, x3=50, x4=51
注意:
1. 枚举中每个成员(标识符)结束符是,, 不是;, 最后一个成员可省略,。
2. 初始化时可以赋负数, 以后的标识符仍依次加1。
3. 枚举变量只能取枚举说明结构中的某个标识符常量。
例如:
enum string
{
x1=5,
x2,
x3,
x4,
};
enum strig x=x3;
此时, 枚举变量x实际上是7。
下面看一个例子：

main()
{
enum colors {red=1,green,blue}col;
int cl;
printf(1=red,2=green,3=blue. seclect: );
scanf(%d,&cl);
col=(enum colors) cl; /*强制转换*/
switch(col)
{
case red:
printf(red\n);
break;
case green:
printf(green\n);
break;
case blue:
printf(blue\n);
break;
defalut:
break;
}
}


* **类型说明** *

类型说明的格式为:
typedef 类型 定义名;
类型说明只定义了一个数据类型的新名字而不是定义一种新的数据类型这里类型是Turbo C许可的任何一种数据类型定义名表示这个类型的新名字。
例如: 用下面语句定义整型数的新名字:
typedef int SIGNED_INT;
使用说明后, SIGNED_INT就成为int的同义词了,此时可以用SIGNED_INT定义整型变量。
例如: SIGNED_INT i, j;(与int i, j等效)。
但 long SIGNED_INT i, j; 是非法的。
typedef同样可用来说明结构、联合以及枚举。
说明一个结构的格式为:
typedef struct
{
数据类型 成员名;
数据类型 成员名;
...
} 结构名;
此时可直接用结构名定义结构变量了。例如:
typedef struct
{
char name[8];
int class;
char subclass[6];
float math, phys, chem, engl, biol;
}student;
student Liuqi;
则Liuqi被定义为结构数组和结构指针。
  我们经常在题目中有要求，输入一个整数，然后以这个整数作为数组的元素个数，下面的程序代码是错误的。
int n,array[n];
scanf(%d,&n);
在Turbo C中，不允许出现动态数组。那么如果必须需要这样时，就只能使用链表了。

一、堆
堆是一种动态存储结构，实际上就是数据段中的自由存储区，它是C语言中使用的一种名称，常常用于动态数据的存储分配。堆中存入一数据，总是以2字节的整数倍进行分配，地址向增加方向变动。堆可以不断进行分配直到没有堆空间为止，也可以随时进行释放、再分配，不存在次序问题。
所谓动态数组是指在程序运行期间确定其大小的，如常用到的动态数组，它们是在程序执行过程中动态进行变化的，即在程序开始部分没有说明大小，只有在程序运行期间用堆的分配函数为其分配存储空间，分配的大小可根据需要而定，这些数据使用过后，可释放它们占用的堆空间，并可进行再分配。
堆和栈在使用时相向生长，栈向上生长，即向小地址方向生长，而堆向下增长，即向大地址方向，其间剩余部分是自由空间。使用过程中要防止增长过度而导致覆盖。
一般的程序我们都是使用小内存模式，它的内存分配如下：
________________
| 代码段 |
|————————|
| 数据段 |
|————————|
| BSS段 |
|————————|
| 堆 |
|----------------| 自由空间
|----------------|
| 栈 |
|————————|
| 远堆 |
|----------------|
|________________| 自由空间

在堆和栈之间、以及远堆地址的后面都是自由空间，总共是64K。
堆管理函数：
1.得到堆和栈之间的自由空间大小的函数
小数据内存模式：unsigned coreleft(void);
大数据内存模式：unsigned long coreleft(void);
对于远堆，可以用farcoreleft()函数。
2.分配一个堆空间函数
void malloc (unsigned size);
该函数将分配一个大小为size字节的堆空间，并返回一个指向这个空间的指针。由于这个指针是void型的，因此当将它赋给其他类型的指针时，必须对该指针进行强制类型转换。例如info是一个结构类型指针，即：
struct addr *info;
将由malloc()函数返回的指针赋给info时，必须进行类型转换：
info=(struct addr *)malloc (sizeof(record));
malloc()函数所分配的堆空间将不进行初始化。在调用malloc()函数时，若当时没有可用的内存空间，该函数便返回一个NULL指针。
3.分配一个堆空间，其大小为能容纳几个元素，没有元素长度为size的函数
void calloc(unsigned n,unsigned size);
该函数将分配一个容量为n*size大小的堆空间，并用0初始化分配的空间。该函数将返回一个指向分配空间的指针，没有空间可用时，则返回一个NULL指针。
4.重新分配堆空间函数
void *realloc(void *ptr,unsigned newsize);
该函数将对由ptr指向的堆空间重新分配，大小变为newsize。
5.释放堆空间函数
void free(void *ptr);

下面举一个关于堆和栈的综合例子：

void push(int);
int pop();
int *pi,*tos;

main()
{
int v;
pi=(int *)malloc(50*sizeof(int));
if(!pi)
{
printf(allocation failure\n);
exit(0);
}
tos=pi;
do
{
printf(please input value,push it;enter 0 then pop;(enter -1 then stop)\n);
scanf(%d,&v);
if(v!=0) push(v);
else printf(pop this is it %d\n,pop());
}
while(v!=-1);
}

void push(int i)
{
pi++;
if(pi==(tos+50))
{
printf(stack overflow\n);
exit(0);
}
*pi=i;
}

int pop()
{
if(pi==tos)
{
printf(stack underflow\n);
exit(0);
}
pi--;
return *(pi+1);
}

程序分配100字节的堆空间，转换成int型赋给pi，当pi为NULL时，表示没有可用的空间了，则显示allocation failure。输入一个整数，压入栈中，当超过50时，则显示stack overflow.当输入0时，则把栈中的数据弹出。这个程序也演示了栈的后进先出的特点。

二、链表
堆是用来存储动态数据的。动态数据最典型的例子就是链表。
形象的说：将若干个数据项按一定的原则前后链接起来，没有数据项都有一个指向下一个数据的指针，则这些数据项靠指针链成一个表，最后的一个数据没有指针(指针为NULL)，这就是链表。可以看出链表放在存储器中，并不一定象数组一样，连续存放，也可以分开存放。由于链的各节点均带有指向下一个节点的地址，因而要找到某个节点，必须要找到上一个节点，如此类推，则可由第一个节点出发找到目的点。链表在数据库建立和管理中用得比较普遍。
链表中的每个节点都具有相同的结构类型，它们是由两部分组成，即数据部分(它们包含一些有用的信息),另一部分就是链的指针。下面就定义一个通信链节点的数据结构：
struct address
{
char name[30];
char street[40];
char city[20];
char state[10];
char zip[6];
struct address *next; /*pointer to next entry*/
}list_entry;
该结构中前五个成员是该节点的信息部分，最后一个成员是指向同一个结构类型的指针。即next又指向一个同样结构类型的节点。

1.建立链表
建立链表时，首先要将第一个节点的内容存入堆中，为此要将堆中能存入该节点内容的内存区域首地址赋给一个指针。我们可以用malloc()函数来分配内存区域。如info是一个指针：
info=(struct address *)malloc(sizeof(list_entry));
当第一个节点存入有info指出的内存区后，再执行该函数，便得到狭义个节点的存储地址info，此时将该info赋给上一个节点的next，并将该节点内容存入info指出的内存区，这样两个节点就链接起来了。此过程反复多次，就可不断的将节点加入链表的尾端。

#include stdlib.h
#include alloc.h
#include stdio.h
#include string.h

struct address
{
char name[30];
char street[40];
char city[20];
char state[10];
char zip[6];
struct address *next;
}list_entry;

void inputs(char *,char *,int);
void dls_store(struct address*);

main()
{
struct address *info;
int i;
for(i=0;i<5;i++)
{
info=(struct address *)malloc(sizeof(list_entry));
inputs(enter name:,info->name,30);
inputs(enter street:,info->street,40);
inputs(enter city:,info->city,20);
inputs(enter state:,info->state,10);
inputs(enter zip:,info->zip,6);
dls_store(info);
}
}

void inputs(char *prompt,char *s,int count)
{
char p[255];
do
{
printf(prompt);
gets(p);
if(strlen(p)>count) printf(\n too long \n);
}
while(strlen(p)>count);
strcpy(s,p);
}

void dls_store(struct address *in)
{
static struct address *last=NULL;
if(!last) last=in;
else last->next=in;
in->next=NULL;
last=in;
}

inputs()函数比较简单，就不说明了。
dls_store()函数是将输入的节点地址写到上一个节点的next指针项。其中定义的结构指针last是一个静态变量，初始值为NULL，这意味着在编译时将为该变量分配一个固定的存储空间以存放其值。因初始值为NULL，这样在第一次调用该函数时，由于它代表一个空指针，因而把由malloc()分配的第一个节点地址赋给它，使last指向该节点，第二次调用时，静态变量last已指向第一个节点地址。如此反复调用，便建立起了n次调用产生的n个节点的链了(本题n=5)。

2.链数据的插入和删除
对于一个已排序好的链表(假设是生序)，现在想插入一个数据进去，可能有三种情况：
(1).比首项数据还小，即插入的数据作为首项出现：
这种情况我们的处理方法是：把该数据作为第一项，指针指向原先的首项即可。设原先首项为top，待插入的数据为in，则：
in->next=top;
即可让该数据作为链表的头。
(2).比最后一项大，即插入的数据作为最后一项出现：
这也很好办，设原先最后一项为old，则：
old->next=in;
in->next=NULL;
(3).作为中间某一项出现：前面是old,后面是top,则：
old->next=in;
in->next=top;
如果想删除一个数据，也可能是出现在开头，中间和结尾。
例如想删除in这个数据，它原先的前面是old,后面是top,即原先的链表是这样：
old->next=in;
in->next=top;
现在删除in，只需把old指向top即可:
old->next=top->next;

/*删除节点函数*/
void delete(struct address *info,struct address *old)
{
if(info)
{
if(info==start) start=info->next; /*删除的是第一个节点*/
else
{
old->next=info->next; /*被删除节点前的指针指向下一个节点*/
last=old; /*若节点是链表尾，则该节点前的节点指针指向NULL*/
}
free(info); /*释放删除节点占用空间*/
}
}

/*查找链表中是否有该数据*/
struct address *search(struct address *top,char *n)
{
while(top)
{
if(!strcmp(n,top->name)) return top; /*找到要删除的节点指针*/
top=top->next; /*继续找*/
}
return NULL; /*没有找到*/
}

/*链表的输出*/
void display(struct address *top)
{
while(top)
{
printf(top->name);
top=top->next;
}
}

链表问题比较复杂，但又是很重要的概念。上面说的输入，查找，删除，插入等功能一定要理解，可以参考别的一些资料看看。
上面说的单链表，但是单链表有一个缺点，就是无法反向操作，当某一个链因破坏而断裂，则整个链就被破坏而无法恢复。双链表可以弥补这个缺点，所谓双链表是指每个节点有两个指针项，一个指针指向其前面的节点，而另一个指针指向后面的节点。关于双链表的使用相对要复杂一些，这里就不介绍了，可以找其他一些资料看看。
  在第一节概述里就说了，C语言是一种中级语言，能对计算机硬件直接操作，这就涉及到位的概念。

一、位的概念
我们知道，在计算机中，一字节占8位(现在的某些电脑也有占16位的)，这样表示的数的范围为0-255，也即00000000-11111111。位就是里面的0和1。
char c=100;
实际上c应该是01100100，正好是64H。其中高位在前，低位在后。
| |
第7位 第0位

二、位逻辑运算符

符号 描述
& 位逻辑与
| 位逻辑或
^ 位逻辑异或
~ 取补

表中除去最后一个运算符是单目运算符，其他都是双目运算符。这些运算符只能用于整型表达式。位逻辑运算符通常用于对整型变量进行位的设置、清零、取反、以及对某些选定的位进行检测。在程序中一般被程序员用来作为开关标志。较低层次的硬件设备驱动程序，经常需要对输入输出设备进行位操作。

& 运算的规则是当两个位都为1时，结果为1，否则为0；
| 运算的规则是当两个位都为0时，结果为0，否则为1；
^ 运算的规则是当两个位相同时，结果为0，否则为1；
~ 运算的规则是当为1时结果为0，当为0时，结果为1。

设置位：设置某位为1，而其他位保持不变，可以使用位逻辑或运算。
char c;
c=c|0x40;
这样不论c原先是多少，和01000000或以后，总能使第6位为1，而其他位不变。

清除位：设置某位为0，而其他位保持不变。可以使用位逻辑与运算。
c=c&0xBF;
这样c和10111111与以后，总能使第6位为0，其他位保持不变。
那如果想让某位为1，其他位都为0怎么办呢？

三、位移运算符
符号 描述
<< 左移
>> 右移

位移运算符作用于其左侧的变量，其右侧的表达式的值就是移动的位数，运算结果就是移动后的变量结果。
b=a<<2;
就是a的值左移两位并赋值为b。a本身的值并没有改变。

向左移位就是在低位沙锅补0，向右移位就是在高位上补0。右移时可以保持结果的符号位，也就是右移时，如果最高位为1，是符号位，则补1而不是补0。
程序员常常对右移运算符来实现整数除法运算，对左移运算符来实现整数乘法运算。其中用来实现乘法和除法的因子必须是2的幂次。

举例：输入一个整数，判断这个数中有几个二进制位1？例如输入67，输出结果应该为3。因为67的相应二进制数为00000000 01000011(0043H)，有3个1出现。
分析：要判断是不是1，只需要判断该位与1与以后是不是1就可以知道。一个整数，判断16次即可。

main()
{
int num,k;
int count=0; /* 记录1的个数 */
scanf(%d,&num);
for(k=0;k<16;k++)
{
if(num&1==1) count++; /* 判断最低位是不是1 */
num>>=1; /* num右移1位 */
}
printf(%d\n,count);
}

这样每次都判断最低位是不是1，判断完以后，让前面的右移一位即可。
对位的操作，一般程序中用的不多，但是在对计算机硬件操作时，肯定会涉及到。例如，我们以后要讲到的对串口和声卡操作就要用到一些。
 由于程序中经常有大量对文件的输入输出操作，它经常构成了程序的主要部分，因而C语言提供了很多输入输出的函数，它们分别用于两种类型文件输入输出系统：即由ANSI标准定义的缓冲文件(也称标准文件(流)输入输出(I/O)系统)；另一类是ANSI标准中没有定义的非缓冲文件(也称非标准文件(流)输入输出(I/O)系统)。
我们已经熟悉了通过键盘和显示器进行输入输出的一些函数，如scanf(),printf()等等，这些通过控制台(键盘、显示器等)进行I/O的操作，可以看作标准文件输入输出系统的一些特例，实际上在标准输入输出系统中的一些函数，有关文件的参数(文件结构指针或称流指针),只要用标准设备的流指针代替，这些标准输入输出函数即成为控制台I/O函数。在任何程序执行时，C系统都定义了5个标准设备文件可供使用。自动打开的5个标准设备文件的文件结构指针(在标准I/O系统中)和文件代号将有一个规定值：

设备 标准文件I/O系统中的流指针名 非标准文件……

键盘(标准输入) stdin 0
显示器(标准输出) stdout 1
显示器(标准错误) stderr 2
串行口(标准辅助) stdoux 3
打印机(标准打印) stdprn 4

这样，不论在标准文件系统还是非标准文件系统中，文件结构只要用上述的流指针或文件代号代替，则这些函数也均适用于控制台设备。

一、文本流和二进制流
在C中引入了流(stream)的概念。它将数据的输入输出看作是数据的流入和流出，这样不管是磁盘文件或者是物理设备(打印机、显示器、键盘等),都可看作一种流的源和目的，视他们为同一种东西，而不管其具体的物理结构，即对他们的操作，就是数据的流入和流出。这种把数据的输入输出操作对象，抽象化为一种流，而不管它的具体结构的方法很有利于编程，而涉及流的输出操作函数可用于各种对象，与其具体的实体无关，即具有通用性。
在C中流可分为两大类，即文本流(text stream)和二进制流(binary stream)。所谓文本流是指在流中流动的数据是以字符形式出现。在文本流中，'\n'被换成回车CR和换行LF的代码0DH和0AH。而当输出时，则0DH和0AH本换成'\n'。
二进制流是指流动的是二进制数字序列，若流中有字符，则用一个字节的二进制ASCII码表示，若是数字，则用一个字节的二进制数表示。在流入流出时，对\n符号不进行变换。例如2001这个数，在文本流中用其ASCII码表示为：
'2' '0' '0' '1'
| | | |
50 48 48 49
共占4字节。而在二进制流中则表示为：00000111 11010001 用十六进制就是07D1。只占两字节。
由此看出，二进制流比文本流节省空间，且不用进行对\n的转换，这样可以大大加快流的速度，提高效率。因而，对于含有大量数字信息的数字流，可以采用二进制流的方式；对于含有大量字符信息的流，则采用文本流的方式。

二、流和文件
在C语言中流就是一种文件形式，它实际上就表示一个文件或设备(从广义上讲，设备也是一种文件)。把流当作文件总觉得不习惯，因而有人称这种和流等同的文件为流式文件，流的输入输出也称为文件的输入输出操作。当流到磁盘而成为文件时，意味着要启动磁盘写入操作，这样流入一个字符(文本流)或流入一个字节(二进制流)均要启动磁盘操作，将大大降低传输效率(磁盘是慢速设备)，且降低磁盘的使用寿命。为此，C语言在输入输出的使用使用了缓冲技术，即在内存为输入的磁盘文件开辟了一个缓冲区(缺省为512字节),当流到该缓冲区装满后，再启动磁盘一次，将缓冲区内容装到磁盘文件中去。读取文件也是类似。
在C语言中将此种文件输入输出操作称为标准输入输出，或称流式输入输出(因这种输入输出操作是ANSI C推荐的标准)。还有一种是不带缓冲文件输入输出，称为非标准文件输入输出或低级输入输出，它将由DOS直接管理。关于这两种输入输出文件系统下节将会介绍。

三、文件FILE的数据结构

typedef struct
{
short level;
unsigned flags;
char fd;
unsigned char hold;
short bsize;
unsigned char *buffer;
unsigned char *curp;
unsigned istemp;
short token;
}FILE;

这是Turbo C中使用的定义(在stdio.h文件中),不同的C编译器，可能使用不同的定义，但基本含义变化不会太大。
flags: 是一个10位的标志字，其具体含义如下：

位 代表符号 含义
0 _F_READ 读
1 _F_WRIT 写
2 _F_BUF 由fclose释放缓冲区
3 _F_LBUF 行缓冲
4 _F_ERR 出错标志
5 _F_EOF EOF文件尾标志
6 _F_BIN 二进制方式
7 _F_IN 在进行输入
8 _F_OUT 在进行输出
9 _F_TERM 文件是一个终端

其他各字段内容以及flags字段内各位所的功能，请参照其他一些资料。这里不多说了，它目前并不是我们要求的内容。
应该注意，不要把文件指针和FILE结构指针混为一谈，它们代表两个不同的地址。文件指针指出了对文件当前读写的数据位置，而FILE结构指针是指出了打开文件所对应的FILE结构在内存中的地址，这个指针它实际本身也包含了文件指针的信息。流指针中的各字段是供C语言内部使用的，用户不应该存取它的任何字段。
  一、标准文件的读写
1.文件的打开fopen()
文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时，必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在，就意味着建立(只对写文件而言，对读文件则出错)，并将文件指针指向文件开头。若已有一个同名文件存在，则删除该文件，若无同名文件，则建立该文件，并将文件指针指向文件开头。
fopen(char *filename,char *type);
其中*filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下：

方式 含义
r 打开，只读
w 打开，文件指针指到头，只写
a 打开，指向文件尾，在已存在文件中追加
rb 打开一个二进制文件，只读
wb 打开一个二进制文件，只写
ab 打开一个二进制文件，进行追加
r+ 以读/写方式打开一个已存在的文件
w+ 以读/写方式建立一个新的文本文件
a+ 以读/写方式打开一个文件文件进行追加
rb+ 以读/写方式打开一个二进制文件
wb+ 以读/写方式建立一个新的二进制文件
ab+ 以读/写方式打开一个二进制文件进行追加

当用fopen(0成功的打开一个文件时，该函数将返回一个FILE指针，如果文件打开失败，将返回一个NULL指针。如想打开test文件，进行写：

FILE *fp;
if((fp=fopen(test,w))==NULL)
{
printf(File cannot be opened\n);
exit();
}
else
printf(File opened for writing\n);
……
fclose(fp);

DOS操作系统对同时打开的文件数目是有限制的，缺省值为5，可以通过修改CONFIG.SYS文件改变这个设置。

2.关闭文件函数fclose()
文件操作完成后，必须要用fclose()函数进行关闭，这是因为对打开的文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到该文件中去，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件得到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。
int fclose(FILE *stream);
它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值。常用以下方法进行测试：

if(fclose(fp)!=0)
{
printf(File cannot be closed\n);
exit(1);
}
else
printf(File is now closed\n);

当打开多个文件进行操作，而又要同时关闭时，可采用fcloseall()函数，它将关闭所有在程序中打开的文件。
int fcloseall();
该函数将关闭所有已打开的文件，将各文件缓冲区未装满的内容写到相应的文件中去，接着释放这些缓冲区，并返回关闭文件的数目。如关闭了4个文件，则当执行：
n=fcloseall();
时，n应为4。
3.文件的读写
(1).读写文件中字符的函数(一次只读写文件中的一个字符)：

int fgetc(FILE *stream);
int fgetchar(void);
int fputc(int ch,FILE *stream);
int fputchar(int ch);
int getc(FILE *stream);
int putc(int ch,FILE *stream);
其中fgetc()函数将把由流指针指向的文件中的一个字符读出，例如：
ch=fgetc(fp);
将把流指针fp指向的文件中的一个字符读出，并赋给ch，当执行fgetc()函数时，若当时文件指针指到文件尾，即遇到文件结束标志EOF(其对应值为-1)，该函数返回一个-1给ch，在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾，从而决定是否继续。

#include stdio.h
main()
{
FILE *fp;
ch ch;
if((fp=fopen(myfile.tex,r))==NULL)
{
printf(file cannot be opened\n);
exit(1);
}
while((ch=fgetc(fp))!=EOF) fputc(ch,stdout);
fclose(fp);
}

该程序以只读方式打开myfile.txt文件，在执行while循环时，文件指针每循环一次后移一个字符位置。用fgetc()函数将文件指针指定的字符读到ch变量中，然后用fputc()函数在屏幕上显示，当读到文件结束标志EOF时，变关闭该文件。
上面的程序用到了fputc()函数，该函数将字符变量ch的值写到流指针指定的文件中去，由于流指针用的是标准输出(显示器)的FILE指针stdout，故读出的字符将在显示器上显示。又比如：
fputc(ch,fp);
该函数执行结构，将把ch表示的字符送到流指针fp指向的文件中去。
在TC中，putc()等价于fput(),getc()等价于fgetc()。
putchar(c)相当于fputc(c,stdout)；getchar()相当于fgetc(stdin)。
注意，这里使用char ch,其实是不科学的，因为最后判断结束标志时，是看ch!=EOF,而EOF的值为-1，这显然和char是不能比较的。所以，某些使用，我们都定义成int ch。
(2).读写文件中字符串的函数

char *fgets(char *string,int n,FILE *stream);
char *gets(char *s);
int fprintf(FILE *stream,char *format,variable-list);
int fputs(char *string,FILE *stream);
int fscanf(FILE *stream,char *format,variable-list);
其中fgets()函数将把由流指针指定的文件中n-1个字符，读到由指针stream指向的字符数组中去，例如：
fgets(buffer,9,fp);
将把fp指向的文件中的8个字符读到buffer内存区，buffer可以是定义的字符数组，也可以是动态分配的内存区。
注意，fgets()函数读到'\n'就停止，而不管是否达到数目要求。同时在读取字符串的最后加上'\0'。
fgets()函数执行完以后，返回一个指向该串的指针。如果读到文件尾或出错，则均返回一个空指针NULL，所以长用feof()函数来测定是否到了文件尾或者是ferror()函数来测试是否出错，例如下面的程序用fgets()函数读test.txt文件中的第一行并显示出来：

#include stdio.h
main()
{
FILE *fp;
char str[128];
if((fp=fopen(test.txt,r))==NULL)
{
printf(cannot open file\n);
exit(1);
}
while(!feof(fp))
{
if(fgets(str,128,fp)!=NULL) printf(%s,str);
}
fclose(fp);
}

gets()函数执行时，只要未遇到换行符或文件结束标志，将一直读下去。因此读到什么时候为止，需要用户进行控制，否则可能造成存储区的溢出。
fputs()函数想指定文件写入一个由string指向的字符串，'\0'不写入文件。
fprintf()和fscanf()同printf()和scanf()函数类似，不同之处就是printf()函数是想显示器输出，fprintf()则是向流指针指向的文件输出；fscanf()是从文件输入。

下面程序是向文件test.dat里输入一些字符：

#include
main()
{
char *s=That's good news;
int i=617;
FILE *fp;
fp=fopne(test.dat, w); /*建立一个文字文件只写*/
fputs(Your score of TOEFLis,fp); /*向所建文件写入一串字符*/
fputc(':', fp); /*向所建文件写冒号:*/
fprintf(fp, %d\n, i); /*向所建文件写一整型数*/
fprintf(fp, %s, s); /*向所建文件写一字符串*/
fclose(fp);
}
用DOS的TYPE命令显示TEST.DAT的内容如下所示:
屏幕显示
Your score of TOEFL is: 617
That's good news

下面的程序是把上面的文件test.dat里的内容在屏幕上显示出来：

#include
main()
{
char *s, m[20];
int i;
FILE *fp;
fp=fopen(test.dat, r); /*打开文字文件只读*/
fgets(s, 24, fp); /*从文件中读取23个字符*/
printf(%s, s);
fscanf(fp, %d, &i); /*读取整型数*/
printf(%d, i);
putchar(fgetc(fp)); /*读取一个字符同时输出*/
fgets(m, 17, fp); /*读取16个字符*/
puts(m); /*输出所读字符串*/
fclose(fp);
getch();
}
运行后屏幕显示:
Your score of TOEFL is: 617
That's good news

4.清除和设置文件缓冲区
(1).清除文件缓冲区函数：
int fflush(FILE *stream);
int flushall();

fflush()函数将清除由stream指向的文件缓冲区里的内容，常用于写完一些数据后，立即用该函数清除缓冲区，以免误操作时，破坏原来的数据。
flushall()将清除所有打开文件所对应的文件缓冲区。
(2).设置文件缓冲区函数
void setbuf(FILE *stream,char *buf);
void setvbuf(FILE *stream,char *buf,int type,unsigned size);
这两个函数将使得打开文件后，用户可建立自己的文件缓冲区，而不使用fopen()函数打开文件设定的默认缓冲区。
对于setbuf()函数，buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定，缺省值为512字节。当选定buf为空时，setbuf函数将使的文件I/O不带缓冲。而对setvbuf函数，则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型，其值可以取如下值：

type 值 含义
_IOFBF 文件全部缓冲，即缓冲区装满后，才能对文件读写
_IOLBF 文件行缓冲，即缓冲区接收到一个换行符时，才能对文件读写
_IONBF 文件不缓冲，此时忽略buf,size的值，直接读写文件，不再经过文件缓冲区缓冲

5.文件的随机读写函数
前面介绍的文件的字符/字符串读写，均是进行文件的顺序读写，即总是从文件的开头开始进行读写。这显然不能满足我们的要求，C语言提供了移动文件指针和随机读写的函数，它们是：
(1).移动文件指针函数：
long ftell(FILE *stream);
int rewind(FILE *stream);
fseek(FILE *stream,long offset,int origin);

函数ftell()用来得到文件指针离文件开头的偏移量。当返回值是-1时表示出错。
rewind()函数用于文件指针移到文件的开头，当移动成功时，返回0，否则返回一个非0值。
fseek()函数用于把文件指针以origin为起点移动offset个字节，其中origin指出的位置可有以下几种：

origin 数值 代表的具体位置

SEEK_SET 0 文件开头
SEEK_CUR 1 文件指针当前位置
SEEK_END 2 文件尾

例如：
fseek(fp,10L,0);
把文件指针从文件开头移到第10字节处，由于offset参数要求是长整型数，故其数后带L。
fseek(fp,-15L,2);
把文件指针从文件尾向前移动15字节。
(2).文件随机读写函数

int fread(void *ptr,int size,int nitems,FILE *stream);
int fwrite(void *ptr,int size,int nitems,FILE *stream);

fread()函数从流指针指定的文件中读取nitems个数据项，每个数据项的长度为size个字节，读取的nitems数据项存入由ptr指针指向的内存缓冲区中，在执行fread()函数时，文件指针随着读取的字节数而向后移动，最后移动结束的位置等于实际读出的字节数。该函数执行结束后，将返回实际读出的数据项数，这个数据项数不一定等于设置的nitems，因为若文件中没有足够的数据项，或读中间出错，都会导致返回的数据项数少于设置的nitems。当返回数不等于nitems时，可以用feof()或ferror()函数进行检查。
fwrite()函数从ptr指向的缓冲区中取出长度为size字节的nitems个数据项，写入到流指针stream指向的文件中，执行该操作后，文件指针将向后移动，移动的字节数等于写入文件的字节数目。该函数操作完成后，也将返回写入的数据项数。

二、非标准文件的读写
这类函数最早用于UNIX操作系统,ANSI标准未定义,但有时也经常用到,DOS 3.0以上版本支持这些函数。它们的头文件为io.h。
由于我们不常用这些函数，所以在这里就简单说一下。
1.文件的打开和关闭
open()函数的作用是打开文件,其调用格式为:
int open(char *filename, int access);
该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容:
基本模式和修饰符, 两者用 (或)方式连接。修饰符可以有多个, 但基本模式只能有一个。

access的规定
--------------------------------------------------------
基本模式 含义 修饰符 含 义
--------------------------------------------------------
O_RDONLY 只读 O_APPEND 文件指针指向末尾
O_WRONLY 只写 O_CREAT 文件不存在时创建文件, 属性按基本模式属性
O_RDWR 读写 O_TRUNC 若文件存在, 将其长度缩为0, 属性不变
O_BINARY 打开一个二进制文件
O_TEXT 打开一个文字文件
---------------------------------------------------------
open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。
close()函数的作用是关闭由open()函数打开的文件, 其调用格式为:
int close(int handle);
该函数关闭文件描述字handle相连的文件。

2.读写函数
int read(int handle, void *buf, int count);
read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中,
返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。

write()函数的调用格式为:
int write(int handle, void *buf, int count);
write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。

3.随机定位函数
lseek()函数的调用格式为:
int lseek(int handle, long offset, int fromwhere);
该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。

tell()函数的调用格式为:
long tell(int handle);
该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同。