关于pascal的问题

1 树的概念：非线性数据结构，它或者是一棵空树，即不含结点的树，或者是一棵空树，即至少有一个结点的树。

(1)每个元素称为结点(2)有一个特定的结点称为根结点或树根(3)除根结点外，其余结点被分成m个互相不相交的有限集合，而每一个子集又都是一棵树，成为原树的子树。

(1)树是递归定义的，这就决定了树的 *** 作和应用大都采用递归思想来解决；

(2)除了根结点没有前趋结点，其余每个结点都有唯一的一个前趋结点；

(3)所有结点都可以有0或者多个后继结点；叶子结点没有后继结点；

(4)一般，树中同层结点从左到右是有次序的，他们之间次序不能互换，这样的树成为有序树，否则为无序树；

(5)树的结点之间关系通过连线表示，连线上没有箭头但不代表无向，其方向隐含为从上向下；

(6)森林是m棵互不相交的树的集合；

2 树的深度和宽度：

③ 结点的度：一个结点拥有的子树的个数称为该结点的度。

②树的度：树的所有结点中的最大度称为该树的度，又称宽度。

③树的深度：树中结点的最大层次称为树的深度或高度。

树的表示方法：①树形图 ②广义表③集合图④凹入表

所有叶结点的度均为0。度不为0的结点成为分支结点。

3 树的其他概念：

父结点/子结点/兄弟结点/

从根结点到某个子结点所经过的所有结点称为这个子结点的祖先；

以某个结点为根的子树中的任一结点都是该结点的子孙；

从一个结点出发，自上而下沿树枝到达另一个结点，称两点间存在一条路径，该路径可用经过的结点序列表示，路径长度等于路径上结点的个数-1；

4 二叉树（度不超过2的树，子树有左右之分，次序不能颠倒，是有序树，二叉树的5种形态）

二叉树的性质：

①二叉树第i（i≥1）层上的结点数目最多为2i-1。

②深度为K的（K≥1）的二叉树最多有2k-1个结点。（满足这个条件即为满二叉树）

③在任意一棵二叉树中，若叶结点的个数为N0，度为2的结点数为n2，则n0=n2+1。

5 满二叉树：

一棵深度为K且有2k-1个结点的二叉树称为满二叉树。

①不存在度数为1的结点 ②且树叶都在最下一层 ③每一层的结点数都达到最大值 （度2）

设满二叉树的结点个数为N，结点标号为1，2，3，……，n，结点位置与标号i具有如下关系：

标号性质：（也为完全二叉树标号性质）

⑴i=1。结点i为根结点，无双亲。

⑵i>1。结点i的双亲结点编号为trunc(i/2)。

⑶n为奇数时，左右分支结点都有左孩子右孩子，n为偶数时，编号为n/2的结点只有左孩子无右孩子。

⑷标号i的结点如有左孩子则标号为i2，如有右孩子则标号为2i+1。

⑸(i>1)，i为偶数时结点i的右兄弟编号为i+1，i为奇数时结点i的左兄弟结点编号为i-1。

⑸2i<n则结点i的左孩子结点编号为2i。2i>n则结点i为叶结点。

⑹2i+1<n则结点i的右孩子结点编号为2i+1。2i+1>n则结点i无右孩子。

6 完全二叉树：

若一棵二叉树与等高度的满二叉树相比，最多只能在最下层结点（叶子），并且缺少的结点都在最右边，即最下层的结点都集中在该层最左边，则称此二叉树为完全二叉树。

当深度为k的有n个结点的二叉树，当且仅当其每个结点都与深度为k的满二叉树中的从上向下自左向右的编号

从1-n一一对应时，成为完全二叉树。

对于任一结点，若它的右子树深度为m则它的深度只能为m或m+1。

具有n个结点的完全二叉树的深度为 trunc [log2n]+1 round [log2(n+1)]

7 树/二叉树的存储结构（线性存储/链式存储）

-----------------------------------------------------------------------------------------------------------------------------------------------------

type pointer=record 父亲表示法 线性

data:integer;

parent:integer;

end;

var tree:array[110]of pointer;

type pointer=^link 孩子表示法 链式

link=record

data:char;

child:array[110]of pointer;

end;

var t:pointer;

----------------------------------------------------------------------------------------------------------------------------------------------------

type pointer=^link 父亲/孩子表示法 链式

link=record

data:char;

father:pointer;

child:array[110]of pointer;

end;

var t:pointer;

type pointer=^link 孩子兄弟表示法 链式

link=record

data:char;

firstchild,next: pointer;

end;

var t:pointer;

---------------------------------------------------------------------------------------------------------------------------------------------------

type pointer=record 二叉树 线性

data:char;

l,r:integer;

end;

var tree:array[110]of pointer;

type pointer=^link 二叉树 链式

link=record

data:char;

l,r:pointer;

end;

var t:pointer;

---------------------------------------------------------------------------------------------------------------------------------------------------

8 树的遍历：

二叉树的遍历方法：①前序遍历（DLR） 又称先根遍历

②中序遍历 (LDR) 又称中根遍历

③后序遍历 (LRD) 又称后根遍历

9 最优二叉树（哈夫曼树）：

1 树的路径长度与权

在一棵树中，两个结点之间的路径分支数称为这两结点的路径长度。

从根结点到某个叶结点的路径分支数称为该叶结点的路径长度。

从树的根结点到每个结点的路径长度之和称为树的路径长度。

为了研究实际问题的需要，有时要给树的叶结点分别赋予实数值，称为叶结点的权值。

若一棵树共有n个带权叶结点，设Wi为树的第i个叶结点的权值，Li为第i个叶结点的路径长度，则树的所有叶结点带权路径长度之和（WPL）的计算公式为： n

WPL=∑WiLi

i=1

2 哈夫曼树

所有叶结点带权路径长度之和最小的树称为哈夫曼树，又称为最优二叉树。

哈夫曼树的特点是树中权值越大的叶结点离根结点越近。

1 二叉树的建立和遍历 （DLR/线性/结点&标号输入）

program temp;

const m=12;

type

node=record

data:char;

l,r:integer;

end;

var tree:array[1m] of node;

i,k:integer;

procedure preorder(i:integer);

begin if i<>0 then begin

write(tree[i]data:4);

preorder(tree[i]l);

preorder(tree[i]r);

end;

end;

begin

for i:=1 to m do

with tree[i] do readln(data,l,r);

preorder(1);

readln;

end

LDR：中序遍历 inorder

inorder(tree[i]l);

write(tree[i]data:4);

inorder(tree[i]r);

LRD：后序遍历 postorder

postorder(tree[i]l);

postorder(tree[i]r);

write(tree[i]data:4);

{注意右侧两种输入结点个数m取值不同}

DLR: a b d h i e j c f k g l

LDR: h d I b j e a k f c g l

LRD: h I d j e b k f l g c a

下标编号 数据域 L指针域 R指针域

A[i] data l r

1 a 2 3

2 b 4 5

3 c 6 7

4 d 8 9

5 e 10 0

6 f 11 0

7 g 0 12

8 h 0 0

9 I 0 0

10 j 0 0

11 k 0 0

12 l 0 0

---------------------------------------------------------------------------

下标编号 数据域 L指针域 R指针域

A[i] data l r

1 a 2 3

2 b 4 5

3 c 6 7

4 d 8 9

5 e 10 11

6 f 12 13

7 g 14 15

8 h 0 0

9 i 0 0

10 j 0 0

11 # 0 0

12 k 0 0

13 # 0 0

14 # 0 0

15 l 0 0

----------------------------------------------------------------------------------------------------------------------------------------------------------

2 二叉树的建立和遍历 （链式）

program treecreat; （结点+孩子输入）

const maxn=20;

type pointer=^link;

link=record

data:char;

l,r:pointer;

end;

stack=record

vex:array[1maxn] of pointer;

f,l:integer;

end;

var head,p1,p2,p3:pointer; s:stack;

n,i,j,k:integer; ch1,ch2,ch3:char;

procedure push(p:pointer);

begin

sl:=sl+1;

svex[sl]:=p;

end;

function pop:pointer;

begin

sf:=sf+1;

pop:=svex[sf];

end;

procedure preorder(p:pointer);

begin

if p<>nil then begin

write(p^data);

preorder(p^l);

preorder(p^r); end;

end;

begin {非递归建立}

sf:=0; sl:=0;

new(p1); head:=p1;push(p1);

readln(p1^data);

readln(n);

for i:=1 to n do begin

p1:=pop; new(p2); new(p3);

readln(ch1,ch2,ch3);

if ch2='#' then p1^l:=nil else begin

p2^data:=ch2; p1^l:=p2; push(p2); end;

if ch3='#' then p1^r:=nil else begin

p3^data:=ch3; p1^r:=p3; push(p3); end;

end;

preorder(head);

end

{链表建立方式 父结点-左右孩子}

a

12

abc

bde

cfg

dhi

ej#

fk#

g#L

h##

i##

j##

k##

L##

-------------------------------------------------------------------------

LDR：中序遍历 inorder

if p<>nil then begin

preorder(p^l);

write(p^data);

preorder(p^r); end;

LDR：后序遍历 posinorder

if p<>nil then begin

preorder(p^l);

preorder(p^r);

write(p^data); end;

----------------------------------------------------------------------------------------------------------------------------------------------------------

3 二叉树的建立和遍历 （链式/结点输入）

program cretrelk;

type pointer=^link;

link=record

data:char;

l,r:pointer;end;

var p:pointer;

procedure preorder(p:pointer);

begin

if p<>nil then begin

write(p^data);

preorder(p^l);

preorder(p^r); end;

end;

procedure create(var p:pointer); {递归方式建立}

var ch:char;

begin

read(ch);

if ch=' ' then p:=nil

else begin

new(p);

p^data:=ch;

create(p^l);

create(p^r);

end;

end;

begin

create(p);

readln;

preorder(p);

readln;

end

输入：ABC_ _DE_ G_ _F_ _ _

先检查序列m吧，mi<=m(i+1)，否则就是0了

然后，只要确定S1就可以确定整个数列

那就先找一个符合要求的S序列，注意，S1<=m1/2，这样就从某个很小的数（-10^9一定够了，再大点可不可以再研究）到m1/2（或m1/2-1/2)，使用二分查找找一个成立的S1。

至于直接s1=m1/2(或m1/2-1/2)是否成立，说不准，貌似不成立。

总之，先找到一个成立的S序列。

（以下k为正整数）

然后，用调整的思路考虑。

（1）如果S1加一，那么S2减一，S3加一，S4减一，S5加一

那么S(k2-1)就与S（k2）越来越接近，当它们相差一或者相等时就不可继续调整，那最小的S（k2）-S(k2-1)再div 2就是S1加一的次数限制。

这个次数限制设为a1

（2）如果S1减一，那么

这次是S（k2)与S（k2+1）决定次数限制，思路一样，得到a2

好，现在，有一个可行的S序列，S1增加有a1种，S1减少有a2种。

那总数就是，a1+1+a2

__cdecl __stdcall 解析2008年03月23日 星期日 17:001如果函数func是__cdecl(默认调用方式)，调用时情况如下

int main()

{

//参数从右到左压栈

push 4

push 3

push 2

push 1

call func

add esp 0x10 //调用者恢复堆栈指针esp，4个参数的大小是0x10(4x4)

}

2如果函数func是__stdcall，调用时情况如下

int main()

{

//参数从右到左压栈

push 4

push 3

push 2

push 1

call func

//恢复堆栈指针由被调用者func负责，方法是"ret 0x10"

}

3如果函数func是__pascal，调用情况如下

int main()

{

//参数从左到右压栈

push 1

push 2

push 3

push 4

call func

//恢复堆栈指针由被调用者func负责，方法是"ret 0x10"

}

3如果函数func是__fastcall，调用情况如下

int main()

{

//参数先用ecx, edx, eax传递，然后再压栈

//不进栈

//(不知为什么，帮助中写的是从左到右传递的，

//是不是错了，还是bcb6和bcb5的不一样)

push 4

mov ecx 3

mov edx 2

mov eax 1

call func

//恢复堆栈指针由被调用者func负责，方法是"ret 0x04",

//因为只进栈一个参数，其余用寄存器传递，所以用ret 0x04恢复

}

发表者：huang_jh

#define callback __stdcall

#define winapi __stdcall

定义成不同的名字只是为了"望文知意"就像hwnd和hcursor是一样的类型

他们都是窗口函数(过程)

发表者：sinman

我收集的，全仍上来了

左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，但不同的是函数名的修饰部分。

_stdcall是pascal程序的缺省调用方式，通常用于win32 api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。vc将函数编译后会在函数名前面加上下划线前缀，在函数名后加上"@"和参数的字节数。

2、c调用约定按从右至左的顺序压参数入栈，由调用者把参数d出栈。对于传送参数的内存栈是由调用者来维护的。另外，在函数名修饰约定方面也有所不同。

_cdecl是c和c＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。函 数采用从右到左的压栈方式。vc将函数编译后会在函数名前面加上下划线前缀。是mfc缺省调用约定。

3、__fastcall调用约定是“人”如其名，它的主要特点就是快，因为它是通过寄存器来传送参数的或更小的参数，剩下的参数仍旧自右向左压栈传送， 被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。

_fastcall方式的函数采用寄存器传递参数，vc将函数编译后会在函数名前面加上"@"前缀，在函数名后加上"@"和参数的字节数。

4、thiscall仅仅应用于“c++”成员函数。this指针存放于cx寄存器，参数从右到左压。thiscall不是关键词，因此不能被程序员指定。

5、naked call采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存esi，edi，ebx，ebp寄存器，退出函数时则产生代码恢复这些 寄存器的内容。naked call不产生这样的代码。naked call不是类型修饰符，故必须和_declspec共同使用。

关键字 __stdcall、__cdecl和__fastcall可以直接加在要输出的函数前，也可以在编译环境的setting\c/c++ \code generation项选择。当加在输出函数前的关键字与编译环境中的选择不同时，直接加在输出函数前的关键字有效。它们对应的命令行参数分别为/gz、 /gd和/gr。缺省状态为/gd，即__cdecl。

要完全模仿pascal调用约定首先必须使用__stdcall调用约定，至于函数名修饰约定，可以通过其它方法模仿。还有一个值得一提的是winapi 宏，windowsh支持该宏，它可以将出函数翻译成适当的调用约定，在win32中，它被定义为__stdcall。使用winapi宏可以创建自己 的apis。

2)名字修饰约定

1、修饰名(decoration name)

“c”或者“c++”函数在内部通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。有些情况下使用函数的修饰名是必要的，如在模块定 义文件里头指定输出“c++”重载函数、构造函数、析构函数，又如在汇编代码里调用“c””或“c++”函数等。

修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。

2、名字修饰约定随调用约定和编译种类(c或c++)的不同而变化。函数名修饰约定随编译种类和调用约定的不同而不同，下面分别说明。

a、c编译时函数名修饰约定规则：

__stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个“@”符号和其参数的字节数，格式为_functionname@number。

__cdecl调用约定仅在输出函数名前加上一个下划线前缀，格式为_functionname。

__fastcall调用约定在输出函数名前加上一个“@”符号，后面也是一个“@”符号和其参数的字节数，格式为@functionname@number。

它们均不改变输出函数名中的字符大小写，这和pascal调用约定不同，pascal约定输出的函数名无任何修饰且全部大写。

b、c++编译时函数名修饰约定规则：

__stdcall调用约定：

1、以“”标识函数名的开始，后跟函数名；

2、函数名后面以“@@yg”标识参数表的开始，后跟参数表；

3、参数表以代号表示：

x--void ，

d--char，

e--unsigned char，

f--short，

h--int，

i--unsigned int，

j--long，

k--unsigned long，

m--float，

n--double，

_n--bool，

pa--表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以“0”代替，一个“0”代表一次重复；

4、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前；

5、参数表后以“@z”标识整个名字的结束，如果该函数无参数，则以“z”标识结束。

其格式为“functionname@@yg@z”或“functionname@@ygxz”，例如

int test1-----“test1@@yghpadk@z”

void test2 -----“test2@@ygxxz”

__cdecl调用约定：

规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的“@@yg”变为“@@ya”。

__fastcall调用约定：

规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的“@@yg”变为“@@yi”。

vc++对函数的省缺声明是"__cedcl",将只能被c/c++调用

cb在输出函数声明时使用4种修饰符号

//__cdecl

cb的默认值，它会在输出函数名前加_，并保留此函数名不变，参数按照从右到左的顺序依次传递给栈，也可以写成_cdecl和cdecl形式。

//__fastcall

她修饰的函数的参数将尽肯呢感地使用寄存器来处理，其函数名前加@，参数按照从左到右的顺序压栈；

//__pascal

它说明的函数名使用pascal格式的命名约定。这时函数名全部大写。参数按照从左到右的顺序压栈；

//__stdcall

使用标准约定的函数名。函数名不会改变。使用__stdcall修饰时。参数按照由右到左的顺序压栈，也可以是_stdcall；

发表者：echoher

far是古代的东西

在16位模式下，指针是16位的

指针的寻址空间只有64k

如果指定far，说明这个指针指向的地址要加上基地址

就是说用far可以指定64k以外的区域

现在已经没用了

一点用也没有了

可能是你编得不太对，我改了一下：

program kjk（input,output);

var a,b,sum:integer;

begin

writeln('a,b=');

readln(a,b);

sum:=a+b;

writeln('sum=',sum);

end

另附资料：PASCAL程序

我们日常生活中所说的程序是把做一件事的各个步骤清晰有序地表达出来。比如说我们要用WORD修改一篇文章，程序则如下：首先打开主机电源，再开显示器，运行WINDOWS，打开WORD编辑窗口，调出要修改的文件，修改完后存盘┈┈同样，我们要让计算机完成一件事，也得告诉它每一步该怎能做。

现在我来看计算机如何完成这样一个任务：给出一个任意圆的半径，求其面积。

程序如下：

PROGRAM CIRCLE（INPUT，OUTPUT）；

CONST PI＝3．14；{用PI代替л，给其赋值为314}

VAR s,r：REAL；

BEGIN

writeln（’INPUT R’）;

readln(R);{读入半径的值}

s:=pirr;

writeln(’S=’,S);

END

以上的第一行是程序首部。PROGRAM是保留字，PASCAL程序都以它开头。CIRCLE是该程序的名字。括号里面是参数，注意：PASCAL的参数都是放在小括号里，不能是中括号或大括号。INPUT 是标准输入文件，OUTPUT是标准输出文件，为了读入数据和输出结果，必须写上参数INPUT和OUTPUT。（如果运行环境是在TURBO PASCAL中，第一行可省略）。CONST是一个常量说明，说明PI的值在本程序里都为314，大括号里是注释部分，程序是不会执行的。VAR是变量说明符，说明变量S，R的类型。从BEGIN开始，一直到END结束，是程序的主干部分。在PASCAL程序中，每个语句都要以 “；”结尾 ，但有两个语句例外：BEGIN 和END。BEGIN语句后不跟任何符号，而作为程序结束的END语句则以“．”结束，END语句前面一个语句末尾可以省略分号。

2． 3程序的构成

PASCAL程序结构包括以下三个部分：

1 程序首部

在本程序中，PROGRAM CIRCLE（INPUT，OUTPUT）；便是首部，在不同的程序中一般只需将名字CIRCLE改成不同的名字便可。

2 程序的说明部分

本程序中，CONST PI＝3．14 便是一个常量说明；VAR S，R：REAL便是一变量说明语句。除此之外，还有其它说明，如：

USE ．．．．．．； 单元说明。

LABEL．．．．．．； 标号说明。

TYPE．．．．．．； 类型定义说明。

FUNCTION．．．．．．； 函数定义说明。

PROCEDURE．．．．．．；过程定义说明。

3 执行部分

如本程序的BEGIN 和END 之间这段语句便是执行部分。要执行的语句就在此间。

一个完整的PASCAL程序总体结构如下：

PROGRAM 程序名（INPUT，OUTPUT）；

USE．．．{单元说明部分}；

LABEL．．．{标号说明部分}；

TYPE．．．{类型说明部分}；

CONST．．．{常量说明部分}；

VAR．．．{变量说明部分}；

FUNCTION．．．{函数说明部分}；

PROCEDURE．．．{过程说明部分}；

BEGIN

程序体

END

顺序结构程序设计

内容提要

本章介绍了PASCAL中的数和符号的表示方法；四种标准数据类型；常量，变量和标准函数；表达式和输入、输出语句的用法。

学习要求

通过对本章的学习，要求能够理解PASCAL中关于数、符号、常量、变量、四种基本的数据类型等知识点，掌握READ、WRITE语句的用法，能够进行顺序结构程序设计。

PASCAL中的数和符号

1．1 符号

在PASCAL中，允许使用的符号很多，但有一定的规则：

1 标2 点符号： “；”是每一句的结束标3 志，4 但在BEGIN后不5 用，6 最后一个END后用“”，7 “，8 ”一般用在括号和变量表中，9 用以分隔多个参数；单引号“ˊ”用于字符型中；“( )”中一般是参数，10 “[ ]”一般用于集合和数组中，11 “{ }”是用来存放注释信息的；“：”是在变量和数据类型之间起分隔作用的。

12 运算符：

算术运算符有：＋，－，＊，／；

关系运算符有：＞，＜，＝，＞＝，＜＝，＜＞；

逻辑运算符有：AND，OR，NOT；

1．2 标识符

在PASCAL语言中，一些事先定义好的由字母开头，后跟数字和字母组成的字符串，它们代表了一定的意义，我们把它们称为标识符。例如：PROGRAM就表明一个程序的开始，VAR则表明后面将要进行变量说明。系统事先定义了不少的标识符，我们把它们叫做保留字；另外，我们也可以自己定义标识符，自定义标识符要注意以下几点：

1 自定义的标2 识符不3 要与系统定义的标4 识符同5 名6 。如：你不7 能定义一个叫BEGIN的标8 识符。

9 标10 识符要以字母开头，11 后跟字母或数字或下划线，12 中间不13 能出现空格，14 长度一般不15 超过8位。

16 标17 识符要先定义后使用，18 这一点我们在后面章节中会学到。

19 标20 识符的英文字母不21 分大小写。

第二节 标准数据类型

PASCAL给编程人员提供了几种标准数据类型，同时也允许自己定义数据类型。

1实型(REAL)

实型就是实数类型，是一种最常见的数据类型。

在PASCAL中，实数有两种表示方法：小数表示法和指数表示法(也称科学表示法)。下面是小数表示法的实例：

347 1236 890000 -000000023

而用科学表示法，以上例子可分别表示为：

347E0 1236E2 89E4 -23E-7

在科学表示法中，“E” 后面的数代表10的幂，前面的数一般在1到10之间取值。

实际上，TURBO PASCAL有五种实数类型：

类型 取值范围 占字节数 有效位数

Real

Single

Double

Extended

comp 29e-39 17e38

15e-45 34e38

50e-324 17e328

19e-4951 11e4932

-263+1 263-1 6

4

8

10

8 7 8

11 12

15 16

19 20

19 20

2 整型（INTEGER）

整型即整数类型。它只能在整数这一无限集合中表示一个有限子集。在16位机中，整数的表示范围为：－32768到32767。

在数学中，整数为实数的一个子集，为什么有了实型还要定义整型呢？

在计算机进行运算中，CPU对整数和实数运算的处理方法不同，整数运算要快于实数运算。计算机在处理实数运算时存在一定的误差，可能存在10000个10相加不等于10000的现象。所以一般不要用等号来判断实数的相等性。

整型的运算符除了+ - /,还有两种特殊的运算符:DIV,MOD

DIV是整除运算,求出整数商:8 DIV 3=2 14 DIV 4=3

MOD是求余数的运算:17 MOD 4=1 -17 MOD 4=-1 17 MOD –4=1

TURBO PASCAL同样支持五种整型定义：

类型 取值范围 占字节数 有效位数

Shortint

Integer

Longint

Byte

Word -128 127

-32768 32767

-2147483648 2147483647

0 255

0 65535 1

2

4

1

2 8

16

32

8

16

3 布尔型（BOOLEAN）

BOOLEAN 一词是根据十九世纪英国数学家George Boolean而命名。布尔型数据用来存放逻辑值，也叫布尔值。布尔值只有两个：真（TRUE）或假（FALSE）。

与布尔运算相关的是逻辑运算符：与（AND），或（OR），非（NOT）。其运算规则如下：

假设有两个条件A和B，只有A和B同时为真时，A AND B的结果才为真，否则为假；当A或B中至少有一个为真时，A OR B的结果为真，否则为假；当A为真时，NOT A的结果为假，A为假时，NOT A 的结果为真。

22 字符型（CHAR）

一个字符型数据变量是用来存放ASCII码字符集内的某个字符。此时字符只代表某个符号，本身不具有原来的含义。例如 ′A′，′6′就是字符。字符型都要用单引号将其引起来。

第3节 常量和变量

3．1 常量

常量是这样一种标识符，该标识符中的数据在整个程序中都不会变化。常量中的数据称为常数，可分为以下四种：

整型常数，如：12，－33，825……

实型常数，如：035, -200, 123456……

布尔型常数，只有两个：TRUE，FALSE

字符型常数，如：′1′, ′2′, ′A′, ′X′, ′@′, ′+′……

另外,还可以用常量标识符来定义常量,如:CONST PI＝314。在常量标识符定义中，必须以CONST开头，在本例中，标识符PI便被定义为实数314，在整个程序中，只要有标识符PI的地方，会自动被替换成数字314。

下面是几个常量标识符定义的例子：

const abc=100;

date=’Monday’;

w=’+’;

3．2 变量

变量是在程序运行过程中，其值可以变化的量。给变量取名字比较灵活，和文件名取名规则比较类似：以字母开头，后面加上数字或字母，中间不留空格。

以下是合法的变量名：A，B，A1，C4，DAY，MY＿FIRST，GOOD……

变量在使用之前必须加以说明，说明的格式如下：VAR 变量表：类型；如VAR R，S：REAL；在这里，VAR是变量说明的保留字，说明变量之前必须得有它；R，S则是变量名，在第一章第三节的程序中它们分别代表半径和面积，这一句变量说明的意思是：变量R，S中将要想存储的数据是实数类型。

我们可以对变量定义这么理解：变量象一个盒子，不同的变量象不同形状的盒子，盒子是用来装东西用的。东西只有四种，分别是：REAL，INTEGER，BOOLEAN，CHAR。现在我们每个盒子上贴上标签，标签名分别是：INTEGER，REAL，BOOLEAN，CHAR，于是，每个盒子不能随便装东西了，贴有REAL标签的盒子只能装REAL类型的东西，贴有CHAR标签的盒子则只能装CHAR类的东西……而且，每个盒子只能装一个东西。定义变量就象给盒子贴标签，但还没有装东西，装东西这个过程要在程序的执行部分才得以实现。

让我们来看看下面这些定义变量的例子：

例1 VAR A1，B1：REAL；

W1，W：CHAR；

F1，F2：BOOLEAN；

DA，DB：INTEGER；

3 给变量赋值

变量定义好后还象是一个空盒子，要使用这个变量得先给它存进一个数，使它才有实际意义。给变量里存储进一个某种类型的数便叫给变量赋值，其格式为：变量名：＝数据。

我们假设事先已象例1那样定义好了变量，下面来看如何给例1中的变量赋值。

A1:=314; B1:=-70;

W1:=’%’; W2:=’A’;

F1:=TRUE; F2:=FALSE;

DA:=9; DB:=-10;

经过以上定义后，我们用到变量实际上是用到变量中的数据。于是：

DA＋DB的值为－1

A1＋B1的值为－386

NOT F1的值为FALSE

3DA的值为27

一个变量中只能存放一个数，但这个数并非恒定。假设一个变量DA已赋好了值3，如果继续给它赋一个新值8，那么，新值会自动取代旧值，DA中的数就变为8了。

注意：PASCAL中的赋值符号“:=”不是数学中的“＝”，它是把符号右边的数装进左边的变量里，如果右边是一表达式，则先计算出表达式的值再赋给左边的变量。变量在左，数字或表达式在右，右边的值赋给左边的变量，这个规则要记牢。

例3：已知变量X，Y，Z的值分别为3，6，－2，看看下面赋值语句执行的情况。

X:＝5 ； 结果是：X中的3被5所取代

X:=Y+Z ； 结果是：右边的表达式的值4被赋给了左边的X

Y:=Y―Z ； 结果是：右边的表达式的值8被赋给了左边的Y

X:=X+1 ； 结果是：将右边3＋1＝4的值被赋给了X变量

Z:=3X―4Y+5；结果是：先将右边的表达式的结果计算出来，为 －10，再将－10赋给变量Z

以下的赋值式均为错误：

2:=x；

3x:=4+z；

8:=9；

3x-6:=z；

以上错误的原因为：赋值号左边都不是变量，而是数字或表达式。其实，赋值语句对右边几乎没有什么要求，对左边也只有唯一的一个要求：必须是一个变量。

第4节 标第5节 准函数

PASCAL提供了丰富的预定义标准函数，通过标准函数我们可以把一些复杂的数学问题简化。下面让我们来看看这些函数的功能。

1 绝对值函数 ABS() 例:ABS(-314)=314 ABS(6)=6

2 平方函数 SQR() 例:SQR(4)=16 SQR(-3)=9

3 开方函数 SQRT() 例:SQRT(9)=3 AQRT(2)=1414

4 正弦函 SIN() 例:SIN(314)=0 SIN(314/2)=10

5 余弦函数 COS() 例:COS(314)=10 COS(314/2)=0

6 以e为底数的指7 数函数EXP() 例:EXP(3)=e3

8 自然对数函数 LN() 例:ln3=ln(3)

9 取整函数 TRUNC() ,其作用是将括号里的数的小数全部去掉 例:

TRUNC(314)=3 TRUNC(479)=4 TRUNC(-28)=-2

10 四舍11 五入取整函数 ROUND(),例:ROUND(314)=314 ROUND(48)=5

ROUND(-32)=-3 ROUND(-57)=-6

12 前导函数PRED(),其作用是对括号中的整数求其前面一个整数,或者对括号中的字符根据ASCII码表中的次序求其前面的一个字符 例:

PRED(3)=2 PRED(123)=122 PRED(‘C’)=’B’ PRED(‘Z’)=’Y’

13 后继函数SUCC(),其作用是对括号中的整数求其后面一个整数,或者对括号中的字符根据ASCII码表中的次序求其后面一个字符 例:

SUCC(7)=8 SUCC(2)=3 SUCC(‘A’)=’B’ SUCC(‘Y’)=’Z’

13奇函数的判别函数 ODD() 其作用是对括号中的整数进行判断,如果为奇数,则结果为真,否则为假 例:ODD(7)=TRUE ODD(4)=FALSE

14取字符函数 CHR() 其作用是将括号中的整数作为字符的序号,或称字符的ASCII码（见附录）,并将与序号对应的字符作为结果写出来 例:

CHR(65)=’A’ CHR(66)=’B’ CHR(97)=’a’

取序号函数ORD() 该函数是CHR()的逆函数,是根据字母求出其ASCII码 例:

ORD(65)=’A’ ORD(66)=’B’ ORD(97)=’a’

ORD(CHR(65))=’A’ CHR(ORD(‘A’))=65

ORD(FALSE)=0 ORD(TRUE)=1

以上这些标准函数的自变量类型和函数类型我们用下面这个表来加以归纳：

自变量类型

函数类型

整 型

实 型

字 符 型

布 尔 型

整 型

ABS

SQR

PRED

SUCC TRUNC

ROUND

ORD

ORD

实 型

SIN

COS

EXP

LN

SQRT SIN

COS

LN

EXP

SQRT

ABS

字 符 型

CHR

PRED SUCC

布 尔 型 ODD PRED SUCC

第6节 表达式

由各种运算符把常量、变量、函数连接起来并且具有确定的值的式子是一个表达式，一个单独的常量,变量,函数也是一个表达式,。我们来看看下列数学式子和表达式之间的关系：

（图T2．1）

在PASCAL语言中，表达式有多种运算符，因此表达式的种类也是多样的，主要有：算术表达式，关系表达式，逻辑表达式，字符表达式等。这里，我们先了解算术表达式，其余几种我们将在后面学到。在表达式中，每个运算符有运算的优先级，我们可以按优先级的高低将其分为这样几级：

NOT

＊，／，DIV，MOD，AND

＋，－，OR

＝，＜＞，＜，＞，＞＝，＜＝

我们还规定：在同一级的的运算符中，其运算次序按从左到右的次序进行；如果有括号，则括号中的表达式优先。

第7节 输入语句

输入语句的功能是在程序执行过程中，暂停下来接受用户从输入端（一般是键盘）输入数据，将接收到的数据存入预先设好的变量中，程序再接着执行。

6．1 READ语句

READ是一个读数语句，后跟变量，读进来的数就装在变量里。如：

READ（X），其意思是等待由键盘输入一个数，然后将此数赋值给变量X。它类似于一个赋值语句。

READ（X，Y，Z），其意思是等待用户由键盘输入三个数，这三个数按输入的次序依次赋给变量X，Y，Z。它等价于以下三个语句：READ（X）；READ（Y）；READ（Z）。

注意事项：

1 由键盘输入的数据类型要与变量的数据类型一致，不能出现将一个实数赋给一个整型变量之类的错误。

2 输入的数据个数要与READ语句中变量的个数一致。如果要输入多个数据，则有两种情况：（1）如果输入的数据是实数或整数类型，则各个数之间用空格隔开，最后才以回车键结束；（2）如果输入的数据类型是字符型，则各字符间不能有分隔符，也不能有单引号把它引起，在最后一个字符后用回车键结束。

3 如果输入数据的个数少于READ括号中变量的个数时，程序会一直等到你输完才会继续执行。

4 如果READ语句中括号中的变量超过一个，则中间用逗号隔开。

例4 已知变量A，例5 B，例6 C都是整型，例7 则READ（A，例8 B，例9 C）有以下几种输入法：

（1） 1□2□3↙（“□”代表空格，（2） “↙”代表回车键，（3） 如未加其它说明，（4） 在本书中都这样表示），（5） 执行的结果为：A＝1，（6） B＝2，（7） C＝3。

（8） 1□2□3□4↙ 执行的结果为A＝1，（9） B＝2，（10） C＝3，（11） 多余的4没起作用。

（12） 1↙2↙3↙ 执行的结果仍为A＝1，（13） B＝2，（14） C＝3

（15） 1□2↙ 执行的结果为A＝1，（16） B＝2，（17） 因没给Z赋值，（18） 则计算机一直处于等待状态。

（19） 1↙2□3↙ 执行的结果仍为A＝1，（20） B＝2，（21） C＝3。

62 READLN语句

READLN语句也是一个输入语句，用法同READ非常类似，同样是将由键盘读入的数据存进后面括号里的变量中。如：READLN（A，B，C）；但是，也有不同之处：READLN语句把来自键盘的一串数据读入相应的变量中后，便自动跳到下一行的第一数据处，如果原来行中还有未读完的数据，则忽略这些数据。另外，READLN语句后面可以不带参数，即只有一个“READLN”。此时它的作用是跳过本行，直接指向下一行的第一个数据，也可以简称为换行。那么，READLN（A，B，C）就相当于以下四句：READ（A），READ（B），READ（C），READLN。

让我们来看一个例子：

例5 程序中的语句 由键盘输入的格式

READ（A，B）； 1­□2□3↙

READ（C，D）； 4□5□6↙

READ（E，F，G）； 7□8□9↙

READ（H）； 10□11□12↙

则执行后的结果是：A＝1，B＝2，C＝3，D＝4，E＝5，F＝6，G＝7，H＝8

READLN（A，B）； 1□2□3↙

READLN（C，D）； 4□5□6↙

READLN（ E，F，G）； 7□8□9↙

READLN（H）； 10­□11□12↙

则执行后的结果是：A＝1，B＝2，C＝4，D＝5，E＝7，F＝8，G＝9，H＝10

第8节 输出语句

当计算机处理完程序后，应该把结果显示在屏幕上或在打印机上打印出来，这样一个过程叫输出。

7．1 WRITE语句

WRITE语句是将其后括号中所带输出项的值打印出来，如果括号中有多个输出项，则一律用逗号隔开。它有以下几种用法：

直接打印数字。如：WRITE（3），则在屏幕上打印一个“3”。

打印变量。如：已知A＝3，B＝6，C＝9 则WRITE（A，B，C）执行的结果是在屏幕上打印3，6，9三个数。

打印表达式。如果括号中是表达式，WRITE语句是先计算结果再打印。如：已知A＝3，B＝6，则WRITE（A＋B－4）语句执行的结果是打印数字5。

打印字符或字符串。WRITE语句中的字符或字符串一律按原样打印。如：

WRITE（′A′） ， 则在屏幕上打印一个字母A；WRITE（′HELLO′），则在屏幕上打印一个词HELLO；WRITE（′3＋5′），在屏幕上不会打印数字8，而是“3＋5”三个字符。

7．2 WRITELN语句

WRITELN语句也是打印语句，用法和WRITE语句非常类似，但WRITE语句在打印时是逐行打印，即一行打满后才换行打印；而WRITELN语句是在打印完本语句所带的参数后，无论该行是否已满，都会换行。

例6 写出下列语句执行后的结果：

WRITE（1，2，3）；

WRITE（4，5，6）；

WRITE（7，8，9）；

执行的结果是：1 2 3 4 5 6 7 8 9（注：在屏幕上打印时是没有空格的）

WRITELN（1，2，3）；

WRITELN（4，5，6）；

WRITELN（7，8，9）；

则执行后的结果是：

1 2 3

4 5 6

7 8 9

另：WRITELN语句如不带参数则表示打印一个空行，即换行。

7．3 打印格式

输出语句在打印数据时，数据在屏幕上所占的宽度是有规定的，打印的域宽有两种：标准域宽和自定义域宽。

标准域宽

标准域宽是指系统默认的宽度。不同版本的TURBO PASCAL对不同的数据所规定的宽度是不同的。在TURBO PASCAL7中，规定如下：

（1）整数在输出时，其宽度就是数据本身的宽度，也就是说数与数之间没有空格。如：在例6中的WRITE语句中，真正的格式是：123456。

（2）实数在输出时，默认的宽度是17位，如：在WRITE（300 , 4117）语句中，其格式如下：3．0000000000E＋01 4．1170000000E＋02。

（3）字符型输出宽度为1，也就是说字符之间没有空格。如：

WRITE（′A′，′B′，′C′）；打印出来就是ABC。另：字符串的输出宽度也是其本身实际的宽度。

（4）布尔型输出的宽度也是其本身实际的宽度，输出的结果要么是

′FALSE′，要么是′TRUE′。

自定义域宽

在输出的时候，系统允许用户自定义输出的域宽。

（1） 单域宽

在WRITE或WRITELN语句所带的括号中的每个输出项后面加上数字n，中间用冒号隔开，数字n则表明该输出项将占的域宽。如：

WRITE（3：5，45：4）；输出格式为：

□□□□3□□45；

WRITE（′A′：2，′B′：2，′C′：3）；输出的格式为：

□A□B□□C。

（2） 双域宽

双域宽是在括号中每个输出项后加上两个数m 、n ,其中m代表输出项所占的总宽度，n代表在总宽度中小数所占的位数，它们中间都要用冒号隔开；要求m＞n。

如：WRITE（－3214．44：12：3）；则输出格式为：

□□□－3214．440

另：我们还可以用在输出项之间加空格的办法来控制数据之间的格式。如：WRITE（1，′′，2，′′，3）；打印出来的格式是：

2 3 ，中间便有了空格。

第9节 顺序程序设计举例

前面学习了PASCAL的一些基本知识点，下面我们利用这些知识点来对给定的任务进程序设计。

例7 将变量A，B中的数交换次序并打印出来。

PROGRAM ex7(input,output);

VAR a,b,c:integer;

BEGIN

writeln('input a,b');

read(a,b);

writeln('a=',a,'b=',b);

c:=a;

a:=b;

b:=c;

writeln('a=',a,'b=',b);

END

例8 已知三角形的三边，求其面积。

在知道三边A，B，C后，可用海伦公式求出其面积：S＝

其中，P＝（A＋B＋C）／2。

PROGRAM EX8(input,output);

VAR s,a,b,c,p:real;

BEGIN

writeln('input a,b,c');

readln(a,b,c);

p:=(a+b+c)/2;

s:=sqrt(p(p-a)(p-b)(p-c));

writeln('s=',s);

END

例9 编写一程序，要求输入一个字符，输出该字符的前趋和后继字符及该字符的ASCII码值。

PROGRAM e9(input,output);

VAR c,c1,c2:char;

n:integer;

BEGIN

writeln('input a character');

read(c);

c1:=pred(c);

c2:=succ(c);

n:=ord(c);

writeln('c=',c:5,'c1=',c1:5,'c2=',c2:5,'n=',n:5);

END

例10 已知一个三位数，将其倒序输出。如：输入479，输出974。

PROGRAM ex10(input,output);

VAR a,b,c,d:integer;

BEGIN

writeln('input a 3_bit number');

readln(d);

a:=d div 100;

c:=d mod 10;

b:=(d-a100-c) div 10;

d:=c100+b10+a;

writeln('d=',d);

END

本章小结

在本章内容中，我们第一次全面接触了TURBO PASCAL语言的程序设计知识，对TURBO PASCAL7的顺序结构程序设计有了初步的了解。PASCAL 的数据类型有四种基本的类型：整型（INTEGER），实型（REAL），布尔型（BOOLEAN），字符型（CHAR）；基本运算有三种：算术运算，关系运算，逻辑运算；要熟练掌握本书给出的标准函数，对每一个数学式要能熟练转化为PASCAL的表达式。输入语句有READ和READLN两种；输出语句有WRITE和WRITELN两种，注意二者的区别。

思考与练习

下面数据哪些是整数，哪些是实数，哪些是非法的数？

30 3 e-8 1e+4 3e 24e-6 00012 50 2

找出下列程序段中的错误

CONST

PI：＝314

A:=4;

B=6;

C:=’A’;

VAR A,B,C,DE,F:REAL;

BEGIN

A+1:=3;

B=6

E,F:=7;

G:=TRUE;

C:=D;

已知有方和程：Ax2+Bx+c=0,输入方程的系数A，B，C，求出其实根（在输入系数时尽量让方程有实根）。

任意输入三个字母，判定其在字母表中是否相邻。

已知三角形两边及夹角，求其面积。

已知有一半径为2 的圆，要求任输一个点的

坐标，判断该点是否在圆内。

任给你一个四位数，将其千位，百位，十位，个位

拆出来。

追加一百分倒是很诱人，，但是知道这是不会发生的。

(1)程序、函数、过程符号

program,function,procedure

(2)说明部分专用定义符号

array,const,file,label,of packed,record,set,type,var

（3）语句专用符号

case,do,downto,else,for,forward,goto,if,repeat,then,to until,while,with

(4)运算符号

and,div,in,mod ,not,or

（5）分隔符号

begin，end

(6)空指针常量

nil

标识符分为两大类：

（1）标准标识符（pascal中可直接使用）

标准常量：false,true,maxint

标准类型：integer,real,char,boolean,text

标准文件：input,output

标准函数：abs绝对值,arctan反正切函数,chr字符,cos余弦,eof不清楚,eoln不清楚,exp指数,ln对数,odd奇数函数,ord序数，pred前趋,sin不用说吧这个,sqr平方,sqrt算术平方根,succ后继,trunc截尾

标准过程：get,new,pack,page,put,read,readln,reset,rewrite,unpack,write,writeln

(2）自定义标识符

自定义标识符是用户按标识符定义的规则自己定义的。

（费了n久，打了上面这些常用的。谢谢也要说声啊）

-----------------------------意思及用法下面咯

简单的：：：

1、 程序、函数、过程的符号：

（1）program 程序

（2）function 函数

（3）procedure 过程

2、 说明部分的专用定义符号

（4）array 定义数组

例如：type data=array[1100] of integer;

（5）const 常量说明

例如：const pi=31415926；

（6）file 文件类型

例如：type text=file of char;

（7）lable 标号说明

格式：lable 标号1,标号2，……；

（8）packed 指令（记录）

（9）var 变量说明

例如：var a,b,c:integer；

（10）record 记录类型

例如：type studata=record

age:integer;

sex:char;

chinese:real;

maths:real;

english:real;

end;

（11）set 集合类型

例如：type num1=set of 110;

（12）type 类型说明

例如：定义“daytype”表示有关日期的数据类型名：

type daytype=(sun,min,tue,wed,thu dri,sat)；

（13）of （见case、array、set、file）

3、语句专用符号

（14）case 分情况语句

格式：case 表达式 of

常数表1：语句1；

常数表2：语句2；

……

常数表n：语句n；

else 语句 n+1

end

（15）do （见for、while）

（16）downto （见for）

（17）else （见if、case）

（18）for 计数循环语句

格式1：for控制变量：=初值 to 终值 do

循环体语句；

格式2：for控制变量：=初值 downto 终值 do

循环体语句；

在for语句中如果使用to，称为递增型计数循环语句；使用downto，称为递减型计数循环语句。

（19）goto 语句

例如：goto 标号

程序不继续执行下一条语句，而转向标号所指的语句执行。

（20）if 条件语句

格式1：if 条件 then语句1；

格式2：if 条件 then语句1 else语句2；

（21）repeat 直到型循环语句

格式：repeat

语句1；

语句2；

语句3；

…

语句n

until 布尔表达式

（22）then （见if）

（23）to （见for）

（24）until （见repeat）

（25）while 当循环语句

格式：While布尔表达式do 语句；

（26）with 语句

（27）forward 函数指令

4、运算符号

（28）and 与

（29）div 整除

（30）in 集体运算符，判断一个元素是否在集合中

（31）mod 求余

（32）not 非

（33）or 或

5、分隔符号

（34）begin 块标记，开始

（35）end 块标记，结束

6、空指针符号

（36）nil 空指针

这东西太杂了，，，，，，，你问具体的，我还好回答，，这样泛泛而谈，，我也说不好

以上就是关于关于pascal的问题全部的内容，包括:关于pascal的问题、pascal程序(序列)、C++中的PASCAL 是什么作用等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！