编程语言C语言学习 222页

编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n编程高手之路—C语言(一)概述       一、C语言的产生与发展C语言是1972年由美国的DennisRitchie设计发明的,并首次在UNIX操作系统的DECPDP-11计算机上使用。它由早期的编程语言BCPL(BasicCombindProgrammingLanguage)发展演变而来。在1970年,AT&T贝尔实验室的Kenhompson根据BCPL语言设计出较先进的并取名为B的语言,最后导致了C语言的问世。随着微型计算机的日益普及,出现了许多C语言版本。由于没有统一的标准,使得这些C语言之间出现了一些不一致的地方。为了改变这种情况,美国国家标准研究所(ANSI)为C语言制定了一套ANSI标准,成为现行的C语言标准。二、C语言的特点C语言发展如此迅速,而且成为最受欢迎的语言之一,主要因为它具有强大的功能。许多著名的系统软件,如PC-DOS,DBASEⅣ都是由C语言编写的。用C语言加上一些汇编语言子程序,就更能显示C语言的优势了。归纳起来C语言具有下列特点:\n1.C是中级语言它把高级语言的基本结构和语句与低级语言的实用性结合起来。C语言可以象汇编语言一样对位、字节和地址进行操作,而这三者是计算机最基本的工作单元。2.C是结构式语言结构式语言的显著特点是代码及数据的分隔化,即程序的各个部分除了必要的信息交流外彼此独立。这种结构化方式可使程序层次清晰,便于使用、维护以及调试。C语言是以函数形式提供给用户的,这些函数可方便的调用,并具有多种循环、条件语句控制程序流向,从而使程序完全结构化。3.C语言功能齐全C语言具有各种各样的数据类型,并引入了指针概念,可使程序效率更高。另外C语言也具有强大的图形功能,支持多种显示器和驱动器。而且计算功能、逻辑判断功能也比较强大,可以实现决策目的。4.\nC语言适用范围大C语言还有一个突出的优点就是适合于多种操作系统,如DOS、UNIX,也适用于多种机型。三、TurboC的产生与发展我们平常用的大部分都是TurboC。TurboC是美国Borland公司的产品,Borland公司是一家专门从事软件开发、研制的公司。该公司相继推出了一套Turbo系列软件,如TurboBASIC,TurboPascal,TurboProlog,这些软件很受用户欢迎。该公司在1987年首次推出TurboC1.0产品,其中使用了全然一新的集成开发环境,即使用了一系列下拉式菜单,将文本编辑、程序编译、连接以及程序运行一体化,大大方便了程序的开发。1988年,Borland公司又推出TurboC1.5版本,增加了图形库和文本窗口函数库等,而TurboC2.0则是该公司1989年出版的。TurboC2.0在原来集成开发环境的基础上增加了查错功能,并可以在Tiny模式下直接生成.COM(数据、代码、堆栈处在同一64K中)文件。还可对数学协处理器(支持8087/80287/80387等)进行仿真。我们目前经常使用的集成环境就是TurboC2.0。Borland公司后来又推出了面向对象的程序软件包TurboC++,它继承发展TurboC2.0的集成开发环境,并包含了面向对象的基本思想和设计方法。习惯上我们也叫它TurboC3.0。\n1991年为了适用Microsoft公司的Windows3.0版本,Borland公司又将TurboC++作了更新,即TurboC的新一代产品BorlandcC++也已经问世了。编程高手之路—C语言（二）变量和常量 \n编译环境设置好以后，就可以正式学习C语言了。一、变量(一)、变量类型和表示方法1.什么是变量？一句话，变量是存储数据的值的空间。由于数值的类型有多种，有整数、小数（浮点数）、字符等等，那么对应的变量就有整型变量、浮点型变量、字符型变量。变量还有其他的具体分类。整型变量还可具体分为无符号型、长整型和短整型。浮点型也可分为单精度型、双精度型和长双精度型。此外还可以分为静态变量、外部变量、寄存器变量和自动存储变量。这些数据类型我们在本节和后面的章节中都会陆陆续续介绍。那么变量我们总要给它取个名字吧，这个名字我们叫做标识符。标识符的命名有一定的规则：(1).标识符只能由字母、数字和下划线三类字符组成(2).第一个字符必须是字母（第一个字符也可以是下划线，但被视作系统自定义的标识符）(3).大写字母和小写字母被认为是两个不同的字符，如A和a是两个不同的标识符(4).标识符可以任意长，但只有前32位有效。有些旧的C版本对外部标识符的限制为6位。这是由于链接程序的限制所总成的，而不是C语言本身的局限性(5).标识符不能是C的关键字2.从上面的规则中，有个关键字的概念。那么什么叫关键字呢？从表面字意上也可以看出，关键字是C语言本身某些特性的一个表示，是唯一的代表某一个意思的。下面列出ANSI标准定义的32个C语言的关键字，这些关键字在以后的学习中基本上都会用到，到时再说它们的各自用法。autobreakcasecharconstcontinuedefaultdodoubleelseenumexternfloatforgotoifintlongregisterreturn\nshortsignedsizeofstaticstructswitchtypedefunionunsignedvoidvolatilewhileC语言还包括一些不能用做标识符的扩展关键字。asmcdecl_cs_ds_esfarhugeinterruptnearpascal_ss所以在以后的学习中，在给变量命名时要避开这些关键字。3.TurboC2.0规定所有变量在使用前都必须加以说明。一条变量说明语句由数据类型和其后的一个或多个变量名组成。变量说明的形式如下:类型<变量表>;这里类型是指TurboC2.0的有效数据类型。变量表是一个或多个标识符名,每个标识符之间用,分隔。(二)、整型变量整型变量是用来存储整数的。整型变量又可具体分为好几种，最基本的整型变量是用类型说明符int声明的符号整型，形式如下：int\nCounter;这里int是类型说明符，Counter是变量的名字。整型变量可以是有符号型、无符号型、长型、短型或象上面定义的普通符号整型。整型是16位的，长整型是32位，短整型等价于整型。以下是几种整型变量的声明示例：longintAmount;/*长整型*/longAmount;/*长整型，等价于上面*/signedintTotal;/*有符号整型*/signedTotal;/*有符号整型，等价于上面*/unsignedintOffset;/*无符号整型*/unsignedOffset;/*无符号整型，等价于上面*/shortintSmallAmt;/*短整型*/shortSmallAmt;/*短整型，等价于上面*/unsignedshortintMonth;/*无符号短整型*/unsignedshortMonth;/*无符号短整型，等价于上面*/从上面的示例可以看出，当定义长整型、短整型、符号整型或无符号整型时，可以省略关键字int。注明：1.用signed对整型变量进行有符号指定是多余的，因为除非用unsigned指定为无符号型，否则整型都是有符号的。2.当一个变量有几重特性时，声明关键字的顺序可以任意。以下几种声明是等价的：unsignedlongT1;longunsignedT2;unsignedlongintT3;unsignedintlongT4;longunsignedint\nT5;longintunsignedT6;intunsignedlongT7;intlongunsignedT8;(三)、浮点类型变量顾名思义，浮点类型变量是用来存储带有小数的实数的。C语言中有三种不同的浮点类型，以下是对这三种不同类型的声明示例：floatAmount;/*单精度型*/doubleBigAmount;/*双精度型*/longdoubleReallyBigAmount;/*长双精度型*/这里Amount,BigAmount,ReallyBigAmount都是变量名。浮点型都是有符号的。(四)、字符型变量字符型变量中所存放的字符是计算机字符集中的字符。对于PC机上运行的C系统，字符型数据用8位单字节的ASCII码表示。程序用类型说明符char来声明字符型变量：char\nch;这条声明语句声明了一个字符型变量，标识符为ch。当以这种形式声明变量之后，程序可以在表达式中引用这个变量，关于语句和表达式的知识在后面将会介绍。字符数据类型事实上是8位的整型数据类型，可以用于数值表达式中，与其他的整型数据同样使用。在这种情况下，字符型变量可以是有符号的，也可以是无符号的。对于无符号的字符型变量可以声明为：unsignedcharch;除非声明为无符号型，否则在算术运算和比较运算中，字符型变量一般作为8位有符号整型变量处理。还有其他的如指针型变量，void型变量，以后再介绍。二、常量常量的意思就是不可改变的量，是一个常数。同变量一样，常量也分为整型常量、浮点型常量、字符型常量，还有字符串常量、转义字符常量和地址常量。(一)、整型常量整型常量可以是长整型、短整型、有符号型、无符号型。在TubboC2.0里有符号整型常量的范围从-32768到32767，无符号整型的为0到65535；有符号长整型的范围为-2147483648到2147483647。无符号长整型的范围为0到4294967295。短整型同字符型。可以指定一个整型常量为二进制、八进制或十六进制，如以下语句：-129,0x12fe,\n0177常量的前面有符号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。\n3.绝对值小于1的浮点数,其小数点前面的零可以省略。如:0.22可写为.22,-0.0015E-3可写为-.0015E-3。4.TurboC默认格式输出浮点数时,最多只保留小数点后六位(三)、字符型常量字符型常量所表示的值是字符型变量所能包含的值。我们可以用ASCII表达式来表示一个字符型常量，或者用单引号内加反斜杠表示转义字符。'A','\x2f','\013';其中：\x表示后面的字符是十六进制数，\0表示后面的字符是八进制数。注意：在TurboC2.0中，字符型常量表示数的范围是-128到127，除非你把它声明为unsigned，这样就是0到255。(四)、字符串常量字符串常量就是一串字符,用双引号括起来表示。Hello,World!\nEnter\nselection:\aError!!!(五)、转义字符上面我们见到的\x,\n,\a等等都是叫转义字符，它告诉编译器需要用特殊的方式进行处理。下面给出所有的转义字符和所对应的意义：转义字符描述\'单引号\双引号\\反斜杠\0空字符\0nnn八进制数\a声音符\b退格符\f换页符\n换行符\r回车符\t水平制表符\v垂直制表符\x十六进制符它们的具体用法我们到讲输出语句时再介绍。(六)、地址常量我们前面说的变量是存储数据的空间，它们在内存里都有对应的地址。在C语言里可以用地址常量来引用这些地址，如下：&Counter,\n∑&是取地址符，作用是取出变量(或者函数)的地址。在后面的输入语句和指针里还会说明。这一节所讲到的变量和常量知识可以说是在一切程序中都要用到，特别是变量的声明和命名规则。编程高手之路—C语言（三）运算符\n无论是加减乘除还是大于小于，都需要用到运算符，在C语言中的运算符和我们平时用的基本上都差不多。运算符包括赋值运算符、算术运算符、逻辑运算符、位逻辑运算符、位移运算符、关系运算符、自增自减运算符。大多数运算符都是二目运算符，即运算符位于两个表达式之间。单目运算符的意思是运算符作用于单个表达式。(具体什么是表达式下一节再说)一、赋值运算符赋值语句的作用是把某个常量或变量或表达式的值赋值给另一个变量。符号为‘=’。这里并不是等于的意思，只是赋值，等于用‘==’表示。注意：赋值语句左边的变量在程序的其他地方必须要声明。得已赋值的变量我们称为左值，因为它们出现在赋值语句的左边；产生值的表达式我们称为右值，因为她它们出现在赋值语句的右边。常数只能作为右值。例如：count=5;total1=total2=0;第一个赋值语句大家都能理解。第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。这样它先total2=0;然后total1=total2;那么我们这样行不行呢？(total1=total2)=0;这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表达式，而赋值语句的左边是不允许表达式存在的。二、算术运算符在C语言中有两个单目和五个双目运算符。符号功能+单目正-单目负*乘法/除法%取模+加法-\n减法下面是一些赋值语句的例子，在赋值运算符右侧的表达式中就使用了上面的算术运算符：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)\n(7/4);最终a的结果是多少？单目减运算符相当于取相反值，若是正值就变为负值，若是负数就变为正值。单目加运算符没有意义，纯粹是和单目减构成一对用的。三、逻辑运算符逻辑运算符是根据表达式的值来返回真值或是假值。其实在C语言中没有所谓的真值和假值，只是认为非0为真值，0为假值。符号功能&&逻辑与||逻辑或!\n逻辑非例如：5!3;0||-2&&5;!4;当表达式进行&&运算时，只要有一个为假，总的表达式就为假，只有当所有都为真时，总的式子才为真。当表达式进行||运算时，只要有一个为真，总的值就为真，只有当所有的都为假时，总的式子才为假。逻辑非(!)运算是把相应的变量数据转换为相应的真/假值。若原先为假，则逻辑非以后为真，若原先为真，则逻辑非以后为假。还有一点很重要，当一个逻辑表达式的后一部分的取值不会影响整个表达式的值时，后一部分就不会进行运算了。例如：a=2,b=1;a||b-1;因为a=2，为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。四、关系运算符关系运算符是对两个表达式进行比较，返回一个真/假值。符号功能>大于<小于>=大于等于<=小于等于==等于!=\n不等于这些运算符大家都能明白，主要问题就是等于==和赋值=的区别了。一些刚开始学习C语言的人总是对这两个运算符弄不明白，经常在一些简单问题上出错，自己检查时还找不出来。看下面的代码：if(Amount=123)……很多新人都理解为如果Amount等于123，就怎么样。其实这行代码的意思是先赋值Amount=123，然后判断这个表达式是不是真值，因为结果为123，是真值，那么就做后面的。如果想让当Amount等于123才运行时，应该if(Amount==123)\n……五、自增自减运算符这是一类特殊的运算符，自增运算符++和自减运算符--对变量的操作结果是增加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;复合赋值运算符有下列这些：符号功能+=加法赋值-=减法赋值*=乘法赋值/=除法赋值%=模运算赋值<<=左移赋值>>=右移赋值&=位逻辑与赋值|=位逻辑或赋值^=位逻辑异或赋值上面的十个复合赋值运算符中，后面五个我们到以后位运算时再说明。\n那么看了上面的复合赋值运算符，有人就会问，到底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自右向左*/%自左向右+-自左向右<<>>自左向右<<=>>=自左向右==!=\n自左向右&自左向右^自左向右|自左向右&&自左向右||自左向右?:自右向左=+=-=*=/=%=&=^=|=<<=>>=自右向左(最低),自左向右在该表中，还有一些运算符我们没有介绍，如指针运算符、sizeof运算符、数组运算符[]等等，这些在以后的学习中会陆续说明的。编程高手之路—C语言（四）表达式和语句\n一、表达式前面已经提到过表达式，相信大家对表达式也有了一个初步的认识，它是由常量、变量、运算符组合(到以后讲函数时，函数也可以是组成表达式的元素)，计算以后返回一个结果值。表达式的结束标志是分号(;)，C语言中所有的语句和声明都是用分号结束，在分号出现之前，语句是不完整的。例如：1+2;Counter/3+5;Height*Width;表达式本身什么事情都不做，只是返回结果值。在程序不对返回的结果值做任何操作的情况下，返回的结果值不起任何作用，表达式的作用有两点，一个是放在赋值语句的右边，另一个是作为函数的参数(以后再介绍)。表达式返回的结果值是有类型的。表达式隐含的数据类型取决于组成表达式的变量和常量的类型。因此，表达式的返回值有可能是某种大小的整型，或者是某精度的浮点型，或者是某种指针类型。这里面就有类型转化的问题了，在前面说整型运算的时候也提到过。类型转化的原则是从低级向高级自动转化(除非人为的加以控制)。计算的转换顺序基本是这样的：字符型-->整型-->长整型-->浮点型-->单精度型-->双精度型就是当字符型和整型在一起运算时，结果为整型，如果整型和浮点型在一起运算，所得的结果就是浮点型，如果有双精度型参与运算，那么答案就是双精度型了。强制转换是这样的，在类型说明符的两边加上括号，就把后面的变量转换成所要的类型了。如：　　(int)a;(float)b;第一个式子是把a转换成整型，如果原先有小数部分，则舍去。第二个式子是把b转换成浮点型，如果原先是整数，则在后面补0。每一个表达式的返回值都具有逻辑特性。如果返回值为非0，则该表达式返回值为真，否则为假。这种逻辑特性可以用在程序流程控制语句中。有时表达式也不参加运算，如：if(a||b)…………5>3?a++:b++;当a为真时，b就不参加运算了，因为不管b如何，条件总是真。\n二、语句(一)、赋值语句其实这个问题，在讲赋值运算符的时候已经讲了一些了。Amount=1+2;Total=Counter/3+5;Area=Height*Width;也许你会发现，这些赋值语句很象代数方程，在某些情况下，我们的确可以这样理解，但有时它们是不一样的。看下面：Num=Num+1;这显然不是一个等式。(二)、用逗号分隔开的声明语句C语言可大多数语言一样，允许用逗号分隔声明语句中的标识符列表，说明这些运算符是同一变量类型。例如：floatArea,Height,Width;但有些程序员喜欢把标识符写在不同的行上。如：floatArea,Height,Width;这样写至少有一个好处，就是可以在每个标识符后边加上注释。在声明变量的时候，也可以直接给变量赋值，这叫做变量的初始化。如：inta;a=3;等价于:inta=3;我们也让某些变量初始化，某些不初始化，如：int\na=3,b,c=5;在进行初始化时，初始化表达式可以是任意的(对全局变量和静态变量有区别)，由于逗号运算符是从左到右运算的，那么看看这样行不行？inta=3,b=a,c=5;(三)、标准输入输出语句TurboC2.0标准库提供了两个控制台格式化输入、输出函数scanf();和printf();这两个函数可以在标准输入输出设备上以各种不同的格式读写数据。scanf()函数用来从标准输入设备(键盘)上读数据，printf()函数用来向标准输出设备(屏幕)写数据。下面详细介绍这两个函数的用法。1.标准输入语句scanf()函数是格式化输入函数,它从标准输入设备(键盘)读取输入的信息。其调用格式为:scanf(<格式化字符串>,<地址表>);格式化字符串包括以下三类不同的字符;(1).空白字符:空白字符会使scanf()函数在读操作中略去输入中的一个或多个空白字符。(2).非空白字符:一个非空白字符会使scanf()函数在读入时剔除掉与这个非空白字符相同的字符。(3).格式化说明符:以%开始,后跟一个或几个规定字符,用来确定输出内容格式。TurboC2.0提供的输入格式化规定符如下:\n━━━━━━━━━━━━━━━━━━━━━━━━━━符号作用──────────────────────────%d十进制有符号整数%u十进制无符号整数%f浮点数%s字符串%c单个字符%p指针的值%x,%X无符号以十六进制表示的整数%o无符号以八进制表示的整数━━━━━━━━━━━━━━━━━━━━━━━━━━地址表是需要读入的所有变量的地址,而不是变量本身，取地址符为'&'。各个变量的地址之间同,分开。例如：scanf(%d,%d,&i,&j);上例中的scanf()函数先读一个整型数,然后把接着输入的逗号剔除掉,最后读入另一个整型数。如果,这一特定字符没有找到,scanf()函数就终止。若参数之间的分隔符为空格,则参数之间必须输入一个或多个空格。说明:\n(a).对于各个变量，类型说明符是什么，输入格式化说明符就应该用对应的类型。否则会出现程序错误或输入数据和理想的不一样。(b).对于字符串数组或字符串指针变量,由于数组名和指针变量名本身就是地址,因此使用scanf()函数时,不需要在它们前面加上&操作符。char*p,str[20];scanf(%s,p);scanf(%s,str);具体字符串，指针的知识以后再介绍。(c).可以在格式化字符串中的%各格式化规定符之间加入一个整数,表示任何读操作中的最大位数。如上例中若规定只能输入10字符给字符串指针p,则第一条scanf()函数语句变为:scanf(%10s,p);程序运行时一旦输入字符个数大于10,p就不再继续读入。实际使用scanf()函数时存在一个问题,下面举例进行说明:当使用多个scanf()函数连续给多个字符变量输入时,例如:charc1,c2;scanf(%c,&c1);scanf(%c,&c2);\n运行该程序,输入一个字符A后回车(要完成输入必须回车),在执行scanf(%c,&c1)时,给变量c1赋值A,但回车符仍然留在缓冲区内,执行输入语句scanf(%c,&c2)时,变量c2输出的是一空行,如果输入AB后回车,那么实际存入变量里的结果为c1为A，c2为B。要解决以上问题,可以在输入函数前加入清除函数fflush();(这个函数的使用方法将在本节最后讲述)。(d).当在格式说明符之间加入'*'时，表示跳过输入，例如：scanf(%3*d,&a);当输入12345的时候，前面三个字符跳过去不考虑，最终变量a的值为45。2.标准输出语句printf()函数是格式化输出函数,一般用于向标准输出设备按规定格式输出信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:printf(<格式化字符串>,<参量表>);其中格式化字符串包括两部分内容:一部分是正常字符,这些字符将按原样输出;另一部分是格式化规定字符,以%开始,后跟一个或几个规定字符,用来确定输出内容格式。\n参量表是需要输出的一系列参数,其个数必须与格式化字符串所说明的输出参数个数一样多,各参数之间用,分开,且顺序一一对应,否则将会出现意想不到的错误。对于输出语句，还有两个格式化说明符符号作用%e指数形式的浮点数%g自动选择合适的表示法说明:(1).可以在%和字母之间插进数字表示最大场宽。例如:%3d表示输出3位整型数,不够3位右对齐。%9.2f表示输出场宽为9的浮点数,其中小数位为2,整数位为6,小数点占一位,不够9位右对齐。%8s表示输出8个字符的字符串,不够8个字符右对齐。如果字符串的长度、或整型数位数超过说明的场宽,将按其实际长度输出。但对浮点数,若整数部分位数超过了说明的整数位宽度,将按实际整数位输出;若小数部分位数超过了说明的小数位宽度,则按说明的宽度以四舍五入输出。另外,若想在输出值前加一些0,就应在场宽项前加个0。例如:%04d表示在输出一个小于4位的数值时,将在前面补0使其总宽度为4位。如果用浮点数表示字符或整型量的输出格式,小数点后的数字代表最大宽度,小数点前的数字代表最小宽度。例如:%6.9s表示显示一个长度不小于6且不大于9的字符串。若大于9,则第9个字符以后的内容将被删除。(2).可以在%和字母之间加小写字母l,表示输出的是长型数。例如:%ld\n表示输出long整数%lf表示输出double浮点数(3).可以控制输出左对齐或右对齐，即在%和字母之间加入一个-号可说明输出为左对齐,否则为右对齐。例如:%-7d表示输出7位整数左对齐%-10s表示输出10个字符左对齐一些特殊规定字符(可以参照前面说的转义字符)━━━━━━━━━━━━━━━━━━━━━━━━━━字符作用──────────────────────────\n换行\f清屏并换页\r回车\tTab符\xhh表示一个ASCII码用16进表示━━━━━━━━━━━━━━━━━━━━━━━━━━由本节所学的printf()函数,并结合上一节学习的数据类型,看下面的语句,加深对TurboC2.0数据类型的了解。charc;inta=1234;\nfloatf=3.141592653589;doublex=0.12345678987654321;c='\x41';printf(a=%d\n,a);/*结果输出十进制整数a=1234*/printf(a=%6d\n,a);/*结果输出6位十进制数a=1234*/printf(a=%06d\n,a);/*结果输出6位十进制数a=001234*/printf(a=%2d\n,a);/*a超过2位,按实际值输出a=1234*/printf(f=%f\n,f);/*输出浮点数f=3.141593*/printf(f=6.4f\n,f);/*输出6位其中小数点后4位的浮点数f=3.1416*/printf(x=%lf\n,x);/*输出长浮点数x=0.123457*/printf(x=%18.16lf\n,x);/*输出18位其中小数点后16位的长浮点数x=0.1234567898765432*/printf(c=%c\n,c);/*输出字符c=A*/printf(c=%x\n,c);/*输出字符的ASCII码值c=41*/上面结果中的地址值在不同计算机上可能不同。当然还有一些输入输出函数，这个以后用到时慢慢再介绍。编程高手之路—C语言（五）编写第一个C语言程序\n前面几节介绍了常量和变量、运算符、表达式和语句的概念，对它们的使用有了一个大概的了解。也许刚学程序的人会觉得有些枯燥，下面我们就来编写第一个C语言程序。#definePI3.1416main(){floatRadius,Area;scanf(%f,&Radius);/*输入半径的值*/Area=PI*Radius*Radius;printf(%f\n,Area);/*输出圆的面积*/}1.一个C语言程序，通常由带有#号的编译预处理语句开始。关于预处理我们在以后介绍，这里的#definePI3.1415926相当于PI代表3.1416，下面在程序中遇到PI，我们就用3.1416替代一下。在以后的程序中，在学习预处理之前，我们都将不使用预处理语句。2.main()\n任何一个完整的程序都需要main()，这是一个函数，具体什么是函数，以后再讲，这儿你就要记住就行。后面有一对{}把所有的语句都括在里面，表明那些语句都属于main()里面。程序运行时从这个左大括号开始。3.{}里面的4行语句大家应该都能明白，先定义两个变量，一个代表半径，一个代表面积，然后输入半径的值，然后求面积，最后在屏幕上输出面积。程序到main()的那对{}的右大括号结束。求面积的语句Area=PI*Radius*Radius;相当于Area=3.1416*Radius*Radius;(完全用3.1416替代PI)。具体程序从编写到运行得到结果的步骤为：1.双击tc.exe，进入TurboC2.0编译界面2.ALT+E进入编辑模式3.书写程序4.F2存储程序(也可进入File菜单，选择save),第一次存储需要写上程序名称(*.C)，回车5.ALT+F9编译，如果有错误和警告，光标停留在错误行，回车进行修改，修改后，回到4;没有错，下一步6.CTRL+F9连接和运行程序7.用ALT+F5查看程序运行结果，任意键返回程序如何打开一个已有的C文件：1.双击tc.exe，进入TurboC2.0编译界面2.F3\n进入load状态，找到所要打开文件的目录，找到文件，回车;后面都一样。具体的有哪些快捷键及其它们的作用，请查看第一节概述。说明：1.必须在程序的最开始部分定义所有用到的变量，例如这里的Area,Radius。2.变量的命名要尽量有意义，如用代表该意思的英文单词、或者是汉语拼音，例如这里的Radius,Area，绝对禁止用毫无干系的字母，如a,b,c。例如下面的程序，虽然意思和上面的一样，但是看上去意思不明朗，时间长了，很可能忘记程序本身的意思。对于仅仅是控制程序运行，不代表实际意思时，可以用一些简单字母。main(){float\na,b;scanf(%f,&a);b=3.1416*a*a;printf(%f\n,b);}3.采用层次书写程序的格式，要有合理的缩进，必要的时候要有空行，一行只书写一个语句。所有语句尽量不分行，除非太长(分行时变量、运算符，格式字符等等不能拆开)，例如下面两个程序看起来就不好看了，虽然它们的功能和前面是一样的。main(){floatRadius,Area;scanf(%f,&Radius);Area=3.1416*Radius*Radius;printf(%f\n,Area);}main(){floatRadius,Area;scanf(%f,%Radius);Area=3.1416*Radius*Radius;printf(%f\n,Area);}4.程序在适当的地方要用/*……*/注释，它的意思表示在/*\n*/里面的所有字符都不参加编译。因为一个较大的程序，经过一段时间，有些地方可能连编程者都忘记了，增加注释可以帮助恢复记忆，调试程序时，也容易找出错误。注释也可以分行写。5.在书写{}时要对齐。虽然不对应也不影响程序运行，但对齐后方便以后检查程序，也是为了美观，特别是后面学到流程控制时，{}一定要对齐。程序设计方法：1.从问题的全局出发，写出一个概括性的抽象的描述。2.定义变量，选取函数，确定算法。算法这个东西不好说，遇到的问题多了，自然就会形成自己一整套的算法。3.按照解决问题的顺序把语句和函数在main()里面堆砌起来。一个好的C程序员应该做到：1.在运行程序之前存盘2.所有在程序中用到的常量都用预处理语句在程序开头定义3.所有在程序中用到的函数都在程序开头声明4.头文件的#ifndef5.变量名和函数名使用有意思的英文单词或汉语拼音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.写上必要的注释这里说的是一些基本的，经常遇到的情况，还有其他很多要注意的地方，在实际编程中都会遇到.编程高手之路—C语言(六)条件语句\n一个表达式的返回值都可以用来判断真假，除非没有任何返回值的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(表达式)\n语句1;else语句2;同样，当语句1或语句2是多于一个语句时，需要用{}把语句括起来。例如：if(x>=0)y=x;elsey=-x;三、if--elseif--else结构。if(表达式1)语句1;elseif(表达式2)语句2;elseif(表达式3)语句3;...else语句n;这种结构是从上到下逐个对条件进行判断,一旦发现条件满点足就执行与它有关的语句,并跳过其它剩余阶梯;若没有一个条件满足,则执行最后一个else\n语句n。最后这个else常起着缺省条件的作用。同样,如果每一个条件中有多于一条语句要执行时,必须使用{和}把这些语句包括在其中。条件语句可以嵌套,这种情况经常碰到,但条件嵌套语句容易出错,其原因主要是不知道哪个if对应哪个else。例如:if(x>20||x<-10)if(y<=100&&y>x)printf(Good);elseprintf(Bad);对于上述情况,TurboC2.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);}elseprintf(Bad);\n下面举几个例子：1.输入一个数,如果大于0，输出plus;如果是负数，输出negative;如果正好是0，则输出zero。main(){floatnum;scanf(%f,&f);if(num>0)printf(plus\n);elseif(num<0)printf(negative\n);elseprintf(zero\n);}先定义两个变量，然后输入一个数，然后判断这个数的范围，输出对应的字符串。2.输入一个数x,输出y。其中y是x的绝对值。main(){floatx,y;scanf(%f,&x);if(x>=0)\ny=x;elsey=-x;printf(%f\n,y);}程序比较简单，这儿就不分析了。其实TruboC2.0把一些常用的功能都写好了，我们只需要使用就可。例如求绝对值的功能在C的库里面就有。看下面的：#includemath.hmain(){floatx,y;scanf(%f,&x);y=fabs(x);\n/*求x的绝对值，然后赋值给y*/printf(%f\n,y);}这个程序和上面的程序完成的功能是一模一样的，都是求绝对值。可以看出，用下面这个方法比上面就要好一些。由于fabs()是一个函数，系统自带的，所以在使用它的时候，我们必须把它所在的库文件math.h包含都程序中，即程序最前面一行。类似的还有求开方sqrt()，求指数幂exp()等等，这些与数学方面有关的函数都在math.h里面。具体哪些有哪些没有，在什么库里面，可以查看一些手册。3.输入x，输出y，x和y满足关系：x<-5y=x;-5<=x<1y=2*x+5;1<=x<4y=x+6;x>=4y=3*x-2;程序如下：main(){floatx,y;scanf(%f,&x);if(x<-5)y=x;elseif(-5<=x&&x<1)y=2*x+5;else\nif(1<=x&&x<4)y=x+6;elsey=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(){floatx,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);elseprintf(%f\t%f\n,z,y);}elseif(y>=x&&y>=z){printf(%f\t,y);if(x>=z)printf(%f\t%f\n,x,z);else\nprintf(%f\t%f\n,z,x);}else{printf(%f\t,z);if(x>=y)printf(%f\t%f\n,x,y);elseprintf(%f\t%f\n,y,x);}}说明：这是一个典型的if语句嵌套结构，如果不使用括号，那么if和else的对应关系就乱了。四、switch--case语句在编写程序时,经常会碰到按不同情况分转的多路问题,这时可用嵌套if-else-if语句来实现,但if-else-if语句使用不方便,并且容易出错。对这种情况,TurboC2.0提供了一个开关语句。开关语句格式为:switch(变量){case常量1:语句1或空;case常量2:语句2或空;\n...case常量n:语句n或空;default:语句n+1或空;}执行switch开关语句时,将变量逐个与case后的常量进行比较,若与其中一个相等,则执行该常量下的语句,若不与任何一个常量相等,则执行default后面的语句。注意:1.switch中变量可以是数值，也可以是字符，但必须是整数。2.可以省略一些case和default。3.每个case或default后的语句可以是语句体,但不需要使用{和}括起来。例如：main(){int\nx,y;scanf(%d,&x);witch(x){case1:y=x+1;break;/*退出开关语句,遇到break才退出*/case\n4: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(){floatnum;chargrade;scanf(%d,&num);if(num>=90)grade='A';elseif(num>=80&&num<89)grade='B';elseif(num>=70&&num<79)grade='C';elseif(num>=60&&num<69)grade='D';elsegrade='E';printf(%c,grade);}(2).用switch语句main(){intnum;char\ngrade;scanf(%d,&num);num/=10;switch(num){case10:case9:grade='A';break;case8:grade='B';break;case7:grade='C';break;case\n6:grade='D';break;default:grade='E';break;}printf(%c,grade);}说明一点，并不是每个case里面有都语句，有时侯里面是空的，就好象这一题。switch语句执行的顺序是从第一case判断，如果正确就往下执行，直到break；如果不正确，就执行下一个case。所以在这里，当成绩是100分时，执行case10:然后往下执行，grade='A';break;退出。想想看，这里为什么要用num/=10;？假设当程序中有浮点数时怎么办呢？编程高手之路—C语言(七)循环语句和循环控制TurboC2.0提供三种基本的循环语句:for语句、while语句和do-while语句。一、循环语句(一)、for循环\n它的一般形式为: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;;)\n语句;这些for循环语句都是正确的。main(){inti,j;printf(ij\n);for(i=0;i<2;i++)for(j=0;j<3;j++)printf(%d%d\n,i,j);}输出结果为:ij000102101112用for循环求1+2+……+100的和：main(){int\nsn=0,i;for(i=1;i<=100;i++)sn+=i;/*1+2+……+100*/printf(%d\n,sn);}从程序可以看出，使用循环语句可以大大简化代码。(二)、while循环它的一般形式为:while(条件)语句;while循环表示当条件为真时，便执行语句。直到条件为假才结束循环。并继续执行循环程序外的后续语句。例如：#includestdio.hmain(){charc;c='\0';/*初始化c*/while(c!='\n')/*回车结束循环*/c=getche();/*带回显的从键盘接收字符*/}\n上例中，while循环是以检查c是否为回车符开始，因其事先被初始化为空，所以条件为真，进入循环等待键盘输入字符；一旦输入回车，则c='\n'，条件为假，循环便告结束。与for循环一样，while循环总是在循环的头部检验条件，这就意味着循环可能什么也不执行就退出。注意:(1).在while循环体内也允许空语句。例如:while((c=getche())!='\n');这个循环直到键入回车为止。(2).可以有多层循环嵌套。(3).语句可以是语句体,此时必须用{和}括起来。用while循环求1+2+……+100的和：main(){intsn=0,i=0;while(++i<=100)sn+=i;/*求1+2+……+100*/printf(%d\n,sn);}(三)、do--while循环\n它的一般格式为:do{语句块;}while(条件);这个循环与while循环的不同在于:它先执行循环中的语句,然后再判断条件是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while循环至少要执行一次循环语句。同样当有许多语句参加循环时，要用{和}把它们括起来。用do--while循环求1+2+……+100的和：main(){intsn=0,i=1;dosn+=i;\n/*求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(){intsn=0,i;for(i=1;i<=100;i++){if(i==51)break;/*如果i等于51，则跳出循环*/sn+=i;\n/*1+2+……+50*/}printf(%d\n,sn);}可以看出，最终的结果是1+2+……+50。因为在i等于51的时候，就跳出循环了。自己写写怎样在while和do--while循环中增加break语句。注意:1.break语句对if-else的条件语句不起作用。2.在多层循环中，一个break语句只向外跳一层。例如：main(){inti,j;printf(ij\n);for(i=0;i<2;i++)for(j=0;j<3;j++){if(j==2)break;printf(%d%d\n,i,j);}}输出结果为:ij0001101\n1当i==0,j==2时，执行break语句，跳出到外层的循环，i变为1。(二)、continue语句continue语句的作用是跳过循环本中剩余的语句而强行执行下一次循环。continue语句只用在for、while、do-while等循环体中,常与if条件语句一起使用，用来加速循环。例如：main(){intsn=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\ni,j;printf(ij\n);for(i=0;i<2;i++)for(j=0;j<3;j++){if(j==1)continue;printf(%d%d\n,i,j);}}输出结果为:ij00021012(三)、goto语句goto语句是一种无条件转移语句，与BASIC中的goto语句相似。goto语句的使用格式为:goto标号;其中标号是TurboC\n2.0中一个有效的标识符，这个标识符加上一个:一起出现在函数内某处，执行goto语句后，程序将跳转到该标号处并执行其后的语句。标号既然是一个标识符，也就要满足标识符的命名规则。另外标号必须与goto语句同处于一个函数中，但可以不在一个循环层中。通常goto语句与if条件语句连用，当满足某一条件时，程序跳到标号处运行。goto语句通常不用，主要因为它将使程序层次不清，且不易读，但在多层嵌套退出时，用goto语句则比较合理。main(){intsn=0,i;for(i=1;i<=100;i++){if(i==51)gotoloop;/*如果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\nsn=0,i;for(i=1;i<=100;i++){if(i==51)gotoloop;/*如果i等于51，则跳出本次循环*/sn+=i;/*1+2+……+50+52+……+100*/loop:;}printf(%d\n,sn);}可以看出这儿的loop语句和continue的作用类似。但是某些情况下又必须使用goto语句，否则会让程序大大臃肿。如：main(){inti,j,k;printf(ijk\n);for(i=0;i<2;i++)for(j=0;j<3;j++)for(k=0;k<3;k++){if(k==2)gotoloop;printf(%d%d\n%d\n,i,j,k);}loop:;}输出结果为:ijk000001如果不使用goto语句，而使用break,continue语句，应该这样main(){inti,j,k;printf(ij\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)\nbreak;}if(k==2)break;}}输出结果为:ijk000001所以在同时跳出多层循环时，应该使用goto语句。记住，所有的goto语句其实都是可以用break,continue代替的。下面举几个例子：1.求两个整数的最大公约数。例如10和15的最大公约数是5。分析：最大公约数一定小于等于最小的那个数一半，同时能被两数整除。main(){intnum1,num2,i,min;scanf(%d%d,&num1,&num2);min=num1for(i=min/2;i>0;i--)if(num1%i==0&&num2%i==0)\nbreak;printf(最大公约数为%d\n,i);}2.求1!+2!+……+n!(n<10)main(){intn,i;longtemp=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\nmath.hmain(){intnum,i,flag=0;scanf(%d,&num);for(i=2;i{flag=0;/*标志变量复位*/if(num%i==0){flag=1;break;}}if(flag==0)printf(是素数\n);elseprintf(不是素数\n);}可以说，在所有的C语言书上，都有判断素数的例题。它的编程思想是：把一个变量作为标志变量，用来标志是不是素数；循环体是从2到sqrt(num)，因为如果一个数不是素数的话，一定能分解成num=num1*num2，它们中的最小值一定小于sqrt(num)，所以循环的时候只要到sqrt(num)就可以了。同时要注意变量复位的问题。\n编程高手之路—C语言(八)数组数组，顾名思义就是一组同类型的数。一、数组的声明声明数组的语法为在数组名后加上用方括号括起来的维数说明。本接仅介绍一维数组。下面是一个整型数组的例子：intarray[10];这条语句定义了一个具有10个整型元素的名为array的数组。这些整数在内存中是连续存储的。数组的大小等于每个元素的大小乘上数组元素的个数。方括号中的维数表达式可以包含运算符，但其计算结果必须是一个长整型值。这个数组是一维的。下面这些声明是合法的：intoffset[5+3];floatcount[5*2+3];下面是不合法的：intn=10;intoffset[n];\n/*在声明时，变量不能作为数组的维数*/二、用下标访问数组元素intoffset[10];表明该数组是一维数组，里面有10个数，它们分别为offset[0],offset[1],……offset[9]；千万注意，数组的第一个元素下标从0开始。一些刚学编程的人员经常在这儿犯一些错误。offset[3]=25;上面的例子是把25赋值给整型数组offset的第四个元素。在赋值的时候，可以使用变量作为数组下标。main(){inti,offset[10];for(i=0;i<10;i++)scanf(%d,&offset[i]);for(i=9;i>=0;i--)printf(%d\n,offset[i]);printf(\n);}题目的意思是先输入10个整数，存入到数组中，然后反序输出。三、数组的初始化前面说了，变量可以在定义的时候初始化，数组也可以。intarray[5]={1,2,3,4,5};在定义数组时，可以用放在一对大括号中的初始化表对其进行初始化。初始化值的个数可以和数组元素个数一样多。如果初始化的个数多于元素个数，将产生编译错误；如果少于元素个数，其余的元素被初始化为0。如果维数表达式为空时，那么将用初始化值的个数来隐式地指定数组元素的个数，如下所式：intarray[]={1,2,3,4,5};这也表明数组array元素个数为5。main(){inti,array[]={1,3,5,7,9,11};for(i=0;i<5;i++)printf(%d,array[i]);printf(\n);}最终结果为13579四、字符数组整数和浮点数数组很好理解，在一维数组中，还有一类字符型数组。char\narray[5]={'H','E','L','L','O'};对于单个字符，必须要用单引号括起来。又由于字符和整型是等价的，所以上面的字符型数组也可以这样表示：chararray[5]={72,69,76,76,79};/*用对应的ASCII码*/举一个例子：main(){inti;chararray[5]={'H','E','L','L','O'};for(i=0;i<5;i++)printf(%d,array[i]);printf(\n);}最终的输出结果为7269767679但是字符型数组和整型数组也有不同的地方，看下面的：chararray[]=HELLO;如果我们能看到内部的话，实际上编译器是这样处理的：chararray[]={'H','E','L','L','O','\0'};看上面最后一个字符'\0'，它是一个字符常量，TurboC编译器总是给字符型数组的最后自动加上一个\0，这是字符的结束标志。所以虽然HELLO只有5个字符，但存入到数组的个数却是6个。但是，数组的长度仍然是5。inti;i=strlen(array);\n/*求字符串的长度，在string.h里面*/可以看出i仍然是5，表明最后的'\0'没有算。#includestring.hmain(){inti,j;chararray[]=094387fdhgkdladhladaskdh;j=strlen(array);for(i=0;iprintf(\n);}其实我们可以根据判断'\0'来输出字符串，看下面的：main(){inti;chararray[]=094387fdhgkdladhladaskdh;for(i=0;array[i]!='\0';i++)\nprintf(%c,array[i]);printf(\n);}举几个例子：1.输入10个整数存入数组中，然后把它们从小到大排列并放在同一数组中。(思路：先找出最小的，放在第一个位置，为了防止把原先的数覆盖掉，可以把原先的第一个数和最小数的位置互换)。main(){intarray[10];inti,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\n,array[i]);printf(\n);}分析：先让第一个值作为基准，如果后面有比它小的，那么就把这两个数互换一下，同时把基准换成小的值。两个数互换应该这样(stmp=a;a=b;b=stmp;)，而不是(a=b;b=a;)，想想这是为什么？必须要用一个变量作为桥梁。这种一个一个的把最小的放在前面的排序方法，我们形象的叫做冒泡法。2.输入一行字符存入数组，然后把他们反序存入到同一数组中。#includestdio.hmain(){charc,stmp,array[80];inti=0,j;while((c=getchar())!='\n')/*注意这儿的用法*/array[i++]=c;array[i]='\0';\n/*为什么要加'\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(){intarray[10]={1,2,3,5,8,15,20,30,100,200};intfirst=0,end=9,middle=(first+end)/2,num,i;scanf(%d,&num);while(array[middle]!=num)/*注意这里面的三行代码*/{if(array[middle]>num)end=middle;else\nfirst=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);}程序没有考虑当输入的数在原先数组中没有时怎么处理。如果要考虑这个问题，程序该怎么改动呢？编程高手之路—C语言(九)多维数组\n一、高维数组有时，数组的维数并不止一维，例如一个记录消费中心在第一季度里各个月的收入数据就可以用二维数组来表示。定义二维数组的方法是在一维数组定义的后面再加上一个用方括号括起来的维数说明。例如：floatarray[3][8];实际上，这个数组可以看成3个连续的一维数组，每个一维数组具有8个元素。该数组在内存中的存储格式为最左边的维数相同的元素连续存储，也即按行存储的。首先存储第一行8个元素，其次是第二行，最后是第三行。main(){intarray[3][3]={1,2,3,4,5,6,7,8,9};inti,j;for(i=0;i<3;i++){for(j=0;j<3;j++)printf(%3d);printf(\n);}}它的输出结果为：12345678\n9可以看出，二维数组元素是按行存储的。我们也可以对数组进行赋值，而不是初始化。main(){intarray[3][3];inti,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);}}当输入123456789<回车>输出为：14725836\n9数组可以是二维、三维甚至是更高维数的，虽然C语言对维数的处理没有上限，但是处理高维数组是很头疼的事。一般尽量避免处理四维和四维以上的数组。下面看一个三维数组的例子：main(){intarray[2][3][4];inti,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(){chars[10][10];inti;for(i=0;i<10;i++)\nscanf(%s,s[i]);}先看它的输入特性，前面在说输入语句的时候说过，遇到字符串输入，可以不加'&'，现在只要记住这个特性就可以，以后说指针的时候再讲为什么。但是这儿为什么用s[i]，可能很多人不太明白。我们定义的是二维数组，而输入的时候，却使用一维数组的形式。这是因为字符串在内存里地址可以用它的名字表示，就好象这种形式：main(){chars[10];scanf(%s,s);}定义的是一维数组，输入语句用变量形式表示一样。通过前面的'%s'形式可以看出，s[i]是一个数组，所以s就是二维数组了。这里要注意一点，scanf()函数在输入字符串时候不能支持空格，看下面的例子：main(){chars[3][10];int\ni;for(i=0;i<10;i++)scanf(%s,s[i]);for(i=0;i<3;i++)printf(%s\n,s[i]);}我们输入：1111222233334444我们是想把1111赋值给s[0],22223333赋值给s[1],4444赋值给s[2]。可实际上编译器是这样做的，把1111赋值给s[0]，把2222赋值给[1]，把3333赋值给s[2]。实际输出：111122223333在输入字符串的时候，如果使用scanf()，就把空格当作下一个输入了。那么我们怎么解决这个问题呢？毕竟很多情况下，一行字符串肯定有空格出现的。我们使用新的函数gets()。这个函数是专门接受字符串输入的，它跳过了空格的影响。把上面的输入语言修改为gets(s[i])即可。我们定义了char\ns[3][10]，超过10个字符肯定不行，如果少于10个字符，电脑怎么处理呢？电脑是在每个字符串的后面自动补上'\0'，作为字符串的结束标志。我们经常在填写一些可选择的内容时经常发现，待选的字符串都是按字母排列好的，我们怎么用C语言实现这个功能？在C语言里，字符串的排序是按照字符的ASCII码来的，如果第一个字符一样，则比较第二个，依次类推。main(){chars1[6]=addfgh,s2[5]=asdlg;inti;for(i=0;s1[i]!='\0'&&s2[i]!='\0';i++){if(s1[i]s2[i]){printf(s1>s2\n);exit(1);}else;}if(s1[i]=='\0'&&s2[i]!='\0')\nprintf(s1s2\n);elseprintf(s1==s2\n);}上面的例子就是比较两个字符串大小的，先比较第一个，如果相同，接着比较第二个，如果不相同，则分出大小。一直往后比较，直到其中某一个到'\0'，你也可以先用strlen()函数找出最小的长度。exit()函数的作用是退出程序，具体它的用法可以看看相关资料。其实C语言把我们经常需要的字符串处理函数都做好了，我们只需要调用它即可。如strcmp()用来比较、strcpy()用来拷贝等等。看看它们的用法：#includestring.hmain(){chars1[10],s2[10],s2[10];intk;gets(s1);gets(s2);k=strcmp(s1,s2);\n/*比较s1和s2大小*/if(k==0)printf(s1==s2\n);elseif(k>0)printf(s1>s2\n);elseprintf(s1s2;如果k=0，则s1=s2。实际上这是一个函数，具体什么是函数，以及为什么写成那种形式，我们下节再说。这些函数都包含在string.h头文件中，所以在程序的开头，都要写上#includestring.h。字符串处理有很多函数，你们可以看看相关的书，也可以看看TurboC的帮助。编程高手之路—C语言(十)函数的定义和调用\n本节介绍C程序的基本单元--函数。函数中包含了程序的可执行代码。每个C程序的入口和出口都位于函数main()之中。main()函数可以调用其他函数，这些函数执行完毕后程序的控制又返回到main()函数中，main()函数不能被别的函数所调用。通常我们把这些被调用的函数称为下层(lower-level)函数。函数调用发生时，立即执行被调用的函数，而调用者则进入等待状态，直到被调用函数执行完毕。函数可以有参数和返回值。程序员一般把函数当作“黑箱”处理，并不关心它内部的实现细节。当然程序员也可以自己开发函数库。说明一点，函数这一节很重要，可以说一个程序的优劣集中体现在函数上。如果函数使用的恰当，可以让程序看起来有条理，容易看懂。如果函数使用的乱七八糟，或者是没有使用函数，程序就会显得很乱，不仅让别人无法查看，就连自己也容易晕头转向。可以这样说，如果超过100行的程序中没有使用函数，那么这个程序一定很罗嗦(有些绝对，但也是事实)。一、函数的定义一个函数包括函数头和语句体两部分。函数头由下列三不分组成：函数返回值类型函数名参数表一个完整的函数应该是这样的：函数返回值类型\n函数名(参数表){语句体；}函数返回值类型可以是前面说到的某个数据类型、或者是某个数据类型的指针、指向结构的指针、指向数组的指针。指针概念到以后再介绍。函数名在程序中必须是唯一的，它也遵循标识符命名规则。参数表可以没有也可以有多个，在函数调用的时候，实际参数将被拷贝到这些变量中。语句体包括局部变量的声明和可执行代码。我们在前面其实已经接触过函数了，如abs(),sqrt()，我们并不知道它的内部是什么，我们只要会使用它即可。这一节主要讲解无参数无返回值的函数调用。二、函数的声明和调用为了调用一个函数，必须事先声明该函数的返回值类型和参数类型，这和使用变量的道理是一样的(有一种可以例外，就是函数的定义在调用之前，下面再讲述)。看一个简单的例子：voida();/*函数声明*/main(){a();/*函数调用*/}voida()/*函数定义*/{intnum;scanf(%d,&num);printf(%d\n,num);}在main()的前面声明了一个函数，函数类型是void型，函数名为a，无参数。然后在main()函数里面调用这个函数，该函数的作用很简单，就是输入一个整数然后再显示它。在调用函数之前声明了该函数其实它和下面这个程序的功能是一样的：main(){int\nnum;scanf(%d,&num);printf(%d\n,num);}可以看出，实际上就是把a()函数里面的所有内容直接搬到main()函数里面(注意，这句话不是绝对的。)我们前面已经说了，当定义在调用之前时，可以不声明函数。所以上面的程序和下面这个也是等价的：voida(){int\nnum;scanf(%d,&num);printf(%d\n,num);}main(){a();}因为定义在调用之前，所以可以不声明函数，这是因为编译器在编译的时候，已经发现a是一个函数名，是无返回值类型无参数的函数了。那么很多人也许就会想，那我们何必还要声明这一步呢？我们只要把所有的函数的定义都放在前面不就可以了吗？这种想法是不可取的，一个好的程序员总是在程序的开头声明所有用到的函数和变量，这是为了以后好检查。前面说了，在调用之前，必须先声明函数，所以下面的做法也是正确的(但在这里我个人并不提倡)。main(){voida();a();}voida(){int\nnum;scanf(%d,&num);printf(%d\n,num);}一般来说，比较好的程序书写顺序是，先声明函数，然后写主函数，然后再写那些自定义的函数。既然main()函数可以调用别的函数，那么我们自己定义的函数能不能再调用其他函数呢？答案是可以的。看下面的例子：voida();voidb();main(){a();}voida(){b();}voidb(){int\nnum;scanf(%d,&num);printf(%d\n,num);}main()函数先调用a()函数，而a()函数又调用b()函数。在C语言里，对调用函数的层数没有严格的限制，我们可以往下调用100层、1000层，但是在这里我们并不提倡调用的层数太多(除非是递归)，因为层数太多，对以后的检查有一些干扰，函数调过来调过去，容易让自己都晕头转向。某些人可能就不明白了，看上面的例子，好象使用函数后，程序变的更长了，更不让人理解。当然，我举的这个例子的确没有必要用函数来实现，但是对于某些实际问题，如果不使用函数，会让程序变的很乱，这涉及到参数问题，我们下一节再说。编程高手之路—C语言(十一)函数参数的传递和值返回\n前面我们说的都是无参数无返回值的函数，实际程序中，我们经常使用到带参数有返回值的函数。一、函数参数传递1.形式参数和实际参数函数的调用值把一些表达式作为参数传递给函数。函数定义中的参数是形式参数，函数的调用者提供给函数的参数叫实际参数。在函数调用之前，实际参数的值将被拷贝到这些形式参数中。2.参数传递先看一个例子：voida(int);/*注意函数声明的形式*/main(){intnum;scanf(%d,&num);a(num);/*注意调用形式*/}voida(intnum_back)\n/*注意定义形式*/{printf(%d\n,num_back);}在主函数中，先定义一个变量，然后输入一个值，在a()这个函数中输出。当程序运行a(num);这一步时，把num的值赋值给num_back，在运行程序过程中，把实际参数的值传给形式参数，这就是函数参数的传递。形参和实参可能不只一个，如果多于一个时，函数声明、调用、定义的形式都要一一对应，不仅个数要对应，参数的数据类型也要对应。voida(int,float);main(){intnum1;floatnum2;scanf(%d,&num1);scanf(%f,&num2);a(num1,num2);}voida(intnum1_back,float\nnum2_back){printf(%d,%f\n,num1_back,num2_back);}上面的例子中，函数有两个参数，一个是整型，一个是浮点型，那么在声明、调用、定义的时候，不仅个数要一样，类型也要对应。如果不对应，有可能使的编译错误，即使没错误，也有可能让数据传递过程中出现错误。再看一个例子：voida(int);main(){intnum;scanf(%d,&num);a(num);}voida(int\nnum){printf(%d\n,num);}看上面的例子，形式参数和实际参数的标识符都是num，程序把实际参数num的值传递给形式参数num。有些人可能就不明白了，既然两个都是num，为什么还要传递呢？干脆这样不就行了吗：voida();main(){intnum;scanf(%d,&num);a();}void\na(){printf(%d\n,num);}其实不然，这就要涉及到标识符作用域的问题。作用域的意思就是说，哪些变量在哪些范围内有效。一个标识符在一个语句块中声明，那么这个标识符仅在当前和更低的语句块中可见，在函数外部的其实地方不可见，其他地方同名的标识符不受影响，后面我们会系统讲解作用域的问题。在这儿你就要知道两个同名的变量在不同的函数中是互不干扰的。前面将的都是变量与变量之间的值传递，其实函数也可以传递数组之间的值。看下面的例子：voida(int[]);main(){intarray[5],i;for(i=0;i<5;i++)scanf(%d,&array[i]);a(array);}voida(intarray[]){inti;for(i=0;i<5;i++)printf(%d\t,array[i]);printf(\n);}这就是数组之间的值传递。注意他们的声明和定义形式，和变量参数传递有什么区别？有了后面的[]就表明传递的是一个数组。其中在定义的时候，也可以写成voida(intarray[5]);想想，如果我们写成了int\narray[4]会有什么情况发生？目前我们只学了数组和变量，以后还会知道指针、结构，到那是，函数也可以传递它们之间的值。二、函数值的返回其实我们也可以把函数当作一个变量来看，既然是变量，那一定也可以有类型。还举最前面的例子，现在要求在main()函数里输入一个整数作为正方形的边长，在子函数里求正方形的面积，然后再在主函数里输出这个面积。我们前面的程序都是在子函数里输出的，现在要求在主函数里输出，这就需要把算好的值返回回来。先看例子：inta(int);/*声明函数*/main(){intnum,area;scanf(%d,&num);area=a(num);/*调用时的形式*/printf(%d,area);}inta(int\nnum){intarea_back;area_back=num*num;returnarea_back;/*返回一个值*/}和前面的程序有几点不同：(1).声明函数类型时，不是void，而是int。这是由于最后要求的面积是整型的，所以声明函数的返回值类型是整型。(2).return语句它的意思就是返回一个值。在C语言中，return一定是在函数的最后一行。(3).调用函数的时候,由于函数有一个返回值，所以必须要用变量接受这个返回值(不是绝对的)，如果我们不用一个变量接受这个值，函数还照样返回，但是返回的这个值没有使用。上面的例子运行过程是这样的，先把实参的值传递给形参，然后在子函数里计算面积得到area_back，然后返回这个面积到主函数，也就是把area_back赋值给area，最后输出。前面说了，返回值有时不一定非要用一个变量来接受，我们可以把上面的程序简化为：int\na(int);main(){intnum;scanf(%d,&num);printf(%d,a(num));/*函数调用放在这儿*/}inta(intnum){intarea_back;area_back=num*num;returnarea_back;}这样函数返回的值就可以直接放到输出缓冲区直接输出了。还可以再简化为：inta(int);main(){int\nnum;scanf(%d,&num);printf(%d,a(num));}inta(intnum){returnnum*num;/*直接在这儿返回*/}对于函数而言，一个函数只能返回一个值，如果想返回一组数值，就要使用数组或者结构或者指针。其实对于这些，还是返回一个值，只是这个值是一个地址而已。但是对于数组的返回有和变量不同，因为数组和地址是联系在一起的。看一个例子：voida(int[]);main(){intarray[5]={1,2,3,4,5},i;a(array);for(i=0;i<5;i++)\nprintf(%d,array[i]);}voida(intarray[]){inti;for(i=0;i<5;i++)array[i]++;}看看这个程序，好象函数没有返回值，但是函数的功能的确实现了，在主函数当中输出的值的确都各加了1上来。这就是因为数组和变量不同的缘故，在后面讲指针的时候再详细说明。下面看一个实际例子，加深对函数的理解：用函数实现，判断一个整数是不是素数？在主函数里输入输出，子函数里判断。#includemath.hintjudge(int);main(){int\nnum,result;scanf(%d,&num);result=judge(num);if(result==1)printf(yes\n);elseprintf(no\n);}judge(intnum){inti,flag=1;for(i=2;i<=sqrt(num);i++)if(num%i==0){flag=0;break;}return\nflag;}可以看出，函数的功能就是为了让程序看起来有条理，一个函数实现一个特定的功能。如果我们还和以前那样，把所有代码都放在main()函数，好象程序就显的臃肿了。而且函数有一个显著的好处就是很方便的使用。这里面的judge()函数判断一个数是不是素数，如果我们以后还有判断某个数是不是素数，就可以直接使用这个函数了。我们这样，把下面的代码：judge(intnum){inti,flag=1;for(i=2;i<=sqrt(num);i++)if(num%i==0){flag=0;break;}returnflag;}保存为judge.h文件，放到include目录里面。以后就可以直接使用这个函数了，就好象直接使用abs(),sqrt()这些函数一样方便。#includemath.h/*必须要有它*/#include\njudge.hmain(){intnum,result;scanf(%d,&num);result=judge(num);if(result==1)printf(yes\n);elseprintf(no\n);}看上面的例子，我们在程序中直接使用了函数judge()，这就是我们自己编写的第一个所谓的库函数。但是程序的第一行要包含math.h文件，这是因为在judge.h里面使用了sqrt()函数，所以为了方便，我们可以把math.h放到judge.h里面，也就是在judge.h文件的第一行加上include\nmath.h,这样，我们的主程序中就不需要包含它了，但是这样做也有副作用，具体有什么副作用，我们以后接触到时再介绍。我们实际用到的一些程序，也许代码有很长，上千行，甚至上万行，这些代码不可能放在一个*.c文件中，所以我们经常把一些功能做成*.h,*c的文件形式，然后在主程序中包含这些文件，这样就把一个大程序分割成几个小块，不仅浏览方便，对以后的修改也有很多好处。我们在平时就应该有这样的好习惯，把一些经常使用的功能做成库函数的形式保存下来，也许刚开始你会觉得很烦琐，可到了后来，也许几年过去了，你会发现，一个好几千行上万行的程序，有一大半的功能你都有，直接调用就可，这会大大缩短你的程序开发周期的。就好象这里的判断素数一样，如果以后还需要判断一个数是不是素数，就没必要再写那些代码了，直接调用judge()函数就可。编程高手之路—C语言(十二)变量的作用域和存储类型\n一、作用域和生存期C程序的标识符作用域有三种：局部、全局、文件。标识符的作用域决定了程序中的哪些语句可以使用它，换句话说，就是标识符在程序其他部分的可见性。通常，标识符的作用域都是通过它在程序中的位置隐式说明的。1.局部作用域前面各个例子中的变量都是局部作用域，他们都是声明在函数内部，无法被其他函数的代码所访问。函数的形式参数的作用域也是局部的，它们的作用范围仅限于函数内部所用的语句块。voidadd(int);main(){intnum=5;add(num);printf(%d\n,num);/*输出5*/}voidadd(intnum){num++;printf(%d\n,num);\n/*输出6*/}上面例子里的两个num变量都是局部变量，只在本身函数里可见。前面我们说了，在两个函数出现同名的变量不会互相干扰，就是这个道理。所以上面的两个输出，在主函数里仍然是5，在add()函数里输出是6。2.全局作用域对于具有全局作用域的变量，我们可以在程序的任何位置访问它们。当一个变量是在所有函数的外部声明，也就是在程序的开头声明，那么这个变量就是全局变量。voidadd(int);intnum;main(){intn=5;add(n);printf(%d\n,num);/*输出6*/}voidadd(num)/*形式参数没有指定类型*/{num++;printf(%d\n,num);\n/*输出6*/}上面的main()和add()里面，并没有声明num，但是在最后输出的时候却要求输出num，这是由于在程序的开始声明了num是全局变量，也就是在所有函数里都可以使用这个变量。这时候一个函数里改变了变量的值，其他函数里的值也会出现影响。上面的例子输出都是6，因为在add()函数里改变了num的值，由于num是全局变量，就好象它们两个函数共用一个变量，所以在main()函数里的num也随之改变了。3.文件作用域在很多C语言书上，都没有说明文件作用域，或者只是略微的提到，其实文件作用域在较大程序中很有作用(在多文件系统中)。文件作用域是指外部标识符仅在声明它的同一个转换单元内的函数汇总可见。所谓转换单元是指定义这些变量和函数的源代码文件(包括任何通过#include指令包含的源代码文件)。static存储类型修饰符指定了变量具有文件作用域。staticintnum;staticvoid\nadd(int);main(){scanf(%d,&num);add(num)printf(%d\n,num);}voidadd(num){num++;}上面的程序中变量num和函数add()在声明是采用了static存储类型修饰符，这使得它们具有文件作用域，仅爱定义它们的文件内可见。由于我们提到的大多数程序都只有一个编译文件组成，所以这种写法没有实际意义。但是实际工程上的文件有很多，它们不是由一个人写成的，由很多人共同完成，这些文件都是各自编译的，这难免使得某些人使用了一样的全局变量名，那么为了以后程序中各自的变量和函数不互相干扰，就可以使用static修饰符，这样在连接到同一个程序的其他代码文件而言就是不可见的。二、变量存储类型前面我们说了，声明变量时用如下类似的形式：intnum;float\ntotal;它们都没有存储类型修饰符，我们在声明时也可以通过存储类型修饰符来告诉编译器将要处理什么类型的变量。存储类型有以下四种：自动(auto)、静态(static)、外部(extern)、寄存器(regiser)。1.自动存储类型自动存储类型修饰符指定了一个局部变量为自动的，这意味着，每次执行到定义该变量的语句块时，都将会为该变量在内存中产生一个新的拷贝，并对其进行初始化。实际上，如果不特别指明，局部变量的存储类型就默认为自动的，因此，加不加auto都可以。main(){autoint\nnum=5;printf(%d\n,num);}在这个例子中，不论变量num的声明是否包含关键字auto，代码的执行效果都是一样的。函数的形式参数存储类型默认也是自动的。2.静态存储变量前面已经使用了static关键字，但是对于局部变量，静态存储类型的意义是不一样的，这时，它是和自动存储类型相对而言的。静态局部变量的作用域仍然近局限于声明它的语句块中，但是在语句块执行期间，变量将始终保持它的值。而且，初始化值只在语句块第一次执行是起作用。在随后的运行过程中，变量将保持语句块上一次执行时的值。看下面两个对应的程序：/*1.C*//*2.C*/intadd();intadd();main()main(){{intresult;intresult;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);}}intadd()int\nadd(){{intnum=50;staticintnum=50;num++;num++;returnnum;returnnum;}}上面两个源文件，只有函数add()里的变量声明有所不同，一个是自动存储类型，一个是静态存储类型。对于1.C文件，输出结果为515151；这很好理解，每次初始值都是50，然后加1上来。对于2.C文件，输出结果为5152\n53；这是由于变量是静态的，只在第一次初始化了50，以后都是使用上次的结果值。当第一次调用add()时，初始化为50，然后加1，输出为51；当第二次调用时，就不初始化了，这时num的值为上次的51，然后加1，输出52；当第三次调用时，num为52，加1就是53了。比较就会发现它们的不同之处了。静态变量在下一节要说的递归函数中经常使用到。当第一次不指明静态变量的初始值时，默认为0。下面举一个例子，把我们说到的静态变量理解一下。求1+2+……+100的值voidadd();intresult;main(){inti;result=0;for(i=0;i<100;i++)add();printf(%d\n,result);}voidadd(){staticintnum=0;num++;result+=num;}add()函数被调用了100次，num的值从1一直变到100，这样就可以求出它们的和了。如果写成int\nnum=0;那就是求1+1+……+1这100个1的值了。实际上类似的这类问题我们可以通过递归函数来解决，什么是递归，我们下一节介绍。3.外部存储类型外部存储类型声明了程序将要用到的、但尚未定义的外部变量。通常，外部存储类型都是用于声明在另一个转换单元中定义的变量。下面举一个例子，这个例子包括两个文件。/*1.C*/voida();main(){externintnum;a();printf(%d\n,num);}/*2.C*/intnum;void\na(){num=5;}这两个程序是分别编译的，然后连接成一个执行文件。具体如何操作，可以查看一些手册，这儿我简单说了一下。把上面两个文件都编译好后，再制作一个.prj文件，里面的内容是：1.c2.c只有这两行，这可在编辑状态下写成，存盘，取名为1.prj。然后选择project选项，选择projectname，填入1.prj文件名，按F9后，即可生成1.exe文件。main()函数中变量num是在另一个文件中定\n义的。因此，当编译器编译1.c时，无法确定该变量的地址。这时，外部存储类型声明告诉编译器，把所有对num的引用当作暂且无法确定的引用，等到所有便宜好的目标代码连接成一个可执行程序模块时，再来处理对变量num的引用。外部变量的声明既可以在引用它的函数的内部，也可以在外部。如果变量声明在函数外部，那么同一转换单元内的所有函数都可以使用这个外部变量。反之，如果在函数内部，那么只有这一个函数可以使用该变量。前面说了文件作用域的问题，如果在声明全局变量时，加上static修饰符，那么该变量只在当前文件内可见，而extern又可以引用其它文件里的变量。所以在一个大型程序中，每个程序员只是完成其中的一小块，为了让自己的变量不让其他程序员使用，保持一定的独立性，经常在全局变量前加static。我们可以这样来说明一下：还是上面的两个文件，现在再增加一个文件3.c，内容为：staticintnum;voida(){num=6;}把1.prj文件后面加上3.c\n这样，我们生成的1.exe文件，执行时输出是5，而不是6。因为3.c文件的num变量增加了文件作用域，在其他文件中是无法使用它的。4.寄存器存储类型被声明为寄存器存储类型的变量，除了程序无法得到其地址外，其余都和自动变量一样。至于什么是变量地址，以后说指针时会详细介绍。main(){registerint\nnum;num=100;printf(%d,num);}使用寄存器存储类型的目的是让程序员指定某个局部变量存放在计算机的某个硬件寄存器里而不是内存中，以提高程序的运行速度。不过，这只是反映了程序员的主观意愿，编译器可以忽略寄存器存储类型修饰符。寄存器变量的地址是无法取得的，因为绝大多数计算机的硬件寄存器都不占用内存地址。而且，即使编译器忽略寄存器类型修饰符把变量放在可设定地址的内存中，我们也无法取地址的限制仍然存在。要想有效的利用寄存器存储类型，必须象汇编语言程序员那样了解处理器的内部构造，知道可用于存放变量的寄存器的数量和种类，以及他们是如何工作的。但是，不同计算机在这些细节上未必是一样的，因此对于一个可移植的程序来说，寄存器存储类型的作用不大。特别是现在很多编译器都能提供很好的优化效果，远比程序员来选择有效的多。不过，寄存器存储类型还是可以为优化器提供重要的参考。编程高手之路—C语言(十三)函数递归\n一、栈在说函数递归的时候，顺便说一下栈的概念。栈是一个后进先出的压入(push)和弹出(pop)式数据结构。在程序运行时，系统每次向栈中压入一个对象，然后栈指针向下移动一个位置。当系统从栈中弹出一个对象时，最近进栈的对象将被弹出。然后栈指针向上移动一个位置。程序员经常利用栈这种数据结构来处理那些最适合用后进先出逻辑来描述的编程问题。这里讨论的程序中的栈在每个程序中都是存在的，它不需要程序员编写代码去维护，而是由运行是系统自动处理。所谓的系统自动维护，实际上就是编译器所产生的程序代码。尽管在源代码中看不到它们，但程序员应该对此有所了解。再来看看程序中的栈是如何工作的。当一个函数(调用者)调用另一个函数(被调用者)时，运行时系统将把调用者的所有实参和返回地址压入到栈中，栈指针将移到合适的位置来容纳这些数据。最后进栈的是调用者的返回地址。当被调用者开始执行时，系统把被调用者的自变量压入到栈中，并把栈指针再向下移，以保证有足够的空间存储被调用者声明的所有自变量。当调用者把实参压入栈后，被调用者就在栈中以自变量的形式建立了形参。被调用者内部的其他自变量也是存放在栈中的。由于这些进栈操作，栈指针已经移动所有这些局部变量之下。但是被调用者记录了它刚开始执行时的初始栈指针，以他为参考，用正或负的偏移值来访问栈中的变量。当被调用者准备返回时，系统弹出栈中所有的自变量，这时栈指针移动了被调用者刚开始执行时的位置。接着被调用者返回，系统从栈中弹出返回地址，调用者就可以继续执行了。当调用者继续执行时，系统还将从栈中弹出调用者的实参，于是栈指针回到了调用发生前的位置。可能刚开始学的人看不太懂上面的讲解，栈涉及到指针问题，具体可以看看一些数据结构的书。要想学好编程语言，数据结构是一定要学的。二、递归递归，是函数实现的一个很重要的环节，很多程序中都或多或少的使用了递归函数。递归的意思就是函数自己调用自己本身，或者在自己函数调用的下级函数中调用自己。递归之所以能实现，是因为函数的每个执行过程都在栈中有自己的形参和局部变量的拷贝，这些拷贝和函数的其他执行过程毫不相干。这种机制是当代大多数程序设计语言实现子程序结构的基础，是使得递归成为可能。假定某个调用函数调用了一个被调用函数，再假定被调用函数又反过来调用了调用函数。这第二个调用就被称为调用函数的递归，因为它发生在调用函数的当前执行过程运行完毕之前。而且，因为这个原先的调用函数、现在的被调用函数在栈中较低的位置有它独立的一组参数和自变量，原先的参数和变量将不受影响，所以递归能正常工作。程序遍历执行这些函数的过程就被称为递归下降。程序员需保证递归函数不会随意改变静态变量和全局变量的值，以避免在递归下降过程中的上层函数出错。程序员还必须确保有一个终止条件来结束递归下降过程，并且返回到顶层。例如这样的程序就是递归：void\na(int);main(){intnum=5;a(num);}voida(intnum){if(num==0)\nreturn;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的时候就不能往下加了。那么我们试着写一下程序。intadd(int);main(){intnum=1,sn;sn=add(num);printf(%d\n,sn);getch();}intadd(intnum){staticint\nsn;sn+=num;if(num==100)returnsn;add(++num);}分析一下程序：前调用add(1)，然后在子函数中把这个1加到sn上面。接着调用add(2)，再把sn加2上来。这样一直到100，到了100的时候，先加上来，然后发现满足了if条件，这时返回sn的值，也就是1+2+……+100的值了。这里有一个问题一定要注意，就是staticintsn;有些人就不明白，为什么要使用static类型修饰符，为什么不使用intsn=0;？如果使用intsn=0;这样的语句，在每次调用函数add()的时候，sn的值都是赋值为0,也就是第一步虽然加了1上来，可是第二次调用的时候，sn又回到了0。我们前面说了，static能保证本次初始化的值是上次执行后的值，这样也就保证了前面想加的结果不会丢失。如果你修改为int\nsn=0，最后结果一定是最后的100这个值而不是5050。2.求数列s(n)=s(n-1)+s(n-2)的第n项。其中s(1)=s(2)=1。可以看出，终止条件一定是s(1)=s(2)=1。递归下降的参数一定是n。inta(int);main(){intn,s;scanf(%d,&n);s=a(n);printf(%d\n,s);getch();}inta(intn){if(n<3)return1;return\na(n-1)+a(n-2);}这个题目主要说明的是，在函数中，不一定只有一个return语句，可以有很多，但是每次对归的时候只有一个起作用。题目不难理解，这儿不分析了。说了这些递归，其实它和函数的调用没有大的区别，主要就是一个终止条件要选好。递归函数很多时候都能用循环来处理。main(){intn=20,array[20];inti;for(i=0;i,>=,<=,==等关系运算符都能正常进行。若p==q为真,则表示p,q指向数组的同一元素;若p(2).指针和整数可进行加、减运算。设p是指向某一数组元素的指针,开始时指向数组的第0号元素,设n为一整数,则p+n就表示指向数组的第n号元素(下标为n的元素)。不论指针变量指向何种数据类型,指针和整数进行加、减运算时,编译程序总根据所指对象的数据长度对n放大,\n在一般微机上,char放大因子为1,int、short放大因子为2,long和float放大因子为4,double放大因子为8。对于下面讲述到的结构或联合,也仍然遵守这一原则。(3).两个指针变量在一定条件下,可进行减法运算。设p,q指向同一数组,则p-q的绝对值表示p所指对象与q所指对象之间的元素个数。其相减的结果遵守对象类型的字节长度进行缩小的规则。对于初学者而言，指针和地址以及指针和数组之间的关系都是非常让人头疼的概念。我说了上面那么多，可能很多人还是一头雾水。这就需要多看看一些书了。毕竟自己理解的东西永远比别人讲解的要深刻。下面举一个例子，来看看指针的应用：main(){charc='A';inti=123;floatf=3.45;char*cp;int\n*ip;float*fp;cp=&c;ip=&i;fp=&f;printf(%c\n,*cp);printf(%d\n,*ip);printf(%f\n,*fp);}如果你们还对指针有不理解，可以再接着输出cp,ip,fp的值看看，看它们到底是什么。编程高手之路—C语言(十六)数组和指针\n指针和数组有着密切的关系,任何能由数组下标完成的操作也都可用指针来实现,但程序中使用指针可使代码更紧凑、更灵活。一、指向数组元素的指针我们定义一个整型数组和一个指向整型的指针变量:inta[10],*p;和前面介绍过的方法相同,可以使整型指针p指向数组中任何一个元素,假定给出赋值运算p=&a[0];此时,p指向数组中的第0号元素,即a[0],指针变量p中包含了数组元素a[0]的地址,由于数组元素在内存中是连续存放的,因此,我们就可以通过指针变量p及其有关运算间接访问数组中的任何一个元素。TurboC中,数组名是数组的第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]。\n(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.二维数组元素的地址为了说明问题,我们定义以下二维数组:inta[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||______|\n|___|___|___|___|但从二维数组的角度来看,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列元素的地址,\n即&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个元素所组成的数组指针在TurboC中,可定义如下的指针变量:int(*p)[3];指针p为指向一个由3个元素所组成的整型数组指针。在定义中,圆括号是不能少的,否则它是指针数组,\n这将在后面介绍。这种数组的指针不同于前面介绍的整型指针,当整型指针指向一个整型数组的元素时,进行指针(地址)加1运算,表示指向数组的下一个元素,此时地址值增加了2(因为放大因子为2),而如上所定义的指向一个由3个元素组成的数组指针,进行地址加1运算时,其地址值增加了6(放大因子为2x3=6),这种数组指针在TurboC中用得较少,但在处理二维数组时,还是很方便的。例如:inta[3][4],(*p)[4];p=a;开始时p指向二维数组第0行,当进行p+1运算时,根据地址运算规则,此时放大因子为4x2=8,所以此时正好指向二维数组的第1行。和二维数组元素地址计算的规则一样,*p+1指向a[0][1],*(p+i)+j则指向数组元素a[i][j]。例：inta[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};main(){inti,(*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]);\nprintf(\n);for(i=0;i<3;i++){b=a+i;/*修改b的指向,每次跳过二维数组的一行*/printf(%d\t,*(b[i]+1));}printf(\n);}程序运行结果如下:913172131119三、字符指针我们已经知道,字符串常量是由双引号括起来的字符序列,例如:astring就是一个字符串常量,该字符串中因为字符a后面还有一个空格字符,所以它由8个字符序列组成。在程序中如出现字符串常量C编译程序就给字符串常量按排一存贮区域,这个区域是静态的,在整个程序运行的过程中始终占用,平时所讲的字符串常量的长度是指该字符串的字符个数,但在按排存贮区域时,C\n编译程序还自动给该字符串序列的末尾加上一个空字符'\0',用来标志字符串的结束,因此一个字符串常量所占的存贮区域的字节数总比它的字符个数多一个字节。TurboC中操作一个字符串常量的方法有:(1).把字符串常量存放在一个字符数组之中,例如:chars[]=astring;数组s共有9个元素所组成,其中s[8]中的内容是'\0'。实际上,在字符数组定义的过程中,编译程序直接把字符串复写到数组中,即对数组s初始化。(2).用字符指针指向字符串,然后通过字符指针来访问字符串存贮区域。当字符串常量在表达式中出现时,根据数组的类型转换规则,它被转换成字符指针。因此,若我们定义了一字符指针cp:char*cp;于是可用:cp=astring;使cp指向字符串常量中的第0号字符a,如图所示。___________________________________CP-----|a||s|t|r|i|n|g|\0||___|___|___|___|___|___|___|___|___|以后我们可通过cp来访问这一存贮区域,\n如*cp或cp[0]就是字符a,而cp[i]或*(cp+i)就相当于字符串的第i号字符,但企图通过指针来修改字符串常量的行为是没有意义的。四、指针数组因为指针是变量,因此可设想用指向同一数据类型的指针来构成一个数组,这就是指针数组。数组中的每个元素都是指针变量,根据数组的定义,指针数组中每个元素都为指向同一数据类型的指针。指针数组的定义格式为:类型标识*数组名[整型常量表达式];例如:int*a[10];定义了一个指针数组,数组中的每个元素都是指向整型量的指针,该数组由10个元素组成,即a[0],a[1],a[2],...,\na[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(intn){staticchar*name[]={Illegalmonth,January,February,March,April,May,June,July,August,September,October,November,\nDecember};return((n<1||n>12)?name[0]:name[n]);}main(){inti;for(i=0;i<13;i++)printf(%s\n,month_name(i));}对于指针这一节，一定要多练习一些题。指针是一个很重要的概念，必须多接触实际的问题才能掌握它。编程高手之路—C语言(十七)指针函数和函数指针\n一、指针函数当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。格式：类型说明符*函数名(参数)当然了，由于返回的是一个地址，所以类型说明符一般都是int。例如：int*GetDate();int*aaa(int,int);函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。int*GetDate(intwk,intdy);main(){intwk,dy;do{printf(Enter\nweek(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(intwk,intdy){staticintcalendar[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];}程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。二、函数指针指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：类型说明符\n(*函数名)(参数)其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。例如：void(*fptr)();把函数的地址赋值给函数指针，可以采用下面两种形式：fptr=&Function;fptr=Function;取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。可以采用如下两种方式来通过指针调用函数：x=(*fptr)();x=fptr();第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：void(*funcp)();void\nFileFunc(),EditFunc();main(){funcp=FileFunc;(*funcp)();funcp=EditFunc;(*funcp)();}voidFileFunc(){printf(FileFunc\n);}void\nEditFunc(){printf(EditFunc\n);}程序输出为：FileFuncEditFunc三、指针的指针指针的指针看上去有些令人费解。它们的声明有两个星号。例如：char**cp;如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。指针的指针需要用到指针的地址。charc='A';char*p=&c;char**cp=&p;通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：char*p1=*cp;charc1=**cp;你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。voidFindCredit(int\n**);main(){intvals[]={7,6,5,-4,3,2,1,0};int*fp=vals;FindCredit(&fp);printf(%d\n,*fp);}voidFindCredit(int**fpp){while(**fpp!=0)if(**fpp<0)break;else\n(*fpp)++;}首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。四、指向指针数组的指针指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。char*Names[]={Bill,Sam,Jim,Paul,Charles,0};main(){char**nm=Names;while(*nm!=0)\nprintf(%s\n,*nm++);}先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。编程高手之路—C语言(十八)结构体结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。结构中可以使用不同的数据类型。一、结构说明和结构变量定义在TurboC中,结构也是一种数据类型,可以使用结构变量,因此,象其它类型的变量一样,\n在使用结构变量时要先对其定义。定义结构变量的一般格式为:struct结构名{类型变量名;类型变量名;...}结构变量;结构名是结构的标识符不是变量名。类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和无值型)。构成结构的每一个类型变量称为结构成员,它象数组的元素一样,但数组中元素是以下标来访问的,而结构是按变量名字来访问成员的。下面举一个例子来说明怎样定义结构变量。structstring{charname[8];intage;charsex[4];chardepart[20];floatwage1,wage2,wage3;\n}person;这个例子定义了一个结构名为string的结构变量person,如果省略变量名person,则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义时上例变成:structstring{charname[8];intage;charsex[4];chardepart[20];floatwage1,wage2,wage3;};structstringperson;如果需要定义多个具有相同形式的结构变量时用这种方法比较方便,它先作结构说明,再用结构名来定义变量。例如:structstringTianyr,Liuqi,...;如果省略结构名,则称之为无名结构,这种情况常常出现在函数内部,用这种结构时前面的例子变成:\nstruct{charname[8];intage;charsex[4];chardepart[20];floatwage1,wage2,wage3;}Tianyr,Liuqi;二、结构变量的使用结构是一个新的数据类型,因此结构变量也可以象其它类型的变量一样赋值、运算,不同的是结构变量以成员作为基本变量。结构成员的表示方式为:结构变量.成员名如果将结构变量.成员名看成一个整体,则这个整体的数据类型与结构中该成员的数据类型相同,这样就可象前面所讲的变量那样使用。下面这个例子定义了一个结构变量,其中每个成员都从键盘接收数据,然后对结构中的浮点数求和,并显示运算结果。请注意这个例子中不同结构成员的访问。\n#includemain(){struct{/*定义一个结构变量*/charname[8];intage;charsex[4];chardepart[20];floatwage1,wage2,wage3;}a;floatwage;charc='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:);\nscanf(%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(Thesumofwageis%6.2f\n,wage);printf(Continue?);c=getche();}}三、结构数组和结构指针结构是一种新的数据类型,同样可以有结构数组和结构指针。1.结构数组结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址,可以定义成一个结构数组。如下所示:struct{\ncharname[8];charsex[4];intage;charaddr[40];}student[40];也可定义为:structstring{charname[8];charsex[4];intage;charaddr[40];};structstringstudent[40];需要指出的是结构数组成员的访问是以数组元素为结构变量的,其形式为:结构数组元素.成员名例如:student[0].namestudent[30].age实际上结构数组相当于一个二维构造,第一维是结构数组元素,每个元素是一个结构变量,\n第二维是结构成员。注意:结构数组的成员也可以是数组变量。例如:structa{intm[3][5];floatf;chars[20];}y[4];为了访问结构a中结构变量y[2]的这个变量,可写成y[2].m[1][4]2.结构指针结构指针是指向结构的指针。它由一个加在结构变量名前的*操作符来定义,例如用前面已说明的结构定义一个结构指针如下:structstring{charname[8];charsex[4];intage;charaddr[40];}*student;\n也可省略结构指针名只作结构说明,然后再用下面的语句定义结构指针。structstring*student;使用结构指针对结构成员的访问,与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为:结构指针名->结构成员其中->是两个符号-和>的组合,好象一个箭头指向结构成员。例如要给上面定义的结构中name和age赋值,可以用下面语句:strcpy(student->name,LuG.C);student->age=18;实际上,student->name就是(*student).name的缩写形式。需要指出的是结构指针是指向结构的一个指针,即结构中第一个成员的首地址,因此在使用之前应该对结构指针初始化,即分配整个结构长度的字节空间,这可用下面函数完成,仍以上例来说明如下:student=(structstring*)malloc(sizeof(structstring));sizeof(structstring)自动求取string结构的字节长度,malloc()函数定义了一个大小为结构长度的内存区域,然后将其诈地址作为结构指针返回。\n注意:1.结构作为一种数据类型,因此定义的结构变量或结构指针变量同样有局部变量和全程变量,视定义的位置而定。2.结构变量名不是指向该结构的地址,这与数组名的含义不同,因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。3.结构的复杂形式：嵌套结构嵌套结构是指在一个结构成员中可以包括其它一个结构,TurboC允许这种嵌套。例如:下面是一个有嵌套的结构structstring{charname[8];intage;structaddraddress;}student;其中:addr为另一个结构的结构名,必须要先进行,说明,即structaddr{charcity[20];unsignedlonzipcode;chartel[14];\n}如果要给student结构中成员address结构中的zipcode赋值,则可写成:student.address.zipcode=200001;每个结构成员名从最外层直到最内层逐个被列出,即嵌套式结构成员的表达方式是:结构变量名.嵌套结构变量名.结构成员名其中:嵌套结构可以有很多,结构成员名为最内层结构中不是结构的成员名。编程高手之路—C语言(十九)联合和枚举联合(union)：一、联合说明和联合变量定义联合也是一种新的数据类型,它是一种特殊形式的变量。联合说明和联合变量定义与结构十分相似。其形式为:union联合名{数据类型成员名;\n数据类型成员名;...}联合变量名;联合表示几个变量公用一个内存位置,在不同的时间保存不同的数据类型和不同长度的变量。下例表示说明一个联合a_bc:uniona_bc{inti;charmm;};再用已说明的联合可定义联合变量。例如用上面说明的联合定义一个名为lgc的联合变量,可写成:uniona_bclgc;在联合变量lgc中,整型量i和字符mm公用同一内存位置。当一个联合被说明时,编译程序自动地产生一个变量,其长度为联合中最大的变量长度。联合访问其成员的方法与结构相同。同样联合变量也可以定义成数组或指针,但定义为指针时,也要用->符号,此时联合访问成员可表示成:联合名->成员名\n另外,联合既可以出现在结构内,它的成员也可以是结构。例如:struct{intage;char*addr;union{inti;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.结构和联合都是由多个不同的数据类型成员组成,但在任何同一时刻,联合中只存放了一个被选中的成员,\n而结构的所有成员都存在。2.对于联合的不同成员赋值,将会对其它成员重写,原来成员的值就不存在了,而对于结构的不同成员赋值互不影响的。下面举一个例了来加深对联合的理解。main(){union{/*定义一个联合*/inti;struct{/*在联合中定义一个结构*/charfirst;charsecond;}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();\n}输出结果为:AB6261从上例结果可以看出:当给i赋值后,其低八位也就是first和second的值;当给first和second赋字符后,这两个字符的ASCII码也将作为i的低八位和高八位。简单的说，就是联合里面的所有变量共用一个内存区域，区域大小是所有变量中最大的那个。改动某一个变量的值，其他的值也会随之改变。枚举(enum)枚举是一个被命名的整型常数的集合,枚举在日常生活中很常见。例如表示星期的SUNDAY,MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,就是一个枚举。枚举的说明与结构和联合相似,其形式为:enum枚举名{标识符[=整型常数],\n标识符[=整型常数],...标识符[=整型常数],}枚举变量;如果枚举没有初始化,即省掉=整型常数时,则从第一个标识符开始,顺次赋给标识符0,1,2,...。但当枚举中的某个成员赋值后,其后的成员按依次加1的规则确定其值。例如下列枚举说明后,x1,x2,x3,x4的值分别为0,1,2,3。enumstring{x1,x2,x3,x4}x;当定义改变成:enumstring{x1,x2=0,x3=50,x4,}x;则x1=0,x2=0,x3=50,x4=51注意:1.枚举中每个成员(标识符)结束符是,,不是;,最后一个成员可省略,。2.初始化时可以赋负数,\n以后的标识符仍依次加1。3.枚举变量只能取枚举说明结构中的某个标识符常量。例如:enumstring{x1=5,x2,x3,x4,};enumstrigx=x3;此时,枚举变量x实际上是7。下面看一个例子：main(){enumcolors{red=1,green,blue}col;intcl;printf(1=red,2=green,3=blue.seclect:);scanf(%d,&cl);col=(enumcolors)cl;\n/*强制转换*/switch(col){casered:printf(red\n);break;casegreen:printf(green\n);break;caseblue:printf(blue\n);break;defalut:break;}}***类型说明***类型说明的格式为:typedef类型定义名;类型说明只定义了一个数据类型的新名字而不是定义一种新的数据类型这里类型是Turbo\nC许可的任何一种数据类型定义名表示这个类型的新名字。例如:用下面语句定义整型数的新名字:typedefintSIGNED_INT;使用说明后,SIGNED_INT就成为int的同义词了,此时可以用SIGNED_INT定义整型变量。例如:SIGNED_INTi,j;(与inti,j等效)。但longSIGNED_INTi,j;是非法的。typedef同样可用来说明结构、联合以及枚举。说明一个结构的格式为:typedefstruct{数据类型成员名;数据类型成员名;...}结构名;此时可直接用结构名定义结构变量了。例如:typedefstruct{charname[8];intclass;charsubclass[6];floatmath,phys,chem,engl,biol;}student;\nstudentLiuqi;则Liuqi被定义为结构数组和结构指针。编程高手之路—C语言(二十)堆和链表我们经常在题目中有要求，输入一个整数，然后以这个整数作为数组的元素个数，下面的程序代码是错误的。intn,array[n];scanf(%d,&n);在Turbo\nC中，不允许出现动态数组。那么如果必须需要这样时，就只能使用链表了。一、堆堆是一种动态存储结构，实际上就是数据段中的自由存储区，它是C语言中使用的一种名称，常常用于动态数据的存储分配。堆中存入一数据，总是以2字节的整数倍进行分配，地址向增加方向变动。堆可以不断进行分配直到没有堆空间为止，也可以随时进行释放、再分配，不存在次序问题。所谓动态数组是指在程序运行期间确定其大小的，如常用到的动态数组，它们是在程序执行过程中动态进行变化的，即在程序开始部分没有说明大小，只有在程序运行期间用堆的分配函数为其分配存储空间，分配的大小可根据需要而定，这些数据使用过后，可释放它们占用的堆空间，并可进行再分配。堆和栈在使用时相向生长，栈向上生长，即向小地址方向生长，而堆向下增长，即向大地址方向，其间剩余部分是自由空间。使用过程中要防止增长过度而导致覆盖。一般的程序我们都是使用小内存模式，它的内存分配如下：________________|代码段||————————||数据段||————————||BSS段||————————||堆||----------------|自由空间|----------------||栈||————————||远堆\n||----------------||________________|自由空间在堆和栈之间、以及远堆地址的后面都是自由空间，总共是64K。堆管理函数：1.得到堆和栈之间的自由空间大小的函数小数据内存模式：unsignedcoreleft(void);大数据内存模式：unsignedlongcoreleft(void);对于远堆，可以用farcoreleft()函数。2.分配一个堆空间函数voidmalloc(unsignedsize);该函数将分配一个大小为size字节的堆空间，并返回一个指向这个空间的指针。由于这个指针是void型的，因此当将它赋给其他类型的指针时，必须对该指针进行强制类型转换。例如info是一个结构类型指针，即：structaddr*info;将由malloc()函数返回的指针赋给info时，必须进行类型转换：info=(structaddr*)malloc\n(sizeof(record));malloc()函数所分配的堆空间将不进行初始化。在调用malloc()函数时，若当时没有可用的内存空间，该函数便返回一个NULL指针。3.分配一个堆空间，其大小为能容纳几个元素，没有元素长度为size的函数voidcalloc(unsignedn,unsignedsize);该函数将分配一个容量为n*size大小的堆空间，并用0初始化分配的空间。该函数将返回一个指向分配空间的指针，没有空间可用时，则返回一个NULL指针。4.重新分配堆空间函数void*realloc(void*ptr,unsignednewsize);该函数将对由ptr指向的堆空间重新分配，大小变为newsize。5.释放堆空间函数voidfree(void*ptr);下面举一个关于堆和栈的综合例子：voidpush(int);intpop();int*pi,*tos;main(){int\nv;pi=(int*)malloc(50*sizeof(int));if(!pi){printf(allocationfailure\n);exit(0);}tos=pi;do{printf(pleaseinputvalue,pushit;enter0thenpop;(enter-1thenstop)\n);scanf(%d,&v);if(v!=0)push(v);elseprintf(popthisisit%d\n,pop());}while(v!=-1);}voidpush(int\ni){pi++;if(pi==(tos+50)){printf(stackoverflow\n);exit(0);}*pi=i;}intpop(){if(pi==tos){printf(stackunderflow\n);exit(0);}pi--;return*(pi+1);}程序分配100字节的堆空间，转换成int型赋给pi，当pi为NULL时，表示没有可用的空间了，则显示allocationfailure。输入一个整数，压入栈中，当超过50时，则显示stack\noverflow.当输入0时，则把栈中的数据弹出。这个程序也演示了栈的后进先出的特点。二、链表堆是用来存储动态数据的。动态数据最典型的例子就是链表。形象的说：将若干个数据项按一定的原则前后链接起来，没有数据项都有一个指向下一个数据的指针，则这些数据项靠指针链成一个表，最后的一个数据没有指针(指针为NULL)，这就是链表。可以看出链表放在存储器中，并不一定象数组一样，连续存放，也可以分开存放。由于链的各节点均带有指向下一个节点的地址，因而要找到某个节点，必须要找到上一个节点，如此类推，则可由第一个节点出发找到目的点。链表在数据库建立和管理中用得比较普遍。链表中的每个节点都具有相同的结构类型，它们是由两部分组成，即数据部分(它们包含一些有用的信息),另一部分就是链的指针。下面就定义一个通信链节点的数据结构：structaddress{charname[30];charstreet[40];charcity[20];charstate[10];char\nzip[6];structaddress*next;/*pointertonextentry*/}list_entry;该结构中前五个成员是该节点的信息部分，最后一个成员是指向同一个结构类型的指针。即next又指向一个同样结构类型的节点。1.建立链表建立链表时，首先要将第一个节点的内容存入堆中，为此要将堆中能存入该节点内容的内存区域首地址赋给一个指针。我们可以用malloc()函数来分配内存区域。如info是一个指针：info=(structaddress*)malloc(sizeof(list_entry));当第一个节点存入有info指出的内存区后，再执行该函数，便得到狭义个节点的存储地址info，此时将该info赋给上一个节点的next，并将该节点内容存入info指出的内存区，这样两个节点就链接起来了。此过程反复多次，就可不断的将节点加入链表的尾端。#includestdlib.h#includealloc.h#includestdio.h#include\nstring.hstructaddress{charname[30];charstreet[40];charcity[20];charstate[10];charzip[6];structaddress*next;}list_entry;voidinputs(char*,char*,int);voiddls_store(structaddress*);main(){structaddress*info;inti;for(i=0;i<5;i++){info=(structaddress*)malloc(sizeof(list_entry));inputs(enter\nname:,info->name,30);inputs(enterstreet:,info->street,40);inputs(entercity:,info->city,20);inputs(enterstate:,info->state,10);inputs(enterzip:,info->zip,6);dls_store(info);}}voidinputs(char*prompt,char*s,intcount){charp[255];do{printf(prompt);gets(p);if(strlen(p)>count)printf(\ntoolong\n);}while(strlen(p)>count);strcpy(s,p);}voiddls_store(structaddress\n*in){staticstructaddress*last=NULL;if(!last)last=in;else\nlast->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;/*删除节点函数*/voiddelete(structaddress*info,structaddress\n*old){if(info){if(info==start)start=info->next;/*删除的是第一个节点*/else{old->next=info->next;/*被删除节点前的指针指向下一个节点*/last=old;/*若节点是链表尾，则该节点前的节点指针指向NULL*/}free(info);/*释放删除节点占用空间*/}}/*查找链表中是否有该数据*/structaddress*search(structaddress*top,char*n){while(top){if(!strcmp(n,top->name))returntop;\n/*找到要删除的节点指针*/top=top->next;/*继续找*/}returnNULL;/*没有找到*/}/*链表的输出*/voiddisplay(structaddress*top){while(top){printf(top->name);top=top->next;}}链表问题比较复杂，但又是很重要的概念。上面说的输入，查找，删除，插入等功能一定要理解，可以参考别的一些资料看看。\n上面说的单链表，但是单链表有一个缺点，就是无法反向操作，当某一个链因破坏而断裂，则整个链就被破坏而无法恢复。双链表可以弥补这个缺点，所谓双链表是指每个节点有两个指针项，一个指针指向其前面的节点，而另一个指针指向后面的节点。关于双链表的使用相对要复杂一些，这里就不介绍了，可以找其他一些资料看看。编程高手之路—C语言(二十一)位操作在第一节概述里就说了，C语言是一种中级语言，能对计算机硬件直接操作，这就涉及到位的概念。一、位的概念我们知道，在计算机中，一字节占8位(现在的某些电脑也有占16位的)，这样表示的数的范围为0-255，也即00000000-11111111。位就是里面的0和1。charc=100;实际上c应该是01100100，正好是64H。其中高位在前，低位在后。||第7位\n第0位二、位逻辑运算符符号描述&位逻辑与|位逻辑或^位逻辑异或~取补表中除去最后一个运算符是单目运算符，其他都是双目运算符。这些运算符只能用于整型表达式。位逻辑运算符通常用于对整型变量进行位的设置、清零、取反、以及对某些选定的位进行检测。在程序中一般被程序员用来作为开关标志。较低层次的硬件设备驱动程序，经常需要对输入输出设备进行位操作。&运算的规则是当两个位都为1时，结果为1，否则为0；|运算的规则是当两个位都为0时，结果为0，否则为1；^运算的规则是当两个位相同时，结果为0，否则为1；~运算的规则是当为1时结果为0，当为0时，结果为1。设置位：设置某位为1，而其他位保持不变，可以使用位逻辑或运算。char\nc;c=c|0x40;这样不论c原先是多少，和01000000或以后，总能使第6位为1，而其他位不变。清除位：设置某位为0，而其他位保持不变。可以使用位逻辑与运算。c=c&0xBF;这样c和10111111与以后，总能使第6位为0，其他位保持不变。那如果想让某位为1，其他位都为0怎么办呢？三、位移运算符符号描述<<左移>>\n右移位移运算符作用于其左侧的变量，其右侧的表达式的值就是移动的位数，运算结果就是移动后的变量结果。b=a<<2;就是a的值左移两位并赋值为b。a本身的值并没有改变。向左移位就是在低位沙锅补0，向右移位就是在高位上补0。右移时可以保持结果的符号位，也就是右移时，如果最高位为1，是符号位，则补1而不是补0。程序员常常对右移运算符来实现整数除法运算，对左移运算符来实现整数乘法运算。其中用来实现乘法和除法的因子必须是2的幂次。举例：输入一个整数，判断这个数中有几个二进制位1？例如输入67，输出结果应该为3。因为67的相应二进制数为0000000001000011(0043H)，有3个1出现。分析：要判断是不是1，只需要判断该位与1与以后是不是1就可以知道。一个整数，判断16次即可。main(){intnum,k;intcount=0;/*记录1的个数*/scanf(%d,&num);for(k=0;k<16;k++){if(num&1==1)count++;/*判断最低位是不是1*/num>>=1;/*num右移1位\n*/}printf(%d\n,count);}这样每次都判断最低位是不是1，判断完以后，让前面的右移一位即可。对位的操作，一般程序中用的不多，但是在对计算机硬件操作时，肯定会涉及到。例如，我们以后要讲到的对串口和声卡操作就要用到一些。编程高手之路—C语言(二十二)文件操作基本常识\n由于程序中经常有大量对文件的输入输出操作，它经常构成了程序的主要部分，因而C语言提供了很多输入输出的函数，它们分别用于两种类型文件输入输出系统：即由ANSI标准定义的缓冲文件(也称标准文件(流)输入输出(I/O)系统)；另一类是ANSI标准中没有定义的非缓冲文件(也称非标准文件(流)输入输出(I/O)系统)。我们已经熟悉了通过键盘和显示器进行输入输出的一些函数，如scanf(),printf()等等，这些通过控制台(键盘、显示器等)进行I/O的操作，可以看作标准文件输入输出系统的一些特例，实际上在标准输入输出系统中的一些函数，有关文件的参数(文件结构指针或称流指针),只要用标准设备的流指针代替，这些标准输入输出函数即成为控制台I/O函数。在任何程序执行时，C系统都定义了5个标准设备文件可供使用。自动打开的5个标准设备文件的文件结构指针(在标准I/O系统中)和文件代号将有一个规定值：设备标准文件I/O系统中的流指针名非标准文件……键盘(标准输入)stdin0显示器(标准输出)stdout1显示器(标准错误)stderr2串行口(标准辅助)stdoux3打印机(标准打印)stdprn\n4这样，不论在标准文件系统还是非标准文件系统中，文件结构只要用上述的流指针或文件代号代替，则这些函数也均适用于控制台设备。一、文本流和二进制流在C中引入了流(stream)的概念。它将数据的输入输出看作是数据的流入和流出，这样不管是磁盘文件或者是物理设备(打印机、显示器、键盘等),都可看作一种流的源和目的，视他们为同一种东西，而不管其具体的物理结构，即对他们的操作，就是数据的流入和流出。这种把数据的输入输出操作对象，抽象化为一种流，而不管它的具体结构的方法很有利于编程，而涉及流的输出操作函数可用于各种对象，与其具体的实体无关，即具有通用性。在C中流可分为两大类，即文本流(textstream)和二进制流(binarystream)。所谓文本流是指在流中流动的数据是以字符形式出现。在文本流中，'\n'被换成回车CR和换行LF的代码0DH和0AH。而当输出时，则0DH和0AH本换成'\n'。二进制流是指流动的是二进制数字序列，若流中有字符，则用一个字节的二进制ASCII码表示，若是数字，则用一个字节的二进制数表示。在流入流出时，对\n符号不进行变换。例如2001这个数，在文本流中用其ASCII码表示为：'2''0''0''1'||||50484849共占4字节。而在二进制流中则表示为：0000011111010001\n用十六进制就是07D1。只占两字节。由此看出，二进制流比文本流节省空间，且不用进行对\n的转换，这样可以大大加快流的速度，提高效率。因而，对于含有大量数字信息的数字流，可以采用二进制流的方式；对于含有大量字符信息的流，则采用文本流的方式。二、流和文件在C语言中流就是一种文件形式，它实际上就表示一个文件或设备(从广义上讲，设备也是一种文件)。把流当作文件总觉得不习惯，因而有人称这种和流等同的文件为流式文件，流的输入输出也称为文件的输入输出操作。当流到磁盘而成为文件时，意味着要启动磁盘写入操作，这样流入一个字符(文本流)或流入一个字节(二进制流)均要启动磁盘操作，将大大降低传输效率(磁盘是慢速设备)，且降低磁盘的使用寿命。为此，C语言在输入输出的使用使用了缓冲技术，即在内存为输入的磁盘文件开辟了一个缓冲区(缺省为512字节),当流到该缓冲区装满后，再启动磁盘一次，将缓冲区内容装到磁盘文件中去。读取文件也是类似。在C语言中将此种文件输入输出操作称为标准输入输出，或称流式输入输出(因这种输入输出操作是ANSI\nC推荐的标准)。还有一种是不带缓冲文件输入输出，称为非标准文件输入输出或低级输入输出，它将由DOS直接管理。关于这两种输入输出文件系统下节将会介绍。三、文件FILE的数据结构typedefstruct{shortlevel;unsignedflags;charfd;unsignedcharhold;shortbsize;unsignedchar*buffer;unsignedchar*curp;unsignedistemp;shorttoken;}FILE;这是TurboC中使用的定义(在stdio.h文件中),不同的C编译器，可能使用不同的定义，但基本含义变化不会太大。flags:是一个10位的标志字，其具体含义如下：位代表符号含义0_F_READ读1_F_WRIT写2_F_BUF\n由fclose释放缓冲区3_F_LBUF行缓冲4_F_ERR出错标志5_F_EOFEOF文件尾标志6_F_BIN二进制方式7_F_IN在进行输入8_F_OUT在进行输出9_F_TERM文件是一个终端其他各字段内容以及flags字段内各位所的功能，请参照其他一些资料。这里不多说了，它目前并不是我们要求的内容。应该注意，不要把文件指针和FILE结构指针混为一谈，它们代表两个不同的地址。文件指针指出了对文件当前读写的数据位置，而FILE结构指针是指出了打开文件所对应的FILE结构在内存中的地址，这个指针它实际本身也包含了文件指针的信息。流指针中的各字段是供C语言内部使用的，用户不应该存取它的任何字段。编程高手之路—C语言(二十三、文件操作)[完]\n一、标准文件的读写1.文件的打开fopen()文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。当使用打开函数时，必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在，就意味着建立(只对写文件而言，对读文件则出错)，并将文件指针指向文件开头。若已有一个同名文件存在，则删除该文件，若无同名文件，则建立该文件，并将文件指针指向文件开头。fopen(char*filename,char*type);其中*filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下：方式含义r打开，只读w打开，文件指针指到头，只写a打开，指向文件尾，在已存在文件中追加rb打开一个二进制文件，只读wb打开一个二进制文件，只写ab打开一个二进制文件，进行追加r+\n以读/写方式打开一个已存在的文件w+以读/写方式建立一个新的文本文件a+以读/写方式打开一个文件文件进行追加rb+以读/写方式打开一个二进制文件wb+以读/写方式建立一个新的二进制文件ab+以读/写方式打开一个二进制文件进行追加当用fopen(0成功的打开一个文件时，该函数将返回一个FILE指针，如果文件打开失败，将返回一个NULL指针。如想打开test文件，进行写：FILE*fp;if((fp=fopen(test,w))==NULL){printf(Filecannotbeopened\n);exit();}elseprintf(Fileopenedfor\nwriting\n);……fclose(fp);DOS操作系统对同时打开的文件数目是有限制的，缺省值为5，可以通过修改CONFIG.SYS文件改变这个设置。2.关闭文件函数fclose()文件操作完成后，必须要用fclose()函数进行关闭，这是因为对打开的文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容不会写到打开的文件中去而丢失。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到该文件中去，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件得到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。intfclose(FILE*stream);它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值。常用以下方法进行测试：if(fclose(fp)!=0){printf(Filecannotbe\nclosed\n);exit(1);}elseprintf(Fileisnowclosed\n);当打开多个文件进行操作，而又要同时关闭时，可采用fcloseall()函数，它将关闭所有在程序中打开的文件。intfcloseall();该函数将关闭所有已打开的文件，将各文件缓冲区未装满的内容写到相应的文件中去，接着释放这些缓冲区，并返回关闭文件的数目。如关闭了4个文件，则当执行：n=fcloseall();时，n应为4。3.文件的读写(1).读写文件中字符的函数(一次只读写文件中的一个字符)：intfgetc(FILE*stream);intfgetchar(void);intfputc(intch,FILE*stream);intfputchar(intch);intgetc(FILE*stream);intputc(intch,FILE\n*stream);其中fgetc()函数将把由流指针指向的文件中的一个字符读出，例如：ch=fgetc(fp);将把流指针fp指向的文件中的一个字符读出，并赋给ch，当执行fgetc()函数时，若当时文件指针指到文件尾，即遇到文件结束标志EOF(其对应值为-1)，该函数返回一个-1给ch，在程序中常用检查该函数返回值是否为-1来判断是否已读到文件尾，从而决定是否继续。#includestdio.hmain(){FILE*fp;chch;if((fp=fopen(myfile.tex,r))==NULL){printf(filecannotbeopened\n);exit(1);}while((ch=fgetc(fp))!=EOF)fputc(ch,stdout);fclose(fp);}\n该程序以只读方式打开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)。注意，这里使用charch,其实是不科学的，因为最后判断结束标志时，是看ch!=EOF,而EOF的值为-1，这显然和char是不能比较的。所以，某些使用，我们都定义成intch。(2).读写文件中字符串的函数char*fgets(char*string,intn,FILE*stream);char*gets(char*s);intfprintf(FILE*stream,char*format,variable-list);intfputs(char*string,FILE*stream);intfscanf(FILE*stream,char\n*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文件中的第一行并显示出来：#includestdio.hmain(){FILE*fp;charstr[128];if((fp=fopen(test.txt,r))==NULL){printf(cannotopen\nfile\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里输入一些字符：#includemain(){char*s=That'sgoodnews;\ninti=617;FILE*fp;fp=fopne(test.dat,w);/*建立一个文字文件只写*/fputs(YourscoreofTOEFLis,fp);/*向所建文件写入一串字符*/fputc(':',fp);/*向所建文件写冒号:*/fprintf(fp,%d\n,i);/*向所建文件写一整型数*/fprintf(fp,%s,s);/*向所建文件写一字符串*/fclose(fp);}用DOS的TYPE命令显示TEST.DAT的内容如下所示:屏幕显示YourscoreofTOEFLis:617That'sgoodnews下面的程序是把上面的文件test.dat里的内容在屏幕上显示出来：#includemain(){char*s,m[20];\ninti;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();}运行后屏幕显示:YourscoreofTOEFLis:617That'sgoodnews4.清除和设置文件缓冲区(1).清除文件缓冲区函数：intfflush(FILE*stream);int\nflushall();fflush()函数将清除由stream指向的文件缓冲区里的内容，常用于写完一些数据后，立即用该函数清除缓冲区，以免误操作时，破坏原来的数据。flushall()将清除所有打开文件所对应的文件缓冲区。(2).设置文件缓冲区函数voidsetbuf(FILE*stream,char*buf);voidsetvbuf(FILE*stream,char*buf,inttype,unsignedsize);这两个函数将使得打开文件后，用户可建立自己的文件缓冲区，而不使用fopen()函数打开文件设定的默认缓冲区。对于setbuf()函数，buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定，缺省值为512字节。当选定buf为空时，setbuf函数将使的文件I/O不带缓冲。而对setvbuf函数，则由malloc函数来分配缓冲区。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型，其值可以取如下值：type值含义_IOFBF文件全部缓冲，即缓冲区装满后，才能对文件读写_IOLBF文件行缓冲，即缓冲区接收到一个换行符时，才能对文件读写_IONBF\n文件不缓冲，此时忽略buf,size的值，直接读写文件，不再经过文件缓冲区缓冲5.文件的随机读写函数前面介绍的文件的字符/字符串读写，均是进行文件的顺序读写，即总是从文件的开头开始进行读写。这显然不能满足我们的要求，C语言提供了移动文件指针和随机读写的函数，它们是：(1).移动文件指针函数：longftell(FILE*stream);intrewind(FILE*stream);fseek(FILE*stream,longoffset,intorigin);函数ftell()用来得到文件指针离文件开头的偏移量。当返回值是-1时表示出错。rewind()函数用于文件指针移到文件的开头，当移动成功时，返回0，否则返回一个非0值。fseek()函数用于把文件指针以origin为起点移动offset个字节，其中origin指出的位置可有以下几种：origin数值代表的具体位置SEEK_SET0文件开头SEEK_CUR1\n文件指针当前位置SEEK_END2文件尾例如：fseek(fp,10L,0);把文件指针从文件开头移到第10字节处，由于offset参数要求是长整型数，故其数后带L。fseek(fp,-15L,2);把文件指针从文件尾向前移动15字节。(2).文件随机读写函数intfread(void*ptr,intsize,intnitems,FILE*stream);intfwrite(void*ptr,intsize,intnitems,FILE\n*stream);fread()函数从流指针指定的文件中读取nitems个数据项，每个数据项的长度为size个字节，读取的nitems数据项存入由ptr指针指向的内存缓冲区中，在执行fread()函数时，文件指针随着读取的字节数而向后移动，最后移动结束的位置等于实际读出的字节数。该函数执行结束后，将返回实际读出的数据项数，这个数据项数不一定等于设置的nitems，因为若文件中没有足够的数据项，或读中间出错，都会导致返回的数据项数少于设置的nitems。当返回数不等于nitems时，可以用feof()或ferror()函数进行检查。fwrite()函数从ptr指向的缓冲区中取出长度为size字节的nitems个数据项，写入到流指针stream指向的文件中，执行该操作后，文件指针将向后移动，移动的字节数等于写入文件的字节数目。该函数操作完成后，也将返回写入的数据项数。二、非标准文件的读写这类函数最早用于UNIX操作系统,ANSI标准未定义,但有时也经常用到,DOS3.0以上版本支持这些函数。它们的头文件为io.h。由于我们不常用这些函数，所以在这里就简单说一下。1.文件的打开和关闭open()函数的作用是打开文件,其调用格式为:intopen(char*filename,intaccess);该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容:基本模式和修饰符,两者用(或)方式连接。修饰符可以有多个,但基本模式只能有一个。access的规定--------------------------------------------------------基本模式含义修饰符含义\n--------------------------------------------------------O_RDONLY只读O_APPEND文件指针指向末尾O_WRONLY只写O_CREAT文件不存在时创建文件,属性按基本模式属性O_RDWR读写O_TRUNC若文件存在,将其长度缩为0,属性不变O_BINARY打开一个二进制文件O_TEXT打开一个文字文件---------------------------------------------------------open()函数打开成功,返回值就是文件描述字的值(非负值),否则返回-1。close()函数的作用是关闭由open()函数打开的文件,其调用格式为:intclose(inthandle);该函数关闭文件描述字handle相连的文件。2.读写函数intread(inthandle,void*buf,intcount);read()函数从handle(文件描述字)相连的文件中,读取count个字节放到buf所指的缓冲区中,返回值为实际所读字节数,返回-1表示出错。返回0表示文件结束。\nwrite()函数的调用格式为:intwrite(inthandle,void*buf,intcount);write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中,返回值为实际写入的字节数。3.随机定位函数lseek()函数的调用格式为:intlseek(inthandle,longoffset,intfromwhere);该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。tell()函数的调用格式为:longtell(inthandle);该函数返回与handle相连的文件现生位置指针,功能和用法与ftell()相同。