Ｃ语言的字符集

Ｃ语言字符集由字母，数字，空格，标点和特殊字符组成。

1.字母

小写字母a～z共26个

大写字母A～Z共26个

2.数字

0～9共10个

3.空白符

空格符、制表符、换行符等统称为空白符。空白符只在字符常量和字符串常量中起作用。在其它地方出现时，只起间隔作用，编译程序对它们忽略不计。因此在程序中使用空白符与否，对程序的编译不发生影响，但在程序中适当的地方使用空白符将增加程序的清晰性和可读性。

4.标点和特殊字符

27个特殊字符：+ - * / = : ;? \ ~| ! # % & () [] ^ <> _ , .“‘空格

1.10 书写程序时应遵循的规则

1.一个说明或一个语句占一行。

2.用{}括起来的部分，通常表示了程序的某一层次结构。{}一般与该结构语句的第一个字母对齐，并单独占一行。

3.低一层次的语句或说明可比高一层次的语句或说明缩进若干格后书写。以便看起来更加清晰，增加程序的可读性。

1.8 输入和输出函数scanf和printf，

 

常用的转义字符及其含义

转义字符	转义字符的意义	ASCII代码
\n	回车换行	10
\t	横向跳到下一制表位置	9
\b	退格	8
\r	回车	13
\f	走纸换页	12
\\	反斜线符"\"	92
\'	单引号符	39
\”	双引号符	34
\a	鸣铃	7
\ddd	1～3位八进制数所代表的字符
\xhh	1～2位十六进制数所代表的字符

 

运算符和表达式

Ｃ语言的运算符可分为以下几类：

1. 算术运算符:用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)、-（取负）共八种。

注意：a：除运算符/要求两个操作数（被除数和除数），其中除数不可以为零；且当两个整数相除时，他们的结果一定为整数。如7/2结果为3.

b：取余运算符%两边只能是证书或整形变量。如18%7值为4。灵活运用%和运算符可以方便地取出一个整数的个位数（对10取余）或去掉一个整数的个位（整除10）

c：自增运算符++和自减运算符—都是单目运算符。若运算符放在变量的前面，则称前置运算，反之。

++i或—I    前置

I++或i--    后置

前置运算是变量的值先加一或减一，然后参加表达式的运算。后置运算则是变量先参加表达式的运算，然后再增一或减一

2. 关系运算符:用于比较运算。包括大于(>)、小于(<)、等于(==)、大于等于(>=)、小于等于(<=)和不等于(!=)六种。

 

3. 逻辑运算符:用于逻辑运算。包括与(&&)、或(||)、非(!)三种。

4. 位操作运算符:参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。

5. 赋值运算符:用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值(&=,|=,^=,>>=,<<=)三类共十一种。

构成复合赋值表达式的一般形式为：

变量 双目运算符=表达式

它等效于

变量=变量运算符 表达式

例如：

a+=5等价于a=a+5

x*=y+7等价于x=x*(y+7)

r%=p等价于r=r%p

复合赋值符这种写法，对初学者可能不习惯，但十分有利于编译处理，能提高编译效率并产生质量较高的目标代码。

6. 条件运算符:这是一个三目运算符，用于条件求值(?:)。

7. 逗号运算符:用于把若干表达式组合成一个表达式(，)。

8. 指针运算符:用于取内容(*)和取地址(&)二种运算。

9. 求字节数运算符:用于计算数据类型所占的字节数(sizeof)。

10. 特殊运算符:有括号()，下标[]，成员(→，.)等几种。

 

4.5.1 printf函数（格式输出函数）

printf函数称为格式输出函数，其关键字最末一个字母f即为“格式”(format)之意。其功能是按用户指定的格式，把指定的数据显示到显示器屏幕上。

“%d”表示按十进制整型输出；

“%ld”表示按十进制长整型输出；

“%c”表示按字符型输出等。

 

2. 格式字符串 在Turbo C中格式字符串的一般形式为：

[标志][输出最小宽度][.精度][长度]类型

其中方括号[]中的项为可选项。

各项的意义介绍如下：

1) 类型：类型字符用以表示输出数据的类型，其格式符和意义如下表所示：

格式字符	意 义
d	以十进制形式输出带符号整数(正数不输出符号)
o	以八进制形式输出无符号整数(不输出前缀0)
x,X	以十六进制形式输出无符号整数(不输出前缀Ox)
u	以十进制形式输出无符号整数
f	以小数形式输出单、双精度实数
e,E	以指数形式输出单、双精度实数
g,G	以%f或%e中较短的输出宽度输出单、双精度实数
c	输出单个字符
s	输出字符串

 

 

2) 标志：标志字符为-、+、#、空格四种，其意义下表所示：

标 志	意 义
-	结果左对齐，右边填空格
+	输出符号(正号或负号)
空格	输出值为正时冠以空格，为负时冠以负号
#	对c,s,d,u类无影响；对o类,在输出时加前缀o；对x类,在输出时加前缀0x；对e,g,f 类当结果有小数时才给出小数点

3) 输出最小宽度:用十进制整数来表示输出的最少位数。若实际位数多于定义的宽度，则按实际位数输出，若实际位数少于定义的宽度则补以空格或0。

4) 精度:精度格式符以“.”开头，后跟十进制整数。本项的意义是：如果输出数字，则表示小数的位数；如果输出的是字符，则表示输出字符的个数；若实际位数大于所定义的精度数，则截去超过的部分。

5.长度:长度格式符为h,l两种，h表示按短整型量输出，l表示按长整型量输出。

 

4.5.2 scanf函数(格式输入函数)

1. scanf函数的一般形式 scanf函数是一个标准库函数，它的函数原型在头文件“stdio.h”中，与printf函数相同，Ｃ语言也允许在使用scanf函数之前不必包含stdio.h文件。

scanf函数的一般形式为：

scanf(“格式控制字符串”，地址表列);

 

2. 格式字符串 格式字符串的一般形式为：

%[*][输入数据宽度][长度]类型

其中有方括号[]的项为任选项。各项的意义如下：

1) 类型：表示输入数据的类型，其格式符和意义如下表所示。

表示输入数据的类型，其格式符和意义如下表所示。

格式	字符意义
d	输入十进制整数
o	输入八进制整数
x	输入十六进制整数
u	输入无符号十进制整数
f或e	输入实型数(用小数形式或指数形式)
c	输入单个字符
s	输入字符串

 

2) “*”符:用以表示该输入项,读入后不赋予相应的变量，即跳过该输入值。 如:

scanf("%d %*d %d",&a,&b);

当输入为：1 2 3时，把1赋予a，2被跳过，3赋予b。

3) 宽度:用十进制整数指定输入的宽度(即字符数)。

例如：

scanf("%5d",&a);

输入：12345678

只把12345赋予变量a，其余部分被截去。

又如：

 

scanf("%4d%4d",&a,&b);

输入：12345678

将把1234赋予a，而把5678赋予b。

4) 长度:长度格式符为l和h，l表示输入长整型数据(如%ld) 和双精度浮点数(如%lf)。h表示输入短整型数据。

使用scanf函数还必须注意以下几点：

1) scanf函数中没有精度控制，如：scanf("%5.2f",&a);是非法的。不能企图用此语句输入小数为2位的实数。

2) scanf中要求给出变量地址，如给出变量名则会出错。如scanf("%d",a);是非法的，应改为scnaf("%d",&a);才是合法的。

3) 在输入多个数值数据时，若格式控制串中没有非格式字符作输入数据之间的间隔则可用空格，TAB或回车作间隔。C编译在碰到空格，TAB，回车或非法数据(如对“%d”输入“12A”时，A即为非法数据)时即认为该数据结束。

4) 在输入字符数据时，若格式控制串中无非格式字符，则认为所有输入的字符均为有效字符。

 

4.4.1 putchar 函数（字符输出函数）

 

putchar 函数是字符输出函数， 其功能是在显示器上输出单个字符。

其一般形式为：

putchar(字符变量)

 

例如：

putchar('A');（输出大写字母A）

putchar(x);（输出字符变量x的值）

putchar(‘\101’);（也是输出字符A）

putchar('\n'); （换行）

对控制字符则执行控制功能，不在屏幕上显示。

使用本函数前必须要用文件包含命令：

#include<stdio.h>

或

#include “stdio.h”

 

4.4.2 getchar函数（键盘输入函数）

getchar函数的功能是从键盘上输入一个字符。

其一般形式为：

getchar();

通常把输入的字符赋予一个字符变量，构成赋值语句，如：

char c;

c=getchar();

使用getchar函数还应注意几个问题：

1) getchar函数只能接受单个字符，输入数字也按字符处理。输入多于一个字符时，只接收第一个字符。

2) 使用本函数前必须包含文件“stdio.h”。

3) 在TC屏幕下运行含本函数程序时，将退出TC 屏幕进入用户屏幕等待用户输入。输入完毕再返回TC屏幕。

4) 程序最后两行可用下面两行的任意一行代替：

putchar(getchar());

printf(“%c”,getchar())

 

4 最简单的C程序设计—顺序程序设计

Ｃ程序的执行部分是由语句组成的。 程序的功能也是由执行语句实现的。

C语句可分为以下五类：

1) 表达式语句

2) 函数调用语句

3) 控制语句

4) 复合语句

5) 空语句

 

1. 表达式语句：表达式语句由表达式加上分号“；”组成。

其一般形式为：

表达式；

执行表达式语句就是计算表达式的值。

例如：

 

x=y+z; 赋值语句；

y+z; 加法运算语句，但计算结果不能保留，无实际意义；

i++; 自增1语句，i值增1。

2. 函数调用语句：由函数名、实际参数加上分号“；”组成。

其一般形式为：

函数名(实际参数表)；

执行函数语句就是调用函数体并把实际参数赋予函数定义中的形式参数，然后执行被调函数体中的语句，求取函数值 (在后面函数中再详细介绍) 。

例如：

printf("C Program");调用库函数，输出字符串。

3. 控制语句：控制语句用于控制程序的流程， 以实现程序的各种结构方式。它们由特定的语句定义符组成。Ｃ语言有九种控制语句。可分成以下三类：

1) 条件判断语句：if语句、switch语句；

2) 循环执行语句：do while语句、while语句、for语句；

3) 转向语句：break语句、goto语句、continue语句、return语句。

4. 复合语句：把多个语句用括号{}括起来组成的一个语句称复合语句。

在程序中应把复合语句看成是单条语句，而不是多条语句。

例如：

{ x=y+z;

a=b+c;

printf(“%d%d”，x，a)；

}

是一条复合语句。

复合语句内的各条语句都必须以分号“;”结尾，在括号“}”外不能加分号。

5. 空语句：只有分号“；”组成的语句称为空语句。空语句是什么也不执行的语句。在程序中空语句可用来作空循环体。

例如

while(getchar()!='\n')

;

本语句的功能是，只要从键盘输入的字符不是回车则重新输入。

这里的循环体为空语句。

 

5.3 if语句

 

5.3.1 if语句的三种形式

1. 第一种形式为基本形式：if if(表达式) 语句

其语义是：如果表达式的值为真，则执行其后的语句， 否则不执行该语句。

 

2. 第二种形式为: if-else if(表达式)

 

语句1；

else

语句2；

其语义是：如果表达式的值为真，则执行语句1，否则执行语句2 。

 

3. 第三种形式为if-else-if形式前二种形式的if语句一般都用于两个分支的情况。 当有多个分支选择时，可采用if-else-if语句，其一般形式为：

if(表达式1)

 

语句1；

elseif(表达式2)

语句2；

elseif(表达式3)

语句3；

…

elseif(表达式m)

语句m；

else

语句n；

其语义是：依次判断表达式的值，当出现某个值为真时，则执行其对应的语句。然后跳到整个if语句之外继续执行程序。 如果所有的表达式均为假，则执行语句n。然后继续执行后续程序。

 

4. 在使用if语句中还应注意以下问题:

 

1) 在三种形式的if语句中，在if关键字之后均为表达式。 该表达式通常是逻辑表达式或关系表达式， 但也可以是其它表达式，如赋值表达式等，甚至也可以是一个变量。例如：

if(a=5) 语句；

if(b) 语句；

都是允许的。只要表达式的值为非0，即为“真”。

如在:

if(a=5)…；

中表达式的值永远为非0，所以其后的语句总是要执行的，当然这种情况在程序中不一定会出现，但在语法上是合法的。

又如，有程序段：

if(a=b)

 

printf("%d",a);

else

printf("a=0");

本语句的语义是，把b值赋予a，如为非0则输出该值，否则输出“a=0”字符串。这种用法在程序中是经常出现的。

2) 在if语句中，条件判断表达式必须用括号括起来，在语句之后必须加分号。

3) 在if语句的三种形式中，所有的语句应为单个语句，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{}括起来组成一个复合语句。但要注意的是在}之后不能再加分号。

例如：

if(a>b)

{a++;

 

b++;}

else

{a=0;

b=10;}

Ｃ语言规定，else 总是与它前面最近的if配对，

 

5.4 switch语句Ｃ语言还提供了另一种用于多分支选择的switch语句，其一般形式为：

switch(表达式){

 

case常量表达式1: 语句1;

case常量表达式2: 语句2;

…

case常量表达式n: 语句n;

default: 语句n+1;

}

其语义是：计算表达式的值。 并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时，即执行其后的语句，然后不再进行判断，继续执行后面所有case后的语句。如表达式的值与所有case后的常量表达式均不相同时，则执行default后

的语句。

【例4.9】

main(){

inta;

printf("inputinteger number: ");

scanf("%d",&a);

switch(a){

case1:printf("Monday\n");

case2:printf("Tuesday\n");

case3:printf("Wednesday\n");

case4:printf("Thursday\n");

case5:printf("Friday\n");

case6:printf("Saturday\n");

case7:printf("Sunday\n");

default:printf("error\n");

}

}

本程序是要求输入一个数字，输出一个英文单词。但是当输入3之后，却执行了case3以及以后的所有语句，输出了Wednesday 及以后的所有单词。这当然是不希望的。为什么会出现这种情况呢?这恰恰反应了switch语句的一个特点。在switch语句中，“case常量表达式”只相当于一个语句标号， 表达式的值和某标号相等则转向该标号执行，但不能在执行完该标号的语句后自动跳出整个switch语句，所以出现了继续执行所有后面case语句的情况。 这是与前面介绍的if语句完全不同的，应特别注意。为了避免上述情况，Ｃ语言还提供了一种break语句，专用于跳出switch语句，break 语句只有关键字break，没有参数。在后面还将详细介绍。修改例题的程序，在每一case语句之后增加break 语句， 使每一次执行之后均可跳出switch语句，从而避免输出不应有的结果。

【例4.10】

main(){

inta;

printf("inputinteger number: ");

scanf("%d",&a);

switch(a){

case1:printf("Monday\n");break;

case2:printf("Tuesday\n"); break;

case3:printf("Wednesday\n");break;

case4:printf("Thursday\n");break;

case5:printf("Friday\n");break;

case6:printf("Saturday\n");break;

case7:printf("Sunday\n");break;

default:printf("error\n");

}

}

在使用switch语句时还应注意以下几点：

1) 在case后的各常量表达式的值不能相同，否则会出现错误。

2) 在case后，允许有多个语句，可以不用{}括起来。

3) 各case和default子句的先后顺序可以变动，而不会影响程序执行结果。

4) default子句可以省略不用。

 

6 循环控制

6.1 概述循环结构是程序中一种很重要的结构。其特点是，在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。Ｃ语言提供了多种循环语句，可以组成各种不同形式的循环结构。

1) 用goto语句和if语句构成循环；

2) 用while语句；

3) 用do-while语句；

4) 用for语句；

 

6.2 goto语句以及用goto语句构成循环goto语句是一种无条件转移语句,与BASIC中的goto语句相似。goto 语句的使用格式为:

 

goto 语句标号；

其中标号是一个有效的标识符,这个标识符加上一个“:”一起出现在函数内某处,执行goto语句后,程序将跳转到该标号处并执行其后的语句。另外标号必须与goto语句同处于一个函数中,但可以不在一个循环层中。通常goto语句与if条件语句连用, 当满足某一条件时, 程序跳到标号处运行。

goto语句通常不用,主要因为它将使程序层次不清,且不易读,但在多层嵌套退出时, 用goto语句则比较合理。

【例6.1】用goto语句和if语句构成循环,。Σ=1001nn

main()

{

inti,sum=0;

i=1;

loop:if(i<=100)

{sum=sum+i;

i++;

gotoloop;}

printf("%d\n",sum);

}

 

6.3 while语句

while语句的一般形式为：

while(表达式)语句

 

其中表达式是循环条件，语句为循环体。

while语句的语义是：计算表达式的值，当值为真(非0)时， 执行循环体语句。

【例6.2】用while语句求。 Σ=1001nn

用传统流程图和N-S结构流程图表示算法

 

6.4 do-while语句do-while语句的一般形式为:

 

do

语句

while(表达式)；

这个循环与while循环的不同在于:它先执行循环中的语句,然后再判断表达式是否为真, 如果为真则继续循环；如果为假, 则终止循环。因此, do-while循环至少要执行一次循环语句。

 

6.5 for语句在C语言中，for语句使用最为灵活，它完全可以取代 while 语句。它的一般形式为:

 

for(表达式1；表达式2；表达式3) 语句

它的执行过程如下：

1) 先求解表达式1。

2) 求解表达式2，若其值为真（非0），则执行for语句中指定的内嵌语句，然后执行下面第3）步；若其值为假（0），则结束循环，转到第5）步。

3) 求解表达式3。

4) 转回上面第2）步继续执行。

5) 循环结束，执行for语句下面的一个语句。

for语句最简单的应用形式也是最容易理解的形式如下：

for(循环变量赋初值；循环条件；循环变量增量)语句

循环变量赋初值总是一个赋值语句, 它用来给循环控制变量赋初值; 循环条件是一个关系表达式,它决定什么时候退出循环；循环变量增量，定义循环控制变量每循环一次后按什么方式变化。

对于for循环中语句的一般形式，就是如下的while循环形式：

表达式1；

while（表达式2）

{语句

表达式3；

}

注意:

1) for循环中的“表达式1（循环变量赋初值）”、“表达式2(循环条件)”和“表达式3(循

 

环变量增量)”都是选择项,即可以缺省,但“；”不能缺省。

2) 省略了“表达式1（循环变量赋初值）”,表示不对循环控制变量赋初值。

3) 省略了“表达式2(循环条件)”,则不做其它处理时便成为死循环。 例如：

for(i=1;;i++)sum=sum+i;

相当于：

i=1;

while(1)

{sum=sum+i;

i++;}

4) 省略了“表达式3(循环变量增量)”,则不对循环控制变量进行操作,这时可在语句体中加入修改循环控制变量的语句。

例如：

for(i=1;i<=100;)

{sum=sum+i;

i++;}

5) 省略了“表达式1（循环变量赋初值）”和“表达式3(循环变量增量)”。

例如：

for(;i<=100;)

{sum=sum+i;

i++;}

相当于：

while(i<=100)

{sum=sum+i;

i++;}

6) 3个表达式都可以省略。

例如：

for(；；)语句

相当于：

while(1)语句

7) 表达式1可以是设置循环变量的初值的赋值表达式，也可以是其他表达式。

例如：

for(sum=0;i<=100;i++)sum=sum+i;

8) 表达式1和表达式3可以是一个简单表达式也可以是逗号表达式。

for(sum=0,i=1;i<=100;i++)sum=sum+i;

 

或：

for(i=0,j=100;i<=100;i++,j--)k=i+j;

9) 表达式2一般是关系表达式或逻辑表达式，但也可是数值表达式或字符表达式，只要其值非零，就执行循环体。

例如：

for(i=0;(c=getchar())!=’\n’;i+=c);

又如：

for(;(c=getchar())!=’\n’;)

printf(“%c”,c);

 

6.7 几种循环的比较

1) 四种循环都可以用来处理同一个问题，一般可以互相代替。但一般不提倡用goto型循环。

2) while和do-while循环，循环体中应包括使循环趋于结束的语句。for语句功能最强。

3) 用while和do-while循环时，循环变量初始化的操作应在while和do-while语句之前完成，而for语句可以在表达式1中实现循环变量的初始化。

 

 

7.2 二维数组的定义和引用

7.2.1 二维数组的定义前面介绍的数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。在实际问题中有很多量是二维的或多维的，因此Ｃ语言允许构造多维数组。多维数组元素有多个下标，以标识它在数组中的位置，所以也称为多下标变量。本小节只介绍二维数组，多维数组可由二维数组类推而得到。

二维数组定义的一般形式是：

类型说明符 数组名[常量表达式1][常量表达式2]

其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。

例如：

int a[3][4];

说明了一个三行四列的数组，数组名为a，其下标变量的类型为整型。该数组的下标变量共有3×4个，即：

a[0][0],a[0][1],a[0][2],a[0][3]

a[1][0],a[1][1],a[1][2],a[1][3]

a[2][0],a[2][1],a[2][2],a[2][3]

二维数组在概念上是二维的，即是说其下标在两个方向上变化，下标变量在数组中的位置也处于一个平面之中，而不是象一维数组只是一个向量。但是，实际的硬件存储器却是连续编址的，也就是说存储器单元是按一维线性排列的。如何在一维存储器中存放二维数组，可有两种方式：一种是按行排列， 即放完一行之后顺次放入第二行。另一种是按列排列， 即放完一列之后再顺次放入第二列。在Ｃ语言中，二维数组是按行排列的。

即：

先存放a[0]行，再存放a[1]行，最后存放a[2]行。每行中有四个元素也是依次存放。由于数组a说明为int类型，该类型占两个字节的内存空间，所以每个元素均占有两个字节)。

 

8.2 函数定义的一般形式

1. 无参函数的定义形式

类型标识符 函数名()

{声明部分

语句

}

其中类型标识符和函数名称为函数头。类型标识符指明了本函数的类型，函数的类型实际上是函数返回值的类型。 该类型标识符与前面介绍的各种说明符相同。函数名是由用户定义的标识符，函数名后有一个空括号，其中无参数，但括号不可少。

{}中的内容称为函数体。在函数体中声明部分，是对函数体内部所用到的变量的类型说明。

在很多情况下都不要求无参函数有返回值，此时函数类型符可以写为void。

我们可以改写一个函数定义：

void Hello()

{

printf("Hello,world \n");

}

这里，只把main改为Hello作为函数名，其余不变。Hello函数是一个无参函数，当被其它函数调用时，输出Hello world字符串。

2. 有参函数定义的一般形式

类型标识符 函数名(形式参数表列)

{声明部分

语句

}

有参函数比无参函数多了一个内容，即形式参数表列。在形参表中给出的参数称为形式参数，它们可以是各种类型的变量，各参数之间用逗号间隔。在进行函数调用时，主调函数将赋予这些形式参数实际的值。形参既然是变量，必须在形参表中给出形参的类型说明。

例如，定义一个函数，用于求两个数中的大数，可写为：

intmax(int a, int b)

{

if(a>b) return a;

elsereturn b;

}

第一行说明max函数是一个整型函数，其返回的函数值是一个整数。形参为a,b,均为整型量。a,b的具体值是由主调函数在调用时传送过来的。在{}中的函数体内，除形参外没有使用其它变量，因此只有语句而没有声明部分。在max函数体中的return语句是把a(或b)的值作为函数的值返回给主调函数。有返回值函数中至少应有一个return语句。

在Ｃ程序中，一个函数的定义可以放在任意位置，既可放在主函数main之前，也可放在main之后。

例如：

可把max 函数置在main之后，也可以把它放在main之前。修改后的程序如下所示。

【例8.1】

intmax(int a,int b)

{

if(a>b)returna;

elsereturn b;

}

main()

{

intmax(int a,int b);

intx,y,z;

printf("inputtwo numbers:\n");

scanf("%d%d",&x,&y);

z=max(x,y);

printf("maxmum=%d",z);

}

现在我们可以从函数定义、函数说明及函数调用的角度来分析整个程序，从中进一步了解函数的各种特点。

程序的第1行至第5行为max函数定义。进入主函数后，因为准备调用max函数，故先对max函数进行说明(程序第8行)。函数定义和函数说明并不是一回事，在后面还要专门讨论。 可以看出函数说明与函数定义中的函数头部分相同，但是末尾要加分号。程序第12 行为调用max函数，并把x, y中的值传送给max的形参a, b。max函数执行的结果(a或b

 

8.3.1 形式参数和实际参数

前面已经介绍过，函数的参数分为形参和实参两种。在本小节中，进一步介绍形参、实参的特点和两者的关系。形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。实参出现在主调函数中，进入被调函数后，实参变量也不能使用。形参和实参的功能是作数据传送。发生函数调用时，主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。

函数的形参和实参具有以下特点：

1. 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。

2. 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使实参获得确定值。

3. 实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配”的错误。

4. 函数调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。

 

【例8.2】可以说明这个问题。

main()

{

intn;

printf("inputnumber\n");

scanf("%d",&n);

s(n);

printf("n=%d\n",n);

}

ints(int n)

{

inti;

for(i=n-1;i>=1;i--)

n=n+i;

printf("n=%d\n",n);

}

本程序中定义了一个函数s，该函数的功能是求Σn_i的值。在主函数中输入n值，并作为实参，在调用时传送给s 函数的形参量n( 注意，本例的形参变量和实参变量的标识符都为n，但这是两个不同的量，各自的作用域不同)。在主函数中用printf 语句输出一次n值，这个n值是实参n的值。在函数s中也用printf 语句输出了一次n值，这个n值是形参最后取得的n值0。从运行情况看，输入n值为100。即实参n的值为100。把此值传给函数s时，形参n的初值也为100，在执行函数过程中，形参n的值变为5050。返回主函数之后，输出实参n的值仍为100。可见实参的值不随形参的变化而变化。

8.4.1 函数调用的一般形式

Ｃ语言中，函数调用的一般形式为：

函数名(实际参数表)

对无参函数调用时则无实际参数表。实际参数表中的参数可以是常数，变量或其它构造类型数据及表达式。各实参之间用逗号分隔。

 

8.5 函数的嵌套调用

 

Ｃ语言中不允许作嵌套的函数定义。因此各函数之间是平行的，不存在上一级函数和下一级函数的问题。但是Ｃ语言允许在一个函数的定义中出现对另一个函数的调用。这样就出现了函数的嵌套调用。即在被调函数中又调用其它函数。这与其它语言的子程序嵌套的情形是类似的。

 

8.6 函数的递归调用一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。Ｃ语言允许函数的递归调用。在递归调用中，主调函数又是被调函数。执行递归函数将反复调用其自身，每调用一次就进入新的一层。

例如有函数f如下：

 

int f(int x)

{

int y;

z=f(y);

return z;

}

这个函数是一个递归函数。但是运行该函数将无休止地调用其自身，这当然是不正确的。为了防止递归调用无终止地进行，必须在函数内有终止递归调用的手段。常用的办法是加条件判断，满足某种条件后就不再作递归调用，然后逐层返回。下面举例说明递归调用的执行过程。

【例8.5】用递归法计算n!

用递归法计算n!可用下述公式表示：

n!=1(n=0,1)

n×(n-1)!(n>1)

按公式可编程如下：

longff(int n)

{

longf;

if(n<0)printf("n<0,input error");

elseif(n==0||n==1) f=1;

elsef=ff(n-1)*n;

return(f);

}

main()

{

intn;

longy;

printf("\ninputa inteager number:\n");

scanf("%d",&n);

y=ff(n);

printf("%d!=%ld",n,y);

}

程序中给出的函数ff是一个递归函数。主函数调用ff后即进入函数ff执行，如果n<0,n==0或n=1时都将结束函数的执行，否则就递归调用ff函数自身。由于每次递归调用的实参为n-1，即把n-1的值赋予形参n，最后当n-1的值为1时再作递归调用，形参n的值也为1，将使递归终止。然后可逐层退回。

 

8.9.2 auto变量函数中的局部变量，如不专门声明为static存储类别，都是动态地分配存储空间的，数据存储在动态存储区中。函数中的形参和在函数中定义的变量（包括在复合语句中定义的变量），都属此类，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。这类局部变量称为自动变量。自动变量用关键字auto作存储类别的声明。

例如：

int f(int a) /*定义f函数，a为参数*/

 

{auto int b,c=3; /*定义b，c自动变量*/

……

}

a是形参，b，c是自动变量，对c赋初值3。执行完f函数后，自动释放a，b，c所占的存储单元。

关键字auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。

8.9.3 用static声明局部变量

有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，这时就应该指定局部变量为“静态局部变量”，用关键字static进行声明。

 

【例8.15】考察静态局部变量的值。

f(inta)

{autob=0;

staticc=3;

b=b+1;

c=c+1;

return(a+b+c);

}

main()

{inta=2,i;

for(i=0;i<3;i++)

printf("%d",f(a));

}

对静态局部变量的说明：

1) 静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，占动态存储空间，函数调用结束后即释放。

2) 静态局部变量在编译时赋初值，即只赋初值一次；而对自动变量赋初值是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

3) 如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）。而对自动变量来说，如果不赋初值则它的值是一个不确定的值。

 

【例8.16】打印1到5的阶乘值。

intfac(int n)

{staticint f=1;

f=f*n;

return(f);

}

main()

{inti;

for(i=1;i<=5;i++)

printf("%d!=%d\n",i,fac(i));

}

8.9.4 register变量

为了提高效率，C语言允许将局部变量得值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。

 

【例8.17】使用寄存器变量。

intfac(int n)

{registerint i,f=1;

for(i=1;i<=n;i++)

f=f*i

return(f);

}

main()

{int i;

for(i=0;i<=5;i++)

printf("%d!=%d\n",i,fac(i));

}

说明：

1) 只有局部自动变量和形式参数可以作为寄存器变量；

2) 一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；

3) 局部静态变量不能定义为寄存器变量。

8.9.5 用extern声明外部变量

外部变量（即全局变量）是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该外部变量，则应该在引用之前用关键字extern对该变量作“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，就可以从“声明”处起，合法地使用该外部变量。

 

【例8.18】用extern声明外部变量，扩展程序文件中的作用域。

intmax(int x,int y)

{intz;

z=x>y?x:y;

return(z);

}

main()

{extern A,B;

printf("%d\n",max(A,B));

}

intA=13,B=-8;

说明：在本程序文件的最后1行定义了外部变量A，B，但由于外部变量定义的位置在函数main之后，因此本来在main函数中不能引用外部变量A，B。现在我们在main函数中用extern对A和B进行“外部变量声明”，就可以从“声明”处起，合法地使用该外部变量A和B。

 

9.2 宏定义

在Ｃ语言源程序中允许用一个标识符来表示一个字符串，称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。

宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。

在Ｃ语言中，“宏”分为有参数和无参数两种。下面分别讨论这两种“宏”的定义和调用。

9.2.1 无参宏定义

无参宏的宏名后不带参数。

其定义的一般形式为：

#define 标识符 字符串

其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。

在前面介绍过的符号常量的定义就是一种无参宏定义。此外，常对程序中反复使用的表达式进行宏定义。

例如：

#define M (y*y+3*y)

它的作用是指定标识符M来代替表达式(y*y+3*y)。在编写源程序时，所有的(y*y+3*y)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(y*y+3*y)表达式去置换所有的宏名M，然后再进行编译。

 

【例9.1】

#defineM (y*y+3*y)

main(){

int s,y;

printf("input a number: ");

scanf("%d",&y);

s=3*M+4*M+5*M;

printf("s=%d\n",s);

}

上例程序中首先进行宏定义，定义M来替代表达式(y*y+3*y),在s=3*M+4*M+5*M中作了宏调用。在预处理时经宏展开后该语句变为：

s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y);

但要注意的是，在宏定义中表达式(y*y+3*y)两边的括号不能少。否则会发生错误。如当作以下定义后：

#difineM y*y+3*y

在宏展开时将得到下述语句：

s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y；

这相当于：

3y²+3y+4y²+3y+5y²+3y；

显然与原题意要求不符。计算结果当然是错误的。因此在作宏定义时必须十分注意。应保证在宏代换之后不发生错误。

对于宏定义还要说明以下几点：

1)宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。

2)宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。

3)宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用# undef命令。

例如：

#definePI 3.14159

main()

{

……

}

#undef PI

f1()

{

……

}

 

表示PI只在main函数中有效，在f1中无效。

4) 宏名在源程序中若用引号括起来，则预处理程序不对其作宏代换。

 

【例9.2】

#defineOK 100

main()

{

printf("OK");

printf("\n");

}

上例中定义宏名OK表示100，但在printf语句中OK被引号括起来，因此不作宏代换。程序的运行结果为：OK这表示把“OK”当字符串处理。

5) 宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名。在宏展开时由预处理程序层层代换。

例如：

#define PI 3.1415926

#define S PI*y*y /* PI是已定义的宏名*/

 

对语句：

printf("%f",S);

在宏代换后变为：

printf("%f",3.1415926*y*y);

6) 习惯上宏名用大写字母表示，以便于与变量区别。但也允许用小写字母。

7) 可用宏定义表示数据类型，使书写方便。

例如：

#define STU struct stu

在程序中可用STU作变量说明：

STU body[5],*p;

 

#defineINTEGER int

在程序中即可用INTEGER作整型变量说明：

INTEGER a,b;

应注意用宏定义表示数据类型和用typedef定义数据说明符的区别。

宏定义只是简单的字符串代换，是在预处理完成的，而typedef是在编译时处理的，它不是作简单的代换，而是对类型说明符重新命名。被命名的标识符具有类型定义说明的功能。

请看下面的例子：

#definePIN1 int *

typedef(int *) PIN2;

从形式上看这两者相似， 但在实际使用中却不相同。

下面用PIN1，PIN2说明变量时就可以看出它们的区别：

PIN1a,b;在宏代换后变成:

int *a,b;

表示a是指向整型的指针变量，而b是整型变量。

然而：

PIN2 a,b;

表示a,b都是指向整型的指针变量。因为PIN2是一个类型说明符。由这个例子可见，宏定义虽然也可表示数据类型， 但毕竟是作字符代换。在使用时要分外小心，以避出错。

8) 对“输出格式”作宏定义，可以减少书写麻烦。

【例9.3】中就采用了这种方法。

#defineP printf

#defineD "%d\n"

#defineF "%f\n"

main(){

inta=5, c=8, e=11;

floatb=3.8, d=9.7, f=21.08;

P(DF,a,b);

P(DF,c,d);

P(DF,e,f);

}

9.2.2 带参宏定义

 

Ｃ语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。

对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

带参宏定义的一般形式为：

#define宏名(形参表) 字符串

在字符串中含有各个形参。

带参宏调用的一般形式为：

宏名(实参表)；

例如：

#defineM(y) y*y+3*y /*宏定义*/

……

k=M(5);/*宏调用*/

……

在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为：

k=5*5+3*5

【例9.4】

#defineMAX(a,b) (a>b)?a:b

main(){

intx,y,max;

printf("inputtwo numbers: ");

scanf("%d%d",&x,&y);

max=MAX(x,y);

printf("max=%d\n",max);

}

上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式(a>b)?a:b，形参a,b均出现在条件表达式中。程序第七行max=MAX(x,y)为宏调用，实参x,y，将代换形参a,b。

宏展开后该语句为：

max=(x>y)?x:y;

用于计算x,y中的大数。

对于带参的宏定义有以下问题需要说明：

1. 带参宏定义中，宏名和形参表之间不能有空格出现。

例如把：

#defineMAX(a,b) (a>b)?a:b

写为：

#define MAX (a,b) (a>b)?a:b

将被认为是无参宏定义，宏名MAX代表字符串 (a,b) (a>b)?a:b。宏展开时，宏调用语句：

max=MAX(x,y);

将变为：

max=(a,b)(a>b)?a:b(x,y);

这显然是错误的。

2. 在带参宏定义中，形式参数不分配内存单元，因此不必作类型定义。而宏调用中的实参有具体的值。要用它们去代换形参，因此必须作类型说明。这是与函数中的情况不同的。在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参值赋予形参，进行“值传递”。而在带参宏中，只是符号代换，不存在值传递的问题。

3. 在宏定义中的形参是标识符，而宏调用中的实参可以是表达式。

【例9.5】

#defineSQ(y) (y)*(y)

main(){

inta,sq;

printf("inputa number: ");

scanf("%d",&a);

sq=SQ(a+1);

printf("sq=%d\n",sq);

}

上例中第一行为宏定义，形参为y。程序第七行宏调用中实参为a+1，是一个表达式，在宏展开时，用a+1代换y，再用(y)*(y) 代换SQ，得到如下语句：

sq=(a+1)*(a+1);

这与函数的调用是不同的，函数调用时要把实参表达式的值求出来再赋予形参。而宏代换中对实参表达式不作计算直接地照原样代换。

4. 在宏定义中，字符串内的形参通常要用括号括起来以避免出错。在上例中的宏定义中(y)*(y)表达式的y都用括号括起来，因此结果是正确的。如果去掉括号，把程序改为以下形式：

【例9.6】

#defineSQ(y) y*y

main(){

inta,sq;

printf("input a number: ");

scanf("%d",&a);

sq=SQ(a+1);

printf("sq=%d\n",sq);

}

运行结果为：

inputa number:3

sq=7

同样输入3，但结果却是不一样的。问题在哪里呢? 这是由于代换只作符号代换而不作其它处理而造成的。宏代换后将得到以下语句：

sq=a+1*a+1;

由于a为3故sq的值为7。这显然与题意相违，因此参数两边的括号是不能少的。即使在参数两边加括号还是不够的，请看下面程序：

【例9.7】

#defineSQ(y) (y)*(y)

main(){

inta,sq;

printf("inputa number: ");

scanf("%d",&a);

sq=160/SQ(a+1);

printf("sq=%d\n",sq);

}

本程序与前例相比，只把宏调用语句改为：

sq=160/SQ(a+1);

运行本程序如输入值仍为3时，希望结果为10。但实际运行的结果如下：

input a number:3

sq=160

为什么会得这样的结果呢?分析宏调用语句，在宏代换之后变为：

sq=160/(a+1)*(a+1);

a为3时，由于“/”和“*”运算符优先级和结合性相同，则先作160/(3+1)得40，再作40*(3+1)最后得160。为了得到正确答案应在宏定义中的整个字符串外加括号，程序修改如下：

【例9.8】

#defineSQ(y) ((y)*(y))

main(){

inta,sq;

printf("inputa number: ");

scanf("%d",&a);

sq=160/SQ(a+1);

printf("sq=%d\n",sq);

}

以上讨论说明，对于宏定义不仅应在参数两侧加括号，也应在整个字符串外加括号。

5. 带参的宏和带参函数很相似，但有本质上的不同，除上面已谈到的各点外，把同一表达式用函数处理与用宏处理两者的结果有可能是不同的。

 

【例9.9】

main(){

inti=1;

while(i<=5)

printf("%d\n",SQ(i++));

}

SQ(inty)

{

return((y)*(y));

}

【例9.10】

#defineSQ(y) ((y)*(y))

main(){

inti=1;

while(i<=5)

printf("%d\n",SQ(i++));

}

在例9.9中函数名为SQ，形参为Y，函数体表达式为((y)*(y))。在例9.10中宏名为SQ，形参也为y，字符串表达式为(y)*(y))。 例9.9的函数调用为SQ(i++)，例9.10的宏调用为SQ(i++)，实参也是相同的。从输出结果来看，却大不相同。

分析如下：在例9.9中，函数调用是把实参i值传给形参y后自增1。 然后输出函数值。因而要循环5次。输出1～5的平方值。而在例9.10中宏调用时，只作代换。SQ(i++)被代换为((i++)*(i++))。在第一次循环时，由于i等于1，其计算过程为：表达式中前一个i初值为1，然后i自增1变为2，因此表达式中第2个i初值为2，两相乘的结果也为2，然后i值再自增1，得3。在第二次循环时，i值已有初值为3，因此表达式中前一个i为3，后一个i为4，乘积为12，然后i再自增1变为5。进入第三次循环，由于i 值已为5，所以这将是最后一次循环。计算表达式的值为5*6等于30。i值再自增1变为6，不再满足循环条件，停止循环。

从以上分析可以看出函数调用和宏调用二者在形式上相似，在本质上是完全不同的。

6. 宏定义也可用来定义多个语句，在宏调用时，把这些语句又代换到源程序内。看下面的例子。

 

【例9.11】

#defineSSSV(s1,s2,s3,v) s1=l*w;s2=l*h;s3=w*h;v=w*l*h;

main(){

int l=3,w=4,h=5,sa,sb,sc,vv;

SSSV(sa,sb,sc,vv);

printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);

}

程序第一行为宏定义，用宏名SSSV表示4个赋值语句，4 个形参分别为4个赋值符左部的变量。在宏调用时，把4个语句展开并用实参代替形参。使计算结果送入实参之中。

9.3 文件包含

文件包含是C预处理程序的另一个重要功能。

文件包含命令行的一般形式为：

#include"文件名"

 

在前面我们已多次用此命令包含过库函数的头文件。例如：

#include"stdio.h"

#include"math.h"

文件包含命令的功能是把指定的文件插入该命令行位置取代该命令行，从而把指定的文件和当前的源程序文件连成一个源文件。

在程序设计中，文件包含是很有用的。一个大的程序可以分为多个模块，由多个程序员分别编程。有些公用的符号常量或宏定义等可单独组成一个文件，在其它文件的开头用包含命令包含该文件即可使用。这样，可避免在每个文件开头都去书写那些公用量，从而节省时间，并减少出错。

对文件包含命令还要说明以下几点：

1. 包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来。例如以下写法都是允许的：

#include"stdio.h"

#include<math.h>

但是这两种形式是有区别的：使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的)，而不在源文件目录去查找；

使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。用户编程时可根据自己文件所在的目录来选择某一种命令形式。

2. 一个include命令只能指定一个被包含文件，若有多个文件要包含，则需用多个include命令。

3. 文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件。

 

9.4 条件编译

预处理程序提供了条件编译的功能。可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。这对于程序的移植和调试是很有用的。

条件编译有三种形式，下面分别介绍：

1. 第一种形式：

#ifdef 标识符

程序段1

#else

程序段2

#endif

它的功能是，如果标识符已被 #define命令定义过则对程序段1进行编译；否则对程序段2进行编译。如果没有程序段2(它为空)，本格式中的#else可以没有，即可以写为：

#ifdef 标识符

程序段

#endif

 

2. 第二种形式：

#ifndef 标识符

程序段1

#else

程序段2

#endif

与第一种形式的区别是将“ifdef”改为“ifndef”。它的功能是，如果标识符未被#define命令定义过则对程序段1进行编译，否则对程序段2进行编译。这与第一种形式的功能正相反。

3. 第三种形式：

 

#if 常量表达式

程序段1

#else

程序段2

#endif

它的功能是，如常量表达式的值为真(非0)，则对程序段1 进行编译，否则对程序段2进行编译。因此可以使程序在不同条件下，完成不同的功能。

 

11 结构体与共用体

11.1 定义一个结构的一般形式

在实际问题中，一组数据往往具有不同的数据类型。例如，在学生登记表中，姓名应为字符型；学号可为整型或字符型；年龄应为整型；性别应为字符型；成绩可为整型或实型。显然不能用一个数组来存放这一组数据。因为数组中各元素的类型和长度都必须一致，以便于编译系统处理。为了解决这个问题，Ｃ语言中给出了另一种构造数据类型——“结构（structure）”或叫“结构体”。 它相当于其它高级语言中的记录。“结构”是一种构造类型，它是由若干“成员”组成的。每一个成员可以是一个基本数据类型或者又是一个构造类型。结构既是一种“构造”而成的数据类型，那么在说明和使用之前必须先定义它，也就是构造它。如同在说明和调用函数之前要先定义函数一样。

定义一个结构的一般形式为：

struct 结构名

{成员表列};

成员表列由若干个成员组成，每个成员都是该结构的一个组成部分。对每个成员也必须作类型说明，其形式为：

类型说明符 成员名;

成员名的命名应符合标识符的书写规定。例如：

structstu

{

intnum;

charname[20];

charsex;

floatscore;

};

在这个结构定义中，结构名为stu，该结构由4个成员组成。第一个成员为num，整型变量；第二个成员为name，字符数组；第三个成员为sex，字符变量；第四个成员为score，实型变量。应注意在括号后的分号是不可少的。结构定义之后，即可进行变量说明。凡说明为结构stu的变量都由上述4个成员组成。由此可见， 结构是一种复杂的数据类型，是数目固定，类型不同的若干有序变量的集合。

11.2 结构类型变量的说明

说明结构变量有以下三种方法。以上面定义的stu为例来加以说明。

1. 先定义结构，再说明结构变量。

如：

struct stu

 

{

int num;

charname[20];

charsex;

floatscore;

};

structstu boy1,boy2;

说明了两个变量boy1和boy2为stu结构类型。也可以用宏定义使一个符号常量来表示一个结构类型。

例如：

#define STU struct stu

STU

{

intnum;

charname[20];

charsex;

floatscore;

};

STU boy1,boy2;

2. 在定义结构类型的同时说明结构变量。

 

例如：

struct stu

{

intnum;

charname[20];

charsex;

floatscore;

}boy1,boy2;

这种形式的说明的一般形式为：

struct 结构名

{

成员表列

}变量名表列;

3. 直接说明结构变量。

 

例如：

struct

{

intnum;

charname[20];

charsex;

floatscore;

}boy1,boy2;

这种形式的说明的一般形式为：

struct

{

成员表列

}变量名表列;

 

11.3 结构变量成员的表示方法在程序中使用结构变量时，往往不把它作为一个整体来使用。在ANSIC中除了允许具有相同类型的结构变量相互赋值以外，一般对结构变量的使用，包括赋值、输入、输出、运算等都是通过结构变量的成员来实现的。

表示结构变量成员的一般形式是：

结构变量名.成员名

例如：

 

boy1.num 即第一个人的学号

boy2.sex 即第二个人的性别

如果成员本身又是一个结构则必须逐级找到最低级的成员才能使用。

例如：

boy1.birthday.month

即第一个人出生的月份成员可以在程序中单独使用，与普通变量完全相同。

11.4 结构变量的赋值

结构变量的赋值就是给各成员赋值。可用输入语句或赋值语句来完成。

 

【例11.1】给结构变量赋值并输出其值。

main()

{

struct stu

{

int num;

char *name;

char sex;

float score;

} boy1,boy2;

boy1.num=102;

boy1.name="Zhangping";

printf("inputsex and score\n");

scanf("%c%f",&boy1.sex,&boy1.score);

boy2=boy1;

printf("Number=%d\nName=%s\n",boy2.num,boy2.name);

printf("Sex=%c\nScore=%f\n",boy2.sex,boy2.score);

}

本程序中用赋值语句给num和name两个成员赋值，name是一个字符串指针变量。用scanf函数动态地输入sex和score成员值，然后把boy1的所有成员的值整体赋予boy2。最后分别输出boy2的各个成员值。本例表示了结构变量的赋值、输入和输出的方法。

11.5 结构变量的初始化

和其他类型变量一样，对结构变量可以在定义时进行初始化赋值。

 

【例11.2】对结构变量初始化。

main()

{

struct stu /*定义结构*/

{

int num;

char *name;

char sex;

float score;

}boy2,boy1={102,"Zhang ping",'M',78.5};

boy2=boy1;

printf("Number=%d\nName=%s\n",boy2.num,boy2.name);

printf("Sex=%c\nScore=%f\n",boy2.sex,boy2.score);

}

本例中，boy2,boy1均被定义为外部结构变量，并对boy1作了初始化赋值。在main函数中，把boy1的值整体赋予boy2，然后用两个printf语句输出boy2各成员的值。

11.6 结构数组的定义

数组的元素也可以是结构类型的。因此可以构成结构型数组。结构数组的每一个元素都是具有相同结构类型的下标结构变量。在实际应用中，经常用结构数组来表示具有相同数据结构的一个群体。如一个班的学生档案，一个车间职工的工资表等。

方法和结构变量相似，只需说明它为数组类型即可。

例如：

struct stu

 

{

int num;

char *name;

char sex;

float score;

}boy[5];

定义了一个结构数组boy，共有5个元素，boy[0]～boy[4]。每个数组元素都具有struct stu的结构形式。对结构数组可以作初始化赋值。

例如：

struct stu

{

int num;

char *name;

char sex;

float score;

}boy[5]={

{101,"Liping","M",45},

{102,"Zhangping","M",62.5},

{103,"Hefang","F",92.5},

{104,"Chengling","F",87},

{105,"Wangming","M",58};

}

当对全部元素作初始化赋值时，也可不给出数组长度。

 

11.7 结构指针变量的说明和使用

11.7.1 指向结构变量的指针一个指针变量当用来指向一个结构变量时，称之为结构指针变量。结构指针变量中的值是所指向的结构变量的首地址。通过结构指针即可访问该结构变量，这与数组指针和函数指针的情况是相同的。

结构指针变量说明的一般形式为：

struct 结构名 *结构指针变量名

例如，在前面的例题中定义了stu这个结构，如要说明一个指向stu的指针变量pstu，可写为：

struct stu *pstu;

当然也可在定义stu结构时同时说明pstu。与前面讨论的各类指针变量相同，结构指针变量也必须要先赋值后才能使用。

赋值是把结构变量的首地址赋予该指针变量，不能把结构名赋予该指针变量。如果boy是被说明为stu类型的结构变量，则：

pstu=&boy

是正确的，而：

pstu=&stu

是错误的。

结构名和结构变量是两个不同的概念，不能混淆。结构名只能表示一个结构形式，编译系统并不对它分配内存空间。只有当某变量被说明为这种类型的结构时，才对该变量分配存储空间。因此上面&stu这种写法是错误的，不可能去取一个结构名的首地址。有了结构指针变量，就能更方便地访问结构变量的各个成员。

其访问的一般形式为：

(*结构指针变量).成员名

或为：

 

结构指针变量->成员名

例如：

(*pstu).num

或者：

pstu->num

应该注意(*pstu)两侧的括号不可少，因为成员符“.”的优先级高于“*”。如去掉括号写作*pstu.num则等效于*(pstu.num)，这样，意义就完全不对了。

下面通过例子来说明结构指针变量的具体说明和使用方法。

【例11.5】

structstu

{

intnum;

char*name;

charsex;

floatscore;

}boy1={102,"Zhang ping",'M',78.5},*pstu;

main()

{

pstu=&boy1;

printf("Number=%d\nName=%s\n",boy1.num,boy1.name);

printf("Sex=%c\nScore=%f\n\n",boy1.sex,boy1.score);

printf("Number=%d\nName=%s\n",(*pstu).num,(*pstu).name);

printf("Sex=%c\nScore=%f\n\n",(*pstu).sex,(*pstu).score);

printf("Number=%d\nName=%s\n",pstu->num,pstu->name);

printf("Sex=%c\nScore=%f\n\n",pstu->sex,pstu->score);

}

本例程序定义了一个结构stu，定义了stu类型结构变量boy1并作了初始化赋值，还定义了一个指向stu类型结构的指针变量pstu。在main函数中，pstu被赋予boy1的地址，因此pstu指向boy1。然后在printf语句内用三种形式输出boy1的各个成员值。从运行结果可以看出：

结构变量.成员名

(*结构指针变量).成员名

结构指针变量->成员名

这三种用于表示结构成员的形式是完全等效的。

11.7.2 指向结构数组的指针

指针变量可以指向一个结构数组，这时结构指针变量的值是整个结构数组的首地址。结构指针变量也可指向结构数组的一个元素，这时结构指针变量的值是该结构数组元素的首地址。

设ps为指向结构数组的指针变量，则ps也指向该结构数组的0号元素，ps+1指向1号元素，ps+i则指向i号元素。这与普通数组的情况是一致的。

 

【例11.6】用指针变量输出结构数组。

struct stu

{

int num;

char*name;

charsex;

floatscore;

}boy[5]={

{101,"Zhouping",'M',45},

{102,"Zhangping",'M',62.5},

{103,"Lioufang",'F',92.5},

{104,"Chengling",'F',87},

{105,"Wangming",'M',58},

};

main()

{

structstu *ps;

printf("No\tName\t\t\tSex\tScore\t\n");

for(ps=boy;ps<boy+5;ps++)

printf("%d\t%s\t\t%c\t%f\t\n",ps->num,ps->name,ps->sex,ps->score);

}

在程序中，定义了stu结构类型的外部数组boy并作了初始化赋值。在main函数内定义ps为指向stu类型的指针。在循环语句for的表达式1中，ps被赋予boy的首地址，然后循环5次，输出boy数组中各成员值。

应该注意的是，一个结构指针变量虽然可以用来访问结构变量或结构数组元素的成员，但是，不能使它指向一个成员。也就是说不允许取一个成员的地址来赋予它。因此，下面的赋值是错误的。

ps=&boy[1].sex;

而只能是：

ps=boy;(赋予数组首地址)

或者是：

ps=&boy[0];(赋予0号元素首地址)

11.7.3 结构指针变量作函数参数

在ANSI C标准中允许用结构变量作函数参数进行整体传送。但是这种传送要将全部成员逐个传送，特别是成员为数组时将会使传送的时间和空间开销很大，严重地降低了程序的效率。因此最好的办法就是使用指针，即用指针变量作函数参数进行传送。这时由实参传向形参的只是地址，从而减少了时间和空间的开销。

 

【例11.7】计算一组学生的平均成绩和不及格人数。用结构指针变量作函数参数编程。

struct stu

{

int num;

char *name;

char sex;

float score;}boy[5]={

{101,"Liping",'M',45},

{102,"Zhangping",'M',62.5},

{103,"Hefang",'F',92.5},

{104,"Chengling",'F',87},

{105,"Wangming",'M',58},

};

main()

{

structstu *ps;

voidave(struct stu *ps);

ps=boy;

ave(ps);

}

voidave(struct stu *ps)

{

intc=0,i;

floatave,s=0;

for(i=0;i<5;i++,ps++)

{

s+=ps->score;

if(ps->score<60)c+=1;

}

printf("s=%f\n",s);

ave=s/5;

printf("average=%f\ncount=%d\n",ave,c);

}

本程序中定义了函数ave，其形参为结构指针变量ps。boy被定义为外部结构数组，因此在整个源程序中有效。在main函数中定义说明了结构指针变量ps，并把boy的首地址赋予它，使ps指向boy数组。然后以ps作实参调用函数ave。在函数ave中完成计算平均成绩和统计不及格人数的工作并输出结果。

由于本程序全部采用指针变量作运算和处理，故速度更快，程序效率更高。

11.8 动态存储分配

在数组一章中，曾介绍过数组的长度是预先定义好的，在整个程序中固定不变。Ｃ语言中不允许动态数组类型。

例如：

int n;

 

scanf("%d",&n);

int a[n];

用变量表示长度，想对数组的大小作动态说明，这是错误的。但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种

问题，用数组的办法很难解决。为了解决上述问题，Ｃ语言提供了一些内存管理函数，这些内存管理函数可以按需要动态地分配内存空间，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。

常用的内存管理函数有以下三个：

1. 分配内存空间函数malloc

调用形式：

(类型说明符*)malloc(size)

功能：在内存的动态存储区中分配一块长度为"size"字节的连续区域。函数的返回值为该区域的首地址。

“类型说明符”表示把该区域用于何种数据类型。

(类型说明符*)表示把返回值强制转换为该类型指针。

“size”是一个无符号数。

例如：

pc=(char *)malloc(100);

表示分配100个字节的内存空间，并强制转换为字符数组类型，函数的返回值为指向该字符数组的指针，把该指针赋予指针变量pc。

2. 分配内存空间函数 calloc

calloc 也用于分配内存空间。

调用形式：

(类型说明符*)calloc(n,size)

功能：在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。

(类型说明符*)用于强制类型转换。

calloc函数与malloc 函数的区别仅在于一次可以分配n块区域。

例如：

ps=(struet stu*)calloc(2,sizeof(struct stu));

其中的sizeof(struct stu)是求stu的结构长度。因此该语句的意思是：按stu的长度分配2块连续区域，强制转换为stu类型，并把其首地址赋予指针变量ps。

2. 释放内存空间函数free

调用形式：

free(void*ptr);

功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，它指向被释放区域的首地址。被释放区应是由malloc或calloc函数所分配的区域。

 

【例11.8】分配一块区域，输入一个学生数据。

main()

{

structstu

{

intnum;

char*name;

charsex;

floatscore;

} *ps;

ps=(struct stu*)malloc(sizeof(struct stu));

ps->num=102;

ps->name="Zhang ping";

ps->sex='M';

ps->score=62.5;

printf("Number=%d\nName=%s\n",ps->num,ps->name);

printf("Sex=%c\nScore=%f\n",ps->sex,ps->score);

free(ps);

}

本例中，定义了结构stu，定义了stu类型指针变量ps。然后分配一块stu大内存区，并把首地址赋予ps，使ps指向该区域。再以ps为指向结构的指针变量对各成员赋值，并用printf输出各成员值。最后用free函数释放ps指向的内存空间。整个程序包含了申请内存空间、使用内存空间、释放内存空间三个步骤，实现存储空间的动态分配。

11.9 链表的概念

在例7.8中采用了动态分配的办法为一个结构分配内存空间。每一次分配一块空间可用来存放一个学生的数据，我们可称之为一个结点。有多少个学生就应该申请分配多少块内存空间，也就是说要建立多少个结点。当然用结构数组也可以完成上述工作，但如果预先不能准确把握学生人数，也就无法确定数组大小。而且当学生留级、退学之后也不能把该元素占用的空间从数组中释放出来。

用动态存储的方法可以很好地解决这些问题。有一个学生就分配一个结点，无须预先确定学生的准确人数，某学生退学，可删去该结点，并释放该结点占用的存储空间。从而节约了宝贵的内存资源。另一方面，用数组的方法必须占用一块连续的内存区域。而使用动态分配时，每个结点之间可以是不连续的(结点内是连续的)。结点之间的联系可以用指针实现。 即在结点结构中定义一个成员项用来存放下一结点的首地址，这个用于存放地址的成员，常把它称为指针域。

可在第一个结点的指针域内存入第二个结点的首地址，在第二个结点的指针域内又存放第三个结点的首地址，如此串连下去直到最后一个结点。最后一个结点因无后续结点连接，其指针域可赋为0。这样一种连接方式，在数据结构中称为“链表”。

 

11.10 枚举类型在实际问题中，有些变量的取值被限定在一个有限的范围内。例如，一个星期内只有七天，一年只有十二个月，一个班每周有六门课程等等。如果把这些量说明为整型，字符型或其它类型显然是不妥当的。为此，Ｃ语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值，被说明为该“枚举”类型的变量取值不能超过定义的范围。应该说明的是，枚举类型是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型。

11.10.1 枚举类型的定义和枚举变量的说明

1. 枚举的定义枚举类型定义的一般形式为：

enum 枚举名{ 枚举值表 };

在枚举值表中应罗列出所有可用值。这些值也称为枚举元素。

例如：

该枚举名为weekday，枚举值共有7个，即一周中的七天。凡被说明为weekday类型变量的取值只能是七天中的某一天。

2. 枚举变量的说明

如同结构和联合一样，枚举变量也可用不同的方式说明，即先定义后说明，同时定义说明或直接说明。

设有变量a,b,c被说明为上述的weekday，可采用下述任一种方式：

enum weekday{ sun,mou,tue,wed,thu,fri,sat };

enum weekday a,b,c;

或者为：

enum weekday{ sun,mou,tue,wed,thu,fri,sat }a,b,c;

或者为：

enum { sun,mou,tue,wed,thu,fri,sat }a,b,c;

11.10.2 枚举类型变量的赋值和使用

枚举类型在使用中有以下规定：

1. 枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。

例如对枚举weekday的元素再作以下赋值：

sun=5;

mon=2;

sun=mon;

都是错误的。

2. 枚举元素本身由系统定义了一个表示序号的数值，从0开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1，…,sat值为6。

【例11.10】

main(){

 

enum weekday

{ sun,mon,tue,wed,thu,fri,sat } a,b,c;

a=sun;

b=mon;

c=tue;

printf("%d,%d,%d",a,b,c);

}

 

说明：

只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如：

a=sum;

b=mon;

是正确的。而：

a=0;

b=1;

是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换。

如：

a=(enum weekday)2;

其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于：

a=tue;

还应该说明的是枚举元素不是字符常量也不是字符串常量，使用时不要加单、双引号。

【例11.11】

main(){

enum body

{ a,b,c,d } month[31],j;

int i;

j=a;

for(i=1;i<=30;i++){

month[i]=j;

j++;

if (j>d) j=a;

}

for(i=1;i<=30;i++){

switch(month[i])

{

case a:printf(" %2d%c\t",i,'a'); break;

case b:printf(" %2d%c\t",i,'b'); break;

case c:printf(" %2d%c\t",i,'c'); break;

case d:printf(" %2d %c\t",i,'d');break;

default:break;

}

}

printf("\n");

 

11.11 类型定义符typedefＣ语言不仅提供了丰富的数据类型，而且还允许由用户自己定义类型说明符，也就是说允许由用户为数据类型取“别名”。类型定义符typedef即可用来完成此功能。例如，有整型量a,b,其说明如下：

int a,b;

 

其中int是整型变量的类型说明符。int的完整写法为integer，为了增加程序的可读性，可把整型说明符用typedef定义为：

typedef int INTEGER

这以后就可用INTEGER来代替int作整型变量的类型说明了。

例如：

INTEGER a,b;

它等效于：

int a,b;

用typedef定义数组、指针、结构等类型将带来很大的方便，不仅使程序书写简单而且使意义更为明确，因而增强了可读性。

例如：

typedef char NAME[20]; 表示NAME是字符数组类型，数组长度为20。然后可用NAME 说明变量，如：

NAME a1,a2,s1,s2;

完全等效于：

char a1[20],a2[20],s1[20],s2[20]

又如：

typedef struct stu

{ char name[20];

int age;

char sex;

} STU;

定义STU表示stu的结构类型，然后可用STU来说明结构变量：

STU body1,body2;

typedef定义的一般形式为：

typedef 原类型名 新类型名

其中原类型名中含有定义部分，新类型名一般用大写表示，以便于区别。

有时也可用宏定义来代替typedef的功能，但是宏定义是由预处理完成的，而typedef则是在编译时完成的，后者更为灵活方便。

 

13 文件

13.1 C文件概述

所谓“文件”是指一组相关数据的有序集合。这个数据集有一个名称，叫做文件名。实际上在前面的各章中我们已经多次使用了文件，例如源程序文件、目标文件、可执行文件、库文件 (头文件)等。

文件通常是驻留在外部介质(如磁盘等)上的，在使用时才调入内存中来。从不同的角度可对文件作不同的分类。从用户的角度看，文件可分为普通文件和设备文件两种。

普通文件是指驻留在磁盘或其它外部介质上的一个有序数据集，可以是源文件、目标文件、可执行程序；也可以是一组待输入处理的原始数据，或者是一组输出的结果。对于源文件、目标文件、可执行程序可以称作程序文件，对输入输出数据可称作数据文件。

设备文件是指与主机相联的各种外部设备，如显示器、打印机、键盘等。在操作系统中，把外部设备也看作是一个文件来进行管理，把它们的输入、输出等同于对磁盘文件的读和写。

通常把显示器定义为标准输出文件，一般情况下在屏幕上显示有关信息就是向标准输出文件输出。如前面经常使用的printf,putchar函数就是这类输出。

键盘通常被指定标准的输入文件，从键盘上输入就意味着从标准输入文件上输入数据。scanf,getchar函数就属于这类输入。

从文件编码的方式来看，文件可分为ASCII码文件和二进制码文件两种。ASCII文件也称为文本文件，这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。

例如，数5678的存储形式为：

ASCII码：00110101 00110110 00110111 00111000

↓ ↓ ↓ ↓

十进制码： 5 6 7 8

共占用4个字节。

ASCII码文件可在屏幕上按字符显示，例如源程序文件就是ASCII文件，用DOS命令TYPE可显示文件的内容。由于是按字符显示，因此能读懂文件内容。

二进制文件是按二进制的编码方式来存放文件的。

例如， 数5678的存储形式为：

00010110 00101110

只占二个字节。二进制文件虽然也可在屏幕上显示，但其内容无法读懂。C系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。

输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件”。

本章讨论流式文件的打开、关闭、读、写、 定位等各种操作。

13.2 文件指针

在Ｃ语言中用一个指针变量指向一个文件，这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。

 

定义说明文件指针的一般形式为：

FILE *指针变量标识符；

 

其中FILE应为大写，它实际上是由系统定义的一个结构，该结构中含有文件名、文件状态和文件当前位置等信息。在编写源程序时不必关心FILE结构的细节。

例如：

FILE *fp；

表示fp是指向FILE结构的指针变量，通过fp即可找存放某个文件信息的结构变量，然后按结构变量提供的信息找到该文件，实施对文件的操作。习惯上也笼统地把fp称为指向一个文件的指针。

13.3 文件的打开与关闭

 

文件在进行读写操作之前要先打开，使用完毕要关闭。所谓打开文件，实际上是建立文件的各种有关信息，并使文件指针指向该文件，以便进行其它操作。关闭文件则断开指针与文件之间的联系，也就禁止再对该文件进行操作。

在Ｃ语言中，文件操作都是由库函数来完成的。在本章内将介绍主要的文件操作函数。

13.3.1 文件的打开(fopen函数)

fopen函数用来打开一个文件，其调用的一般形式为：

文件指针名=fopen(文件名,使用文件方式);

 

其中，

“文件指针名”必须是被说明为FILE类型的指针变量；

“文件名”是被打开文件的文件名；

“使用文件方式”是指文件的类型和操作要求。

“文件名”是字符串常量或字符串数组。

例如：

FILE *fp；

fp=("file a","r");

其意义是在当前目录下打开文件file a，只允许进行“读”操作，并使fp指向该文件。

又如：

FILE*fphzk

fphzk=("c:\\hzk16","rb")

其意义是打开C驱动器磁盘的根目录下的文件hzk16，这是一个二进制文件，只允许按二进制方式进行读操作。两个反斜线“\\”中的第一个表示转义字符，第二个表示根目录。

使用文件的方式共有12种，下面给出了它们的符号和意义。 文件使用方式	意义
“rt”	只读打开一个文本文件，只允许读数据
“wt”	只写打开或建立一个文本文件，只允许写数据
“at”	追加打开一个文本文件，并在文件末尾写数据
“rb”	只读打开一个二进制文件，只允许读数据
“wb”	只写打开或建立一个二进制文件，只允许写数据
“ab”	追加打开一个二进制文件，并在文件末尾写数据

 

“rt+”	读写打开一个文本文件，允许读和写
“wt+”	读写打开或建立一个文本文件，允许读写
“at+”	读写打开一个文本文件，允许读，或在文件末追加数据
“rb+”	读写打开一个二进制文件，允许读和写
“wb+”	读写打开或建立一个二进制文件，允许读和写
“ab+”	读写打开一个二进制文件，允许读，或在文件末追加数据

例如：

fclose(fp);

正常完成关闭文件操作时，fclose函数返回值为0。如返回非零值则表示有错误发生。

13.4 文件的读写

对文件的读和写是最常用的文件操作。在Ｃ语言中提供了多种文件读写的函数：

·字符读写函数 ：fgetc和fputc

 

·字符串读写函数：fgets和fputs

·数据块读写函数：freed和fwrite

·格式化读写函数：fscanf和fprinf

下面分别予以介绍。使用以上函数都要求包含头文件stdio.h。

13.4.1 字符读写函数fgetc和fputc

字符读写函数是以字符(字节)为单位的读写函数。 每次可从文件读出或向文件写入一个字符。

1. 读字符函数fgetc

fgetc函数的功能是从指定的文件中读一个字符，函数调用的形式为：

字符变量=fgetc(文件指针)；

 

例如：

ch=fgetc(fp);

其意义是从打开的文件fp中读取一个字符并送入ch中。

对于fgetc函数的使用有以下几点说明：

1) 在fgetc函数调用中，读取的文件必须是以读或读写方式打开的。

2) 读取字符的结果也可以不向字符变量赋值，

例如：

fgetc(fp);

但是读出的字符不能保存。

3) 在文件内部有一个位置指针。用来指向文件的当前读写字节。在文件打开时，该指针总是指向文件的第一个字节。使用fgetc函数后，该位置指针将向后移动一个字节。 因此可连续多次使用fgetc函数，读取多个字符。应注意文件指针和文件内部的位置指针不是一回事。文件指针是指向整个文件的，须在程序中定义说明，只要不重新赋值，文件指针的值是不变的。文件内部的位置指针用以指示文件内部的当前读写位置，每读写一次，该指针均向后移动，它不需在程序中定义说明，而是由系统自动设置的。

 

【例13.1】读入文件c1.doc，在屏幕上输出。

#include<stdio.h>

main()

{

FILE *fp;

char ch;

if((fp=fopen("d:\\jrzh\\example\\c1.txt","rt"))==NULL)

{

printf("\nCannot open file strike any keyexit!");

getch();

exit(1);

}

ch=fgetc(fp);

while(ch!=EOF)

{

putchar(ch);

ch=fgetc(fp);

}

fclose(fp);

}

本例程序的功能是从文件中逐个读取字符，在屏幕上显示。程序定义了文件指针fp,以读文本文件方式打开文件“d:\\jrzh\\example\\ex1_1.c”，并使fp指向该文件。如打开文件出错，给出提示并退出程序。程序第12行先读出一个字符，然后进入循环，只要读出的字符不是文件结束标志(每个文件末有一结束标志EOF)就把该字符显示在屏幕上，再读入下一字符。每读一次，文件内部的位置指针向后移动一个字符，文件结束时，该指针指向EOF。执行本程序将显示整个文件。

2. 写字符函数fputc

fputc函数的功能是把一个字符写入指定的文件中，函数调用的形式为：

fputc(字符量，文件指针)；

 

其中，待写入的字符量可以是字符常量或变量，例如：

fputc('a',fp);

其意义是把字符a写入fp所指向的文件中。

对于fputc函数的使用也要说明几点：

1) 被写入的文件可以用写、读写、追加方式打开，用写或读写方式打开一个已存在的文件时将清除原有的文件内容，写入字符从文件首开始。如需保留原有文件内容，希望写入的字符以文件末开始存放，必须以追加方式打开文件。被写入的文件若不存在，则创建该文件。

2) 每写入一个字符，文件内部位置指针向后移动一个字节。

3) fputc函数有一个返回值，如写入成功则返回写入的字符，否则返回一个EOF。可用此来判断写入是否成功。

 

【例13.2】从键盘输入一行字符，写入一个文件，再把该文件内容读出显示在屏幕上。

#include<stdio.h>

main()

{

FILE*fp;

charch;

if((fp=fopen("d:\\jrzh\\example\\string","wt+"))==NULL)

{

printf("Cannot open file strike any keyexit!");

getch();

exit(1);

}

printf("input a string:\n");

ch=getchar();

while (ch!='\n')

{

fputc(ch,fp);

ch=getchar();

}

rewind(fp);

ch=fgetc(fp);

while(ch!=EOF)

{

putchar(ch);

ch=fgetc(fp);

}

printf("\n");

fclose(fp);

}

程序中第6行以读写文本文件方式打开文件string。程序第13行从键盘读入一个字符后进入循环，当读入字符不为回车符时，则把该字符写入文件之中，然后继续从键盘读入下一字符。每输入一个字符，文件内部位置指针向后移动一个字节。写入完毕，该指针已指向文件末。如要把文件从头读出，须把指针移向文件头，程序第19行rewind函数用于把fp所指文件的内部位置指针移到文件头。第20至25行用于读出文件中的一行内容。

 

13.4.2 字符串读写函数fgets和fputs

1. 读字符串函数fgets 函数的功能是从指定的文件中读一个字符串到字符数组中，函数调用的形式为：

fgets(字符数组名,n,文件指针);

其中的n是一个正整数。表示从文件中读出的字符串不超过 n-1个字符。在读入的最后一个字符后加上串结束标志'\0'。

 

例如：

fgets(str,n,fp);

的意义是从fp所指的文件中读出n-1个字符送入字符数组str中。

【例13.4】从string文件中读入一个含10个字符的字符串。

#include<stdio.h>

main()

{

FILE *fp;

char str[11];

if((fp=fopen("d:\\jrzh\\example\\string","rt"))==NULL)

{

printf("\nCannot open file strike any key exit!");

getch();

exit(1);

}

fgets(str,11,fp);

printf("\n%s\n",str);

fclose(fp);

}

本例定义了一个字符数组str共11个字节，在以读文本文件方式打开文件string后，从中读出10个字符送入str数组，在数组最后一个单元内将加上'\0'，然后在屏幕上显示输出str数组。输出的十个字符正是例13.1程序的前十个字符。

对fgets函数有两点说明：

1)在读出n-1个字符之前，如遇到了换行符或EOF，则读出结束。

2)fgets函数也有返回值，其返回值是字符数组的首地址。

 

2.写字符串函数fputs

fputs函数的功能是向指定的文件写入一个字符串，其调用形式为：

fputs(字符串,文件指针);

其中字符串可以是字符串常量，也可以是字符数组名，或指针变量，例如：

fputs(“abcd“,fp);

 

其意义是把字符串“abcd”写入fp所指的文件之中。

【例13.5】在例13.2中建立的文件string中追加一个字符串。

#include<stdio.h>

main()

{

FILE *fp;

char ch,st[20];

if((fp=fopen("string","at+"))==NULL)

{

printf("Cannotopen file strike any key exit!");

getch();

exit(1);

}

printf("inputa string:\n");

scanf("%s",st);

fputs(st,fp);

rewind(fp);

ch=fgetc(fp);

while(ch!=EOF)

{

putchar(ch);

ch=fgetc(fp);

}

printf("\n");

fclose(fp);

}

本例要求在string文件末加写字符串，因此，在程序第6行以追加读写文本文件的方式打开文件string。然后输入字符串，并用fputs函数把该串写入文件string。在程序15行用rewind函数把文件内部位置指针移到文件首。再进入循环逐个显示当前文件中的全部内容。

13.4.3 数据块读写函数fread和fwtrite

 

Ｃ语言还提供了用于整块数据的读写函数。可用来读写一组数据，如一个数组元素，一个结构变量的值等。

读数据块函数调用的一般形式为：

fread(buffer,size,count,fp);

写数据块函数调用的一般形式为：

fwrite(buffer,size,count,fp);

其中:

buffer 是一个指针，在fread函数中，它表示存放输入数据的首地址。在fwrite函数中，它表示存放输出数据的首地址。

size 表示数据块的字节数。

count 表示要读写的数据块块数。

fp 表示文件指针。

例如：

fread(fa,4,5,fp);

其意义是从fp所指的文件中，每次读4个字节(一个实数)送入实数组fa中，连续读5次，即读5个实数到fa中。

【例13.6】从键盘输入两个学生数据，写入一个文件中，再读出这两个学生的数据显示在屏幕上。

#include<stdio.h>

struct stu

{

char name[10];

int num;

int age;

char addr[15];

}boya[2],boyb[2],*pp,*qq;

main()

{

FILE *fp;

char ch;

int i;

pp=boya;

qq=boyb;

if((fp=fopen("d:\\jrzh\\example\\stu_list","wb+"))==NULL)

{

printf("Cannotopen file strike any key exit!");

getch();

exit(1);

}

printf("\ninputdata\n");

for(i=0;i<2;i++,pp++)

scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);

pp=boya;

fwrite(pp,sizeof(structstu),2,fp);

rewind(fp);

fread(qq,sizeof(structstu),2,fp);

printf("\n\nname\tnumberage addr\n");

for(i=0;i<2;i++,qq++)

printf("%s\t%5d%7d%s\n",qq->name,qq->num,qq->age,qq->addr);

fclose(fp);

}

本例程序定义了一个结构stu,说明了两个结构数组boya和boyb以及两个结构指针变量pp和qq。pp指向boya,qq指向boyb。程序第16行以读写方式打开二进制文件“stu_list”，输入二个学生数据之后，写入该文件中，然后把文件内部位置指针移到文件首，读出两块学生数据后，在屏幕上显示。

13.4.4 格式化读写函数fscanf和fprintf

fscanf函数，fprintf函数与前面使用的scanf和printf 函数的功能相似，都是格式化读写函数。两者的区别在于fscanf函数和fprintf函数的读写对象不是键盘和显示器，而是磁盘文件。

 

这两个函数的调用格式为：

fscanf(文件指针,格式字符串,输入表列);

fprintf(文件指针,格式字符串,输出表列);

例如：

fscanf(fp,"%d%s",&i,s);

fprintf(fp,"%d%c",j,ch);

用fscanf和fprintf函数也可以完成例10.6的问题。修改后的程序如例10.7所示。

【例13.7】用fscanf和fprintf函数成例10.6的问题。

#include<stdio.h>

struct stu

{

char name[10];

int num;

int age;

char addr[15];

}boya[2],boyb[2],*pp,*qq;

main()

{

FILE*fp;

charch;

inti;

pp=boya;

qq=boyb;

if((fp=fopen("stu_list","wb+"))==NULL)

{

printf("Cannotopen file strike any key exit!");

getch();

exit(1);

}

printf("\ninputdata\n");

for(i=0;i<2;i++,pp++)

scanf("%s%d%d%s",pp->name,&pp->num,&pp->age,pp->addr);

pp=boya;

for(i=0;i<2;i++,pp++)

fprintf(fp,"%s%d %d %s\n",pp->name,pp->num,pp->age,pp->

addr);

rewind(fp);

for(i=0;i<2;i++,qq++)

fscanf(fp,"%s%d %d %s\n",qq->name,&qq->num,&qq->age,qq->addr);

printf("\n\nname\tnumberage addr\n");

qq=boyb;

for(i=0;i<2;i++,qq++)

printf("%s\t%5d%7d %s\n",qq->name,qq->num, qq->age,

qq->addr);

fclose(fp);

}

与例10.6相比，本程序中fscanf和fprintf函数每次只能读写一个结构数组元素，因此采用了循环语句来读写全部数组元素。还要注意指针变量pp,qq由于循环改变了它们的值，因此在程序的25和32行分别对它们重新赋予了数组的首地址。

13.5 文件的随机读写

前面介绍的对文件的读写方式都是顺序读写，即读写文件只能从头开始，顺序读写各个数据。 但在实际问题中常要求只读写文件中某一指定的部分。为了解决这个问题可移动文件内部的位置指针到需要读写的位置，再进行读写，这种读写称为随机读写。

实现随机读写的关键是要按要求移动位置指针，这称为文件的定位。

 

13.5.1 文件定位

移动文件内部位置指针的函数主要有两个，即 rewind 函数和fseek函数。

rewind函数前面已多次使用过，其调用形式为：

rewind(文件指针);

它的功能是把文件内部的位置指针移到文件首。

下面主要介绍fseek函数。

fseek函数用来移动文件内部位置指针，其调用形式为：

fseek(文件指针,位移量,起始点);

其中：

“文件指针”指向被移动的文件。

“位移量”表示移动的字节数，要求位移量是long型数据，以便在文件长度大于64KB 时不会出错。当用常量表示位移量时，要求加后缀“L”。

“起始点”表示从何处开始计算位移量，规定的起始点有三种：文件首，当前位置和文件尾。

其表示方法如下表。 起始点	表示符号	数字表示
文件首	SEEK_SET	0
当前位置	SEEK_CUR	1
文件末尾	SEEK_END	2

例如：

fseek(fp,100L,0);

其意义是把位置指针移到离文件首100个字节处。

还要说明的是fseek函数一般用于二进制文件。在文本文件中由于要进行转换，故往往计算的位置会出现错误。

13.5.2 文件的随机读写

在移动位置指针之后，即可用前面介绍的任一种读写函数进行读写。由于一般是读写一个数据据块，因此常用fread和fwrite函数。

下面用例题来说明文件的随机读写。

 

【例13.8】在学生文件stu_list中读出第二个学生的数据。

#include<stdio.h>

struct stu

{

char name[10];

int num;

int age;

char addr[15];

}boy,*qq;

main()

{

FILE *fp;

char ch;

int i=1;

qq=&boy;

if((fp=fopen("stu_list","rb"))==NULL)

{

printf("Cannot open file strikeany key exit!");

getch();

exit(1);

}

rewind(fp);

fseek(fp,i*sizeof(struct stu),0);

fread(qq,sizeof(struct stu),1,fp);

printf("\n\nname\tnumber ageaddr\n");

printf("%s\t%5d %7d%s\n",qq->name,qq->num,qq->age,

qq->addr);

}