a

b

Not a

a and b

a or b

a xor b

false

false

true

false

false

false

false

true

true

false

ture

true

true

false

false

false

true

true

true

true

false

true

true

false

函数和过程名

功 能

说 明

copy(s,m,n)

取s中第m个字符开始的n个字符

若m大于s的长度，则返回空串；否则，若m+n大于s的长度，则截断

length(s)

求s的动态的长度

返回值为整数

pos(sub,s)

在s中找子串sub

返回值为sub在s中的位置，为byte型

insert(sour,s,m)

在s的第m个字符位置处插入子串sour

若返回串超过255，则截断

delete(s,m,n)

删除s中第m个字符开始的n个字符串

若m大于s的长度，则不删除；否则，若m+n大于s的长度，则删除到结尾

Str(x[:w[:d]],s)

将整数或实数x转换成字符串s

w 和 d是整型表达式，意义同带字宽的write语句

val(s,x,code)

将字符串S 转换成整数或实数x

在前面几章中我们用到了整型、实型、布尔型、字符型的数据。以上数据类型是由pascal规定的标准数据类型，只要写integer,real,boolean, char, pascal 编译系统就能识别并按这些类型来处理。pascal还允许用户定义一些类型，这是其它一些语言所没有的，这就使得pascal使用灵活、功能丰富。

一、枚举类型

　　随着计算机的不断普及，程序不仅只用于数值计算，还更广泛地用于处理非数值的数据。例如，性别、月份、星期几、颜色、单位名、学历、职业等，都不是数值数据。
　　在其它程序设计语言中，一般用一个数值来代表某一状态，这种处理方法不直观，易读性差。如果能在程序中用自然语言中有相应含义的单词来代表某一状态，则程序就很容易阅读和理解。也就是说，事先考虑到某一变量可能取的值，尽量用自然语言中含义清楚的单词来表示它的每一个值，这种方法称为枚举方法，用这种方法定义的类型称枚举类型。
　　枚举类型是一种很有实用价值的数据类型，它是pascal一项重要创新。

　　（一）枚举类型的定义
　　枚举类型是一种自定义类型，要使用枚举类型当然也要先说明枚举类型。
　　枚举类型的一般格式:
　　　(标识符1,标识符2,…,标识符n)
　　说明：①括号中的每一个标识符都称为枚举元素或枚举常量。
　　　　　②定义枚举类型时列出的所有枚举元素构成了这种枚举类型的值域（取值范围），也就是说，该类型的变量所有可能的取值都列出了。
　　例如，下列类型定义是合法的：
　　type days=(sun,mon,tue,wed,thu,fri,sat);
　　colors=(red,yellow,blue,white,black,green);
　　而下列类型定义是错误的(因为枚举元素非标识符):
　　type colortype=('red','yellow','blue','white');
　　numbers=(1,3,5,7,9);
　　ty=(for,do,while);

　　（二）枚举类型变量
　　定义了枚举类型，就可以把某些变量说明成该类型。如：
　　var holiday,workday:day;
　　　incolor:colors;
　　也可以把变量的说明与类型的定义合并在一起,如:
　　var holiday,workday:(sun,mon,tue,wed,thu,fri,sat);
　　　incolor:(red,yellow,blue,white,black,green);

　　（三）枚举类型的性质

　　⒈枚举类型属于顺序类型
　　根据定义类型时各枚举元素的排列顺序确定它们的序号，第一个枚举元素的序号为0。例如：设有定义：
　　type days=(sun,mon,tue,wed,thu,fri,sat);
　　则:
　　ord(sun)=0,ord(mon)=1,ord(sat)=6;succ(sun)=mon,succ(mon)=tue,
　　succ(fri)=sat;pred(mon)=sun,pred(tue)=mon,pred(sat)=fri。
　　应注意的是：枚举类型中的第一个元素无前趋，最后一个元素无后继。

　　⒉对枚举类型只能进行赋值运算和关系运算
　　一旦定义了枚举类型及这种类型的变量，则在语句部分只能对枚举类型变量赋值，或进行关系运算，不能进行算术运算和逻辑运算。
　　在枚举元素比较时，实际上是对其序号的比较。当然，赋值或比较时，应注意类型一致。
　　例如，设程序有如下说明：
　　type days=(sun,mon,tue,wed,thu,fri,sat);
　　　　colors=(red,yellow,blue,white,black,green);
　　var color:colors;
　　　　weekday:days;
　　则下列比较或语句是合法的:
　　weekday:=mon;
　　if weekday=sun then write('rest');
　　weekday<>sun
　　而下面比较或语句是不合法的:
　　mon:=weekday;
　　mon:=1;
　　if weekday=sun or sat then write('rest');
　　sun>red
　　weekday<>color

　　⒊枚举变量的值只能用赋值语句来获得
　　也就是说，不能用read(或readln)读一个枚举型的值。同样，也不能用write(或writeln)输出一个枚举型的值。如write(red)是非法的，会发生编译错误。千万不要误认为，该语句的结果是输出"red"三个字符。
　　但对枚举数据的输入与输出可通过间接方式进行。输入时，一般可输入一个代码，通过程序进行转换，输出时，也只是打印出与枚举元素相对应的字符串。这在后面的例题中将有使用示例。

　　⒋同一个枚举元素不能出现在两个或两个以上的枚举类型定义中。
　　如:
　　type color1=(red,yellow,white);
　　　　 color2=(blue,red,black);
　　是不允许的，因为red属于两个枚举类型。

　　（四）、枚举类型应用举例

　　例1 一周七天用sun,mon,tue,wed,thu,fri,sat表示， 要求利用枚举类型编程：当输入星期几的数字,能输出它的后一天是星期几(也用英文表示)。
　　源程序如下：
　　program ex6_1;
　　type week=(sun,mon,tue,wed,thu,fri,sat);
　　var
　　　　i : integer;
　　　　day,sucday : week;
　　begin
　　　write('What date is it');readln(i);
　　　case i of {根据输入i转换成枚举型}
　　　　1:day:=mon;
　　　　2:day:=tue;
　　　　3:day:=wed;
　　　　4:day:=thu;
　　　　5:day:=fri;
　　　　6:day:=sat;
　　　　7:day:=sun;
　　　end;
　　　{计算明天sucday}
　　　if (day=sat) then sucday:=sun
　　　else sucday:=succ(day);
　　　{输出明天是星期几}
　　　write('The next day is ');
　　　case sucday of
　　　　sun:writeln('sunday');
　　　　mon:writeln('monday');
　　　　tue:writeln('tuesday');
　　　　wed:writeln('wednesay');
　　　　thu:writeln('thursday');
　　　　fri:writeln('friday');
　　　　sat:writeln('saturday');
　　　end;
　　　end.
　　评注：程序中变量day、sucday分别表示今天、明天。

二、子界类型

　　如果我们定义一个变量i为integer类型，那么i的值在微型机系统的pascal中,使用2字节的定义表示法,取值范围为-32768～32767。而事实上，每个程序中所用的变量的值都有一个确定的范围。
　　例如，人的年龄一般不超过150，一个班级的学生不超过100人，一年中的月数不超过12，一月中的天数不超过31，等等。
　　如果我们能在程序中对所用的变量的值域作具体规定的话，就便于检查出那些不合法的数据，这就能更好地保证程序运行的正确性。而且在一定程度上还会节省内存空间。
　　子界类型就很好解决如上问题。此外，在数组的定义中，常用到子界类型，以规定数组下标的范围，上一章有关数组知识中我们已用到。

　　（一）子界类型定义
　　子界类型的一般格式：
　　　　<常量1>..<常量2>
　　说明: ①其中常量1称为子界的下界,常量2称为子界的上界。
　　　　　②下界和上界必须是同一顺序类型（该类型称为子界类型的基类型），且上界的序号必须大于下界的序号。例如，下列说明：
　　type age=0.5..150;
　　　letter=0..'z';
　　　let1='z'..'a';
　　都是错误的。
　　③可以直接在变量说明中定义子界类型。如：
　　type letter='a'..'d';
　　　　　var ch1,ch2:letter;
　　可以合并成:
　　var ch1,ch2:'a'..'d';
　　当然，将类型定义和变量定义分开，则更为清晰。

　　（二）子界类型数据的运算规则

　　⒈凡可使用基类型的运算规则同样适用该类型的子界类型。
　　例如，可以使用整型变量的地方，也可以使用以整型为基类型的子界类型数据。
　　⒉对基类型的运算规则同样适用于该类型的子界类型。
　　例如，p，mod要求参加运算的数据为整, 因而也可以为整型的任何子界类型数据。
　　⒊基类型相同的不同子界类型数据可以进行混合运算。

　　例如：设有如下说明：
　　type　a=1..100;
　　　　　b=1.1000;
　　　　　c=1..500;
　　var 　
　　　　　x:a;
　　　　　y:b;
　　　　　t:c;
　　　　　z:integer;
　　则下列语句也是合法的：
　　Z:=Sqr(x)+y+t;
　　下列语句:
　　　t:=x+y+z;
　　当X+Y+Z的值在1～500范围内时是合法的，否则会出错。

　　（三）子界类型应用举例
　　例2 利用子界类型作为情况语句标号，编一个对数字， 大小写字母和特殊字符进行判别的程序。
　　源程序如下：
　　program cas;
　　var c:char;
　　begin
　　　readln(c);
　　case c of
　　　'0'..'9':writeln('digits');
　　　'A'..'Z':writeln('UPPER-CASELETTERS');
　　　'a'..'z':writeln('lower-caseletters');
　　　esle writeln('special charactors');
　　end;
　end.

　　例3 使用子界型情况语句，当输入月、日、年(10 30 1986)，输出30 Oct 1986。
　　源程序如下:
　　program ex6_3;
　　　var month:1..12;
　　　　　date:1..31;
　　　　　year:1900..1999;
　　　begin
　　　　write('Enter date(mm-dd-yy):');
　　　　readln(month,date,year);
　　　　write(date);
　　　　case month of
　　　　　1:write('Jan':5);
　　　　　2:write('Feb':5);
　　　　　3:write('Mar':5);
　　　　　4:write('Apr':5);
　　　　　5:write('May':5);
　　　　　6:write('Jun':5);
　　　　　7:write('Jul':5);
　　　　　8:write('Aug':5);
　　　　　9:write('Sep':5);
　　　　　10:write('Oct':5);
　　　　　11:write('Nov':5);
　　　　　12:write('Dec':5);
　　　　end;
　　　　writeln(year:7);
　　　end.
　　枚举类型和子界类型均是顺序类型，在前面一章数组的定义时，实际上我们已经用到了子界类型，数组中的下标类型确切地讲可以是和枚举类型或子界类型，大多数情况下用子界类型。
　　如有如下说明：
　　type color=(red,yellow,blue,white,black);
　　var
　　　　a:array[color]of integer;
　　　　b:array[1..100]of color;
　　都是允许的。

三、集合类型

　　集合是由具有某些共同特征的元素构成的一个整体。在pascal中,一个集合是由具有同一有序类型的一组数据元素所组成，这一有序类型称为该集合的基类型。

　　（一）集合类型的定义和变量的说明
　　集合类型的一般形式为：
　　　　set of <基类型>;
　 说明: ①基类型可以是任意顺序类型, 而不能是实型或其它构造类型。同时，基类型的数据的序号不得超过255。例如下列说明是合法的:
　　type letters=set of 'A'..'Z';
　　numbers=set of 0..9;
　　s1=set of char;
　　ss=(sun,mon,tue,wed,thu,fri,sat);
　　s2=set of ss;
　　②与其它自定义类型一样, 可以将类型说明与变量说明合并在一起.如:
　　type numbers=set of 0..9;
　　var s:numbers;
　　与 var s:set of 0..9;等价。

　　（二）集合的值
　　集合的值是用"［"和"］"括起来，中间为用逗号隔开的若干个集合的元素。如：
　　[] 空集
　　[1,2,3]
　　['a','e','i','o','u']
　　都是集合。
　　说明：
　　①集合的值放在一对方括号中，各元素之间用逗号隔开。
　　②在集合中可以没有任何元素，这样的集合称为空集。
　　③在集合中，如果元素的值是连续的，则可用子界型的表示方法表示。例如：　　
　　　　［1,2,3,4,5,7,8,9,10,15］
　　可以表示成：
　　　　 ［1..5,7..10,15］
　　④集合的值与方括号内元素出现的次序无关。例如，［1,5,8 ］和［5,1,8］的值相等。
　　⑤在集合中同一元素的重复出现对集合的值没有影响。例如，［1,8,5,1,8］与［1,5,8］的值相等。
　　⑥每个元素可用基类型所允许的表达式来表示。如［1,1+2,4］、［ch］、［succ(ch)］。

　　（三）集合的运算

　　⒈赋值运算
　　只能通过赋值语句给集合变量赋值，不能通过读语句赋值，也不能通过write(或writeln)语句直接输出集合变量的值。
　　⒉集合的并、交、差运算
　　可以对集合进行并、交、差三种运算，每种运算都只能有一个运算符、两个运算对象，所得结果仍为集合。三种运算符分别用"＋"、"＊"、"－"表示。注意它们与算术运算的区别。
　　⒊集合的关系运算
　　集合可以进行相等或不相等、包含或被包含的关系运算，还能测试一个元素是否在集合中。所用的运算符分别是：＝、＜＞、＞＝、＜＝、ｉｎ
　　它们都是二目运算，且前４个运算符的运算对象都是相容的集合类型，最后一个运算符的右边为集合，左边为与集合基类型相同的表达式。

　　例4 设有如下说明：
　　type weekday=(sun,mon,tue,wed,thu,fri,sat);
　　　　　week=set of weekday;
　　　　　subnum=set of 1..50;
　　写出下列表达式的值:
　　⑴［sun,sat］+［sun,tue,fri］
　　⑵［sun,fri］*［mon,tue］
　　⑶［wun,sat］*［sun..sat］
　　⑷［sun］-［mon,tue］
　　⑸［mon］-［mon,tue］
　　⑹［sun..sat］-［mon,sun,sat］
　　⑺［1,2,3,5］=［1,5,3,2］
　　⑻［1,2,3,4］<>［1..4］
　　⑼［1,2,3,5］>=［1..3］
　　⑽［1..5］<=［1..4］
　　⑾［1,2,3］<=［1..3］
　　⑿ 2 in［1..10］
　　答: 表达式的值分别是:
　　⑴ ［sun,sat,tue,fri］
　　⑵ ［ ］
　　⑶ ［sun,sat］
　　⑷ ［ ］
　　⑸ ［ ］
　　⑹ ［tue..fri］
　　⑺ TRUE
　　⑻ FALSE
　　⑼ TRUE
　　⑽　FALSE
　　⑾ TRUE
　　⑿ TRUE

　　例5 输入一系列字符，对其中的数字字符、字母字符和其它字符分别计数。输入'？'后结束。
　　源程序如下：
　　program ex10_2;
　　var id,il,io:integer;
　　　　ch:char;
　　　　letter:set of char;
　　　　digit:set of '0'..'9';
　　begin
　　　　letter=['a'..'z','A'..'Z'];
　　　　digit:=['0'..'9'];
　　　　id:=0;il:=0;io:=0;
　　　　repeat
　　　　 read(ch);
　　　　 if ch in letter
　　　　 then il:=il+1
　　　　 else if ch in digit
　　　　　　then id:=id+1
　　　　　　else io:=io+1;
　　　until ch='?';
　　 writeln('letter:',il,'digit:',id,'Other:',io);
　　end.

四、记录类型
　　在程序中对于组织和处理大批量的数据来说，数组是一种十分方便而又灵活的工具，但是数组在使用中有一个基本限制，这就是：一个数组中的所有元素都必须具有相同的类型。但在实际问题中可能会遇到另一类数据，它是由性质各不相同的成份组成的，即它的各个成
份可能具有不同的类型。例如，有关一个学生的数据包含下列项目：
　　　　学号　　字符串类型
　　　　姓名　　字符串类型
　　　　年龄　　整型
　　　　性别　　字符型
　　　　成绩　　实型数组
　　Pascal给我们提供了一种叫做记录的结构类型。在一个记录中，可以包含不同类型的并且互相相关的一些数据。

　　（一）记录类型的定义
　　在pascal中，记录由一组称为"域"的分量组成，每个域可以具有不同的类型。
　　记录类型定义的一般形式：
　　record
　　 <域名1>:<类型1>;
　　 <域名2>:<类型2>;
　　　: :
　　　: :
　　　<域名n>:<类型n>;
　　end;
　　说明：①域名也称域变量标识符， 应符合标识符的语法规则。在同一个记录中类型中，各个域不能取相同的名，但在不同的记录类型中，两个类型中的域名要以相同。
　　②记录类型的定义和记录变量可以合并为一个定义，如：
　　type date=record
　　　　　　year:1900..1999;
　　　　　　month:1..12;
　　　　　　day:1..31
　　　　　end;
　　var x:date;
　　可以合并成:
　　var x: record
　　　　　　year:1900..1999;
　　　　　　month:1..12;
　　　　　　day:1..31
　　　　　end;
　　③对记录的操作,除了可以进行整体赋值， 只能对记录的分量──域变量进行。
　　④域变量的表示方法如下：
　　记录变量名.域名
　　如前面定义的记录X,其3个分量分别为:x.year ，x.month ，x.day。
　　⑤域变量的使用和一般的变量一样, 即域变量是属于什么数据类型，便可以进行那种数据类型所允许的操作。

　　（二）记录的嵌套
　　当一个记录类型的某一个域类型也是记录类型的时候，我们说发生了记录的嵌套，看下面的例子：
　　例6 某人事登记表可用一个记录表示, 其中各项数据具有不同的类型，分别命名一个标识符。而其中的"出生年月日"又包括三项数据，还可以用一个嵌套在内层的记录表示。
　　具体定义如下:
　　type　sexs=(male,female);
　　　　　date=record
　　　　　　year:1900..1999;
　　　　　　month:1..12;
　　　　　　day:1..31;
　　　　　end;
　　personal=record
　　　　　　name:string[15];
　　　　　　sex:sexs;
　　　　　　birthdate:date;
　　　　　　home:string[40];
　　　　　end;

　　例7 设计一个函数比较两个dates日期类型记录变量的迟早。
　　设函数名、形参及函数类型定义为：
　　AearlyB(A,B:dates):boolean;
　　函数的形参为两个dates类型的值参数。当函数值为true 时表示日期A早于日期B,否则日期A迟于日期B或等于日期B。显然不能对Ａ、Ｂ两个记录变量直接进行比较，而要依具体的意义逐域处理。
　　源程序如下：
　　program ex6_7;
　　type dates=record
　　　　　　year:1900.1999;
　　　　　　month:1..12;
　　　　　　day:1..31
　　　　　end;
　　var x,y:dates;
　　function AearlyB(A,B:dates):boolean;
　　var earln:boolean;
　　begin
　　　early:=false;
　　　if (A.year<B.year) then early:=true;
　　　if (A.year=B.year)and(A.month<B.month)
　　　then early:=true;
　　　if (A.year=B.year)and(A.month=B.month)and(A.day<B.day)
　　　then early:=true;
　　　AearlyB:=early;
　　　end;{of AearlyB}
　　begin
　　　write('Input DATE X(mm-dd-yy):')readln(X.month,X.day,X.year);
　　　write('Input DATE Y(mm-dd-yy):')readln(Y.month,Y.day,Y.year);
　　　if AearlyB(X,Y) then writeln(Date X early!') else writeln('Date X not 　　　early!');
　　end.

　　（三）开域语句
　　在程序中对记录进行处理时，经常要引用同一记录中不同的域，每次都按6.4.1节所述的格式引用，非常乏味。为此Pascal提供了一个with语句，可以提供引用域的简单形式。
　　开域语句一般形式:
　　with <记录变量名表> do
　　<语句>
　　功能: 在do后的语句中使用with后的记录的域时, 只要直接写出域名即可，即可以省略图10.2.2中的记录变量名和"."。
　　说明: ①一般在with后只使用一个记录变量名。如：
　　write('Input year:');
　　readln(x.year);
　　write('Input month:');
　　readln(x.month);
　　write('Input day:');
　　readln(x.day);
　　可以改写成:
　　with x do
　　　begin
　　　　write('Input year:');readln(year);
　　　　write('Input month:');readln(month);
　　　　write('Input day:');readln(day);
　　　end;
　　②设x,y是相同类型的记录变量，下列语句是非法的：
　　　　with x,y do...;
　　③with后接若干个记录名时,应是嵌套的关系。如有记录说明：
　　　　var x:record
　　　　　　i:integer;
　　　　　　y:record
　　　　　　　　j:0..5;
　　　　　　　　k:real;
　　　　　　　end;
　　　　　　m:real
　　　　　end;
　　可以使用:
　　with x do
　　begin
　　　　read(i);
　　　　with y do
　　　　　　read(j,k);
　　　　readln(m);
　　end;
　　或简写为:
　　with x,y do
　　readln(i,j,k,m);

　　例8 读入10个日期，再对每个日期输出第二天的日期。输入日期的格式是月、日、年，如9□30□1993，输出的格式为10/1/1993。
　　分析: 可用一个记录变量today表示日期。 知道一个日期后要更新为第二天的日期，应判断输入的日期是否为当月的最后一天，或当年的最后一天。
　　源程序如下:
　　program ex6_8;
　　　type date=record
　　　　　　　　month:1..12;
　　　　　　　　day:1..31;
　　　　　　　　year:1900..1999;
　　　　　　　end;
　　　var today:array[1..10]of date;
　　　　　　i:integer;
　　　　　　maxdays:28..31;

　　　begin
　　　　for i:=1 to 10 do {输入10个日期}
　　　　　with today[i] do
　　　　　　readln(month,day,year);
　　　　for i:=1 to 10 do
　　　　　with today[i] do{求第i个日期中月份最后一天maxdays}
　　　　　　begin　　
　　　　　　　case month of
　　　　　　　　1,3,5,7,8,10,12:maxdays:=31;
　　　　　　　　4,6,9,11 :maxdays:=30;
　　　　　　　　2　　　　 :if(year mod 400=0) or( year mod 4=0)
　　　　　　　　　　　　　　and(year mod 100<>0)
　　　　　　　　　　　　　then maxdays:=29
　　　　　　　　　　　　　else maxdays:=28;
　　　　　　　end;
　　　　　　　if day=maxdays
　　　　　　　　then begin
　　　　　　　　　　day:=1;　　
　　　　　　　　　　if month=12
　　　　　　　　　　　then begin
　　　　　　　　　　　　　　　　month:=1;year:=year+1;
　　　　　　　　　　　　　　end
　　　　　　　　　　　　else month:=month+1;
　　　　　　　　　　end
　　　　　　 　　else day:=day+1;
　　　　　　　writeln(month,'/',day,'/',year);
　　　　　end;
　　end.

五、应用实例

　　例9 编制用筛法求1-n(n≤200)以内素数的程序。
　　分析: 由希腊著名数学家埃拉托色尼提出的所谓"筛法"，步骤如下：
　　　　　①将所有候选数放入筛中；
　　　　　②找筛中最小数（必为素数）next，放入集合primes中；
　　　　　③将next的所有倍数从筛中筛去；
　　　　　④重复②～④直到筛空。
　　编程时，用集合变量sieve表示筛子，用集合primes存放所有素数。
　　源程序如下：
　　program ex10_3;
　　const n=200;
　　var sieve,primes:set of 2..n;
　　　　next,j:integer;
　　begin
　　　　sieve:=[2..n];{将所有候选数放入筛中}
　　　　primes:=[];{素数集合置空}
　　　　next:=2;
　　　　repeat
　　　　　{找筛sieve中最小一个数}
　　　　　while not(next in sieve) and(next<=n)do
　　　　　　next:=succ(next);
　　　　　primes:=primes+[next];{将最小数放入素数集合中}
　　　　　{将这个素数的倍数从筛中删去}
　　　　j:=next;
　　　　while j<=n do
　　　　　begin
　　　　　　sieve:=sieve-[j];
　　　　　　j:=j+next;
　　　　　end
　　　　until sieve=[];
　　　　j:=0;
　　　　for next:=2 to n do{打印出所有素数}
　　　　　if next in primes then
　　　　　begin
　　　　　　write(next:5);
　　　　　　j:=j+1;
　　　　　　if j mod 10=0 then writeln;
　　　　　end;
　　　　writeln;
　　end.

练习

　　1．一家水果店出售四种水果，每公斤的价格是：苹果1.50元，桔子1.80元，香蕉2.0，菠萝1.60元。编一个程序，使售货员只要从键盘输入货物的代码及重量，计算机便能显示货物的名称、单价、重量及总价。

　　2．输入一个英语句子，以句号．为结束标志， 统计句子中元音字母出现的次数，把句子所有辅音字母组成一个集合，并把这些辅音字母打印出来。

　　3．编程序建立某班25人的数学课程成绩表，要求用数组类型和记录类型，其成绩表格式如下：
　　　　姓名　　性别　　平时成绩　　期中考试　　期终考试　　总评成绩
　　　　张良　　男　　　 　90 　　　　85 　　　　92 　　　　　?
　　　　王心　　男　　　 　70 　　　　82 　　　　71 　　　　　?
　　　　……
　　　　李英　　女　　　 　82 　　　　84 　　　　75 　　　　　?
　　其中总评成绩=平时成绩×20％＋期中考试×30％＋期终考试×％50。

4． 输入五个学生的出生日期(月/日/年)和当天的日期,然后用计算机计算出每个人到当天为止的年龄各是多少?（如某人1975年10月1日出生,今天是94年12月1日,则他的年龄应为19岁,而另一人的出生日期为76年12月30日,则他的年龄为17岁。）

第十二课过程与函数

前面我们曾经学习了程序设计中的三种基本控制结构（顺序、分支、循环）。用它们可以组成任何程序。但在应用中，还经常用到子程序结构。
　　通常，在程序设计中，我们会发现一些程序段在程序的不同地方反复出现，此时可以将这些程序段作为相对独立的整体，用一个标识符给它起一个名字，凡是程序中出现该程序段的地方，只要简单地写上其标识符即可。这样的程序段，我们称之为子程序。
　　子程序的使用不仅缩短了程序，节省了内存空间及减少了程序的编译时间，而且有利于结构化程序设计。因为一个复杂的问题总可将其分解成若干个子问题来解决，如果子问题依然很复杂，还可以将它继续分解，直到每个子问题都是一个具有独立任务的模块。这样编制的程序结构清晰，逻辑关系明确，无论是编写、阅读、调试还是修改，都会带来极大的好处。
　　在一个程序中可以只有主程序而没有子程序(本章以前都是如此)，但不能没有主程序，也就是说不能单独执行子程序。pascal中子程序有两种形式：函数和过程。

一、函数
　　在此之前，我们曾经介绍并使用了pascal提供的各种标准函数，如ABS,SUCC等等，这些函数为我们编写程序提供了很大的方便。但这些函数只是常用的基本函数，编程时经常需要自定义一些函数。
　　（一）函数的说明
　　在pascal中，函数也遵循先说明后使用的规则，在程序中，函数的说明放在调用该函数的程序（主程序或其它子程序）的说明部分。函数的结构主程序的结构很相似。
　　函数定义的一般格式:
　　function <函数名> (<形式参数表>):<类型>; {函数首部}
　　

　　说明:
　　①函数由首部与函数体两部分组成。
　　②函数首部以关键字function开头。
　　③函数名是用户自定义的标识符。
　　④函数的类型也就是函数值的类型，所求得的函数值通过函数名传回调用它的程序。可见，函数的作用一般是为了求得一个值。
　　⑤形式参数简称形参，形参即函数的自变量。自变量的初值来源于函数调用。在函数中，形参一般格式如下：
　　变量名表1：类型标识符1；变量名表2：类型标识符2；…;变量名表n：类型标识符n
　　可见形参表相当于变量说明，对函数自变量进行说明，但应特别注意：此处只能使用类型标识符，而不能直接使用类型。
　　⑥当缺省形参表（当然要同时省去一对括号）时，称为无参函数。
　　⑦函数体与程序体基本相似，由说明部分和执行部分组成。
　　⑧函数体中的说明部分用来对本函数使用的标号、常量、类型、变量、子程序加以说明，这些量只在本函数内有效。
　　⑨函数体的执行部分由begin开头，end结束，中间有若干用分号隔开的语句，只是end后应跟分号,不能像程序那样用句号"."。
　　⑩在函数体的执行部分，至少应该给函数名赋一次值，以使在函数执行结束后把函数值带回调用程序。

　　（二）函数的调用
　　我们可以在任何与函数值类型兼容的表达式中调用函数，或者说，函数调用只能出现在允许表达式出现的地方，或作为表达式的一个因子。
　　函数调用方式与标准函数的调用方式相同。
　　函数调用的一般格式：
　　　　＜函数名＞
　　　　或
　　　　＜函数名＞（实在参数表）
　
　　说明：①实在参数简称实参。实参的个数必须与函数说明中形参的个数一致，实参的类型与形参的类型应当一一对应。
　　②调用函数时，一般的，实参必须有确定的值。
　　③函数调用的步骤为：计算实参的值，"赋给"对应的形参；

　　（三）函数的应用举例
　　例1 求正整数A和B之间的完全数(A<B).
　　分析：所谓完全数是指它的小于该数本身的因子之和等于它本身，如6＝1＋2＋3，6即是一个完全数。因此我们可定义一个布尔型函数perfect(x),若x是完全数,其值为TURE,否则为FALSE。整个程序算法如下：
　　1 for i:=A to B do
　　2 if perfect(i) then writeln(i);
　　源程序如下：
　　program ex7_1;
　　var
　　　　i,a,b : integer;
　　function perfect(x:integer):boolean;
　　var
　　　　k,sum : integer;
　　begin
　　　{累加x所有小于本身的因数}
　　　sum:=1;
　　　for k:=2 to x p 2 do
　　　　if x mod k=0 then sum:=sum+k;
　　　{判断x是否是完全数}
　　　perfect:=x=sum; {将结果赋值给函数名}
　　end;{end of perfect}
　　begin{主程序开始}
　　　write('Input a,b:');
　　　repeat {输入0<a<b}
　　　　readln(a,b);
　　　until (a>0)and(b>0)and(a<b);
　　　writeln('List of all perfect numbers:');
　　　{从a到b逐个判断,是完全数则打印出来
　　　for i:=a to b do
　　　　　　　　　　　　
　　　　if perfect(i) then writeln(i);
　　end.
　　自定义函数只是主程序的说明部分，若主程序中没有调用函数，则系统不会执行函数子程序。当主程序调用一次函数时，则将实在参数的值传给函数的形式参数，控制转向函数子程序去执行，子程序执行完毕后自动返回调用处。

二、过程
　　在pascal中,自定义过程与自定义函数一样,都需要先定义后调用。函数一般用于求值，而过程一般实现某些操作。

　　（一）过程的说明
　　过程说明的一般格式为：
　　procedure <过程名> (<形式参数表>); {过程首部}
　　

　　说明: ①过程首部以关键字procedure开头。
　　②过程名是用户自定义的标识符，只用来标识一个过程，不能代表任何数据，因此不能说明"过程的类型"。
　　③形参表缺省（当然要同时省去一对括号）时，称为无参过程。
　　④形参表的一般格式形式如下：
　　　　[var] 变量名表：类型；…；[var] 变量名表：类型。
　　其中带var的称为变量形参，不带var的称为值形参。在函数中，形参一般都是值形参，很少用变量形参（但可以使用）。例如，下列形参表中：
　　　　(x,y:real;n:integer;var w:real;var k:integer;b:real)
　　x、y、n、b为值形参,而w、k为变量形参。
　　调用过程时，通过值形参给过程提供原始数据，通过变量形参将值带回调用程序。因此，可以说，值形参是过程的输入参数，变量形参是过程的输出参数。有关变参，这在后面内容具体叙述。
　　⑤过程体与程序、函数体类似。与函数体不同的是：函数体的执行部分至少有一个语句给函数名赋值，而过程体的执行部分不能给过程名赋值，因为过程名不能代表任何数据。
　　⑥过程体的说明部分可以定义只在本过程有效的标号、常量、类型、变量、子程序等。

　　（二）过程的调用
　　过程调用是通过一条独立的过程调用语句来实现的，它与函数调用完全不同。过程调用与调与标准过程（如write,read等）的方式相同。调用的一般格式为：
　　＜过程名＞　
　　或
　　＜过程名＞（实在参数表）

　　说明: ①实参的个数、类型必须与形参一一对应。
　　②对应于值形参的实参可以是表达式，对应于变量形参的实参只能是变量。
　　③过程调用的步骤为：计算实参的值；将值或变量的"地址"传送给对应的形参；执行过程体；返回调用处。
　　过程与函数有下列主要区别：
　　①过程的首部与函数的首部不同；
　　②函数通常是为了求一个函数值，而过程可以得到若干个运算结果，也可用来完成一系列的数据处理，或用来完成与计算无关的各种操作；
　　③调用方式不同。函数的调用出现在表达式中，而过程调用是一个独立的语句。

　　（三）过程的应用举例
　　例2 输出以下一个图形:
　　　　*
　　　　**
　　　　***
　　　　****
　　　　*****
　　　　******
　　分析：我们前面学习可用的二重循环打印出上图形, 现我们设置一个过程打印出N个连续的"*"号。
　　源程序如下：
　　program ex7_2;
　　　var i:integer;
　　　procedure draw_a_line(n:integer); {该过程打印出连续n 个星号,并换行}
　　　　var j:integer;
　　　　begin
　　　　　for j:=1 to n do
　　　　　　write('*');
　　　　　writeln;
　　　　end;
　　begin
　　　for i:=1 to 6 do
　　　　draw_a_line(i);{调用过程,第I行打印i个连续星号}
　　end.

三、过程、函数的数据传递
　　在程序调用子程序时，调用程序将数据传递给被调用的过程或函数，而当子程序运行结束后，结果又可以通过函数名、变参。当然也可以用全局变量等形式实现数据的传递。这一节我们，就来研究参数传递与局部变量、全局变量等问题。

　　（一）数值参数和变量参数
　　前面已经讲过，pascal子程序中形式参数有数值形参（简称值参）和变量形参（变参）两种。事实上，还有函数形参和过程形参两种，只是应用并不太多，我们不作深入地研究。

　　1、值形参
　　值参的一般格式如§7.1.1所示。应该强调的是：
　　①形参表中只能使用类型标识符，而不能使用类型。
　　②值形参和对应的实参必须一一对应，包括个数和类型。
　　③实参和值形参之间数据传递是单向的，只能由实参传送给形参，相当赋值运算。
　　④一个特殊情况是，当值形参是实型变量名时，对应的实参可以是整型表达式。
　　⑤值形参作为子程序的局部量，当控制返回程序后，值形参的存储单元释放。

　　2、变量形参
　　变量形参的一般格式如§7.2.1所示，必须在形参前加关键字var。
　　应该注意的是：
　　①与变量形参对应的实参只能是变量名，而不能是表达式。
　　②与变量形参对应的实参可以根据需要决定是否事先有值。
　　③变量形参与对应的实参的类型必须完全相同。
　　④对变量形参，运行时不另外开辟存储单元，而是与对应的实参使用相同的存储单元。也就是说，调用子程序时，是将实参的地址传送给对应的变量形参。
　　⑤当控制返回到调用程序后，变量形参的存储单元不释放，但变量形参本身无定义，即不得再使用。
　　⑥选用形式参时，到底是使用值形参还是变量形参，应慎重考虑。值形参需要另开辟存储空间，而变量形参会带来一些副作用。一般在函数中使用值形参，而在过程中才使用变量形参，但也有例外。

　　例3 写出下列两个程序的运行结果。
　　program ex1; 　　　　　　　　　　　program ex2;
　　　var a,b:integer; 　　　　　　　　　var a,b:integer;
　　　procedure swap(x,y:integer); 　　　procedure swap(Var x,y:integer) ;
　　　　var t:integer; 　　　　　　　　　　　var t:integer;
　　　　begin 　　　　　　　　　　　　　　　　begin
　　　　　t:=x;x:=y;y:=t; 　　　　　　　　　　　t:=x;x:=y;y:=t;
　　　　end; 　　　　　　　　　　　　　　　　　end;
　　　begin 　　　　　　　　　　　　　　　　　begin
　　　　a:=1;b:=2; 　　　　　　　　　　　　　　a:=1;b:=2;
　　　　writeln(a:3,b:3); 　　　　　　　　　　　writeln(a:3,b:3);
　　　　swap(a,b);　　　　　　　　　　　　　　　　swap(a,b);
　　　　writeln(a:3,b:3); 　　　　　　　　　　　　writeln(a:3,b:3);
　　　end. 　　　　　　　　　　　　　　　　　　end.

　　分析：这两个程序唯一的区别是ex1中将x,y作为值形参，而 ex2中将x,y作为变量形参，因此在ex2中对x,y的修改实际上是对调用该过程时与它们对应的变量a,b的修改，故最后，a,b的值为2，1。而ex1中调用swap过程时，只是将a,b的值传递给x,y，之后在过程中的操作与a,b无关。
　　答：ex1的运行结果为: ex2的运行结果为:
　　　　　　1 2 　　　　　　　　1 2
　　　　　　1 2 　　　　　　　　2 1

　　（二）全程变量、局部变量及它们的作用域
　　在主程序的说明部分和子程序的说明部分均可以说明变量，但它们的作用范围是特定的。

　　1、局部量及其作用域
　　在介绍过程和函数的说明时，我们曾指出，凡是在子程序内部作用的变量，应该在本子程序内加以说明。这种在子程序内部说明的变量称为局部变量。形式参数也只是在该子程序中有效，因此也属于局部变量。
　　一个变量的作用域是指在程序中能对此变量进行存取的程序范围。因此，局部变量的作用域就是其所在的子程序。实际上，局部变量只是当其所在的子程序被调用时才具有确定的存储单元，当控制从子程序返回到调用程序后，局部变量的存储单元就被释放，从而变得无定义。
　　事实上，在子程序内定义的标号、符号常量、类型、子程序也与局部变量具有相同的作用域。

　　2、全程量及其作用域
全程量是指在主程序的说明部分中说明的量。全程量的作用域分两种情况：
　　①当全程量和局部量不同名时，其作用域是整个程序范围（自定义起直到主程序结束）。
　　②当全程量和局部量同名时，全程量的作用域不包含局部量的作用域。

　　例4 写出下列程序的运行结果:
　　program ex7_4;
　　　var x,y:integer;
　　　procedure a;
　　　　var x:integer;
　　　　begin
　　　　　x:=2;
　　　　　writeln('#',x,'#');
　　　　　writeln('#',y,'#');
　　　　end;{of a}
　　　begin{main program}
　　　　x:=1;y:=2;
　　　　writeln('*',x,'*'，y);
　　　　a;
　　　　writeln('***',x,'***',y);
　　　end.
　　分析：程序中x,y是全局变量,但在过程a中也有变量x，故全程变量x的作用域为除过程a外的任何地方。而y的作用域包含了子程序a，即整个程序。
　　答：运行结果如下:
　　　　*1*2
　　　　#2#
　　　　#2#
　　　　***1***2
　　评注：变量作用域内对变量的操作都是对同一存储单元中的量进行的。

四、过程和函数的嵌套
　　Pascal语言中，使用过程和函数，能使程序设计简短，便于阅读，节省存贮单元和编译时间。程序往往设计成分层结构，由一个主程序和若干个过程及函数组成。在过程或函数中，还可以说明另一些过程或函数，即过程或函数可以分层嵌套。在同一层中亦可说明几个并列的过程或函数。例如：
　　

　　上例过程的分层嵌套关系如下：0层主程序sample内并列两个1层过程P1a和P1b。过程P1a又嵌套两个2层过程p2a和p2b，2层的第二过程p2b又嵌套过程p3，p3就是第3层。其中p1b,p2a和p3不再嵌套别的过程，称为基本过程。这种分层结构的程序设计，特别要注意局部变量的使用范围和过程调用的要求。
　　在主程序sample中定义的变量,可以在所有的过程中使用,主程序可调用p1a和p1b两个过程。过程p1a中定义的变量,只能在p2a,p2b 和p3中使用。它能调用p2a,p2b两个过程,而不能调用p3和p1b。 在过程p1b中定义的变量,只能在p1b中使用,它只能调用过程p1a。过程p2a不能调用任何过程。过程p2b可以调用并列过程p2a和p3，而过程p3可以调用p2a过程。
　　过程调用是有条件的，过程定义在先，调用在后。同一层过程，后说明的过程可以调用先说明的过程。如果要调用在它后面定义的过程（或函数），可使用<向前引用>FORWARD这个扩充标识符。 要注意的是<向前引用>过程(或函数)首部中形式参数表写一次即可, 不必重复。如：
　　procedure extend(var a,b:integer);
　　forward;
　　表示过程extend<向前引用>。因此,过程extend 的说明部分只须如下书写:
　　procedure extend;
　　<说明部分>
　　begin
　　:
　　end;

五、子程序（模块化）结构的程序设计

　　例5 对6到60的偶数验证哥德巴赫猜想：不小于6的偶数可分解成两个素数之和。
　　分析：用布尔型函数prime(x)判断x是否是素数,若是, 函数值为真，否则，函数值为假。算法如下所示。
　　1． t:=6
　　2． while t≤60 do
　　3． t11;
　　4． repeat
　　5． t11+2; /* 找下一个素数a */
　　6． until prime(t1)and prime(t-t1); /*直到a,b都是素数*/
　　7． writeln(i,'=',t1,'+',t-t1);
　　8． tt+2;
　　9． endwhile

　 源程序如下:
　　program ex9_7;
　　　var t,t1:integer;
　　　function prime(x:integer):boolean;
　　　　var i:integer;
　　　　begin
　　　　　if x=1
　　　　　　then prime:=false
　　　　　　else if x=2
　　　　　　　　　　then prime:=true
　　　　　　　　　　else begin
　　　　　　　　　　　　　　prime:=true;
　　　　　　　　　　　　　　i:=2;
　　　　　　　　　　　　　　while (i<=round(sqrt(x)))and(x mod i<>0) do
　　　　　　　　　　　　　　　i:=i+1;
　　　　　　　　　　　　　　　if i<=round(sqrt(x)) then prime:=false;
　　　　　　　　　　　　　end;
　　　　　end;{of prime}

　　　　begin
　　　　　t:=6;
　　　　　while t<=60 do
　　　　　　begin
　　　　　　　t1:=1;
　　　　　　　repeat
　　　　　　　　t1:=t1+2;
　　　　　　　until prime(t1) and prime(t-t1);
　　　　　　　writeln(t,'=',t1,'+',t-t1);
　　　　　　　t:=t+2;
　　　　　　end;
　　　end.

　　例6 编写一个给一个分数约分的程序。
　　源程序如下：
　　program ex7_6;　　　┌──变量参数
　　　 var a,b:integer; ↓
　　　　procedure common(var x,y:integer);
　　　　　var i,j,k:integer;
　　　　　begin
　　　　　　{求x,y的最大公约数}
　　　　　　i:=x;j:=y;
　　　　　　repeat
　　　　　　　k:=i mod j;
　　　　　　　i:=j;j:=k;
　　　　　　until k=0;
　　　　　　　{对x,y进行约分}
　　　　　　　　x:=x p i;y:=y p i;
　　　　　　end;
　　　　　begin
　　　　　　　write('Input a,b=');readln(a,b);
　　　　　　　common(a,b);
　　　　　　　writeln(a,b:5);
　　　　　　end.
　　如输入:
　　Input a,b=12 8
　　则输出:
　　3 2

练习

　　1． 输入5个正整数求它们的最大公约数。（提示：可用一个数组将５个数存放起来，然后求第一个数和第二个数的公约数，再求第三个数与前两个数公约数的公约数，这样求得前三个整数最大公约数……如此类推可求出５个整数的最大公约数）

　　2． 给一维数组输入任意6个整数,假设为:
　　　　　　7 4 8 9 1 5
　　　　请建立一个具有以下内容的方阵：
　　　　　　7 4 8 9 1 5
　　　　　　4 8 9 1 5 7
　　　　　　8 9 1 5 7 4
　　　　　　9 1 5 7 4 8
　　　　　　1 5 7 4 8 9
　　　　　　5 7 4 8 9 1
　　　　(请用子程序编写)。

　　3． 求两个正整数的最小公倍数。

　　4． 输入一个任意位的正整数,将其反向输出。

　　5． 有五位同学,其各科成绩如下:
　　　　学号 数学 语文 英语 总分 名次
　　　　 1　 108　 97　90
　　　 　2　 98　　88　100
　　　　 3 　100 　43　89
　　　　 4 　84 　 63　50
　　　　 5 　97 　 87　100
　　（１）编写一个过程enter,输入每个学生成绩并计算各人的总分。
　　（２）编写过程minci,用以排出每个人的名次。
　　（３）按学号顺序输出。

第十三章　动态数据类型

前面介绍的各种简单类型的数据和构造类型的数据属于静态数据。在程序中，这些类型
的变量一经说明，就在内存中占有固定的存储单元，直到该程序结束。
　　程序设计中，使用静态数据结构可以解决不少实际问题，但也有不便之处。如建立一个
大小未定的姓名表，随时要在姓名表中插入或删除一个或几个数据。而用新的数据类型──
指针类型。通过指针变量，可以在程序的执行过程中动态地建立变量，它的个数不再受限制，
可方便地高效地增加或删除若干数据。

一、指针的定义及操作

　　（一）指针类型和指针变量

　　在pascal中,指针变量(也称动态变量)存放某个存储单元的地址；也就是说， 指针变量
指示某个存储单元。
　　指针类型的格式为:＾基类型

　　说明: ①一个指针只能指示某一种类型数据的存储单元，这种数据类型就是指针的基类
型。基类型可以是除指针、文件外的所有类型。例如，下列说明：
　　type pointer=^Integer;
　　　　　　　　var p1,p2:pointer;
　　定义了两个指针变量p1和p2，这两个指针可以指示一个整型存储单元(即p1、p2 中存放的是某存储单元的地址，而该存储单元恰好能存放一个整型数据)。

　　②和其它类型变量一样，也可以在var区直接定义指针型变量。
　　例如：var a:^real; b:^boolean;
　　又如：type person=record
　　　　　　　　　　　name:string[20];
　　　　　　　　　　　sex:(male,female);
　　　　　　　　　　　age:1..100
　　　　　　　　　　end;
　　　　　var pts:^person;

　　③pascal规定所有类型都必须先定义后使用，但只有在定义指针类型时可以例外，如下
列定义是合法的：
　　type pointer=^rec;
　　　　　　rec=record
　　　　　　　　a:integer;
　　　　　　　　b:char
　　　　　　　end;

　　（二）开辟和释放动态存储单元

　　1、开辟动态存储单元
　　在pascal中，指针变量的值一般是通过系统分配的，开辟一个动态存储单元必须调用标
准过程new。
　　new过程的调用的一般格式:
　　New(指针变量)
　　功能：开辟一个存储单元，此单元能存放的数据的类型正好是指针的基类型，并把此存
储单元的地址赋给指针变量。

　　说明：①这实际上是给指针变量赋初值的基本方法。例如，设有说明：var p:^Integer;
这只定义了P是一个指示整型存储单元的指针变量，但这个单元尚未开辟，或者说P中尚未有值（某存储单元的首地址）。当程序中执行了语句new(p)才给ｐ赋值，即在内存中开辟（分配）一个整型变量存储单元，并把此单元的地址放在变量ｐ中。示意如下图：

　　
　　(a)编译时给 　(b)执行New(p)后 　(c)(b)的简略表示
　　　p分配空间 　　　生成新单元
　　?表示值不定 　新单元的地址为XXXX
　　　　　　　　　　内存单元示意图

　　②一个指针变量只能存放一个地址。如再一次执行New(p)语句，将在内存中开辟另外一个新的整型变量存储单元，并把此新单元的地址放在ｐ中，从而丢失了原存储单元的地址。
　　③当不再使用ｐ当前所指的存储单元时，可以通过标准过程Dispose释放该存储单元。

　　⒉释放动态存储单元
　　dispose语句的一般格式:dispose(指针变量)
　　功能：释放指针所指向的存储单元，使指针变量的值无定义。

　　（三）动态存储单元的引用

　　在给一个指针变量赋以某存储单元的地址后，就可以使用这个存储单元。
　　引用动态存储单元一般格式：＜指针变量＞＾

　　说明：①在用New过程给指针变量开辟了一个它所指向的存储单元后，要使用此存储单元的唯一方法是利用该指针。
　　②对动态存储单元所能进行的操作是该类型（指针的基类型）所允许的全部操作。

　　例1 设有下列说明:
　　var p:^integer; i:integer;
　　画出执行下列操作后的内存示意图：
　　　　New(p); P^:=4;i:=p^;

　　解: 如下图所示。
　　　
　　　(a)编译时 (b)执行New语句 　　(c)执行P^:=4 　　(d)执行i:=P^
　　　　分配存储
　　　　　单元
　　　　　　　　　　　　　　　　　内存单元示意图

　　（四）对指针变量的操作

　　前已述及，对指针所指向的变量（如Ｐ＾）可以进行指针的基类型所允许的　全部操作。
对指针变量本身，除可用New、Dispose过程外，尚允许下列操作：

　　⒈具有同一基类型的指针变量之间相互赋值

　　例2 设有下列说明与程序段:
　　var p1,p2,p3:^integer;
　　begin
　　 New(P1) ; New(P2); New(P3);
　　　P1:=P2; P2:=P3;
　　end;

　　2、可以给指针变量赋nil值
　　nil是PASCAL的关键字，它表示指针的值为"空"。例如，执行：
　　p1:=ni1后，p1的值是有定义的，但p1不指向任何存储单元。

　　3、可以对指针变量进行相等或不相等的比较运算
　　在实际应用中，通常可以在指针变量之间，或指针变量与nil之间进行相等(＝)或不相等(＜＞＝的比较，比较的结果为布尔量。

　　例3 输入两个整数，按从小到大打印出来。
　　分析：不用指针类型可以很方便地编程，但为了示例指针的用法，我们利用指针类型。定义一个过程swap用以交换两个指针的值。

　　源程序如下：
　　Type pointer=^integer;
　　var p1,p2:pointer;
　　procedure swap(var q1,q2:pointer);
　　　var q:pointer;
　　　begin
　　　　q:=q1;
　　　　q1:=q2;
　　　　q2:=q;
　　　end;
　　begin
　　　new(p1);new(p2);
　　　write('Input 2 data:');readln(pq^,p2^);
　　　if p1^>p2^ then swap(p1,p2);
　　　writeln('Output 2 data:',p1^:4,p2^:4);
　　end.

　　二、链表结构

　　设有一批整数(12，56，45，86，77，……，)，如何存放呢? 当然我们可以选择以前学过的数组类型。但是，在使用数组前必须确定数组元素的个数。如果把数组定义得大了，就会有大量空闲存储单元，定义得小了，又会在运行中发生下标越界的错误，这是静态存储分配的局限性。
　　利用本章介绍的指针类型可以构造一个简单而实用的动态存储分配结构――链表结构。
　　下图是一个简单链表结构示意图：
　　

　　其中：①每个框表示链表的一个元素，称为结点。
　　②框的顶部表示了该存储单元的地址(当然，这里的地址是假想的)。
　　③每个结点包含两个域：一个域存放整数，称为数据域，另一个域存放下一个结点(称为该结点的后继结点，相应地，该结点为后继结点的前趋结点)的地址。
　　④链表的第一个结点称为表头，最后一个结点表尾，称为指针域；
　　⑤指向表头的指针head称为头指针(当head为nil时，称为空链表)，在这个指针变量中 存放了表头的地址。
　　⑥在表尾结点中，由指针域不指向任何结点，一般放入nil。

　　（一）链表的基本结构

　　由上图可以看出：
　　①链表中的每个结点至少应该包含两个域；一是数据域，一是指针域。因此，每个结点都是一个记录类型，指针的基类型也正是这个记录类型。因此，head可以这样定义：
　　type pointer=^ rec；
　　　rec=record
　　　　　　data：integer;
　　　　　　next:pointer;
　　　　　end;
　　　var head:pointer;
　　②相邻结点的地址不一定是连续的。整个链表是通过指针来顺序访问的，一旦失去了一个指针值，后面的元素将全部丢失。
　　③与数组结构相比，使用链表结构时；可根据需要采用适当的操作步骤使链表加长或缩 短，而使存储分配具有一定的灵活性。这是链表结构的优点。
　　④与数组结构相比，数组元素的引用比较简单，直接用"数组名[下标]"即可，因为数组元素占用连续的存储单元，而引用链表元素的操作却比较复杂。

　　（二）单向链表的基本操作

　　上图所示的链表称为单向链表。下面我们通过一些例题来说明对单向链表的基本操作，并假设类型说明如前所述。

　　例6 编写一个过程，将读入的一串整数存入链表， 并统计整数的个数。
　　分析：过程的输入为一串整数，这在执行部分用读语句完成。过程的输出有两个：一是链表的头指针，一是整数的个数，这两个输出可以用变量形参来实现。
　　由于不知道整数的个数，我们用一个特殊的9999作为结束标记。

　　过程如下：
　　procedure creat(var h:pointer;var n:integer);
　　var p,q:pointer;x:integer;
　　begin
　　　　n:=0;h:=nil; read(x);
　　　　while x<>9999 do
　　　　begin
　　　　　New(p);
　　　　　n:=n+1;p^.data:=x;
　　　　　if n=1 then h:=p
　　　　　else q^.next:=p;
　　　　　q:=p;read(x)
　　　　end;
　　　　if h<>nil then q^.next:=nil;
　　　　Dispose(p);
　　end;

　　例7 编一过程打印链表head中的所有整数,5个一行。
　　分析：设置一个工作指针P,从头结点顺次移到尾结点，每移一次打印一个数据。

　　过程如下：
　　procedure print(head:pointer);
　　var p:pointer; n:integer;
　　begin
　　　n:=0;p:=head;
　　　while p<>nil do
　　　　begin
　　　　　write(p^.data:8);n:=n+1;
　　　　　if n mod 5=0 then writeln;
　　　　　p:=p^.next;
　　　　end;
　　　writeln;
　　end;

　　（三）链表结点的插入与删除

　　链表由于使用指针来连接，因而提供了更多了灵活性，可以插入删除任何一个成分。
　　设有如下定义：
　　type pointer=^rec;
　　rec=record
　　　　data:integer;
　　　　next:pointer
　　　end;
　　var head:pointer;

　　⒈结点的插入
　　如下图所示,要在P结点和Q结点之间插入一个结点m,其操作如下:
　　　

　　只要作如下操作即可:
　　　New(m);
　　　read(m^.data);
　　　m^.next:=q;
　　　p^.next:=m; 

　　例8 设链表head中的数据是按从小到大顺序存放的，在链表中插入一个数，使链表仍有序。
　　分析：显然，应分两步：查找、插入。设ｐo指向要插入的结点，若仅知道ｐo应插在ｐ之前（作为ｐ的前趋结点）是无法插入的，应同时知道ｐ的前趋结点地址ｑ。
　　当然，如果插在链表原头结点这前或原链表为空表或插在原尾结点之后，则插入时又必须作特殊处理。

　　过程如下：
　　procedure inserting(var head:pointer;x:integer);
　　var po,p,q:pointer;
　　begin
　　　new(po);po^.data:=x;
　　　p:=head;
　　　if head=nil{原表为空表}
　　　　then begin
　　　　　head:=po;po^.next:=nil;
　　　　end
　　　else begin
　　　　while (p^.data<x)and(p^.next<>nil)do
　　　　begin
　　　　　q:=p;p:=p^.next
　　　　end;
　　　　if p^.data>=x{不是插在原尾结点之后}
　　　　then begin
　　　　　　if head=p then head:=po
　　　　　　else q^.next:=po;
　　　　　　po^.next:=p
　　　　　end
　　　else begin
　　　　　　po^.next:=po;
　　　　　　po^.next:=nil
　　　　end;
　　　end;
　　end;

　　⒉结点的删除
　　如下图所示，要在删除结点P的操作如下:
　　

　　要删除结点P,则只要将其前趋结点的指针域指向P 的后继结点即可。
　　q^.next:=p^.next;
　　dispose(p);

　　例9 将链表head中值为X的第一个结点删除
　　分析: 有三种情况存在:头结点的值为X; 除头结点外的某个结点值为X;无值为X的结点。为将前两种情况统一起来， 我们在头结点之前添加一个值不为Ｘ的哨兵结点。
　　算法分两步：查找、删除。

　　过程如下：
　　procedure deleteing(var head:pointer;x:integer);
　　var p,q:pointer;
　　begin
　　　New(p);p^.data:=x-1;p^.next:=head;
　　　head:=p;{以上为添加哨兵结点}
　　　while(x<>p^.data)and(p^.next<>nil)do
　　　begin
　　　　q:=p;
　　　　p:=p^.next
　　　end;
　　　if x=p^.data{存在值为X的结点}
　　　then q^.next:=p^.next
　　　else writeln('NOt found!');
　　　head:=head^.next{删除哨兵}
　　end;

　　（四）环形链表结构

　　在单向链表中，表尾结点的指针为空。如果让表尾结点的指针域指向表头结点，则称为单向环形链表，简称单链环。如图所示。
　　　　

　　　　　　　　　　　　　　　　单链环示意图
　　（五）双向链表结构

　　单链表中，每个结点只有一个指向其后继结点的指针域。如果每个结点不仅有一个指向其后继结点的指针域，还有一个指向其前趋的指针域，则这种链表称为双向链表。如图所示。
　　　　　

　　　　　　　　　　　双向链表示意图
　　可用如下定义一个数据域为整型的双向链表:
　　　　type pointer=^node;
　　　　　　node=record
　　　　　　　　　prev:pointer;
　　　　　　　　　data:integer;
　　　　　　　　　next:pointer;
　　　　　　　　end;
　　对双向链表的插入、删除特别方便。与单向链环相似，我们还可定义双向链环。

　　三、综合例析

　　例10 读入一串以"＃"为结束标志的字符，统计每个字符出现的次数。
　　分析：设置一个链表存放，每读入一个字符，就从链表的头结点向后扫描链表，如果在链表中此字符已存在，则其频率加1， 否则将该字符的结点作为链表的新头结点，相应频率为1。

　　源程序如下：
　　program ex11_10;
　　type ref=^letters;
　　　　　letters=record
　　　　　　　　　key:char;
　　　　　　　　　count:integer;
　　　　　　　　　next:ref;
　　　　　　　　end;
　　　var k:char;
　　　　sentinel,head:ref;
　　　procedure search(x:char);
　　　var w:ref;
　　　begin
　　　　w:=head;
　　　　sentinel^.key:=x;
　　　　while w^.key<>x do w:=w^.next;
　　　　if w<>sentinel
　　　　then w^.count:=w^.count+1
　　　　else begin
　　　　　　　　w:=head;new(head);
　　　　　　　　with head^ do
　　　　　　　　　begin
　　　　　　　　　　　key:=x;count:=1;next:=w;
　　　　　　　end
　　end;
　　end;{of search}
　　procedure printlist(w:ref);
　　　begin
　　　　while w<>sentinel do
　　　　　begin
　　　　　　writeln(w^.key:2,w^.count:10);
　　　　　　w:=w^.next;
　　　　　end;
　　　end;{of printlist}
　　begin{main program}
　　　new(sentine);
　　　with sentinel^ do
　　　　begin
　　　　　key:='#';count:=0;next:=nil;
　　　　end;
　　　head:=sentinel;
　　　read(k);
　　　while k<>'#' do
　　　　begin
　　　　　search(k);read(k);
　　　　end;
　　　printlist(head);
　　end.

　　例11　用链表重写筛法求2～100之间所有素数程序。
　　源程序如下：
　　program ex11_12;
　　　uses crt;
　　　type link=^code;
　　　　　　code=record
　　　　　　　　　key:integer;
　　　　　　　　　next:link;
　　　　　　　　end;
　　　var head:link;
　　　procedure printlist(h:link);{打印链表h}
　　　　var p:link;
　　　　begin
　　　　　p:=h;
　　　　　while p<>nil do
　　　　　　begin
　　　　　　　write(p^.key,'-->');
　　　　　　　p:=p^.next;
　　　　　　end;
　　　　end;
　　　procedure buildlink;{建立链表}
　　　　var p,q:link;
　　　　i:integer;
　　　　begin
　　　　　new(head);
　　　　　head^.key:=2;
　　　　　p:=head;
　　　　　for i:=3 to 100 do
　　　　　　begin
　　　　　　　new(q);
　　　　　　　q^.key:=i;
　　　　　　　q^.next:=nil;
　　　　　　　p^.next:=q;
　　　　　　　p:=q;
　　　　　　end;
　　　　end;
　　　procedure prime;{筛法将找到的素数的倍数从链表中删除}
　　　　var h,p,q:link;
　　　　begin
　　　　　h:=head;
　　　　　while h<>nil do
　　　　　　begin
　　　　　　　p:=h;q:=p^.next;
　　　　　　　while q<>nil do
　　　　　　　　if (q^.key mod h^.key=0) then
　　　　　　　　　begin
　　　　　　　　　　p^.next:=q^.next;
　　　　　　　　　　dispose(q);
　　　　　　　　　　q:=p^.next;
　　　　　　　　　end
　　　　　　　　else begin
　　　　　　　　　　　　p:=q;
　　　　　　　　　　　　q:=q^.next;
　　　　　　　　　　　end;
　　　　　　　h:=h^.next;
　　　　　　end;
　　　　end;
　　　begin{main program}
　　　　　clrscr;
　　　　　buildlink;
　　　　　printlist(head);
　　　　　writeln;
　　　　　prime;
　　　　　printlist(head);
　　　　end.

在DOS操作中，我们所谈及的文件称之为外部文件。外部文件是存储在外部设备上， 如：外存储器上，可由计算机操作系统进行管理，如用dir、type等命令直接对文件进行操作。

　　Pascal所谈及的文件，称之为内部文件。内部文件的特点是文件的实体（实际文件）也是存储在外存储器上，成为外部文件的一分子，但在使用时必须在程序内部以一定的语句与实际文件联系起来，建立一一对应的关系，用内部文件的逻辑名对实际文件进行操作。内部文件的逻辑名必须符合ＰＡＳＣＡＬ语言标识符的取名规则。

　　Pascal中的文件主要用于存放大量的数据。如：成绩管理，原始数据很多，使用文件先将其存入磁盘，通过程序读出文件中的数据再进行处理，比不使用文件要来得方便、有效。

　　Pascal中的一个文件定义为同一类型的元素组成的线性序列。文件中的各个元素按一定顺序排列，可以从头至尾访问每一个元素，从定义上看，文件与数组相似，但它们之间有着明显不同的特征，主要表现在：

　　（１）文件的每一个元素顺序存贮于外部文件设备上（如磁盘上）。因此文件可以在程序进行前由Pascal程序或用文字编辑软件，如edit、ws、Turbo Pascal的edit命令等产生，或在运行过程中由程序产生，且运行完后，依然存贮在外部设备上。
　　（２）在系统内部，通过文件指针来管理对文件的访问。文件指针是一个保存程序在文件中位置踪迹的计算器，在一固定时刻，程序仅能对文件中的一个元素进行读或写的操作，在向文件写入一个元素或从文件读取一个元素后，相应的文件指针就前进到下一元素位置。而数组是按下标访问。
　　（３）在文件类型定义中无需规定文件的长度即元素的个数，就是说元素的数据可动态改变，一个文件可以非常之大，包含许许多多元素，也可以没有任何元素，即为一个空文件。而数组的元素个数则是确定的。

　　使用文件大致有以下几个步骤；
　　（１）说明文件类型，定义文件标识符；
　　（２）建立内部文件与外部文件的联系；
　　（３）打开文件；
　　（４）对文件进行操作；
　　（５）关闭文件。
　　Turbo Pascal将文件分为三类：文本文件（顺序）、有类型文件（顺序或随机）和无类型文件（顺序或随机）。下面将介绍这些文件及其操作。

一、文本文件

　　文本文件又称为正文文件或行文文件，可供人们直接阅读，是人机通信的基本数据形式之一。文本文件可用文字编辑程序（如DOS的edit或Turbo Pascal的编辑命令edit）直接建立、阅读和修改， 也可以由ＰＡＳＣＡＬ程序在运行过程中建立。

　　１、文本文件的定义：
　　文本文件的类型为TEXT，它是由ASCII字符组成的，是Pascal提供的标准文件之一。标准文件 TEXT已由Pascal说明如下：
　　TYPE TEXT=FILE OF CHAR；
　　因此，TEXT同标准类型INTEGER、READ等一样可以直接用于变量说明之中，无需再由用户说明。 例如：
　 VAR F1，F2：TEXT；
　　这里定义了两个文本文件变量F1和F2。

　２、文本文件的建立
　　文本文件的建立有两种方法：

　　（１）直接用Turbo Pascal的Edit建立原始数据文件。
　　例1　将下表中的数据存入名为A.dat的文件中。
　　　3 4
　　　29 30 50 60
　　　80 90 70 75
　　　60 50 70 45
　　操作步骤：
　　①进入Turbo Pascal的编辑状态；
　　②输入数据；
　　③存盘，文件名取A.dat。
　　此时，已将数据存入文本文件A.dat中。文本文件也可用DOS中的Edit等软件建立。

　　（２）用程序的方式建立中间数据或结果数据文件。
　　用程序的方式建立文件操作步骤为：
　　①定义文本文件变量；

　　②把一外部文件名赋于文本文件变量，使该文本文件与一相应外部文件相关联；
　　命令格式：ASSIGN(f，name)
　　f为定义的文本文件变量
　　name为实际文件文件名
　　如：ASSIGN(F1,`FILEIN.DAT`)
　　或：ASSIGN(F1,`PAS\FILEIN.RES`)
　　这样在程序中对文本文件变量F1的操作，也就是对外部实际文件`FILEIN.DAT`或`FILEIN.RES`的操作。上例中文件`FILEIN.DAT`是存贮在当前目录中，而文件`FILEIN.RES`则是存贮在PAS子目录中。

　　③打开文本文件，准备写；
　　命令格式１：REWRITE(f)
　　功能：创建并打开新文件准备写，若已有同名文件则删除再创建
　　命令格式２：APPEND(f)
　　功能：打开已存在的文件并追加

　　④对文件进行写操作；
　　命令格式：WRITE(f，<项目名>)
　　或：WRITELN(f，<项目名>)
　　功能：将项目内容写入文件f中

　　⑤文件操作完毕后，关闭文件。
　　命令格式：CLOSE(f)

　　例2 从键盘上读入表12.1的数据，用程序写入名为B.dat的文件中。
　　　

　　３、读取文本文件
　　文本文件内容读出操作步骤：
　　①定义文本文件变量；
　　②用ASSIGN(f，name)命令，将内部文件f与实际文件name联系起来；
　　③打开文本文件，准备读；
　　命令格式：READ(f，<变量名表>) READLN(f，<变量名表>)
　　功能：读文件f中指针指向的数据于变量中
　　文本文件提供了另外两个命令，在文本的操作中很有用处，它们是：
　　EOLN(f)：回送行结束符　　
　　EOF(f)：回送文件结束符
　　⑤文件操作完毕，用CLOSE(f)命令关闭文件。

　　例3 读出例12.1建立的文本文件，并输出。
　　　　

　　由于文本文件是以ASCII码的方式存储，故查看文本文件的内容是极为方便，在DOS状态可使用 DOS中TYPE等命令进行查看，在Turbo Pascal中可以象取程序一样取出文件进行查看。

　　４、文本文件的特点

　　（１）行结构
　　文本文件由若干行组成，行与行之间用行结束标记隔开，文件末尾有一个文件结束标记。由于各行长度可能不同，所以无法计算出给定行在文本文件中的确定位置，从而只能顺序地处理文本文件，而且不能对一文本文件同时进行输入和输出。
　　（２）自动转换功能
　　文本文件的每一个元素均为字符型，但在将文件元素读入到一个变量（整型，实型或字符串型）中时，Pascal会自动将其转换为与变量相同的数据类型。与此相反在将一个变量写入文本文件时，也会自动转移为字符型。

　　例４ 某学习小组有１０人，参加某次测验，考核６门功课， 统计每人的总分及各门的平均分，将原始数据及结果数据放入文本文件中。

　　分析
　　（１）利用Turbo Pascal的EDIT建立原始数据文件TESTIN.DAT存贮在磁盘中，其内容如下：
　　10 6
　　1 78 89 67 90 98 67
　　2 90 93 86 84 86 93
　　3 93 85 78 89 78 98
　　4 67 89 76 67 98 74
　　5 83 75 92 78 89 74
　　6 76 57 89 84 73 71
　　7 81 93 74 76 78 86
　　8 68 83 91 83 78 89
　　9 63 71 83 94 78 95
　　10 78 99 90 80 86 70

　　（２）程序读入原始数据文件，求每人的总分及各门的平均分；
　　（３）建立结果数据文件，文件名为TEXTIN.RES.

　　程序：

　　
　　
　　

　　例５ 读入一个行长不定的文本文件。排版，建立一个行长固定为６０个字符的文件， 排版要求：(1)当行末不是一个完整单词时，行最后一个字符位用'－'代替， 表示与下一行行头组成完整的单词；(2)第一行行头为两个空格，其余各行行头均不含有空格。

　　分析
　　（１）建立原始数据文件。
　　（２）程序边读入原始数据文件内容，边排版。
　　（３）每排完一行行长为６０字符，并符合题中排版条件，写入目标文件中。

　　设原始数据TEXTCOPY.DAT文件内容如下：
　　Pavel was arrested.
　　That dat Mother did not light the stove.
　　Evening came and a cold wind was blowing.
　　There was a knock at the window.
　　Then another.
　　Mother was used to such knocks,but this time she gave a little start of joy.
　　Throwing a shawl over her shoulders,she opened the door.

　　程序：

　　
　　　
　　

　　对TEXTCOPY.DAT文本文件运行程序得到排版结果文件TEXTCOPY.RES内容如下：
　　　　Pavel was arrested.That dat Mother did not light the stov-
　　evening came and a cold wind was blowing.There was a knock
　　at the window.Then another.Mother was used to such knocks,b-
　　ut this time she gave a little start of joy.Throwing a shawl
　　over her shoulders,she opened the door.

二、有类型文件

　　文本文件的元素均为字型符。若要在文件中存贮混合型数据，必须使用有类型文件。

　　１、有类型文件的定义
　　有类型文件中的元素可以是混合型的，并以二进制格式存贮，因此有类型文件（除了字符类型文件，因为它实质上是文本文件）不象文本文件那样可以用编辑软件等进行阅读和处理。
　　有类型文件的类型说明的格式为：
　　类型标识符＝File of 基类型；
　　其中基类型可以是除了文件类型外的任何类型。例如：
　　FILE1=FILE OF INTEGER;
　　FILE2=FILE OF ARRAY[1--10] OF STRING;
　　FILE3=FILE OF SET OF CHAR;
　　FILE4=FILE OF REAL;
　　FILE5=FILE OF RECORD;
　　NAME:STRING;
　　COURSE:ARRAY[1--10] OF READ;
　　SUN:READ;
　　END;
　　等等，其中FILE2,FILE3,FILE5中的数组、集合、记录等类型可以先说明再来定义文件变量。
　　例如：
　　VAR
　　F1:FILE;
　　F2,F3:FILE3;
　　F4:FILE5;
　　与前面所有类型说明和变量定义一样，文件类型说明和变量定义也可以合并在一起，例如：
　　VAR
　　F1:FILE OF INTEGER;
　　F2，F3:FILE OF SET OF CHAR;
　　F4:FILE OF RECORD
　　NAME:STRING;
　　COURSE:ARRAY[1--10] OF REAL;
　　SUM:READ;
　　END;

　　Turbo Pascal对有类型文件的访问既可以顺序方式也可以用随机方式。
　　为了能随机访问有类型文件，Turbo Pascal提供如下几个命令：
　　命令格式１：seek(f,n)
　　功能：移动当前指针到指定f文件的第n个分量，f为非文本文件，n为长整型
　　命令格式２：filepos(f)
　　功能：回送当前文件指针，当前文件指针在文件头时，返回，函数值为长整型
　　命令格式３：filesize(f)
　　功能：回送文件长度，如文件空，则返回零，函数值为长整型

　　２、有类型文件的建立
　　有类型文件的建立只能通过程序的方式进行，其操作步骤与文本文件程序方式建立的步骤相仿，不同之处：（１）有类型文件的定义与文本文件的定义不同；（２）有类型文件可以利用SEEK命令指定指针随机写入。

　　３、有类型文件的访问
　　有类型文件访问的操作步骤与文本文件的程序访问操作步骤相仿，区别之处：（１）有类型文件的定义与文本文件的定义不同；（２）有类型文件可以利用SEEK命令访问文件记录中的任一记录与记录中的任一元素。

　　例６ 建立几个学生的姓名序、座号、六门课程成绩总分的有类型文件。
　　
　　分析：为简单起见，这里假设已有一文本文件FILEDATA.TXT，其内容如下：
　　10
　　li hong
　　1 89 67 56 98 76 45
　　wang ming
　　2 99 87 98 96 95 84
　　zhang yi hong
　　3 78 69 68 69 91 81
　　chang hong
　　4 81 93 82 93 75 76
　　lin xing
　　5 78 65 90 79 89 90
　　luo ze
　　6 96 85 76 68 69 91
　　lin jin jin
　　7 86 81 72 74 95 96
　　wang zheng
　　8 92 84 78 89 75 97
　　mao ling
　　9 84 86 92 86 69 89
　　cheng yi
　　10 86 94 81 94 86 87

　　第一个数１０表示有１０个学生，紧接着是第一个学生的姓名、座号、６科成绩，然后是第二个学生，等等。
　　从文本文件中读出数据，求出各人的总分，建立有类型文件，设文件名为filedata.fil，文件的类型为记录studreco，见下例程序。

　　程序：
　　
　　　　
　　　　
　　　

　　例７　产生数１－１６的平方、立方、四次方表存入有类型文件中， 并用顺序的方式访问一遍，用随机方式访问文件中的１１和１５两数及相应的平方、立方、四次方值。

　　分析：建立有类型文件文件名为BIAO.FIL，文件的类型为实数型。
　　（１）产生数１－１６及其平方、立方、四次方值，写入BIAO.FIL，并顺序读出输出；
　　（２）用SEEK指针分别指向１１和１５数所在文件的位置，其位置数分别为１０×４和１４×４（注意文件的第一个位置是０），读出其值及相应的平方、立方、四次方值输出。

　　程序：

　　
　　　

　　程序运行结果如下：
　　

　　另外，Turbo Pascal还提供了第三种形式文件即无类型文件，无类型文件是低层Ｉ/Ｏ通道，如果不考虑有类型文件、 文本文件等存在磁盘上字节序列的逻辑解释，则数据的物理存储只不过是一些字节序列。这样它就与内存的物理单元一一对应。无类型文件用１２８个连续的字节做为一个记录（或分量）进行输入输出操作，数据直接在磁盘文件和变量之间传输，省去了文件缓解区，因此比其它文件少占内存，主要用来直接访问固定长元素的任意磁盘文件。
　　无类型文件的具体操作在这里就不一一介绍，请参看有关的书籍。

三、综合例析

　　例８　建立城市飞机往返邻接表。文本文件CITY.DAT内容如下：
　　第一行两个数字Ｎ和Ｖ；
　　Ｎ代表可以被访问的城市数，Ｎ是正数＜１００；
　　Ｖ代表下面要列出的直飞航线数，Ｖ是正数＜１００；
　　接下来Ｎ行是一个个城市名，可乘飞机访问这些城市；
　　接下来Ｖ行是每行有两个城市，两城市中间用空格隔开，表示这两个城市具有直通航线。
　　如：CITY1 CITY2表示乘飞机从CITY1到CITY2或从CITY2到CITY1。
　　生成文件CITY.RES，由０、１组成的Ｎ×Ｎ邻接表。
　　邻接表定义为：
　　　　　　　　　　　

　　分析
　　（１）用从文本文件city.dat中读入Ｎ个城市名存入一些数组CT中；
　　（２）读入Ｖ行互通航班城市名，每读一行，查找两城市在CT中的位置L、K，建立邻接关系，lj[l,k]=1和lj[k,j]=1；
　　（３）将生成的邻接表写入文本文件CITY.RES中。

　　设CITY.DAT内容如下：
　　10 20
　　fuzhou
　　beijin
　　shanghai
　　wuhan
　　hongkong
　　tiangjin
　　shenyan
　　nanchan
　　chansa
　　guangzhou
　　fuzhou beijin
　　fuzhou shanghai
　　fuzhou guangzhou
　　beijin shanghai
　　guangzhou beijin
　　wuhan fuzhou
　　shanghai guangzhou
　　hongkong beijin
　　fuzhou hongkong
　　nanchan beijin
　　nanchan tiangjin
　　tiangjin beijin
　　chansa shanghai
　　guangzhou wuhan
　　chansa beijin
　　wuhan beijin
　　shenyan beijin
　　shenyan tiangjin
　　shenyan shanghai
　　shenyan guangzhou

　　程序：

　　
　　　

　　得到CITY.RES文件内容如下：
　　10
　　1 fuzhou
　　2 beijin
　　3 shanghai
　　4 wuhan
　　5 hongkong
　　6 tiangjin
　　7 shenyan
　　8 nanchan
　　9 chansa
　　10 guangzhou
　　0 1 1 1 1 0 0 0 0 1
　　1 0 1 1 1 1 1 1 1 1
　　1 1 0 0 0 0 1 0 1 1
　　1 1 0 0 0 0 0 0 0 1
　　1 1 0 0 0 0 0 0 0 0
　　0 1 0 0 0 0 1 1 0 0
　　0 1 1 0 0 1 0 0 0 1
　　0 1 0 0 0 1 0 0 0 0
　　0 1 1 0 0 0 0 0 0 0
　　1 1 1 1 0 0 1 0 0 0

　　例９ 对例１２.３的FILEDATE.FIL文件内容按总分的高低顺序排序。
　　分析：
　　文件的排序就是将文本文件的各分量按一定要求排列使文件有序，文件排序有内排序和外排序二种，内排序是指将文件各分量存入一个数组，再对数组排列，最后将该数组存入原来的文件。外排列不同于内排列，它不是将文件分量存入数组，而是对文件直接排序，内排序比外排序速度要快，但当文件很大时，无法调入内存，此时用外排序法较合适。
　　本程序使用过程SEEK，实现外排序。

　　程序：
　　
　　　　
　　　

字符串函数

求长度length
定义：function Length(S: String): Integer;
例子：
var
S: String;
begin
Readln (S);
Writeln('"', S, '"');
Writeln('length = ', Length(S));
end.

复制子串copy
定义： function Copy(S: String; Index: Integer; Count: Integer): String;

注意：S 是字符串类型的表达式。Index和Count是整型表达式。Copy 返回S中从Index开始，Count个字符长的一个子串。
例子：
var S: String;
begin
S := 'ABCDEF';
S := Copy(S, 2, 3); { 'BCD' }
end.

插入子串insert
定义：procedure Insert(Source: String; var S: String; Index: Integer);

注意：Source 是字符串类型的表达式。 S 是任意长度字符串类型变量。Index 是整型表达式。Insert 把 Source插在S中Index处。如果结果字符串的长度大于255，那么255之后的字符将被删除。

例子：
var
S: String;
begin
S := 'Honest Lincoln';
Insert('Abe ', S, 8); { 'Honest Abe Lincoln' }
end.

删除子串delete
定义：procedure Delete(var S: String; Index: Integer; Count:Integer);

注意：S 是字符串类型变量。 Index和Countare是整型表达式。Delete 删除S中从Index开始的Count个字符。如果Index大于S的长度，则不删除任何字符；如果Count大于S中从Index开始的实际字符数，则删除实际的字符数。

例子：
var
s: string;
begin
s := 'Honest Abe Lincoln';
Delete(s,8,4);
Writeln(s); { 'Honest Lincoln' }
Delete(s,9,10);
Writeln(s); { 'Honest L' }
end.

字符串转为数值val
定义： procedure Val(S; var V; var Code: Integer);
在这里:
S 是由一系列数字字符构成的字符串类型变量；。
V 是整型或实型变量；
Code 是Integer型变量

注意：Val将S转为它的数值形式。
例子：
var s:string;I, Code: Integer;
begin
s:='1234';
val(s,i,code);
writeln(i); { 1234 }
end.

求绝对值函数abs(x)
定义：function Abs(X): (Same type as parameter);
说明：X可以是整型，也可以是实型；返回值和X的类型一致
例子：
var
r: Real;
i: Integer;
begin
r := Abs(-2.3); { 2.3 }
i := Abs(-157); { 157 }
end.

取整函数int(x)
定义：function Int(X: Real): Real;
注意：X是实型数，返回值也是实型的；返回的是X的整数部分，也就是说，X被截尾了（而不是四舍五入）
例子：
var R: Real;
begin
R := Int(123.567); { 123.0 }
R := Int(-123.456); { -123.0 }
end.

截尾函数trunc(x)
定义：function Trunc(X: Real): Longint;
注意：X是实型表达式. Trunc 返回Longint型的X的整数部分
例子：
begin
Writeln(1.4, ' becomes ', Trunc(1.4)); { 1 }
Writeln(1.5, ' becomes ', Trunc(1.5)); { 1 }
Writeln(-1.4, 'becomes ', Trunc(-1.4)); { -1 }
Writeln(-1.5, 'becomes ', Trunc(-1.5)); { -1 }
end.

四舍五入函数round(x)
定义：function Round(X: Real): Longint;
注意：X是实型表达式. Round 返回Longint型的X的四舍五入值.如果返回值超出了Longint的表示范围，则出错.
例子：
begin
Writeln(1.4, ' rounds to ', Round(1.4)); { 1 }
Writeln(1.5, ' rounds to ', Round(1.5)); { 2 }
Writeln(-1.4, 'rounds to ', Round(-1.4));{ -1 }
Writeln(-1.5, 'rounds to ', Round(-1.5));{ -2 }
end.

取小数函数frac(x)
定义：function Frac(X: Real): Real;
注意：X 是实型表达式. 结果返回 X 的小数部分; 也就是说，Frac(X) = X - Int(_X).
例子：
var
R: Real;
begin
R := Frac(123.456); { 0.456 }
R := Frac(-123.456); { -0.456 }
end.
 
求平方根函数sqrt(x)和平方函数sqr(x)
定义：
平方根：function Sqrt(X: Real): Real;
注意：X 是实型表达式. 返回实型的X的平方根.
平方：function Sqr(X): (Same type as parameter);
注意：X 是实型或整型表达式.返回值的类型和X的类型一致，大小是X的平方，即X*X.

例子：
begin
Writeln('5 squared is ', Sqr(5)); { 25 }
Writeln('The square root of 2 is ',Sqrt(2.0)); { 1.414 }
end.

附录三  关于fillchar的使用和讨论
 

大家听说过fillchar这个标准过程吧。 很好用的。
var a:array [1..10] of arrtype;

执行fillchar(a,sizeof(a),0);
当arrtype为
1.real(其他差不多)                                   使得a中的元素全部成为0.0
2.integer(byte,word,longint,shortint都相同)   全部为0
3.boolean                                                全部为false
4.char                                                    全部为#0

执行fillchar(a,size(a),1);
写几个特殊的
1.integer            全部为157（不知道为什么）
2.real                很大的一个数，同上。
3.boolean           全部为true
4.byte,shortint    全部为1,所以integer不行可以暂时用这两个嘛。 要不然就减去156

附录五   程序的调试(一) ——步骤法

     任何一个天才都不敢说，他编的程序是100%正确的。几乎每一个稍微复杂一点的程序都必须经过反复的调试，修改，最终才完成。所以说，程序的调试是编程中的一项重要技术。我们现在就来掌握一下基本的程序调试。
我们以下的示范，是以时下比较流行的Borland Pascal 7.0为例子，其他的编程环境可能略有不同，但大致上是一致的。


     我们先编一个比较简单的程序，看看程序是如何调试的。

     该程序是输出300以内同时能被2，3，5整除的整数。 现在我们开始调试。 调试有多种方法，先介绍一种，权且叫步骤法，步骤法就是模拟计算机的运算，把程序每一步执行的情况都反映出来。通常，我们有F8即STEP这个功能来实现，如图：
不断地按F8，计算机就会一步步地执行程序，直到执行到最后的“end.”为止。


     可能你还没有发现F8的威力，我们不妨把上面的程序略微修改一下，再配合另外的一种调试的利器watch，你就会发现步骤法的用处。

     如图，我们单击菜单栏中debug选项，里面有一项叫watch的选项，我们单击它。

     就会出现一个watch窗口：
     watch窗口可以让我们观察变量的变化情况，具体操作是在watches窗口内按Insert键：
     这时，屏幕上弹出一个菜单，我们输入所需要观察的变量名，我们分别输入i,a,b,c这4个变量名，于是watches窗口内就有如下的4个变量的状态：


     这时，我们再次使用步骤法，我们会发现，这4个变量的状态随着程序的执行而不断变化，比如：

     这样我们就可以方便地知道执行每一步之后，程序的各个变量的变化情况，从中我们可以知道我们的程序是否出错，在哪里出错，方便我们及时地修改。
     下一次，我们介绍另外的一种方法，断点法

程序的调试(二) ——断点法

在前面我们已经学习了基本的程序调试方法——步骤法。步骤法有一个缺点，就是在遇到循环次数比较多或者语句比较多的时候，用起来比较费时，今天我们来学习一种新的也是常用的调试方法——断点法。
      所谓断点法，就是在程序执行到某一行的时候，计算机自动停止运行，并保留这时各变量的状态，方便我们检查，校对。我们还是以前面求同时能被2，3，5整除的3000以内的自然数为例，具体操作如下：
      我们把光标移动到程序的第14行，按下ctrl+F8，这时我们会发现，该行变成红色，这表明该行已经被设置成断点行，当我们每次运行到第14行的时候，计算机都会自动停下来供我们调试。
      我们必须学以致用，赶快运用刚学的watch方法，看看这家伙到底有多厉害。

请记住，计算机是执行到断点行之前的一行，断点行并没有执行，所以这时b:=true这一句并没有执行。

      断点行除了有以上用处之外，还有另外一个重要用处。它方便我们判断某个语句有没有执行或者是不是在正确的时刻执行，因为有时程序由于人为的疏忽，可能在循环或者递归时出现我们无法预料的混乱，这时候通过断点法，我们就能够判断程序是不是依照我们预期的顺序执行。

附录六    Pascal的多种退出语句用法

1、   break 是用来退出其所在的循环语句

即 ： 不论在任何一个循环语句中 执行了 break 的话， 马上退出这个语句。
相当于 ： goto 这一层循环语句 最末尾一句的下一句。
例如：var i : integer;
begin
for i := 1 to 10 do
begin
{1} writeln(i);
break;
writeln(i+1);
end;
readln
end.
执行结果 ：
         1

可见 第一次循环 时 ， 执行了{1}句 后 ， 执行 break ，然后马上退出了这个for语句。 {*****} 注意 ： 以上两个语句 只 对 它们所在的 那层循环语句 起作用，也就是说 ： 如果有多个 循环语句 相嵌套， 其中 某一层 执行了continue / break 语句， 它们并不能影响上面几层的循环语句。

2、exit 是退出当前程序块；

即 ： 在任何子程序 中执行 exit ， 那么 将退出 这个子程序；如果是在 主程序中执行 exit ， 那么将退出整个程序。相当于 ： goto 这个程序块 的 末尾 的 end 例如 ： 试除法判断素数时，一旦整除，就把函数值赋为false ，然后exit;{******}注意 ： 类似上面的 ， exit也是只对当前 这一个 子程序产生作用，如果多重嵌套子程序 ， 那么其中某个子程序执行了exit以后，将返回到 调用它的那个语句 的下一个语句。

3、halt : 没什么好说的，退出整个程序，Game Over.

例如 ： 搜索时， 一旦找到一个解，就打印，然后执行halt，退出整个程序。使用exit , halt 应该注意的地方：要注意所有可能会退出 子程序或主程序 的地方 均要妥善处理好善后工作，比如 文件是否关闭 ，输出是否完整等。

最后说一句 ， 使用这些语句 使得程序结构不止有一个出口，破坏了结构化程序设计的 标准控制结构 ， 使程序难以调试 （但是往往便于编写），应尽量避免使用，因为它们完全可以用其它语句代替，所以，除非使用这些语句 能给 编写程序 带来 较大的方便，且可读性不受到影响，才值得一用。

转载于:https://www.cnblogs.com/Chaobs/p/3838433.html

免责声明：本站内容（文字信息+图片素材）来源于互联网公开数据整理或转载，仅用于学习参考，如有侵权问题，请及时联系本站删除，我们将在5个工作日内处理。联系邮箱：303555158#qq.com（把#换成@）

综合百科

• 幼儿园六一新颖创意主题名称
• 北京印刷学院多少分能考上？附2024年最低录取分数线及位次
• 2023全国甲卷答案-2023全国甲卷真题
• 带临字的成语
• 连云港师范高等专科学校2024年录取分数线：最低多少分
• 什么是三丝
• 什么是旋转矩阵
• 2025年湖北工业大学多少分能考上？请看往年最低分数线
• 萎字可以怎么组词
• 2024年仰恩大学录取分数线：各省高考最低分是383

网站导航

• 首页
• 知识问答
• SEO
• 成功案例
• 关于我们

---

Copyright © 格特瑞商务咨询-贵州做网站公司 版权所有 | 黔ICP备19002813号-1

贵公网安备52260102556330号

QQ咨询

QQ在线咨询

• 客户经理
• 客户经理
• 客户经理
• 客户经理

客服热线

13272073477

客户咨询热线

添加微信

微信便捷交流

返回顶部