PASCAL高级语言_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
105页免费48页免费40页免费22页免费33页免费22页免费124页1下载券12页免费89页2下载券4页免费
喜欢此文档的还喜欢199页1下载券48页免费260页7下载券125页免费18页免费
PASCAL高级语言|P​A​S​C​A​L
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢第一讲 Pascal语言基础知识_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
文档贡献者山东省寿光市古城街道北洛初中语文教师116993.6浏览总量总评分
评价文档：
8页免费100页免费67页免费48页免费30页免费87页免费35页免费34页免费13页免费12页免费
喜欢此文档的还喜欢70页免费
第一讲 Pascal语言基础知识|
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
大小：437.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢pascal语言初赛的几个问题_百度知道
pascal语言初赛的几个问题
1.关于所排序（堆/选择/快速等)算间复杂度请给详细介绍2.关于逻辑结构问题（顺序表序表哈希表单链表双向链表哪逻辑结构并给介绍）急十谢
提问者采纳
（八）各种排序
基于元素间比较排序间复杂度快于O(nlogn) 选择排序 插入排序 冒泡排序 快速排序 归并排序 堆排序 希尔排序间复杂度 O(n2) O(n2) O(n2) O(nlogn) O(nlogn) O(nlogn) 约O(n1.5)稳定性 稳定 稳定 稳定 稳定 稳定 稳定 稳定数据序 变 变快 变快 变慢 变 变 变特殊应用
求第k数 求逆序数 优先队列
待排序元素值范围内则使用O(n)间基数排序1. 按策略划内部排序五类：插入排序、选择排序、交换排序、归并排序配排序 2. 待排文件用存储式:（1） 顺序表(或直接用向量)作存储结构 排序程：记录本身进行物理重排（即通关键字间比较判定记录移合适位置）（2）
链表作存储结构 排序程：须移记录仅需修改指针通类排序称链表(或链式)排序；（3） 用顺序式存储待排序记录同建立辅助表 排序程：需辅助表表目进行物理重排（即移辅助表表目移记录本身）适用于难于链表实现仍需避免排序程移记录排序3. 排序按平均间排序四类（1）平阶(O(n2))排序
般称简单排序例直接插入、直接选择冒泡排序；（2）线性数阶(O(nlgn))排序
快速、堆归并排序；（3）O(n1+￡)阶排序
￡介于01间数即0&￡&1希尔排序；（4）线性阶(O(n))排序
桶、箱基数排序4. 各种排序比较:简单排序直接插入快速排序快文件序直接插入冒泡均佳（九）线性表1. 数组链表
（1）已知二维数组首元素址每元素所占存储空间求其元素存储址
（2）三角矩阵：n行n列数组沿主角线称要存储三角即n行n列数组三角按行存储至维数组a[j,k]（j&=k）应维数据第(j-1)j/2+kn行n列数组三角按列存储至维数组a[j,k]（j&=k）应第(2n-k+2)(k-1)/2+j-k+1
（3）数组优缺点:每查询较快,要O(1)间;每插入删除较慢,造量元素移, 需要O(n)间(4) 链表优缺点: 每查询元素较慢,需要O(n)间遍历链表; 每插入删除间较快要O(1)间2. 队列循环队列(1)
先进先（FIFO）端（队尾）插入另端（队首）删除数组或链表模拟(2)
用于宽度优先遍历(3)
n位置数组存储队列线性队列存储n元素循环队列存储n-1元素(4)
循环队列head表示队首tail表示插入位置则前已元素数(tail-head+n) mod n
(5) 队空:tail=head或(tail-head) mod n=0；队满: (tail-head+n) mod n=n-1或(tail+1)mod n=head
其他类似问题
您可能关注的推广回答者：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁pascal语言
1.1 Pascal编辑环境
1.下载Turbo Pascal6.0
(1)下载turbo pascal
(2)属性设置
2.Turbo Pascal 6.0环境介绍
(1)进入与退出(注意:退出时必须使用文件菜单中的退出命令或Alt+X)
(2)编辑程序
光标移动键的使用
Backspace键:删除光标前一个字符
Ctrl+N:在光标前插入一行
Ctrl+Y:删除光标所在行
Home:光标移到行首
End:光标移到行尾
PageUp/PageDown:上下翻页
Insert:插入与改写状态切换
(3)编译程序(Compile):Alt+F9
(4)运行程序(Run):Ctrl+F9
(5)保存程序(Save):F2
(6)打开原有的程序:F3
(7)查看程序运行结果:Alt+F5
(8)调试时增加观察项:Ctrl+F7
1.2 简单Pascal程序的结构
例1下列是一Pascal源程序:
&program lt1;{程序首部}
var&&&&&&&&
{说明部分}
begin&&&&&&
{执行部分}
& a:=3355;
& sum:=a+b;
& writeln('sum=',sum);
1.3 完整的Pascal程序结构
一个完全的Pascal程序结构
program 程序名；
uses 已知单元说明；
label 标号说明；
const 常量说明；
type 类型说明；
var 变量说明；
function 函数说明；
procedure 过程说明；
2.1 Pascal字符与符号
1．标识符
标识符的定义：标识符就是以字母开头的字母数字序列，有效长度为63个字符，并且大小写等效。可以用来标示常量、变量、程序、函数等。例如例1.1中的Area(程序名)，pi(符号常量)，s、r(变量名)都是标识符。
(2) 标识符的分类：
a.保留字(关键字)
所谓保留字是指在Pascal语言中具有特定的含义，你必须了解它的含义，以便于正确的使用，否则会造成错误。标准Pascal语言中的保留字一共有35个，Turbo
Pascal语言一共有51个。下面是Pascal语言的保留字:
AND，ARRAY，BEGIN，CASE，CONST，DIV，DO，DOWNTO，ELSE，END，FILE，FOR，FUNTION，GOTO，IF，IN，LABEL，MOD，NIL，NOT，OF，OR，PACKED，PROCEDURE，PROGRAM，RECORD，REPEAT，SET，THEN，TO，TYPE，UNTIL，VAR，WHILE，WITH等
b.标准标识符：指Pascal语言预先定义的标识符，具有特殊含义。
以下列举了Turbo Pascal语言部分常用的标准表识符：
标准常量 False Maxint True
标准类型 Boolean Char Real Integer
标准函数 Abs Arctan Chr Cos Eof Eoln Exp
Ln Odd Ord Pred Round Sin Sqr
Sqrt Succ Trunc
标准过程 Dispose Get New Pack Page Put Read
Readln Reset Rewrite Unpack Write Writeln
标准文件 Input Output
c．用户自定义标识符：由你自己根据需要来定义。
（1）选用的标识符不能和保留字相同。
（2）语法上允许预定义的标准标识符作为你自己定义的标识符使用，但最好还是不要用。
以下列举了你自己在定义标识符时可以用的字符：
A——Z；a——z；0——9；+，-，*，/，=，&&，&=，&=，&，&，(，)，[，]，{，}，:=，，，；，.，：，..，'，^
2.2 Pascal数据类型
数据是程序设计的一个重要内容，其重要特征----数据类型，确定了该数据的形、取值范围以及所能参与的运算。
Turbo Pascal
提供了丰富的数据类型，这些数据类型可以分为三大类：简单类型、构造类型和指针类型，其中简单类型可以分为标准类型（整型、实型、字符型和布尔型）和自定义类型（枚举型和子界型），构造类型可以分为数组类型、集合类型、记录类型和文件类型。这些数据类型中除了指针类型是动态数据类型外，其他的都是静态数据类型。在这些数据类型中的简单类型都是有序类型，除了实型以外的简单类型都是顺序类型，所谓顺序类型就是他们的值不仅是有序的而且是有顺序号。
在这里主要介绍整型、实型、字符型和布尔型四种常用的数据类型。
1.整型
一个整型数据用来存放整数。Turbo Pascal支持五种预定义整型，它们是shortint（短整型）、 integer（整型）、
longint（长整型）、 byte（字节型）和 word（字类型），Turbo
Pascal分别用相同的名字作为他们的标识符。每一种类型规定了相应的整数取值范围以及所占用的内存字节数。
类型 数值范围 占字节数 格式
shortint -128..128 1 &&
inteter -3 2 & 带符号16位
longint -..&
4 & 带符号32位
byte 0..255 1 带符号8位
word 0..65535 2 带符号16位
Pascal规定了两个预定义整型常量标识符maxint和maxlonint，他们各表示确定的常数值，maxint为32767，
longint为，他们的类型分别是integer 和longint
2.实型
一个实型数据用来存放实数。Turbo Pascal支持五种预定义实型，它们是real（基本实型）、
single（但精度实型）、double（双精度实型）、extended（扩展实型）、comp（装配实型），Turbo
Pascal分别用相同的名字作为他们的标识符。每一种类型规定了相应的实数取值范围、所占用的内存字节数以及它们所能达到的精度
类型 数值范围 占字节数 有效位数
real 2.9e-39..1.7e38 6 11..12
single 1.5e-45..3.4e38 4 7..8
double 5.0e-324..1.7e308 8 15..16
Pascal支持两种用于执行实型运算的代码生成模式：软件仿真模式和80x87浮点模式。除了real可以在软件仿真模式下直接运行以外，其他类型必须在80x87浮点模式下运行。
3.布尔型
一个布尔型数据用来存放逻辑值（布尔值）。布尔型的值只有两个：false和true，并且false的序号是0，true的序号是1。false
和true都是预定义常数标识符，分别表示逻辑假和逻辑真。并且true&false。boolean是布尔型的标识符。
4.字符型
字符型用char作为标识符。字符型必须用单引号括起来，字母作为字符型时，大小写是不等价的，并且字符型只允许单引号中有一个字符，否则就是字符串。
2.3 常量与变量
1.常量
(1)常量：在某个程序的整个过程中其值不变的量。
(2)常量定义：常量定义出现在说明部分。它的语法格式是：
&常量标识符&=&常量&;
&常量标识符&=&常量&;
常量标识符的类型由定义它的常量的类型决定。例如：const a=12 隐含说明a是整型；const r=3.21
隐含说明r是实型......
(3)常量定义部分必须以保留字const开头，可以包含一个或几个常量定义，而且每个常量均以分号结束。
(4)Turbo Pascal类型常量
类型常量，又称变量常数，它是Turbo
Pascal的一个扩充特性。类型常量的定义与标准Pascal规定的常数定义和变量说明有所区别。类型常量定义的语法格式：
&简单类型常量标识符&:简单类型=常数；
例如：
counter:integer=0;
flag:boolean=
index:0..100=0;
2.变量
(1)变量：在某个程序中的运行过程中其值可以发生改变的量
(2)变量说明：变量说明出现在说明部分。它的语法格式是：
&变量标识符列表&:&类型&;
&变量标识符列表&:&类型&;
其中，保留字var表示开始一个变量说明部分。变量标识符列表是一个用逗号隔开的标识符序列，冒号后面的类型是类型标识符。每个变量说明均以分号结束。
例如：
2.4 标准函数
1.算术函数
函数标识符 自变量类型 意义 结果类型
abs 整型、实型 绝对值 同自变量
arctan 整型、实型 反正切 实型
cos 整型、实型 余弦 实型
exp 整型、实型 指数 实型
frac 整型、实型 小数部分 实型
int 整型、实型 整数部分 实型
ln 整型、实型 自然对数 实型
pi 无自变量 圆周率 实型
sin 整型、实型 正弦 实型
sqr 整型、实型 平方 同自变量
sqrt 整型、实型 平方根 实型
例：abs(-4)=4 abs(-7.49)=7.49 arctan(0)=0.0
sin(pi)=0.0 cos(pi)=-1.0 frac(-3.71)=-0.71
int(-3.71)=-3.0 sqr(4)=16 sqrt(4)=2
2.标准函数
函数标识符 自变量类型 意义 结果类型
odd 整型 判断奇数 布尔型
pred 离散类型 求前趋 同自变量
succ 离散类型 求后继 同自变量
例：odd(1000)=false pred( succ(
odd(3)=true pred('x')='w succ('x')='y'
3.转换函数
函数标识符 自变量类型 意义 结果类型
chr byte 自变量对应的字符 字符型
ord 离散类型 自变量对应的序号 longint
round 实型 四舍五入 longint
trunc 实型 截断取整 longint
例：chr(66)='B' ord('A')=65 round(-4.3)=-5 trunc(2.88)=2
4.杂类函数
函数标识符 自变量类型 意义 结果类型
random 无自变量 [0,1间的随机实数 real
random word [0,自变量间的随机整数) word
randomize 无自变量 初始化内部随机数产生器 longint
upcase 字符型 使小写英文字母变为大写 字符型
downcase 字符型 使小写英文字母变为大写 字符型
2.5 运算符和表达式
1.运算符和优先级
(1)运算符
是实型，如果全部的运算对象都是整型并且运算不是除法，则结果为整型，若运算是除法，则结果是实型 a.算术运算符
运算符 运算 运算对象 结果类型
+ 加 整型、实型 只要有一个运算对象是实型，结果就
- 减 整型、实型 是实型，如果全部的运算对象都是整
* 乘 整型、实型 型并且运算不是除法，则结果为整型，
/ 除 整型、实型 若运算是除法，则结果是实型。
div 整除 整型 整型
mod 取余 整型 整型
b.逻辑运算符
运算符 运算 运算对象 结果类型
not 逻辑非 布尔型 布尔型
and 逻辑与 布尔型 布尔型
or 逻辑或 布尔型 布尔型
xor 逻辑异或 布尔型 布尔型
c.关系运算符
运算符 运算 运算对象 结果类型
= 等于 简单类型 布尔型
&& 不等于 简单类型 布尔型
& 小于 简单类型 布尔型
& 大于 简单类型 布尔型
&= 小于等于 简单类型 布尔型
&= 大于等于 简单类型 布尔型
(2)优先级
运算符 优先级
not 1(高)
*,/,div,mod,and 2
xor,+,-,or 3
in,=,&&,&=,&=,&& 4(低)
2.表达式
(1)算术表达式：算术表达式是由算术运算符连接常量、变量、函数的式子。算术表达式中各个运算符的次序为： (
)--&函数--&*,/,div,mod--&+,1
(2)布尔表达式：Turbo Pascal提供给布尔表达式以下基本操作：逻辑运算和关系运算。
（3）数学上的表达式与pascal语言表达式的区别
数学表达式&&&&&&
PASCAL表达式&&&&&&&&&&&
2a&&&&&&&&&&&&&&&&&&
2*a&&&&&&&&&&&&&&&&&&&
*号不能省略
a&b&&&&&&&&&&&&&&&&
a/b&&&&&&&&&&&&&&&&&&&&&
除号的写法
a≠b&&&&&&&&&&&&&&&&
a&&b&&&&&&&&&&&&&&&&&
不等号的写法
a≤b&&&&&&&&&&&&&&&&
a&=b&&&&&&&&&&&&&&&&&
小于等于号的写法
3.1 赋值语句
PASCAL有两个语句可以改变变量的值。赋值语句是其中之一（另一个是读语句）。赋值，顾名思义，就是把一个值赋予某个量。可以这理解：变量相当于装东西的容器，赋值的过程就是把东西放进容器的过程。赋值语句格式如下：
变量：=表达式；
写赋值语句有以下几点要注意：
1、赋值号“：=”
赋值号由两个字符构成，是一个运算符。如果把这两个字符拆开，那么这两个字符就是别的意思了：“：”是分隔符而“=”是关系运算符，判定两个对象是否相等。刚刚写程序的同学要特别注意这一点。
例：a，b：integer；——是一个说明语句。“：”是变量表和变量类型的分隔符
a=b——是一个表达式。它的值是一个布尔类型的量：TRUE或FALSE
a：=3；——是一个语句。把整型常量值3赋给整型变量a
2、变量要先说明
在赋值号左边出现的变量，要在程序头的说明部先加以说明，否则编译时出错。
3、表达式必须要有确定的值
赋值号右边出现的表达式，必须是可以求值的。也就是说，经过运算之后，能得出一个具体的、确定的值出来。大家想一想，如果连表达式自己都不知道自己的值是多少，怎么还能把值“赋予”别人呢？
4、赋值号两边的数据类型必须相同或相容
我们知道，PASCAL中的量不管是变量还是常量都有一个属性称为“数据类型”。数据类型相同的或相容的才可以相互赋值。
怎么来理解这句话呢？打个比方，我们沏功夫茶用的是小茶杯，装饭时用饭碗。如果用饭碗来泡功夫茶，用小茶杯来装饭，那情形一定很滑稽而且是不可行的。回到PASCAL中来，赋值号左边变量如果是整型，右边表达式的值的类型也要是整型；赋值号左边变量如果是字符型，右边表达式的值的类型也要是字符型……否则的话，也要出错了。这是数据类型相同的情况。
对于数据类型相容的，我们也可以用一个例子来帮助理解。我们都喝过功夫茶，也喝过大杯茶。把功夫茶倒在大茶杯里，一般不会出什么问题；但如果把大杯里的茶倒在功夫茶杯里呢？可能小茶杯装不下大茶杯里的茶，茶“溢出”了。在PASCAL中也会出现这种情况。当一种数据类型的取值范围包含着另一种数据类型的取值范围时，就可能出现类型相容的情况。如实型与整型，整型、字符型与它们各自的子界类型……如果把整型值赋给实型变量，把整型子界值赋给整型变量，不会出错；但如果反过来，就会出现“溢出”，出错了。
因些，我们在写赋值语句时，要注意两边的类型是否匹配。
例：有程序如下：
var a，b：integer；c：real；d：0..100；
{-------------以上是相同数据类型进行赋值}
{-------------以上是相容数据类型进行赋值}
{-------------以上两个赋值语句都出现溢出，编译时出错}
3.2 读语句
读语句（read语句）和赋值语句一样，能够改变变量的值。与赋值语句不同，读语句从键盘或文件接收值赋予变量，而赋值语句则直接由程序语句获得。读语句格式如下：
read(变量名表)；
readln(变量名表)；
读语句是编程中用得最多的语句之一。在使用时有几点要注意：
1、变量名表。写在括号中的变量，都要在变量说明中先预以说明；变量与变量之间，以“,”分隔；
read(a,b);
2、从键盘接收数据时，要注意各种不同数据类型数据的分隔符不同。所谓分隔符就是两个完整的数值之间的标记，也可以这样理解，当计算机从键盘读入数据时，一旦碰到分隔符，就认为当前的数据读入已完成，可以把它赋给相应的变量了。各种数据类型的分隔符如下：
数值型（包括整型、实型以及它们的子界类型）以空格或回车符作为分隔符；
字符型不需分隔符（因为字符型数据的长度固定，只有一个）；
字符串以回车符作为分隔符。
3、注意read与readln的区别
例：有两段程序有相同的变量说明如下，不同的读语句，我们可以通过比较它们执行结果的异同来理解read与readln的区别。
变量说明& var a,b,c,d:integer；
程序段一& read(a);
readln(b,c);
程序段二& readln(a);
read(b,c);
read(d) 1& 6& 7&
输入数据& 1 2 3 4 5
在程序段一执行时，“read(a);”语句接收了第一个数据1并将它赋给变量a；接着执行第二个语句“readln(b,c);”，接收了第一行数据中的2、3并把它们分别赋给变量b,c，同时，把本行其它数据全部屏蔽掉，也就是宣布它们全部作废。程序段二的执行情况也是如此。
因此，我们可以得出结论：语句read只管接收数据，语句readln接收完数据后，还把同行的其它数据全部宣布作废。
4、“”语句从键盘接收一个回车符。这个语句通常用在需要暂停的地方。如输出时用来等待程序员看清结果。
3.3 写语句
写（write）语句是Pascal中唯一能将运算结果送出显示在显示器屏幕的语句。格式如下：
write(输出量表)；{输出后不换行}
writeln(输出量表)；{输出后换行}
writeln；{输出一个回车符}
使用写语句时也有一些小问题需要注意。
1、输出量可以是：
变量。输出变量的值。输出多个变量时，变量间用“,”分隔。
表达式。输出的是表达式的值。
常量。直接输出常量值。
2、场宽的限制在输出不同格式的数值时的作用：
例1：输出多个空格。
write(''：n);句子的意思是以n个字符宽度输出冒号前数据项，如果数据项长度不足n，则前面以空格补齐；如果数据项长度大于n，则以实际长度输出。如上语句句输出n个空格。
例2：数据项间隔。
如输出最多四位的数据：write(x:5)。则数据间至少分隔一个空格。
例3：实型数据小数位数的确定。
实型数据不带格式限制时，以科学计数法的形式输出，和我们的一般书写习惯不同。如果加上场宽的限制，则可以有不同的效果：
writeln(a);{输出 1.E+00}
wiiteln(a:0:2);{输出 1.88 整数部分按实际位数输出，小数部分保留两位小数，末位四舍五入.}
writeln(a:0:0):{输出 2 只输出整数部分，小数部分四舍五入}
3、“”语句通常用于输出多组数据时在屏幕上输出空行来分隔数据组。
5.1 For语句
1.递增型FOR循环。&
FOR 循环控制变量:=循环初值 TO 循环终值 DO
循环的语句（或语段）
例： FOR I:=5 TO 10 DO WRITELN (I);
输出的结果为： 5 6 7 8 9 10 即循环一共执行了6次
如果要重复多个语句，一定要用BEGIN-END形式：
FOR I:=1 TO 10 DO
WRITELN (I);
WRITELN (10-I);
2.递减型FOR循环&
FOR 循环控制变量:=循环初值 DOWNTO 循环终值 DO 循环语句
递减型FOR循环与递增型FOR循环基本相同，只是循环控制变量每次递减。
3.FOR循环的几点注意内容：
(1)循环控制变量必须是顺序类型的变量。所谓顺序类型的变量，就是指整型，字符型，枚举型，子界型，不允许是实型。
(2)不允许在循环体内再对循环控制变量赋值。
A:=10;B:=50;
FOR K:=A TO B DO
K:=K+1;{这一句是错误的！！！！！！！！}
WRITELN (K);
(3)当循环初值或循环终值中包含变量时，允许在循环体内改变这些变量的值，但并不改变原定的循环次数。
A:=1;B:=10;
FOR I:=A TO B DO
A:=5;B:=4;
在上面例子中，A，B的值在循环的内部发生了变化，但并不影响循环的次数，依然是10次。
4.多重循环 循环体由PASCAL语句构成，当然也可以包含FOR语句，这就构成了循环的嵌套，形成多重循环。
例如，以下FOR循环输出5行，每行输出10个星号(*)
FOR i:=1 to 5 DO
FOR j:=1 TO 10 DO
Write('*');
初学者应当特别注意，内层的循环变量不能和外层的循环变量相同。也就是说，嵌套的各层循环应当使用不同的变量作为循环变量。
5.2 While语句
&1.WHILE循环的执行形式 WHILE
布尔表达式 DO 语句
WHILE k&0 DO
Writeln (k);
(1)WHIlE 和DO是PASCAL保留关键字，是WHILE循环语句的组成部分。
(2)保留关键字DO后面的“语法”只能是一条语句，称为“循环体”；如果循环
体中需要包含多个语句则应该如上例所示，采用一条复合语句。&
2.WHILE循环的执行功能&&&&&
当执行到WHILE语句时
(1)求出布尔表达式的值
(2)若布尔表达式的值为真，则执行循环体内的语句；若为“假”，执行步骤4
(3)重复步骤1和2
(4)循环结束，执行循环后面的语句。
5.3 Repeat-Until语句
1．REPEAT-UNTIL类型的循环的执行形式
UNTIL 布尔表达式
例如：以下循环求n=1+2+3+……+100
n:=0;t:=i;
n:=n+t; t:=t+1;
UNTIL t&100;
(1)REPEAT和UNTIL是PASCAL保留关键字。
(2)在REPEAT和UNTIL之间的语句构成循环。在它们之间可以有任意多个语句，这一点和FOR，WHILE循环不同，FOR，WHILE循环体在语法上只允许一条语句。
2．REPEAT-UNTIL循环的执行功能
(1)遇到REPEAT语句后，即进入循环体，顺序执行循环体内的语句。
(2)遇到UNTIL语句后，求布尔表达式的值。若值为假，则返回步骤1；若为“真”，执行步骤3
(3)循环结束，执行UNTIL后面的下一条语句。
6.1 一维数组
a:array [1..10]
其中：a是这一批数据的名称，称为数组名；array、of是定义数组的保留字；中括号中的数字是数据编号的下限和上限，财时也说明了数据的个数（上限-下限）；最后一个是数据的基类型，如integer，char，real，boolean。
2、数组元素的输入：
数组名代表的并不是一个变量，而是一批变量，因而，不能直接整个数组读入，而是要逐个数组元素读入，通常用循环结构来完成这一功能。下面是几个常用输入数组元素的例子：
for i:=1 to 10 do read(a[i]);
{————从键盘读入数组元素的值；最常用的方法}
for i:=1 to 10 do a[i]:=i;
{————数组元素a[1]到a[10]的值分别为1到10；数据赋初值}
for i:=1 to 10 do a[i]:=0;
{————数组元素清0；最常用的数据初始化的方法}
for i:=1 to 10 do a[i]:=random(100);
{————随机产生10个100以内的数，赋给各数组元素}
3、数组元素的输出：
和数组元素的输入相同，数组元素的输出也不能由一个write语句直接完成。同样要逐个数组元素输出。通常也用循环结构来完成这一功能：
for i:=1 to 10 do write(a[i],' ');{————数组元素之间用空格分隔}
&4、数组的应用：
例1：从键盘输入10个数，将这10个数逆序输入，并求这10个数的和，输出这个和。
program p1;
&&& a:array
for i:=1 to 10 do read(a[i]);
for i:=10 downto 1 do write(a[i],' ');
&&& for i:=1 to
10 do s:=s+a[i];
writeln('s=',s);
&例2：用筛法求100以内的素数（质数）。
分析：素数是除了1和它本身以外没有其它约数的数。用筛法求素数的方法是：用质数筛去合数：从第一个素数2开始，把它的倍数去掉；这样2以后的第一个非0数就一定也是素数，把它的倍数也删了……重复这个删数过程，直到在所找到的素数后再也找不到一个非0数。把所有非0数输出。
program p2;
&&& a:array
for i:=1 to 100 do a[i]:=i;
a[1]:=0;i:=2;
while i&=100 do
while k&=100 do
&&&&&&&&&&&&
&&&&&&&&&&&&
{————上面将所有a[i]的倍数清0}
while a[i]=0 do i:=i+1;
{————查找接下来的第一个非0数}
for i:=1 to 100 do if a[i]&&0 then
write(a[i],' ');
6.2 二维数组
一维数组在编程中多用于描述线性的关系：如一组数；一组成绩；一组解答等。数组元素只有一个下标，表明该元素在数组中的位置。二维数组在编程中多数用于描述二维的关系：如地图、棋盘、城市街道、迷宫等等。而二维数组元素有两个下标：第一个下标表示该元素在第几行，第二个下标表示在第几列。
1.二维数组的定义：
a：array[1..10,1..5] of integer；
其中：a是数组名，由程序员自定；array和of是定义数组的保留字；（这两点和一维数组定义的格式一样）中括号中的两个范围表示二维数组共有多少行、多少列（第一个范围表示行数，第二个范围表示列数）；最后一个表示数组元素的类型，规定和一维数组一样。如上例，定义了一个二维数组a，共有10行5列。
2.使用二维数组：
1、数组元素的指称：数组名[行号，列号]。如第三行第四个元素：a[3,4]。
对某一行进行处理。如累加第4行的数据。则固定行号为4。如：for i:=1 to 5 do s:=s+a[4,i];
对某一列进行处理。如累加第4列的数据。则固定列号为4。如：for i:=1 to 10 do
s:=s+a[i,4];
2、二维数组的输入输出要用双重循环来控制：
for i:=1 to 10 do{————控制行数}
&&& for j:=1 to
5 do read(a[i,j]){————第一行读入5个元素}
{————读入一个换行符}
{————最常用的方法：从键盘读入数据初始化二维数组}
for i:=1 to 10 do
for j:=1 to 5 do a[i,j]:=0;
{————最常用的方法：将二维数组清0}
for i:=1 to 10 do
for j:=1 to 5 do write(a[i,j]:4);
{————最常用的输出方法：按矩阵形式输出二维数组的值}
例1：竞赛小组共有20位同学，这学期每位同学共参与了三项比赛，请统计每位同学的平均分。
分析：定义一个20行3列的二维数组来存放这些成绩。定义一个20个元素的一维数组来存放平均分。
program p1;
&&& a:array
[1..20,1..3]
b:array [1..20]
for i:=1 to 20 do
for j:=1 to 3 do read(a[i,j]);
{————从键盘上读入20个同学的三次竞赛成绩}
for i:=1 to 20 do b[i]:=0;
{————先将平均分数组清0}
for i:=1 to 20 do
for j:=1 to 3 do b[i]:=b[i]+a[i,j];{————计算总分}
b[i]:=b[i]/3;{————计算平均分}
for i:=1 to 20 do write(b[i]:5:1);
{————输出平均分}
6.3 字符串
字符串用于存放整批的字符数据。通常编程中使用字符串存放字符化了的数字数据。如高精度运算时存放操作数和运算结果。字符串可以看作是特殊的字符串数组来处理。当然，它也有自已的特点。下面是字符串定义的格式：
s: s1:string[15];
字符串定义时，如不指定长度，则按该类型的最大长度（255个字符）分配空间，使用时最大可用长度为255个；如果在中括号中给出一个具体的值（1—255之间），则按这个值的大小分配空间。使用时，最大的可用长度即为该值。
2.字符串的输入、输出：
字符串类型既可按数组方式输入、输出，也可直接输入、输出：readln(s)；writeln(s)；多个字符串输入时以回车作为数据间的分隔符；每个readln语句只能读入一个字符串。
3.有关字符串的操作：
操作& 类型& 作用&
返回值& 例子&
length(s) 函数& 求字符串s的长度 整型 s:='';
l:=length(s);{l的值为9}
copy（s,w,k) 函数& 复制s中从w开始的k位 字符串
s1:=copy(s,3,5);{s1的值是'34567'}
val(s,k,code) 过程&
将字符串s转为数值，存在k中；code是错误代码&& var
s:='1234';
val(s,k,code);
write(k);{k=1234}
str(i,s) 过程&
将数值i转为字符串s&& i:=1234;
write(s);{s='1234'}
Delete(s,w,k) 过程&
在s中删除从第w位开始的k个字符&& s := 'Honest
Abe Lincoln';
Delete(s,8,4);
Writeln(s); { 'Honest Lincoln' }
Insert(s1, S, w) 过程&
将s1插到s中第w位&& S := 'Honest
Insert('Abe ', S, 8); { 'Honest Abe Lincoln' }
Pos(c, S) 函数& 求字符c在s中的位置 整型 S := ' 123.5';
i :=Pos(' ', S);{i的值为1}
将两个字符串连接起来&& s1:='1234';
s2:='5678';
s:=s1+s2;{''}
1.过程的定义
procedure 过程名(形式参数:参数说明);{也可以不带参数}
2．过程的调用
过程名(实在参数表);
例1:求n个自然数的最大公约数;
program gcd1;
const maxn=100;
var n,i,gcd:
a:array[1..maxn]
&write('n=(&100)');readln(n);
&for i:=1 to n do
&write('a[',i,']=');readln(a[i]);
&until a[i]&0;
procedure find_gcd(x,y:integer);{定义过程}
& begin x:=y;y:=r;r:=x mod
&writeln('GCD=' ,gcd);
&gcd:=a[1];
&for i:=2 to n do
&find_gcd(gcd,a[i]);
&1．函数的定义
function 函数名(形参表):函数类型; { ————函数首部}
var {————局部变量说明部分}
begin {————函数体}
... {————函数语句}
函数名:=表达式
２．函数的调用:
函数在语法上相当于一个表达式，所以，调用时，函数不能独立成为一个语句；它可以出现在任何表达式可以出现的地方。
例如赋值语句的右边：
X:=函数名(实在参数表); {————X的类型与函数类型必须一致}
又，如果函数类型是boolean，则还可以出现在条件语句中，充当条件表达式：
if 函数名(实在参数表) then ……
例3：编一程序，求从10名同学中选出3名代表，有几种不同的选法。
&（公式：C(m,n)=m!/n!*(m-n)!从m中选n)
program zohe1;
function factor(x:integer):{定义}
& for i:=1 to x do p:=p*i;
& factor:=p;{这个语句必须}
&write('m,n=');readln(m,n);
&c:=factor(m) div
(factor(n)*factor(m-n));{调用}
&writeln('c(',m,',',n,')=',c);
8.3全局变量和局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。全局变量作用域是整个程序；局部变量作用域是定义该变量的子程序。当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
例4：全局变量和局部变量。
program local_
procedure sub1;
& writeln('i in sub=',i);
& writeln('k in sub=',k);
&i:=2;k:=9;
&writeln('i in main=',i);
&writeln('k in sub=',k);
&writeln('i in main=',i);
&writeln('j in main=',j);
上述程序运行时将出现Unknown
Identfier；因为变量j在主程序中没定义。
当删除本语句时。运行结果如下：
i in main＝2
k in main＝9
i in sub＝17
k in sub＝9
i in main＝2
8. 4 值参和变量参数
值形参——传值：调用时可用表达式代替形参，不该变实在参数的值。
变量形参——传地址：调用时必须用变量代替行参变量，改变实在参数的值。
例4：请看下列程序的运行结果。
program li3_10;
var& a,b,c:
procedure sub(x,y:var z:integer);
&x:=x+1;y:=y+1;z:=x+y;
&writeln('sub:x=',x:2,'y=',y:2,'z=',z:2);
&a:=1;b:=4;c:=9;
&writeln('main:a=',a:2,'b=',b:2,'c=',c);
&sub(a,b,c);
&writeln('main:a=',a:2,'b=',b:2,'c=',c);
&sub(c+5,b*b,a);
&writeln('main:a=',a:2,'b=',b:2,'c=',c);
main：a＝1 b＝4 c＝9
sub：x＝2 y＝5 z＝7
main：a＝1 b＝4 c＝7
sub：x＝13 y＝17 z＝30
main：a＝30 b＝4 c＝7
Pascal有丰富的数据类型，在程序设计中有特殊而方便的应用。
类型定义的语法格式：
&标识符1&=&类型1&；
&标识符2&=&类型2&；
&标识符n&=&类型n&；
8.1子界与枚举
1.子界类型:
当某些变量的取值范围很具体时,可用子界类型,它更符合实际、便于查错和节省内存。
type riqi=1..31;
zimu='A'..'Z';
也可以直接定义:
day：1..31;
year:0..200;
ch1:'A'..'Z';
8.2 枚举类型:
通过预定义列出所有值的标识符来定义一个有序集合，这些值的次序和枚举类型说明中的标识符的次序是一致的。枚举类型的形式：
(标识符1，……，标识符n)
例如：
daystype=(sunday,monday,tuesday,wednesday,thursday,friday,saturday)
枚举元素只能是标识符，而不能是数值常量或字符常量。例如以下的定义是错误的：&
type daystype=('sun','mon','tue','wed','thu','fri','sat')
枚举元素是标识符，不要把作为枚举元素的标识符视作变量名，它不能被赋值。同一个枚举元素不能出现在两个或两个以上的枚举类型定义中。例如以下的定义是错误的：
type daytype1=(monday,tuesday);
daytype2=(monday,wednesday);
可以将枚举类型的定义和变量的定义结合在一起。例如：var a:(monday,tuesday,sunday)
枚举类型属于顺序类型。根据定义类型时各枚举元素的排列顺序确定它们的序列，序列号从0开始。
例如：已经定义daystype
ord(sunday)=0,succ(sunday)=monday,pred(friday)=thursday
但是枚举类型中的第一个元素没有前趋，最后一个元素没有后继。Turbo
Pascal不允许直接读写枚举值，所以枚举值的输出常用case语句间接的输出。枚举值的输入，则要一一判断读入字符是否是枚举类型的标识符。若是才能赋给枚举变量，否则就会出错。
例如：枚举值的输出
case day of
sunday:write('sunday');
monday:write('monday');
tuesday:write('tuesday');
wednesday:write('wednesday');
thursday:write('thursday');
friday:write('friday');
saturday:write('saturday');
1．集合的定义：
type 类型名=set of 基类型
例如：
type
num=
var
n:
var
n:
２．集合的表示：
用一组方括号括号一组元素来表示，元素之间用逗号分隔。如：
[A,B,C,D]－－有四个枚举量的集合
['A','B','C','D']－－有四个字符的集合
[1..20]－－包含了1到20中所有整数的集合
[0]－－只有一个元素0的单元素集
[]－－空集
３.集合的运算：
(1)并(a+b):属于a或属于b
[0..7]+[0..4]的值为[0..7]
(2)交(a*b):既属于a又属于b
[0..7]*[0..4]的值为[0..4]
(3)差(a-b):属于a但不属于b
[0..7]-[0..4]的值为[5..7]
(4)相等(a=b):a,b的元素完全一样
[0..7]=[0..4]的值为false
(5)不等(&&):元素不一样
[0..7]&&[0..4]的值为true
(6)包含于(&=):
[0..7]&=[0..4]的值为false
(7)包含(&=):
[0..7]&=[0..4]的值为true
(8)成员(in):
1 in [0..4]的值为true
４.注意事项：
(1)集合运算相当快，在程序中常用集合表达式来描述复杂的测试。如
A)条件表达式： (ch='T') or (ch='t') or (ch='Y') or (ch='y')
可用集合表达式表示为：
ch in ['T','t','Y','y']
B)if (ch&=20) and (ch&=50) then
可写成：
if ch in [20..50] then ...;
(2)集合类型是一种使用简便，节省内存面又运算速度快的数据类型。
(3)Turbo Pascal规定集合的元素个数不超过256个(当实际问题所需的元素个数大于256时，
可采用布尔数组代替集合类型)。所以如下定义是错误的： var i:
(4)集合类型变量不能进行算术运算，了不允许用读/写语句直接输入/输出集合。 所以集合的建立：
A)要通过赋值语句实现;
B)或先初始化一个集合，然后通过并运算向集合中逐步加入各个元素.
(5)集合元素是无序的，所以ord，pred和succ函数不能用于集合类型的变量。
1.记录的定义：
type 类型标识符=record
字段名1：类型1；
字段名2：类型2；
...
字段名n：类型n；
type
studata=record
num:string[6];
name:string[8];
sex:
s:array[1..5]
student:
students:array[1..10]
2.记录的运用：
(1)对记录中和个域的引用，要写出记录名和域名，如：student.num
(2)开域语句：with。
with 记录名 do 语句；
with 记录名1，记录名2，... do 语句；
注意：
1. 在do后面语句中使用的记录的域时，只要简单地写出域名就可以了， 域名前的记录变量和"."均可省略。
2. 在关键字with后面，语句可以是一个简单语句，了可以是一个复合语句。
虽然在with后可以有多个记录变量名，但一般在with后只使用一个记录变量名。
文件是一种构造型的数据类型。在程序中都需要产生一些输出，也需要接受若干个输入。这些输入、输出实际上是用文件的方法来实现的，在Pascal中用标准文件“input”和“output”来实现，它们分别对应标准输入设备和标准输出设备（可省略不写）这也就是一些程序的程序书写如下的原因了：
program ex(input,output);
但有时大量数据的读入和输出都是来是磁盘文件，这就要求我们必须熟练掌握对磁盘文件的操作。
对于我们来说，我们只必须掌握文本文件（或称正文文件，text）的读写即可:
1.文本文件的定义：
文本文件不是简单地由某类型的元素序列所组成，它的基本元素是字符，由它们构成行，若干行组成一份原文。由于各行的长度可以不同，所以文本文件只能顺序地处理。文本文件的定义如下：
var
fp:
2.文本文件的读操作：
(1)调用assign过程，把磁盘文件赋予文本文件变量；
assign(fp,filename);
(2)调用reset过程，为读操作做准备；
reset(fp);
(3)在需要读数据的位置调用read过程或readln过程。
readln(fp,var1,var2,...,varn);
3.文本文件的写操作：
(1)调用assign过程，把磁盘文件赋予文本文件变量；
assign(fp,filename);
(2)调用rewrite过程，为读操作做准备；
rewrite(fp);
(3)在需要读数据的位置调用write过程或writeln过程。
writeln(fp,var1,var2,...,varn);
4.文本文件的关闭操作：
close(fp);
5.文本文件的其他操作：
(1)EOF(fp)—布尔函数，用于判断文件结束否。
(2)EOLN(fp)—布尔函数，用于判断行结束否。
例1:下面是一个建立和使用文件的程序：
const n=3; m=2;
type student=record
score:array[1..m] of 0..100;
var& st:array[1..n]
sumst:array[1..n]
sumsub:array[1..m]
&assign(stfile,'score.fil');
&rewrite(stfile);
&for i:=1 to n do
&writeln('Input student&
',i,'& name and ',m,' score');
&readln(st[i].name) ;
&&& for j:=1 to
read(st[i].score[j]);
&write(stfile,st[i]);
&close(stfile);
assign(stfile,'score.fil');
reset(stfile);
for i:=1 to m do sumsub[i]:=0;
for i:=1 to n do
& read(stfile,st[i]);
& with st[i] do
& sumst[i]:=0;
& for j:=1 to m do
& sumst[i]:=sumst[i]+score[j];
& sumsub[j]:=sumsub[j]+score[j];
close(stfile);
&for i:=1 to n do
&& sum:=sum+sumst[i];
&for i:=1 to n do
&&& with st[i]
write(name);
&&& for j:=1 to
m do write(score[j]:6);
writeln(sumst[i]:6);
&write('sum=');
&for i:=1 to m do
&write(sumsub[i]:6);
&writeln(sum:8);
指针是通过地址来访问变量的一种特殊的数据类型，属于动态的数据结构，它可以在需要时产生，用完后则又可以取消或回收，以减少占用的内存空间。指针变量与其他类型的变量不同，它占有的不是数据，而是地址。
由于动态数据结构的变量是在程序执行过程中动态生成的，所以不能预先予以说明，无法预先给这些变量起名字，访问时也无法通过名字直接输出或显示，而只能用指针得到其地址，然后间接访问。
1、定义指针类型
在Turbo
Pascal中，指针变量用来存放某个存储单元的地址，即指针变量指向某个存储单元。一个指针变量仅能指向某一种类型的存储单元，这种数据类型是在指针类型的定义中确定的，称为指针类型的基类型。指针类型定义如下：
类型名＝^基类型名；
例如：type q=^
var a,b,c:q;
说明：q是一指向整型存储单元的指针类型，其中"^"为指针符。a,b,c均定义为指针变量，分别可以指向一个整型存储单元。
上例也可用变量说明为：
var a,b,c:^
指针也可以指向有结构的存储单元。
例如：type person=record
name:string[10];
sex:(male,female);
age:20..70
var pt:^
pt为指向记录类型person的指针变量。
2、动态变量
应用一个指针指向的动态存储单元即动态变量的形式如下：
指针变量名^
例如：p^、q^、r^
指针变量p和它所指向的动态变量p^之间有如下关系：
以下语句把整数5存放到p所指向的动态变量p^中去：
以下语句把p所指向的p^中的值赋给整型变量i：
如果指针变量p并未指向任何存储单元，则可用下列赋值语句：
其中nil是保留字，表示“空”，相当于C语言里面的null
3、对动态变量的操作
在Turob Pascal程序中，动态变量不能由var直接定义而是通过调用标准过程new建立的。过程形式为：
new(指针变量名);
如果有下列变量定义语句：
var p:^
仅仅说明了p是一个指向整型变量单元的指针变量，但这个整型单元并不存在，在指针变量p中还没有具体的地址值。在程序中必须通过过程调用语句：new(p);才在内存中分配了一个整型变量单元，并把这个单元的地址放在变量p中，一个指针变量只能存放一个地址。在同一时间内一个指针只能指向一个变量单元。当程序再次执行new(p)时，又在内存中新建立了一个整型变量单元，并把新单元的地址存放在p中，从而丢失了旧的变量单元的地址。
为了节省内存空间，对于一些已经不使用的现有动态变量，应该使用标准过程dispose予以释放。过程形式为：dispose(指针变量名)；为new(指针变量名)的逆过程，其作用是释放由指针变量所指向的动态变量的存储单元。例如在用了new(p)后在调用dispose(p)，则指针p所指向的动态变量被撤销，内存空间还给系统，这时p的值为
4．需要注意之处
1、P与P^的区别
P是指向该动态变量的指针变量名，P^则称为动态变量或标志变量。P的值是P^的首地址，P^的值为与基类型相同的一个值。
2、定义后及时分配存储单元
定义了一个指针变量后，并没有为该指针分配动态存储单元，此时的P的值无定义，调用P^则会产生运行错误。若想使该指针可用，可以对指针赋值，也可以通过NEW（）过程分配存储单元。
3、使用后及时收回存储单元
指针使用后，不会自动归还占用的存储空间，应及时使用DISPOSE（）过程来释放P^所占用的存储单元，以免浪费有限的存储空间．
11.2 单链表
单链表的数据类型可定义如下：
type dlb=^
&node=record
连续输入一序列整数,组成链表（并以动态的形式把它们记录下来）,当输入的数为-1时,停止输入,然后把输入的整数按相反的顺序输出.
type link=^
data=record
& readln(i);
& while i&&-1
& with p^ do
&& num:=i;
&& next:=q;
& readln(i);
& while p&&nil
&& write(p^.num:6);
练习:将例1中如果数据不按现反的顺序(按输入时的顺序)输出时,怎样建表.(程序)
上述建表方式其实就是分别从表头和表尾插入元素,下面是从表中插入元素;
例2:输入若干整数（输入32767停止输入）排序（小到大）输出之。
type link=^
data=record
var head,p,q,r:
& readln(i);
& while i&&32767
&& new(p);
&& p^.num:=i;
&& p^.next:=
&& if head=nil then begin
head:=p;end
if p^.num&q^.num then begin head:=p;p^.next:=q
while (p^.num &=q^.num) and
(q&&nil) do begin r:=q
if q=nil then r^.next:=p else begin r^.next:=p;p^.next:=q end
&& readln(i);
& while p&&nil
write(p^.num:6);
指针是通过地址来访问变量的一种特殊的数据类型，属于动态的数据结构，它可以在需要时产生，用完后则又可以取消或回收，以减少占用的内存空间。指针变量与其他类型的变量不同，它占有的不是数据，而是地址。
由于动态数据结构的变量是在程序执行过程中动态生成的，所以不能预先予以说明，无法预先给这些变量起名字，访问时也无法通过名字直接输出或显示，而只能用指针得到其地址，然后间接访问。
1、定义指针类型
在Turbo
Pascal中，指针变量用来存放某个存储单元的地址，即指针变量指向某个存储单元。一个指针变量仅能指向某一种类型的存储单元，这种数据类型是在指针类型的定义中确定的，称为指针类型的基类型。指针类型定义如下：
类型名＝^基类型名；
例如：type q=^
var a,b,c:q;
说明：q是一指向整型存储单元的指针类型，其中"^"为指针符。a,b,c均定义为指针变量，分别可以指向一个整型存储单元。
上例也可用变量说明为：
var a,b,c:^
指针也可以指向有结构的存储单元。
例如：type person=record
name:string[10];
sex:(male,female);
age:20..70
var pt:^
pt为指向记录类型person的指针变量。
2、动态变量
应用一个指针指向的动态存储单元即动态变量的形式如下：
指针变量名^
例如：p^、q^、r^
指针变量p和它所指向的动态变量p^之间有如下关系：
以下语句把整数5存放到p所指向的动态变量p^中去：
以下语句把p所指向的p^中的值赋给整型变量i：
如果指针变量p并未指向任何存储单元，则可用下列赋值语句：
其中nil是保留字，表示“空”，相当于C语言里面的null
3、对动态变量的操作
在Turob Pascal程序中，动态变量不能由var直接定义而是通过调用标准过程new建立的。过程形式为：
new(指针变量名);
如果有下列变量定义语句：
var p:^
仅仅说明了p是一个指向整型变量单元的指针变量，但这个整型单元并不存在，在指针变量p中还没有具体的地址值。在程序中必须通过过程调用语句：new(p);才在内存中分配了一个整型变量单元，并把这个单元的地址放在变量p中，一个指针变量只能存放一个地址。在同一时间内一个指针只能指向一个变量单元。当程序再次执行new(p)时，又在内存中新建立了一个整型变量单元，并把新单元的地址存放在p中，从而丢失了旧的变量单元的地址。
为了节省内存空间，对于一些已经不使用的现有动态变量，应该使用标准过程dispose予以释放。过程形式为：dispose(指针变量名)；为new(指针变量名)的逆过程，其作用是释放由指针变量所指向的动态变量的存储单元。例如在用了new(p)后在调用dispose(p)，则指针p所指向的动态变量被撤销，内存空间还给系统，这时p的值为
4．需要注意之处
1、P与P^的区别
P是指向该动态变量的指针变量名，P^则称为动态变量或标志变量。P的值是P^的首地址，P^的值为与基类型相同的一个值。
2、定义后及时分配存储单元
定义了一个指针变量后，并没有为该指针分配动态存储单元，此时的P的值无定义，调用P^则会产生运行错误。若想使该指针可用，可以对指针赋值，也可以通过NEW（）过程分配存储单元。
3、使用后及时收回存储单元
指针使用后，不会自动归还占用的存储空间，应及时使用DISPOSE（）过程来释放P^所占用的存储单元，以免浪费有限的存储空间．
11.2 单链表
单链表的数据类型可定义如下：
type dlb=^
&node=record
连续输入一序列整数,组成链表（并以动态的形式把它们记录下来）,当输入的数为-1时,停止输入,然后把输入的整数按相反的顺序输出.
type link=^
data=record
& readln(i);
& while i&&-1
& with p^ do
&& num:=i;
&& next:=q;
& readln(i);
& while p&&nil
&& write(p^.num:6);
练习:将例1中如果数据不按现反的顺序(按输入时的顺序)输出时,怎样建表.(程序)
上述建表方式其实就是分别从表头和表尾插入元素,下面是从表中插入元素;
例2:输入若干整数（输入32767停止输入）排序（小到大）输出之。
type link=^
data=record
var head,p,q,r:
& readln(i);
& while i&&32767
&& new(p);
&& p^.num:=i;
&& p^.next:=
&& if head=nil then begin
head:=p;end
if p^.num&q^.num then begin head:=p;p^.next:=q
while (p^.num &=q^.num) and
(q&&nil) do begin r:=q
if q=nil then r^.next:=p else begin r^.next:=p;p^.next:=q end
&& readln(i);
& while p&&nil
write(p^.num:6);
练习:建立一个若干整数的链表后(-1结束）再从链表中删除从键盘上输入一个整数的所有结点.(程序)
链表的删除程序如下:
type link=^
data=record
var head,p,tail,r:
& writeln('input lbdata:');
& readln(i);
& while i&&-1
&& new(p);
&& p^.num:=i;
&& p^.next:=
& if head=nil then begin head:=p; tail:=p
else begin tail^.next:=p; tail:=
& readln(i);
& write('input delete integer:');
& readln(x);
& while p&&nil
&&& if p^.num=x
if p=head then begin head:=p^.p:=head end
&&&&&&&&&&&&&&
p^.next&&nil&
&&&&&&&&&&&&&&&&&&&&&&
begin r^.next:=p^.p:=p^.next end
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&
begin r^.next:=p:=nil end
else begin r:=p;p:=p^.
& while p&&nil
&& write(p^.num:6);
12.1 单步执行
任何一个天才都不敢说，他编的程序是100%正确的。几乎每一个稍微复杂一点的程序都必须经过反复的调试，修改，最终才完成。所以说，程序的调试是编程中的一项重要技术。我们现在就来掌握一下基本的程序调试。
我们以下的示范，是以时下比较流行的Borland Pascal
7.0为例子，其他的编程环境可能略有不同，但大致上是一致的。
我们先编一个比较简单的程序，看看程序是如何调试的。
for i:=1 to 300 do
&&&&&&&&&&
if i mod 2 = 0 then
&&&&&&&&&&&&&&&&&
if i mod 3 = 0 then
&&&&&&&&&&&&&&&&&&&&&&
if i mod 5 = 0 then
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
writeln(i);
该程序是输出300以内同时能被2，3，5整除的整数。 现在我们开始调试。
调试有多种方法，先介绍一种，权且叫步骤法，步骤法就是模拟计算机的运算，把程序每一步执行的情况都反映出来。通常，我们有F8即STEP这个功能来实现，如图：
不断地按F8，计算机就会一步步地执行程序，直到执行到最后的“end.”为止。
可能你还没有发现F8的威力，我们不妨把上面的程序略微修改一下，再配合另外的一种调试的利器watch，你就会发现步骤法的用处。
for i:=1 to 300 do
&&&&&&&&&&
&&&&&&&&&&
&&&&&&&&&&
&&&&&&&&&&
if i mod 2 = 0 then a:=
&&&&&&&&&&
if i mod 3 = 0 then b:=
&&&&&&&&&&
if i mod 5 = 0 then c:=
&&&&&&&&&&
if a and b and c then writeln(i);
如图，我们单击菜单栏中debug选项，里面有一项叫watch的选项，我们单击它。
就会出现一个watch窗口：
watch窗口可以让我们观察变量的变化情况，具体操作是在watches窗口内按Insert键：
这时，屏幕上弹出一个菜单，我们输入所需要观察的变量名，我们分别输入i,a,b,c这4个变量名，于是watches窗口内就有如下的4个变量的状态：
这时，我们再次使用步骤法，我们会发现，这4个变量的状态随着程序的执行而不断变化，比如：
这样我们就可以方便地知道执行每一步之后，程序的各个变量的变化情况，从中我们可以知道我们的程序是否出错，在哪里出错，方便我们及时地修改。
下一次，我们介绍另外的一种方法，断点法。
12.2 断点发
在前面我们已经学习了基本的程序调试方法——步骤法。步骤法有一个缺点，就是在遇到循环次数比较多或者语句比较多的时候，用起来比较费时，今天我们来学习一种新的也是常用的调试方法——断点法。
所谓断点法，就是在程序执行到某一行的时候，计算机自动停止运行，并保留这时各变量的状态，方便我们检查，校对。我们还是以前面求同时能被2，3，5整除的3000以内的自然数为例，具体操作如下：
我们把光标移动到程序的第14行，按下ctrl+F8，这时我们会发现，该行变成红色，这表明该行已经被设置成断点行，当我们每次运行到第14行的时候，计算机都会自动停下来供我们调试。
我们必须学以致用，赶快运用刚学的watch方法，看看这家伙到底有多厉害。
请记住，计算机是执行到断点行之前的一行，断点行并没有执行，所以这时b:=true这一句并没有执行。
断点行除了有以上用处之外，还有另外一个重要用处。它方便我们判断某个语句有没有执行或者是不是在正确的时刻执行，因为有时程序由于人为的疏忽，可能在循环或者递归时出现我们无法预料的混乱，这时候通过断点法，我们就能够判断程序是不是依照我们预期的顺序执行。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。
