科学计算的语言－FORTRAN95

Size: px

Start display at page:

Download "科学计算的语言－FORTRAN95"

路富
9 years ago
Views:

1 科学计算的语言 -FORTRAN95 目录第一篇闲话第 1 章目的是计算第 2 章 FORTRAN95 如何描述计算第 3 章 FORTRAN 的编译系统第二篇计算的叙述第 4 章 FORTRAN95 语言的形貌第 5 章准备数据第 6 章构造数据第 7 章声明数据第 8 章构造表达式第 9 章基本计算 ( 一 ) 赋值语句第 10 章基本计算 ( 二 ) 选择控制结构第 11 章基本计算 ( 三 ) 循环控制结构第三篇计算任务的剖分与组合第 12 章程序的单位第 13 章过程及其通讯第 14 章固有过程第 15 章通讯第 16 章数据文件的管理第 17 章数据文件的编辑附录 A. 语句 B. 固有过程 C. 语法参考文献 J. Adams, W. Brainerd, J. Martin, and J. Wagener. Fortran 95 Handbook. ALL the documents of krsna.lamost.org are made available under the terms of the Creative Commons Attribution License.

第 12 章程序的单位第 13 章过程及其通讯第 14 章固有过程第 15 章通讯第 16 章数据文件的管理第 17 章数据文件的编辑附录 A. 语句 B. 固有过程 C. 语法参考文献 J. Adams, W.

2 第一篇闲话中国数学的经典著作大都以依据不同方法或不同类型分成章节的问题集的形式出现每一个别问题又都分成若干个条目 : 条目一是问, 提出有具体数值的问题 ; 条目二是答, 给出这一问题的具体数值答案 ; 条目三称为术, 一般说来乃是解答与条目一同种类型问题的普遍方法, 实际上就相当于现在计算机科学中的算法, 但有时也相当于一个公式或一个定理 ; 条目四是注, 说明术的依据与理由, 实质上相当于一种证明 ; 宋元以来, 可能是由于印刷术的发达, 往往加上条目五草, 记述依据术得出答案的详细计算过程早在九章算术中, 第八章方程章全章就是线性联立方程组的解法依刘微注 : 并列为行, 故谓之方程又说 : 令每行为率, 二物者再程, 三物者三程, 皆如物数程之当时以筹作算, 依题意将数据按物数排成各行, 然后进行运算中学教科书解线性方程组的消元法, 最早即见之于九章算术数学在中国古时历来称为算术这正好反映了中国古算构造性计算性与机械化的特色数学不仅为了应用, 即使为了在纯数学范畴内获得具体结果, 也一不能无算, 二必须有术中国古代算术的思想与方法, 正好与近代计算机的使用融合无间, 也必将因此而重返青春, 以另一种崭新面貌在未来的数学发展中扮演重要角色 [1] ---- 吴文俊对中国传统数学的再认识 [1] 吴文俊, 中科院院士, 我国最卓越的现代数学家之一, 在拓扑学等领域取得世界性成就, 近年积极推动数学机械化领域的发展第 1 章目的是计算我们这本书描述了一门语言不幸的是语言很难成为我们的爱好, 更何况 FORTRAN 语言也无法仿效英语, 能够被某些英语大师成功地转换为一种疯狂因此几乎每一个学习过编程语言的人都会有一种痛苦地记忆, 那就是一种极端缺乏趣味的痛苦, 因为很容易我们就会忘记这种语言的用处显然, 如果一种工具连用处都不是那么明显的话, 哪里还谈得上给人带来乐趣呢? 所以要想在 FORTRAN 语言的学习过程当中不至于总是遭遇无聊, 唯一的解救之途就是一开始就要找到学习它的绝对充足的理由, 并且在学习过程中还会不得不反复地依靠这个理由, 来说服自己需要更加有耐心, 更加能够忍受烦琐和约定, 逐渐地, 也许我们能够从 FORTRAN 语言的惊人表达能力当中, 体会到一种新的看待世界的角度, 这大概会是我们享受那么多的枯燥之后,

达, 往往加上条目五草, 记述依据术得出答案的详细计算过程早在九章算术中, 第八章方程章全章就是线性联立方程组的解法依刘微注 : 并列为行, 故谓之方程又说 : 令每行为率, 二物者再程, 三物者三程, 皆如物数程之当时以筹作算,

3 所能够得到的最佳回报所以我们不得不在进入正题之前, 扯点闲话, 看看学习 FORTRAN 的理由何在 1.1 始于计算, 终于计算在荒莽的历史尽头, 我们常常听说人类之所以能够凭借虚弱的身躯, 一次又一次地打退其他凶猛动物的猖狂进攻, 而终于成就为今日当之无愧的万兽之王, 这个原因有很多种解释, 比如说是劳动, 说是手, 说是大脑, 莫衷一是, 各有各的理论和证据, 确实是个很难取得定论的问题, 因此我想提出一种新的解释, 大概是不会遭到立刻的覆灭性打击人类的进化始于计算, 我相信在有关非洲黑猩猩的纪录片里面, 可以看到黑猩猩也会用手使用工具, 一个黑猩猩家庭为了生活也勤于劳动, 一个黑猩猩群落社会里面的形形色色的政治行为, 显示它们的大脑也不是很闲, 但有一次我看到黑猩猩们抢香蕉时, 总是把自己已经抢到手的香蕉给弄丢了而无知觉, 突然觉得它们最缺乏的也许是算数的能力所以我想, 人类的起源一定跟计算有莫大的关系当然这些都是戏说而已, 不过如果说人类的科学是从计算开始的, 应该是不会有太大的争议的也许有人说人类的科学活动应该是起源于观察, 但从动物行为学的角度来看, 观察这种行为是很难界定的, 而计算则是非常好界定的行为, 因为最原始的计算行为显然应该就是数数可以想像, 当人类开始意识到自我在这个世界的孤独存在时, 对于日月星辰和风雨雷电的无常和力量该是多么地恐惧啊! 而人类把自己从这种恐惧当中解救出来的第一个方法应该就是算数算数导致了人类最早的科学活动, 即天文学和几何学人们从对日月星辰的计数当中发现了天体的运行是有常的, 而不是什么不可琢磨的妖魔鬼怪在主宰 ; 从对土地与山河的度量中建立了明确的几何概念, 从而对自己所生活的世界开始了真正的理解而这种理解活动一旦开始, 就无法停止了, 演变至今, 就构成了我们人类最值得自豪的成就 - 科学科学的历史表明了它的基础, 就是计算如果我们只是一味地观察, 我们会纪录下来大量的经验, 然而却无法理解这些经验的含义, 更进一步, 对于经验有了总结归纳之后, 哪怕是进行计算的确切程度不同, 也会导致不同的对于自然的理解一个很著名的例子, 就是太阳系行星的运动的问题对于古人来说, 所谓行星的意思就是那些星星是相对于恒星在明显地运动, 在漫天的相互位置不变的恒星的对比之下, 很少的这种匆匆行者是非常引人注目的于是很早开始人们就纪录这些行星的运行轨道在古希腊时代, 最有名的关于这些行星运动的研究是托勒密完成的, 他对有关行星的纪录数据进行了计算, 得到了一个极其圆满的行星运动模型, 即以地球为宇宙中心, 行星围绕地球做严格圆周运动现在看来, 他的观测数据肯定不会是很精确, 而他的计算也不会很准确, 一直到开普勒, 在获得了非常精确的行星轨道运行的数据的基础上, 进行了大量的计算, 最终得到了革命性的开普勒三定律接下来牛顿出场了, 他更是一个计算天才, 正是通过计算, 从开普勒三定律获得了他的最伟大的发现, 万有引力定律然后还是通过计算, 我们现在可以运用牛顿万有引力公式的计算而把脚印留到月球的寂寞沙

脑, 莫衷一是, 各有各的理论和证据, 确实是个很难取得定论的问题, 因此我想提出一种新的解释, 大概是不会遭到立刻的覆灭性打击人类的进化始于计算, 我相信在有关非洲黑猩猩的纪录片里面, 可以看到黑猩猩也会用手使用工具, 一

4 尘上还有一个非常独特的例子, 就是中国的古代科学和技术, 更是强烈地依赖计算相比于古希腊, 中国的古代数学几乎完全是以计算为中心的, 翻开中国的古代数学书, 一个鲜明的特点就是几乎完全是针对问题的数学计算方面的内容, 而很少有古希腊传统的公理, 定理与证明实际上, 古代中国在技术上一直领先于世界, 很难说跟这种重视计算的风格没有关系其中最有名的例子就是祖冲之关于圆周率的计算, 而我们现在都很清楚, 祖冲之的计算不仅是为圆周率提供了一个远比西方要精确的具体数值, 更重要的是提供了一种非常通用的计算方法, 即一种近似积分计算, 而这种计算方法对于古代中国的技术进步的重要作用, 正是一个表明计算的重要性的典范如果说计算在科学的早期发展中扮演了关键的作用, 那么我们还是可以说计算仍然在现代科学技术扮演着关键的角色固然现代的科学技术领域广阔而渊深, 然而哪里没有计算的身影呢? 甚至在某些科学哲学家的看法里面, 能否进行计算是衡量一个理论是否已经成为科学的一个部门的标准也许这种说法不免偏激, 但是计算对于科学与技术的意义, 确实是一个深刻的问题我们不妨考察一下物理学里面计算所占据的地位, 也许有助于更深地理解这个问题几乎是一直到十九世纪, 物理学还是以实验为主要内容, 进入二十世纪之后, 一场物理学革命飞快地竖立了理论物理学的丰碑, 足以与传统的实验物理学分庭抗礼而这种局面在二战时期就开始改变, 二战后在实验物理与理论物理之外, 计算物理鼎足而立, 导致这种变局的最关键的因素就是电子计算机的发明在计算机没有发明之前, 人们不得不采取各种方式来回避过于庞大的计算问题, 而大量的关键问题, 又非得进行庞大的计算不可, 以物理学为例, 一旦我们透彻地解决了线性问题之后, 接踵而来的就是远比线性现象更为广泛的非线性现象, 对于非线性问题, 我们已经掌握的解析方法极其贫乏, 这就逼迫我们走上直接计算之路而除了非线性问题之外, 物理学乃至整个自然科学看待世界的方式都是原子式的, 即我们总是可以把一个现象理解为它的组成成分的相互作用的结果, 于是我们就有了分子, 原子等基本的科学观念, 这种做法一直都是充满胜利的, 然而这种胜利也是伴随着沉重代价的, 即当我们重新面对复杂现象时, 不得不从它的组成成分开始考虑, 这就是统计物理学的基本思想, 显然这种做法给我们带来了繁重的计算任务, 因为迄今为止, 我们人类对于一个包含超过了 3 个的, 具有相互作用的成员的系统的精确解析求解, 已经是有点一筹莫展了, 更何况常见的那些动辄包含了成千上万成员的系统呢? 因此在很大一部分情况下, 我们唯一的选择, 就是直接的计算因此我们可以说, 计算确实是科学的基石之一至于我们所生活的这个几乎完全由科学技术所塑造的世界, 哪里没有计算的身影呢? 如果说计算帮助我们理解了自然, 进一步我们还可以说计算创造了我们的生活任何一个科学上的对于自然的新的理解, 要转变为为人所用的技术时, 基本的途径就是计算道理很显然, 当我们要制造一种自然界从未出现过的物品时, 我们需要的是具体的制造数据, 而不能只是一堆公式, 那么数据从哪里来呢? 当然只能从对公式的计算得来因此我们可以把计算理解为理论的实现途径即理论无论是要反映真实世界, 还是要体现到我们的实际物品上, 它都需要通过一条叫计算的路, 理论武装了我们的大脑, 而计算则创造了我们的世界所以我们可以说, 人类的历史, 最早是始于计算, 而这个历史的实现的最前沿, 则仍然是终于计算

了一个远比西方要精确的具体数值, 更重要的是提供了一种非常通用的计算方法, 即一种近似积分计算, 而这种计算方法对于古代中国的技术进步的重要作用, 正是一个表明计算的重要性的典范如果说计算在科学的早期发展中扮演了

5 1.2 描述计算的语言长久以来, 人类的计算都是依靠自己来完成的, 但如果仔细考虑一下, 就会发现计算的实质是把一个经过清楚的分析, 明确了求解的方法的问题, 分解为明确, 可行, 而有限的步骤, 显然这种工作本质上是机械性的, 如果把已经得到求解方法的问题还交给人脑来计算, 显然有浪费人力之嫌 ; 从另外一个方面来讲, 往往一个需要专门加以计算的问题, 也是一个需要进行庞大的计算的问题, 庞大到人力已经难以胜任的程度因此这两个方面都要求人类发明能够进行计算的机器, 这就直接导致了计算机的发明今天当我们面临需要计算的问题时, 对付问题的就不再只是一个大脑, 而是一个大脑加上一台机器所以接下来的问题就是如何让大脑与计算机协同工作, 使得大脑能够专门用来寻求问题的算法, 而计算机能够被用来计算解这种协同工作的第一个要求就是人需要能够把自己对于问题的计算过程的理解表示为机器的机械运动首先人对于问题及其求解的理解是可以非常清晰地依靠数学语言来加以描述说明的然后我们再看机器那一端所谓计算机就是能够自动执行一系列机器动作的机器, 对于那些机器动作, 我们可以把它们和基本的计算操作对应起来, 这就使得有可能把计算问题的能行的计算步骤分解为有限的机器操作, 这里剩下的问题就是一方面是我们熟知的描述问题求解的数学语言, 另一方面就是描述机器操作的语言, 这两个方面的语言如何对应的问题下面我们讨论一个非常简单的例子, 用来说明这里面的语言翻译问题一个一元二次方程的求解是一个很简单的数学问题设方程的形式为 : 2 ax bx c a + + = 0, 0 那么方程的解的一般公式为 : x 1 = + 2 b b 4a 2a c x 2 = 2 b b 4ac 2a 注意我们现在的目的是计算, 而不是求解析解, 因此得到这个公式不是问题的结束, 而是问题的开始, 即运用这个公式, 在 a,b,c 都有具体取值的情况下, 求出具体的数值解因为如果该方程描述的是一个抛体运动, 那么我们需要知道的当然是解的数值, 以便我们了解和控制该抛体运动所以我们还需要进一步把这个数学表述转述为一个具体的求值过程的描述如下 : (1) 获得 a,b,c 的具体取值 ; 2 (2) 根据 a,b,c 的具体取值计算 b 4ac 的值 ; 2 (3) 如果 b 4ac大于 0, 那么分别计算上面的两个公式的数值, 得到两个不同的实数根 ; (4) 如果 b 2 x 4ac=0, 那么计算公式 b = 2a, 得到的 x 的值就是方程的两个相同的根 ;

发明能够进行计算的机器, 这就直接导致了计算机的发明今天当我们面临需要计算的问题时, 对付问题的就不再只是一个大脑, 而是一个大脑加上一台机器所以接下来的问题就是如何让大脑与计算机协同工作, 使得大脑能够专门用来

6 2 (5) 如果 b 4ac小于 0, 那么分别计算上面的两个公式的数值, 得到两个不同的复数根这样得到的上面的 5 个计算步骤描述, 才是希望计算机所执行的计算过程的一个大概描述当然这个描述是基于我们已经获得的对于一元二次方程的求解问题的数学上的彻底了解那么描述计算机的操作的语言是什么样的形式呢? 我们知道所谓计算机的工作在本质上是运行一些基本的机械电子操作, 固然我们可以把那些操作根据运算法则而定义为相应的运算, 例如一个开关电路的信号叠加, 可以适当地定义为二进制数值的加法, 但显然不可能期望依靠这种物理现象能够直接地表达更加复杂的计算, 例如上面公式里面的开平方幸好我们依靠数学, 可以做到把任何复杂的计算分解或近似分解为极少数简单计算的叠加与组合因此最终我们已经至少在理论上可以期望使用计算机来完成那些具有明确求解过程的计算任务然而问题是当我们需要向计算机提交一个数值计算任务时, 如果总是要求我们首先把计算任务的描述按照计算机所能够理解和执行的程度来进行的话, 无疑会使得向计算机提交计算任务成为一件极其麻烦的事情, 本来我们利用计算机的目的是为了减轻自己的机械劳动工作量, 如果向计算机提交问题是如此麻烦的话, 显然不符合我们发明计算机的初衷因此进入二十世纪五十年代后, 提出了计算机高级语言的概念, 所谓高级语言, 就是非常接近我们平常对于数学问题的描述的语言, 而所谓给出计算机高级语言, 实质上并不是说计算机能够直接理解高级语言了, 而是把高级语言到计算机内部的机器语言的翻译工作本身交给计算机来完成, 因为这种翻译工作在规范了高级语言之后, 是计算机自身就完全可以做到的, 当然这个翻译任务本身又是一个需要我们首先明确给出一般解答的计算问题世界上第一个诞生的计算机高级语言就是我们在这本书里要给出的 FORTRAN FORTRAN 最早是 IBM 公司在 1957 给出的, 专门用于向 IBM 自己生产的 704 计算机提交表述计算问题的一个计算问题的求解过程如果使用了计算机语言来表述, 就称为一个程序, FORTRAN 正是这样一种专门用来写程序的语言由于 IBM 的 709 计算机的成功, 同时也使得 FORTRAN 获得了广泛的传播, 这时 FORTRAN 的语言本性开始在另外一个方面显示了出来, 即语言的生命就在于它的传播于是大多数其它计算机制造商也纷纷使得他们的产品能够输入和理解 FORTRAN 语言 FORTRAN 语言从它的名称来源就可以知道是一种与某些特定机器进行通讯的语言工具即 FORTRAN 语句可以通过特定的机器上配置的编译程序而翻译成机器语言, 因此早期的 FORTRAN 语言具有强烈的与机器系统相关的一些特征, 它们反映了那些特定机器的某些特点, 显然如果考虑到高级语言的本质是要用来描述计算过程, 即所谓算法语言, 那么这些与机器相关的特征是没有意义的, 而 FORTRAN 不断更新版本所带来的进步, 也就包含了不断舍弃这种特征的目的在内 FORTRAN 的这种历史痕迹的一个例子就是把语言用那些特定机器所能接受的字符序列 ( 亦就是 IBM 公司用来向计算机输入程序的卡片穿孔设备的 48 个字符 ) 来定义. 而它的那种卡片输入方式决定了很多的程序书写格式例如通常把语言中的一个语句写在一个记录上, 也就对应着穿孔的一张卡片 ; 各个语句按顺序读入, 对应着卡片的顺序读入 ; 卡片的格式是固定的, 构成后来所谓的固定源码形式这就是最初提出计算机高级语言时我们所拥有的第一种高级语言的状况不久降生的另外一种高级语言是 ALGOL, 这个名称就是算法语言的简称, 因此可以预料到这种语言具有与 FORTRAN 非常不同的面貌, 因为这种语言在设计初始, 就不是计算机制造公司为某种特定机器设计的, 而是纯粹面向描述计算过程的, 也就是所谓面向算法描述的

我们知道所谓计算机的工作在本质上是运行一些基本的机械电子操作, 固然我们可以把那些操作根据运算法则而定义为相应的运算, 例如一个开关电路的信号叠加, 可以适当地定义为二进制数值的加法, 但显然不可能期望依靠这种物

7 ALGOL 最早是在 1958 年由德意志联邦共和国应用数学与力学协会提出的 ALGOL 的设计目标显然比 FORTRAN 要来得高远, 它希望不仅能够用于人对机器转述计算过程, 也希望能够直接用于人与人之间的对于算法的描述为了实现这个通用的目的,ALGOL 的字符不是针对任一具体机器定义的, 因此它不反映任何一台特定机器的特性实际上 ALGOL 所使用的字符与词汇完全是独立定义的除此之外 ALGOL 还具有许多更加独特的性质不过语言终久摆脱不了它的市场属性, 由于 FORTRAN 更加具有市场侵占能力, 最终 FORTRAN 至今还是主流的科学计算编程语言, 而 ALGOL 语言则不幸成为了任人凭吊的古董 1.3 为什么选择 FORTRAN 到底选择什么样的语言, 本身是一类非常具有争议性的问题曾几何时, 在科学计算领域, 就沸沸腾腾地讨论过最好使用什么样的语言也许我们可以说这是一个见仁见智的问题, 因为我们作为语言的使用者, 总是拣自己已经很熟悉的语言, 当然总是自己能够很好驾驭的语言是最好的但是具体地针对科学计算来说, 由于科学计算问题具有自身的独特的价值标准, 在这个价值标准之下, 各种不同的语言还是可以进行客观比较的首先我们得把自己面临的任务界定清楚, 也就是什么是科学计算问题? 所谓科学计算问题大体上包括如下三个涵义 : 问题本身以及问题的解答都能够使用数学语言予以精确描述 ; 如果要使用通常的数学方法来给出我们所需要的数值答案, 会很麻烦或者根本无法给出 ; 问题以一定的科学与技术知识作为背景我们会看到正是科学计算问题的这种内涵决定了它在选择计算语言时所具有的价值标准首先, 一个科学计算问题总是要以一个数学计算问题的形式出现, 因此描述科学计算问题的语言应该能够自然地描述数学问题, 即要求编程语言和数学语言在表达方式上具有比较直接自然的对应关系然后一个科学计算问题之所以需要使用计算机, 那肯定是因为这个问题具有一定的计算量, 那么程序的运行效率往往是选择语言时最重要的考量因素正是在这两点上,FORTRAN 是现在众多语言当中的绝对胜出者在描述数学语言的自然性方面, FORTRAN 可以说比现在还活着的任何语言都强当然在历史上曾经出现过象 ALGOL 那样的相当数学化的语言, 可惜的是它缺乏市场生存能力, 所以就只剩下 FORTRAN 独美于今了 FORTRAN 擅长描述数学计算, 这点应该是几乎没有什么争议的也正是由于这个缘故,FORTRAN 的易学是公认的任何一个科技专业人员, 只要对于一个具体问题的数学求解过程有明晰的概念, 要把这个求解过程翻译为 FORTRAN 语言是非常轻松的至于执行速度方面, 则常常有些似是而非的说法误导初学者最典型的一个错误观念就是 C 代码的执行速度最快这个说法来源于 C 语言的特殊性, 因为 C 语言更多的是一种系统编程语言, 对硬件的控制能力很强, 在高级语言里面无出其右者, 于是给人以 C 程序的速度必定最快的印象但是忘记了这个速度快是来自 C 语言的系统编程特性, 而在做科学计算时, 并不需要过多地涉及到系统内核, 因此 C 语言的长处在科学计算方面可以说并不能适当地发挥, 相反, 在数值计算方面,C 绝对不是 FORTRAN 的对手, 因为相对于 C 以系统编程为目的,FORTRAN 是以科

由于 FORTRAN 更加具有市场侵占能力, 最终 FORTRAN 至今还是主流的科学计算编程语言, 而 ALGOL 语言则不幸成为了任人凭吊的古董 1.

8 学计算为目的的, 语言本身在设计之初, 就考虑到了针对科学计算而进行优化, 因此 FORTRAN 生成的可执行代码是高度优化的实际的运行效率方面的比较也表明了 FORTRAN 在科学计算方面的优越性无论是国内还是国外, 也无论是经典的串行机还是并行矢量机, 大量的经验表明, 在执行同一个科学计算任务时, C 或 C++ 代码的效率都低于 FORTRAN 代码, 除了常见的对于 C 有着高效的迷信之外, 还常常有着对于 FORTRAN 是如何如何落后的偏见当然这种偏见是有来源的, 那就是曾经功勋卓著的 FORTRAN 77 在很长一段时间里面, 都缺乏进取心, 使得迄今很多人提起 FORTRAN, 想到的就是在当今时代已经显得非常落后的 FORTRAN 77 实质上,FORTRAN 标准在进入 FORTRAN 90 时代之后, 特别是现时的 FORTRAN 95 版本, 可以说只要是对于科学计算有用的特性,C 和 C++ 有的, 现在 FORTRAN 95 绝对不缺, 而反过来 FORTRAN 95 所具有的很多针对科学计算的特性, 却是 C 和 C++ 所不具有的哪怕是 C++ 最引以为傲的面向对象性质,FORTRAN 2000 也将全面引入所以说,FORTRAN 已经完全赶上了编程语言的潮流与程序运行的效能有关的另外一个重要方面, 是程序语言能否支持程序的并行运行, 在这点上, 可以说 FORTRAN 表现了它的最大优势, 因为 FORTRAN 95 正是着力于获得并行计算的能力的一个版本由于现代科学计算的规模越来越大, 计算并行化是一条不得不走的路线, 现代计算机硬件的发展, 也使得并行化具有实际的普及前景, 因为不仅专门的大型计算机是并行的, 现在的一般 PC 都可以拥有多个处理器, 因此现代的从事科学计算的用户不得不掌握并行化计算的编程能力但是进行并行化编程所遇到的一个主要问题, 就是任何过程编程语言都内在地使用线性存储模式, 也就是一个数组的元素总是被认为按照数组元素的先后顺序而连续地存储在内存单位里面, 这样一种模式就决定了这样的过程编程语言无法真正地实现对并行计算的描述而 FORTRAN 95 则完全改观了这种制约, 因为在 FORTRAN 95 里面对于数组以及数组运算建立了全新的面向并行化计算的概念, 诸如纯过程的概念, 逐元过程的概念,FORALL 结构等等, 都有效地摆脱了线性存储模式的制约, 使得 FORTRAN 95 成为描述并行计算的标准语言, 特别是那些专用的数据并行化语言都纷纷采用 FORTRAN 作为基础语言, 例如高性能 FORTRAN(High Performance Fortran),Fortran D,Vienna Fortran, 以及 CRAFT 等这样就使得使用 FORTRAN 95 编写的程序可以直接在这些数据并行化语言的平台上运行, 而反过来使用这些专用语言编写的程序也可以毫不困难地转移到 FORTRAN 95 平台上运行, 这样一种局面使得 FORTRAN 在并行计算领域独领风骚综上所述, 我们完全可以说 FORTRAN 95 是进行科学计算的最佳语言, 作为需要进行科学计算的科学与技术领域的工作人员, 掌握 FORTRAN 95 远比掌握 C,C++ 等语言要重要得多, 至于那些计算机符号代数与数值计算软件, 例如 MATHEMATICA,MAPLE,MATLAB,Macsyma, MATHCAD 等等, 只能说是进行科学计算的教学模型与辅助工具, 由于它们都提供了现成的算法, 因此可以使得初学者能够应用于一些简单的场合, 真正要用它们来对付稍微大一点的问题, 有经验的用户都知道, 那会是一件非常痛苦的强人所难的事情因此最终要自由地进行科学计算, 则非 FORTRAN 莫属 1.4 FORTRAN 的进步下面我们介绍一下 FORTRAN 在历史上所取得的重要进步, 特别是 FORTRAN 95 有别于

的, 那就是曾经功勋卓著的 FORTRAN 77 在很长一段时间里面, 都缺乏进取心, 使得迄今很多人提起 FORTRAN, 想到的就是在当今时代已经显得非常落后的 FORTRAN 77 实质上,FORTRAN 标准在进入 FORTRAN 90 时代之后, 特别是现时的

9 FOR TRAN 90 的特征, 更能够引导我们走向高性能的 FORTRAN 并行编程的领域 FORTRAN 95 的进步 FORTRAN 的每一个进步, 都意味着要把很多的语言特征归结为三类 : 新的语言特征 ; 顾名思义, 就是 FORTRAN 最新版本引入的全新语言过时的语言特征 ; 就是暂时在最新的 FORTRAN 标准里面仍然可以使用, 而不会出现不兼容的情形, 但是被指明为过时的语言特征, 是在未来的下一个 FORTRAN 版本里面将要被淘汰的部分废弃的语言特征顾名思义, 就是在过去的 FORTRAN 版本里面曾经出现过, 但在现在的版本里面已经不许使用的语言特征下面分别介绍它们新的语言特征 FORTRAN 95 所增加的新的语言成分包括全新的功能和对旧有功能的改进两个部分它们主要包括 : FORALL 语句与结构纯 (PURE) 过程逐元 (ELEMENTAL) 过程 WHERE 结构的扩展默认初始化 NULL 固有函数 CPU_TIME 固有子例行程序固有函数 CEILING,FLOOR,MAXLOC,MINLOC 的扩展可分配数组的动态去分配名称列表输入里面的注释最小域宽格式说明用于支持 IEEE 754/854 浮点运算标准的某些修改下面分别予以说明 1. FORALL 语句与结构 FORALL 语句与结构和纯过程这两个新的语言成分, 主要是为了提高在多处理器系统上面的程序并行运行效率而引进的只要系统支持并行的赋值,FORALL 语句以及结构, 就能够自然地实现对一个庞大的数组的所有元素进行同时赋值, 从而充分地利用了系统的并行效能这个新特征的引入充分显示了 FORTRAN 在并行运算方面的努力 2. 纯 (PURE) 过程 PURE 是一个完全新引入的过程属性具有 PURE 属性的函数或子例行程序, 除了返回值之外, 将不具有任何的后效也就是说, 对于它的任意变元或全局变量, 它都不改变它们的值, 指

会出现不兼容的情形, 但是被指明为过时的语言特征, 是在未来的下一个 FORTRAN 版本里面将要被淘汰的部分废弃的语言特征顾名思义, 就是在过去的 FORTRAN 版本里面曾经出现过, 但在现在的版本里面已经不许使用的语言特征下面

10 针关联状态, 以及数据映射, 也不执行输入输出在 FORTRAN 95 标准里面, 一些场合要求其中的过程必须具有 PURE 属性特别地 PURE 属性对于应用 FORALL 语句或结构进行并行赋值是必要条件 3. 逐元 (ELEMENTAL) 过程逐元过程同样是执行并行运算的强大工具把一个逐元过程应用到一个数组, 就把这个针对数组的运算转化为对数组的所有元素的单个的运算, 所有单个的结果再组合起来, 返回一个同样形状的数组 4. WHERE 结构的扩展 WHERE 结构经过扩展, 可以包含一个 FORALL 结构的嵌套, 而 FORALL 结构又可以包含 WHERE 语句或结构的嵌套两者的配合使用具有强大的功能 5. 默认初始化默认初始化可以应用于派生类型, 包括哑元, 这样就能保证具有指针成员的派生类型对象能够一直可以访问从而避免了出现内存可分配, 但是不能去分配的情形对于指针, 可以使用新的固有函数 NULL 来给出初始的关联状态, 也可以在使用数据之前, 使用 NULLIFY 语句来获得初始化 6. NULL 固有函数新引入的固有函数 NULL 的功能主要是给指针赋予一个初始的去关联的关联状态 NULL 函数可以在一个类型声明语句当中使用, 给定一个指针的初始去关联状态, 也可以在一个结构构造器里面使用, 用来给定其中指针成员的初始去关联状态 7. CPU_TIME 固有子例行程序固有函数 CPU_TIME 用来测量一个程序或一段代码所消耗的处理器时间这个函数的测量结果不一定是非常准确的, 但在一些情形下是非常有用的例如用来比较不同代码的运行时间, 从而比较它们的效率 ; 也可以用来检测一个并行程序是不是真正地把一个变元作为一个数组来并行处理, 从而评价它的并行效率 8. 固有函数 CEILING,FLOOR,MAXLOC,MINLOC 的扩展在 FORTRAN 90 和高性能 FORTRAN 之间, 某些固有函数以及相关函数存在某些不兼容, 因为在高性能 FORTRAN 里面, 在不同的变元位置增加了一个 DIM 函数在 FORTRAN 95 里面, 就放松了对于变元顺序的要求, 这样在变元序列当中 MASK 和 DIM 的出现就可以是任意的了, 从而保证了 FORTRAN 95 与高性能 FORTRAN 的兼容性 9. 可分配数组的动态去分配在 FORTRAN 95 里面, 当退出一个给定的作用域时, 其中没有通过使用 SAVE 而得到保留的可分配数组, 就自动地去分配, 和使用 DEALLOCATE 语句的效果一样这样就可以防止可能发生的内存遗漏, 从而规范分配过程 10. 名称列表输入里面的注释在名称列表输入纪录当中可以使用注释, 从而方便了用户

WHERE 结构的扩展 WHERE 结构经过扩展, 可以包含一个 FORALL 结构的嵌套, 而 FORALL 结构又可以包含 WHERE 语句或结构的嵌套两者的配合使用具有强大的功能 5.

11 11. 最小域宽格式说明在使用数值的格式输出的时候, 运用增强的输出格式编辑描述符, 就可以对域宽进行极小化, 从而避免输出时的白边 12. 用于支持 IEEE 754/854 浮点运算标准的某些修改在所有以前的 FORTRAN 版本里面, 都不区分 +0. 和 -0., 即正 0 和负 0, 在 FORTRAN 95 版本里面, 就能够区分这两者了, 即在使用 SIGN 函数时, 可以通过让第一个变元为 0, 而第二个变元为负号, 就得到负过时的语言特征 FORTRAN 95 里面被划归为过时的语言特征, 在 FORTRAN 90 里面还是允许正常使用的, 但是在 FORTRAN 95 里面已经强烈地不提倡使用, 因为它们在下一个 FORTRAN 版本里面会被彻底淘汰这些过时的语言特征主要包括 : 算术 IF 语句 DO 终止的某些形式替代返回计算 GO TO 语句语句函数可执行语句之间的 DATA 语句哑长度字符函数固定源码形式字符型声明里面的 CHARACTER* 形式下面分别说明, 并特别要注意它们为什么是多余的或容易产生错误的 1. 算术 IF 语句算术 IF 语句的功能完全可以通过使用 IF 语句或 IF 结构来替代 2. DO 终止的某些形式共享 DO 终止, 或者不是使用 END DO 语句或 CONTINUE 语句的 DO 终止都是过时的, 无论是从安全的角度, 还是从清晰的角度, 都最好使用具有不带标签的 END DO 语句的 DO 结构块形式 3. 替代返回替代返回强烈地依赖标签, 是不值得提倡的, 而且同样的功能完全可以通过 CASE 结构来实现 4. 计算 GO TO 语句计算 GO TO 语句完全可以使用 CASE 结构来代替, 而且 CASE 结构还具有比计算 GO TO 语句更加广泛的功能从结构化编程的角度来看, 也应该使用 CASE 结构, 而不是完全非结构化的, 带有早期与系统相关特征的计算 GO TO 语句 5. 语句函数内部函数就具有语句函数的许多特征而语句函数非常容易与赋值语句相混淆, 所以语句函

, 即正 0 和负 0, 在 FORTRAN 95 版本里面, 就能够区分这两者了, 即在使用 SIGN 函数时, 可以通过让第一个变元为 0, 而第二个变元为负号, 就得到负 0 1.4.

12 数也是不提倡使用的 6. 可执行语句之间的 DATA 语句如果在程序的可执行部分使用 DATA 语句的话, 会容易让人产生一种错觉, 即 DATA 语句能够在程序的执行过程当中进行赋值, 而实际上,DATA 语句只能用于数据的初始化, 因此 DATA 语句最好还是只用于程序的说明部分 7. 哑长度字符函数哑长度字符函数要求在调用程序当中声明函数的名称, 它完全可以通过运用具有显式界面或动态字符长度的子例行程序或函数来替代 8. 固定源码形式固定源码形式完全是由早期的卡片纸带式输入输出方式所决定, 而现在卡片纸带式输入输出早已经不再使用, 因此这种源码形式必定是要被淘汰的 9. 字符型声明里面的 CHARACTER* 形式在字符型声明语句当中用来说明字符长度的 CHARACTER* 完全是多余的, 一般提倡采用更为合乎英语习惯的形式废弃的语言特征在 FORTRAN 90 里面还可以使用的语言特征有些已经被 FORTRAN 95 完全废弃了, 因此要特别留意它们, 以免出现源代码无法在 FORTRAN 95 系统里面调试通过的情况这些被 FORTRAN 95 废弃的语言特征主要包括 : 实型和双精度实型的 DO 变量从块的外部分支到块内部的 END IF 语句 PAUSE 语句 ASSIGN 语句, 带标签的 GO TO 语句 nh 编辑描述符为了能够阅读使用 FORTRAN 90 以及更早版本的源代码, 下面还是分别予以简要的说明请注意它们遭到淘汰的原因所在 1. 实型和双精度实型的 DO 变量实型和双精度实型的 DO 变量或循环控制的 DO 参数都是难以移植的, 而且也是很少用到的因此现代的 FORTRAN 版本都要求 DO 变量为标量整型变量 2. 从块的外部分支到块内部的 END IF 语句从块的外部分支到块内部的 END IF 语句对于语句的执行序列的控制, 是完全不必要的, 也是不规范的, 因此已经被完全淘汰了 3. PAUSE 语句 PAUSE 语句用于把一个正在运行的程序挂起来, 直到系统或操作重新开始运行它的功能完全是多余的, 因为 WRITE 语句可以发送消息到任何设备, 例如操作控制台或终端, 而 READ 语句则可以等待或接收来自同一个设备的消息它们的配合使用就可以替代特别的 PAUSE 语句

序的说明部分 7. 哑长度字符函数哑长度字符函数要求在调用程序当中声明函数的名称, 它完全可以通过运用具有显式界面或动态字符长度的子例行程序或函数来替代 8.

13 4. ASSIGN 语句, 带标签的 GO TO 语句 ASSIGN 语句用来给一个整型变量赋予一个语句的标签它的一般用途就是, 在程序的运行过程当中, 通过 ASSIGN 语句就可以给该整型变量赋予分支目标语句的标签, 从而给程序提供一种动态分支的能力然而整型变量除了可以具有标签值之外, 还有可能具有一般的整数值, 这就会容易导致程序错误, 也使得程序难以阅读实际上 ASSIGN 语句, 以及带标签的 GO TO 语句的功能, 都可以由内部过程实现, 因为 ASS IGN 语句无非就是纪录了一个可重用代码块完成运行后的返回点 ASSIGN 语句还可以把一个 FORMAT 语句的标签动态地赋予一个整型变量, 然后该变量就可以用作 WRITE,READ,PRINT 语句的格式说明符不过这个功能也可以通过把字符型变量, 数组, 以及常量用作格式说明符而得到实现总之, 标签的使用总是不合时宜的 5. nh 编辑描述符使用这个编辑描述符非常容易导致错误, 因为跟在该描述符后面的字符数目很容易计算错误, 而如果使用字符常量编辑描述符来行使相同的功能的话, 则根本不需要计算字符数目第二篇计算的叙述算法的每一个步骤, 都必须给予确切的定义对于算法当中所考虑的每一种情况, 每一个有待执行的动作, 都必须严格地和不含混地加以规定对于以描述算法作为目的而设计出来的, 采用了形式的定义的程序设计语言, 或者说计算机语言, 它的每一个语句都必须有非常确切的意义 ---- D.E.Knuth [1] The Art of Computer Programming 本质上 FORTRAN 就是一门语言, 一门人与计算机赖以进行有效交流的语言, 在这个意义上和我们使用的中文, 英文等没有本质差别现在假设要来描述一种大家都陌生的语言, 那么总是要分成两个方面来描述, 即一方面要描述这门语言的表象和形态, 也就是它使用哪些符号, 哪些词汇, 一般的句式如何, 怎样才能完整叙述一个任务之类 ; 另一方面需要说明这门语言的语义, 也就是说这门语言是如何用来表达我们需要它表达的意思的第 4 章基本上就是描述 FORTRAN 作为一种语言的基本形态, 也就是书写这种语言的书写规则接下来几章则逐步说明如何用 FORTRAN 来表达我们的要求, 或者反过来说,FORTRAN 提供了些什么表达方式, 以便我们用来向计算机提出合理的任务 : 表达基本数据 ; 表达数据的结构 ; 完整地描述数据 ; 构造表达式 ;

纪录了一个可重用代码块完成运行后的返回点 ASSIGN 语句还可以把一个 FORMAT 语句的标签动态地赋予一个整型变量, 然后该变量就可以用作 WRITE,READ,PRINT 语句的格式说明符不过这个功能也可以通过把字符型变量, 数组, 以及

14 驱动计算的赋值 ; 计算过程的结构控制 ; 在整个第二篇, 我们将领略到 FORTRAN 95 是如何能够做到精致地描述计算的, 而把一个问题阐述清楚了, 就意味着问题已经解决了一大半 [1] Donald E. Knuth ( 高纳德 ), Stanford University 的 The Art of Computer Programming 荣休教授, 而 The Art of Computer Programming( 计算机程序设计技巧 ) 正是他的伟大著作的名称洋洋七大卷的 The Art of Computer Programming 是当今全世界每一个计算机科学家所膜拜的圣经 1974 年在该书刚完成前面很少一部分时, 就给他带来了计算机科学家们梦寐以求的图灵奖第 4 章 FORTRAN 95 语言的形貌要说明一门语言的形态, 必须回答以下问题 : 它使用哪些符号来表达信息? 它的词汇如何构成? 它的语句如何构成? 如何表达一个完整的任务? 具体的对于一门计算机语言, 把这几个问题更加明确地转换过来, 就是 : 它使用键盘上的哪些符号, 各个符号有哪些用途? 它的词汇如何由键盘字符构成? 含有哪些固定的词汇? 以及容许自由构成合法词汇的规则是什么? 它具有哪些固定的语句格式? 以及容许自由构成合法语句的规则是什么? 我们交待给计算机的任何任务, 都必须明确说明任务的开始, 执行步骤和完成, 因此一段完整的源代码应该具备什么样的形式? 以及应该具备哪些要素? 本章就是要回答这些问题 4.1 FORTRAN 语言所使用的字符从最抽象的层面来看, 人与计算机的交流只是信息的交流, 而信息总是需要依靠某种信号来表示, 对于人来说, 最方便的就是字符而对于计算机来说, 自然就是键盘所能敲出的那些字符 ( 信号 ), 因此下面就是要说明 : FORTRAN 95 能识别键盘上敲出的哪些字符? 每个字符对于 FORTRAN 95 来说又意味着什么? FORTRAN 95 所使用的基本字符按照 FORTRAN 95 标准的规定, 一切 FORTRAN 95 的实现平台都必须使用下面表 4-1 所列出来的这个基本的字符集, 或者说, 这个字符集是所有遵循 FORTRAN 95 标准的编译器所使用

Programming 是当今全世界每一个计算机科学家所膜拜的圣经 1974 年在该书刚完成前面很少一部分时, 就给他带来了计算机科学家们梦寐以求的图灵奖第 4 章 FORTRAN 95 语言的形貌要说明一门语言的形态, 必须回答以下问题 : 它

15 的字符集的公共子集这样原则上, 局限在这个字符集上的源码是能够被任何遵循 FORTRAN 95 标准的编译器所识别的表 4-1 基本的 FORTRAN 95 字符集 : 文字字符英文字母 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 数字下划线 _ 特殊字符图形名称空格 = 等号十加号图形名称 : 冒号! 叹号引号一减号 % 百分号 * 星号 & 英语的 and / 斜线 ; 分号 ( 左括号 < 小于 ) 右活号 > 大于, 逗号? 问号. 小数点或句号 $ 货币符号撇号可以看到基本字符分为两大类 : 文字字符和特殊字符除了货币符号可以本地化之外, 其他任何字符都必须依照表里的形式对于基本字符有如下几个问题需要予以注意一. 文字字符的用处 : 主要是命名的作用, 可以用来命名语言中的一切对象, 这三种符号可以混合使用 ; 其中数字还具有它本来的含义, 就是表示数目二. 特殊字符的用处 : 特殊字符主要具有功能的意义, 如编辑功能, 运算功能, 语法功能等 FORTRAN 95 标准原则上接受小写字母因此除了以下位置, 大小写是等价的三. 大小写必须区分的位置 : 作为字符常量的字符串里面 ; 输入输出的纪录里面 ; 作为编辑描述符的引号或撇号里面因为在上述几种情形, 大小写是字符型数据的不同数据取值如果不幸遇到一个 FORTRAN 95 标准的怪异的编译平台, 偏偏不接受小写字母, 这是 FORTRAN 95 标准所许可的, 这时就得小心了不过幸好我们常用的编译平台, 例如 CVF, 都是接受小写字母的另外, 在 OPEN 或者 INQUIRE 语句里面的 FILE= 或 NAME= 后面是否区分大小写, 也是由编译平台指定的

小数点或句号 $ 货币符号撇号可以看到基本字符分为两大类 : 文字字符和特殊字符除了货币符号可以本地化之外, 其他任何字符都必须依照表里的形式对于基本字符有如下几个问题需要予以注意一.

16 如果是需要调用其他语言写的子程序, 而恰好该种语言 ( 例如 C 语言 ) 是区分大小写的, 这时就需要特别小心例 4-1 如果用 C 写了两个子程序 EIGEN 和 eigen, 然后有如下的 FROTRAN 片断 : EXTERNAL EIGEN... CALL EIGEN... END 这时它是该引用 EIGEN 还是 eigen 呢? 如果所使用的 FROTRAN 系统正好是怪异的那种, 没问题如果是常见的如 CVF, 这时它就无法区分 EIGEN 和 eigen, 这样就必须给它们更换名称了四. 数字的涵义 : 除了以下情形, 数字总是表示十进位数字属于二进制, 八进制, 十六进制的字面常量 ; 带有 B,O,Z 编辑描述符的输入输出纪录例 4-2 以下语句当中的数字不是属于十进位数字 : DATA I, J, K / O 1001, 23.54, Z 5CA2 / 其中第一个为八进制数, 第二个为十进制数, 第三个为十六进制数五. 下划线的涵义 : 下划线的主要作用就是置于单词之间代替空格, 使得我们在命名时使用清楚的英语词汇下划线不能置于任意名称的前面, 但是可以置于名称的最后下划线也用于在字面常量中区隔常量的值和种别参数无论给什么对象起名, 都尽量使用完整的英语单词, 同时使用下划线以区隔不同的单词所谓好记性不如烂笔头, 只有这样才能切实保证你在任何时候, 在程序代码的任意位置都知道任意变量等的含义与平台有关的 FORTRAN 辅助字符集上节列出的基本字符集是在一切 FROTRAN 的编译平台都可以使用的, 被 FORTRAN 95 标准规定为必须使用的默认字符集另外还有些辅助的字符则是不同的平台有不同的用法约定辅助字符分两类 : 可打印字符和不可打印字符可打印字符 ; 各种本地化语言的字符, 象汉字, 希腊字母等, 都可以应用在字符串, 注释, 和输入输出纪录当中不可打印字符主要就是控制字符, 例如制表符 Tab 键制表符 (Tab 键 ) 在 FORTRAN77 标准当中主要用来表示 6 个空格, 这样在固定源程序形式的代码的每行的开头使用 Tab, 就自动地空出 6 个空格对于一个 FORTRAN77 标准的编译系统来说, 在固定源程序形式里的 Tab 被看成是至少 6 个空格, 而在自由源程序形式里的 Tab 被看成 1 个空格这样如果 Tab 被放在文本当中用于输出格式控制, 那么这种默认的转换方式, 有时就会导致输出格式的混乱

数字的涵义 : 除了以下情形, 数字总是表示十进位数字属于二进制, 八进制, 十六进制的字面常量 ; 带有 B,O,Z 编辑描述符的输入输出纪录例 4-2 以下语句当中的数字不是属于十进位数字 : DATA I, J, K / O 1001, 23.

17 有关 FORTRAN 95 的辅助字符集的使用规则, 请参考具体的编译系统的说明 4.2 词汇所谓 FORTRAN 的词汇就是一个语句的最小的意义单位, 它由一个或多个 FORTRAN 字符集里的字符组成包括两类共 6 种, 分类例举如下 : 由文字字符组成的词汇, 包括 4 种 : 语句关键词 :IMPLICIT 名称 :EIGEN_FREQUENCY_3 由单个词汇组成的字面常量 : _long 标识符 :213 由特殊字符组成的算符 : +,.OR. 定界符 : 逗号,=,=,:,::,;,% FORTRAN 95 的一切合法的词汇都必须按照语法来构成完备的构词语法规则在附录 B 给出下面分别予以详细说明 1. 语句关键词语句关键词的功用 : 标志语句本身例 4-3 下面的 DO 语句中的关键词 DO 本身标志了该语句 DO I=1,500 标志选项例 4-4 下面的 INTENT 语句当中的 IN,OUT, 或 INOUT INTENT(IN),A B INTENT(INOUT),X,Y,Z 用在语句当中, 起分界的作用例 4-5 如下面 DO 语句当中的 WHILE DO WHILE(. NOT. VECTOR ) 键词并非所有的语句都必须包含关键词, 在 FORTRAN 里面, 赋值语句和函数都不需要关尽管 FORTRAN 95 不区分大小写, 本书任何地方出现的语句关键词都使用大写字母纯粹是为了醒目的原因 2. 名称在一个程序当中, 任何对象都需要有一个名称, 给它们命名所得到的词汇, 可以说就是一般语言里的名词, 这样的对象包括 : 变量, 命名常量, 程序单元, 过程, 公用块, 构造, 派生类型, 哑元等

个词汇组成的字面常量 :1.234567_long 标识符 :213 由特殊字符组成的算符 : +,.OR. 定界符 : 逗号,=,=,:,::,;,% FORTRAN 95 的一切合法的词汇都必须按照语法来构成完备的构词语法规则在附录 B 给出下面分别予以详细说明 1.

18 名称的拼写规则为 : 名称必须由字母开头, 可以由文字字符混合组成, 而下划线不能作为名称的第一个字符一个名称至多允许含有 31 个字符 3. 常量一个常量就是对一个值的合乎语法的字符标记常量分为字面常量和命名常量两种 : 一个值如果没有在程序里面经过命名, 则称为字面常量, 这种常量不能取派生数据类型例 Z 5120A TRUE. (33.2, 5.0) 一个值如果在程序里面经过命名, 则称为命名常量, 这种常量能取派生数据类型例 4-7 在如下声明语句当中的常量 UNSTABLE_POINT 为命名常量 : REAL, DIMENSION(3), PARAMETER ::UNSTABLE_POINT =& (/5.332, 0.221, /) 对于常量的语义, 将在说明数据时进一步讨论 4. 语句标签在一个程序单元内部, 对任何一条语句, 都可以在该语句的前面加上语句标签, 以便在该程序单元内部的任何其他位置引用该语句需要引用其他语句的语句包括 CALL 语句,DO 结构, 分支语句, 输入输出语句等语句标签的书写规则为 : 语句标签由 1 到 5 个十进制数字组成, 其中必须至少有一个数字不能是 0, 例如 000 不能作为标识符 ; 标识符以 0 开头是没有任何意义的, 例如 0034 与 34 没有区别标识符不能放置于空语句之前例上面的语句只出现了一个语句标签, 是不合法的对于在一个程序单元内部, 标识符不唯一出现的情形, 具有特殊的含义, 将在后面讨论 5. 算符算符用在表达式当中, 通过运算而获得某种类型的值算符分为固有算符和自定义算符两类 : 固有算符在 FORTRAN 95 语法当中, R310 规定了固有算符的构成法则例 4-9

0) 一个值如果在程序里面经过命名, 则称为命名常量, 这种常量能取派生数据类型例 4-7 在如下声明语句当中的常量 UNSTABLE_POINT 为命名常量 : REAL, DIMENSION(3), PARAMETER ::UNSTABLE_POINT =& (/5.332, 0.221, 190.

19 // 表示字符串的连接 + 表示对数值的加法.NOT. 表示逻辑否.OR. 表示逻辑或上面都是固有算符自定义算符自定义算符的一般语法形式为 :.XXX. 即在两个句点之间有 n 个字符构成的字符串,n 不大于 31 中间的字母串最好是一个表达该运算含义的英文单词这个单词不能与固有算符或者逻辑常量里面已经使用了的单词重复 6. 定界符全部的定界符有如下 12 种形式 : / ( ) (/ /), = => : :: ; % 其中 ( 和 ),(/ 和 /) 都必须成对出现顾名思义, 这些定界符的功能就是在一个连续的源码文本当中, 用来把不同性质的源码成分区分开它们的具体含义将在具体的语句当中说明 4.3 语句一条语句由一些词汇组成, 可以理解为表示要求计算机进行的一个动作, 但一个说明, 一个描述之类的, 表面看好象不是计算机的一个动作, 不过实质上同样要求机器内部的一个动作与之相对应, 因此同样也构成 FORTRAN 的一条语句 FORTRAN 95 的语句分为两大类 : 非执行语句当需要引入或说明一个程序单元或子程序, 或者是说明数据类型时, 就需要使用非执行语句可执行语句当需要计算机进行一个指定动作时, 就需要使用可执行语句 FORTRAN 95 全部的语句的具体分类, 以及语法和例示参见附录 A, 语句的语法也参见附录 B 在后面的有关章节则分别说明了所涉及到的主要的语句 4.4 源码形式一个 FORTRAN 95 程序就是由以下三种形式的程序成分所构成的分行的文本 : FORTRAN 语句注释 INCLUDE 行

定界符全部的定界符有如下 12 种形式 : / ( ) (/ /), = => : :: ; % 其中 ( 和 ),(/ 和 /) 都必须成对出现顾名思义, 这些定界符的功能就是在一个连续的源码文本当中, 用来把不同性质的源码成分区分开它们的具体含义将在具体

20 在一个 FORTRAN 95 程序里面, 一条语句占一行或多行, 一行也可以有多条语句, 程序文本当中可以包含空行, 但不具有任何含义, 被 FORTRAN 编译器忽略这种形态的文本就是 FORTRAN 的源代码 ( 源程序 ) 从 FORTRAN90 开始, 对于源程序的书写格式要求已经完全现代化了, 也就是出现了所谓自由源程序格式, 而此前,FORTRAN 的固定源程序格式一直是初学者视为畏途的主要因素, 那种传统的固定源程序格式完全是 FORTRAN 作为始祖级的高级语言的遗留痕迹, 因为早期的源程序输入不是通过键盘, 而是运用穿孔纸带, 正是穿孔纸带的格式规定了相应的源程序的书写格式现在之所以我们还需要了解这点, 是因为 FORTRAN 的悠久历史, 决定了有大量的源代码正是使用了那种古老格式, 那是一个今天我们不得不继承的宝库, 要想使用它们, 显然就得会读那种格式, 因此我们只需要了解固定格式, 却不需要遵循固定格式来写代码例 4-10 在这个例子里面, 表明了行与语句之间可以有多种排列形式 : 这里的例子显示了所谓自由源程序格式的自由之所在这里使用了 & 作为一个语句在行与行之间连续的标志, 而! 后面的字符永远是注释 23 FORMAT( 6Y, J9)! 这是一条语句占有完整的一行的例子 37 FUNCTION string_concat(s1, &! 这里一条语句被分到两行 s2) 空格是被忽略的 64 FORMAT( 6Y, J0);37 FUNCTION &! 这里一行里有两条语句, 其中一条 string_concat(s1, s2)! 语句还只是它的一部分 TYPE (string) :: s1, s2, string_concat string_concat%string_data = s1% string_data(1:s1%length) // & s2%string_data(1:s2%length);string_concat%length &! 这行里包含两条 = s1%length + s2%length! 部分语句 END FUNCTION string_concat 源码文本的一般规则如下 : 在一个程序单元内部, 行与行之间的顺序是有意义的, 只有两个例外 : 注释行的顺序与位置可以非常自由 ; 在 CONTAINS 语句和 END 语句之间的子程序的顺序也可以是任意的在一个程序单元内部, 或者完全使用自由格式, 或者完全使用固定格式但是一个程序内部的不同程序单元则可以使用不同的格式后面要说明为了便于协调起见, 如何使用一种自由格式与固定格式兼容的特定格式所谓字符文本是指如下两种情形下的字符串 : 作为一个字符字面常量的取值的字符或字符串 ; 被字符串编辑描述符控制的字符或字符串那么描述符本身和续行符 & 永远都不属于其邻近的字符文本

期的源程序输入不是通过键盘, 而是运用穿孔纸带, 正是穿孔纸带的格式规定了相应的源程序的书写格式现在之所以我们还需要了解这点, 是因为 FORTRAN 的悠久历史, 决定了有大量的源代码正是使用了那种古老格式, 那是一个今天

21 针对字符文本的规则与针对非字符文本的规则是不一样的例 4-11 下面例子说明了空格在字符文本与非字符文本当中的不同使用规则 : 22 CHAR = NAME01 // KNOWLEDGE ARCHIVE 23 CHAR = NAME02 // KNOWLEDGEARCHIVE 在双引号里的字符串之间的空格是有意义的, 因此上面的两个字符串是不同的 DO43I=1,N DO 43 I = 1,N 而上面这两条语句是等价的自由源程序格式自由源程序格式的主要思想就是不限制语句在行内的位置与固定格式相比, 主要是空格的用法有差异自由源程序格式的一般规则如下 : 对于 FORTRAN 的基本字符集而言, 一行至多能容纳 132 个字符, 如果出现非基本字符集当中的字符, 则具体的平台会有相应的规定, 这时, 可能能够容纳的字符数目就会少于 132 例 4-12 假如下面的语句刚好包含 132 个字符, 但是其中含有中文字符 : TEXT = CHINESE_SENTENCE this line has exactly 132 characters and contains 人这时, 一个具体的实现平台会有相应的规定, 一般来说它会认为上面语句的字符太多了, 因此为保险起见, 尽量使用续行符只要字符! 不是作为字符文本当中的一个字符, 那么在该行内它后面的所有字符都是属于注释的内容而 FORTRAN 对于注释内容没有任何限制, 可以是任意形式, 因为反正任何编译器对于注释部分都是忽略掉的一行内可以在语句后面接注释内容, 也可以整行就以! 开头, 这时该行就是完全的注释行总之, 注释的位置可以是任意的, 关键是一行的任意位置只要出现了注释符!, 那么它后面直到行末, 都会被编译器认为是注释内容而不加理会因此不要把语句放置在一行内的注释后面只要字符 & 不是作为字符文本当中的一个字符, 那么在该行内它后面只能接空格以及注释, 在紧接着的行内只要存在非注释部分, 那就是和该 & 前面的部分是连续的, 被称为连续行在 FORTRAN 里, 一个语句所跟随的连续行不能超过 39 行一行的非注释部分不能只是一个续行符 & 注释不能利用该字符来表示续行, 因此如果注释部分的行末为字符 &, 则它只是属于注释内容的一个字符, 不具有续行的意思一行如果只包含空格字符, 或者根本不包含任何字符 ( 这两者表现一样 ), 那么编译器总是把该行视为注释行, 予以忽略一行之内可以不止包含一条语句, 语句之间必须用 (;) 加以分隔任何辅助字符集当中的字符都可以在字符字面常量和字符串编辑符当中使用

22 标签被放置于语句之前, 任何情形下都必须避免标签被认为是属于一条语句内部的字符按照 FORTRAN 语法, 空语句是合法语句, 只要空语句不是出现在一行的开头, 因此连续的 ;;, 甚至中间包含空格 ; ;, 都会被认为是单个的 ;, 因为字符 ; 总是意味着它的前面是一条语句, 即使为空语句, 也不算语法错误例 4-13 下面的语句都是合法的 X=(3.0,4.6);Y=(44.5,566.0) 这里的 ; 是作为语句分隔符 X=(3.0,4.6); 这里的 ; 被忽略而不认为是错误 X=(3.0,4.6); ;;; ;Y=(44.5,566.0) 这里的 ; ;;; ; 等价于一个 ;, 因为分号之间的空格被认为是空语句, 不算语法错误 X=(3.0,4.6)& ;Y=(44.5, 566.0) 这里分号放在一行的开头, 因为该行是连续行 Y=(44.5,& 566.0);Z= ZERO 例 4-14 下面的写法是错误的 53 INTEGER X,Y! 这里 53 是合法的标签 IF (X==0)76 Y=X! 这里的标签 76 不能说明自己不属于 IF 语句下面我们更加详细地说明在自由源码形式里面续行符和空格的用法 1. 续行符只是采用续行符的不同用法, 就有可能产生完全不等价的语句, 因为续行符能够导致名称的变化所以如果一个名称, 字符常量, 或词汇被迫分行, 则必须在前一行的末尾和后一行的开头紧接着字符使用 & 例 4-15 ENERGY = 0.5*MASS * VILOC&! 这里 VILOCITY 是一个变量名 &ITY**2 ENERGY = 0.5*MASS * VILOC &! 这里变量名成了 VILOC ITY! &ITY**2 ENERGY = 0.5*MASS * VILOC & &! 这里变量名成了 VILOC & ITY! &ITY**2 上面的三个语句是完全不等价的!

23 2. 空格的使用规则在具有固定名称以及固定格式的算符当中, 不能随意使用空格因为空格默认的功能就是分隔不同的词汇例 4-16 CALL SUBROUTINE A CALL SUBRO UTINE A! 错误语句! IF X =.NOT. IF X =.NOT.! 这两条语句不同例 4-17 下面语句当中的空格是不可少的 : INTEGER X,Y IF A=0 DO Y=1, 20 但不是所有情形下的词汇之间必须要有空格, 在不会产生混乱的前提下, 有些语句关键词之间的空格是可以省略的, 对于语句关键词来说, 所有这些不同的情形列举如下表 4-1: 非必须的空格表 4-1 语句关键词中间空格含义的不同情形必要的空格 BLOCK DATA DOUBLE COMPLEX DOUBLE COMPLEX DOUBLE PRECISION ELSE IF END BLOCK DATA END DO END FILE END FORALL END FUNCTION END IF END INTERFACE END MODULE END PROGRAM END SELECT END SUBROUTINE CASE DEFAULT DO WHILE DO WHILE IMPLICIT type-specifier IMPLICIT NONE INTERFACE ASSIGNMENT INTERFACE OPERATOR MODULE PROCEDURE RECURSIVE FUNCTION RECURSIVE SUBROUTINE RECURSIVE type-specifier FUNCTION type-specifier FUNCTION type-specifier RECURSIVE FUNCTION END TYPE END WHERE GO TO IN OUT SELECT CASE

24 4.4.2 固定源程序格式今天已经没有必要按照固定格式书写源程序, 只需要能够阅读古老的使用固定格式的代码, 如果有必要把固定格式的源程序转换为自由格式, 也可以运用某些小软件完成, 因此下面只是简要地介绍固定格式的几个规则语句只能书写在一行的第 7 到第 72 个格子上空格除了在字符常量里以外, 都是没有意义的在某行第一格为字符 C, 或 *, 就表示该行整行都是注释注释总是被忽略字符! 只要不是出现在第 6 格, 也不是属于字符文本, 则从它开始一直到该行的行末, 都属于注释一行如果只包含空格字符, 或者根本不包含任何字符 ( 这两者表现一样 ), 那么编译器总是把该行视为注释行, 予以忽略一行中的多条语句用一个或多个分号分隔 ; 分号可以出现在行末, 但没有更多的意义 ; 分号不能是一行的第 7 到第 72 个格子上第一个非空格字符除了空格和 0 之外的任意字符, 只要出现在某行第 6 格上, 则表示该行为连续行一行后面最多只能有 19 个连续行, 第一行称为初始行标识符只能出现在第 1 到第 5 格上, 被连续的语句只有第一行可以使用标识符, 这样下面所有的连续行的第 1 到第 5 格上只能是空格 END 语句不能被连续, 它也不能被视为初始行兼容源程序格式在某些情形下, 需要书写能够同时被自由格式和固定格式兼容的源码, 要做到这点, 只需要遵循以下规则即可 : 标识符只能出现在第 1 到第 5 格上, 语句只能书写在一行的第 7 到第 72 个格子上按照自由格式的规则使用空格使用! 作注释符, 但不要放置在第 6 格, 也不要是用使用字符 C, 或 * 作注释符需要连续行时, 在被连续行的第 73 格写 &, 同时在连续行的第 6 格也写 &, 第 74 格到 80 格保持空格或者只写注释而连续行的第 1 到第 5 格上只能是空格下面就是一个同时满足两种源码形式要求的代码例程 : 例 4-18 Column: ! Define the function CUT_SIN DOUBLE PRECISION FUNCTION CUT_SIN(X) CUT_SIN = X - X**3/FACTOR(3) + X**5/FACTOR(5)& &- X**7/FACTOR(7) CONTAINS

25 INTEGER FUNCTION FACTOR(N) FACTOR = 1 DO 10 I = N, 1, FACTOR = FACTOR * I END FUNCTION FACTOR END FUNCTION CUT_SIN 程序结构在 FORTRAN 95 的语法规则里面规定了程序结构的完整定义, 参见附录 B 不过那里的语法规则并没有完备地表述在一个程序单元里, 各种语句应该遵循什么顺序下面给出一般原则 : 数据类型声明和指定的语句必须放置在可执行结构或语句之前 ; FORMAT,DATA,ENTRY 语句也可以放置在可执行语句中间, 不过把 DATA 语句放置在可执行语句中间是一种过时的做法 ; 如果出现 USE 语句, 必须总是放在最前面 ; 如果出现内部子程序或模块子程序, 则必须跟在 CONTAINS 语句后面例 4-19 下面是一个典型的只包含一个程序单元, 也就是主程序的 FORTRAN 程序 :! 本程序能够求出所有之间每一位上的数字的立方和等于自身的三位数 PROGRAM SUM_OF_ CUBES INTEGER A,B,C DO A = 1,9 DO B = 0,9 DO C = 0,9 IF (100*A + 10*B + C == A**3 + B**3 + C**3) & PRINT (3I1), A,B,C END DO END DO END DO END PROGRAM SUM_OF_CUBES RUN SUM_OF_CUBES 大家不妨尝试一下, 之间还存在这样的数字吗? 如果是平方呢? 下面的表 4-2 给出了程序单元的基本模式, 其中处于同一水平位置的各语句之间没有严格的前后顺序, 而不同的行则表示了严格的在程序当中出现的前后顺序 :

26 表 4-2 程序单元的基本模式程序, 函数, 子例行程序, 模块, 数据块语句 USE 语句 FORMAT 语句, IMPLICIT NONE ENTRY 语句 PARAMETER 语句 PARAMETER 语句, DATA 语句 DATA 语句 CONTAINS 语句内部子程序或模块子程序 END 语句 IMPLICIT 语句派生数据类型定义, 接口块, 数据类型声明语句, 语句函数语句, 特定语句可执行结构把 DATA 语句放置在可执行结构中间已经过时语句函数语句已经过时表 4-3 给出一个特定的语句能够在什么结构中出现, 不能在什么结构中出现的概貌 : 表 4-3 语句的环境作用单元的种类语句主程序模块数据块外部子程序模块子程序内部子程序接口块 USE 语句 Y Y Y Y Y Y Y ENTRY 语句 N N N Y Y N N FORMAT 语 Y N N Y Y Y N 句其他声明 Y Y Y Y Y Y Y DATA 语句 Y Y Y Y Y Y N 派生类型定 Y Y Y Y Y Y Y 义接口块 Y Y N Y Y Y Y 语句函数 Y N N Y Y Y N CONTAINS Y Y N Y Y N N 可执行语句 Y N N Y Y Y N 其中 Y 表示该语句可以在相应的结构当中出现,N 表示不能出现 4.5 INCLUDE 行很多时候一个完整程序的源码还可以原封不动地移植到另一个程序源码的中间, 这时并不需要把被移植源码完整地抄写过来, 而只需要简单地运用 INCLUDE 行即可

27 例 4-20 PROGRAM GREEN_FUNCTION REAL X,Y,Z.! 语句省略 INCLUDE GAUSE.! 语句省略 END 这样源码文件 GAUSE 就直接进入程序 GREEN_FUNCTION 的源码里面, 取代了 INCLUDE 行的位置 INCLUDE 行由关键词 INCLUDE 和其后的文件名称组成其中的文件名称是一个字符文本常量 INCLUDE 行只是针对编译器的一个提示, 而不是属于程序内的 FORTRAN 语句其中的字符文本常量不能带作为命名常量的种别参数 INCLUDE 行必须放置在程序当中, 其所引用文件应当出现的位置 INCLUDE 行所在行不能有任何其他文字, 包括标识符, 当然可以有注释 INCLUDE 行可以进行嵌套, 嵌套的层数由具体的编译器规定注意在嵌套的同时不能导致定义循环 INCLUDE 行之前的语句不能是被连续行, 其后的语句也不能是连续行 4.6 与其他语言的语法要素方面的比较下面简要地比较一下, 作为一种语言,FORTRAN 和其它语言在总的语法风格方面的异同一种计算机语言的语法远比任何自然语言的语法要来得简单明了, 计算机语言的语法风格可以明确地归结为各种基本语法要素的选择因此可以按照语法要素对不同的语言加以比较 1. 字符集按照语言的所谓形式定义, 语言就是取自一个有限字符集合的任意字符所构成的有限字符串的集合显然, 一种语言选择哪些字符作为它的字符集, 正是语言文法设计的第一步最常用的字符集就是 ASCII 字符集, 而一套完整的字符集除基本字母和数字外, 通常还包含一些特殊字符, 以便为语言提供足够的表达手段表面看来, 一种语言所使用的字符越多, 它的表达能力应该是越大, 然而在增大字符集的同时, 也增加了编译时词法分析的分量, 因此这里的折衷方式的不同, 造就了不同语言的字符集的差异字符集的选择首先来自语言的输入输出设备对于 FORTRAN,C 等大多数语言, 是面向以工业标准键盘为主的输入输出设备的, 因此这些语言的字符集可以说是大同小异的, 不过也有例外, 如 APL 语言就使用了 ASCII 字符集之外非常特殊的字符, 因此这种语言的字符集就不能被大多数输入输出设备直接使用从计算机历史来讲, 到了 1960 年代的早期, 计算机行业对字符的表示大都由六位字节转变为八位字节, 这样理论上就有了 256 个字符可用, 分配给 52 个大小写字母十个数字以及一些标点符号, 应该是足够了不过, 由于计算机语言本地化的趋势越来越流行, 语言的国际化导致

28 各种民族语言的文字都要求进入字符集除了法语, 德语里的语音符号之外, 希腊语, 阿拉伯语之类的语言有着完全不同的字符集而如果中文和日文要进入计算机语言, 则需要一个有一万多符号的字符集因此甚至出现了一种想法, 就是考虑用十六位 (65536) 来表示字符集 2. 语句标签在 FORTRAN77 及其前面的标准里, 语句标签的使用具有严重的时代烙印, 而随着技术的进步, 这种过时的玩意在大多数情况下不再具有任何价值, 特别是严重地损害源码的可读性因此语句标签在任何语言里都是属于需要淘汰的对象 3. 运算算符字符 + 和 -( 加号和减号 ) 在大多数语言里都是代表两种基本的数学运算, 不过除了这两个符号之外, 其他的运算算符就有相当多的花样了例如只是用特殊字符来表示基本运算算符, 典型的就是 APL 语言, 还有 LISP 语言 TIMES 语言等的逻辑运算符 ; 而大多数语言使用一些字符组合, 同时也利用特殊字符来表示部分运算算符, 有时还使用一些不属于上述两种之中任意一种的字符串来表示部分运算算符, 例如 FORTRAN 里面的.EQ. 表示相等, 指数运算用 ** 表示等 4. 关键词计算机语言大都使用保留字与关键词, 从而能够提高翻译器的检错能力而且大多数以关键词开始的语句本身就表明了语句的类型例如 IF READ 等一种语言究竟使用多少保留字和关键词, 往往是一个折衷的结果 : 保留字少, 可以减少编程者的记忆负担, 同时却会增加语法分析的困难 ; 而如果使用大量的保留字, 例如 COBOL 语言, 使用了大量的保留字, 使得编程者很难全部记下, 因此就会常常出现不小心使用保留字作变量名的错误, 当然使用很多的保留字, 就会使得翻译过程中的语法分析变得更为简单特别需要注意的是, 当一种语言出现新版本时, 得小心是否引入了新的保留字, 例如 COBOL 语言, 就在新标准里引入了新的保留字, 这就意味着那些在程序中使用新的保留字作为变量名 ( 或其他名字 ) 的旧程序, 按照新标准在语法上就不再正确了, 尽管这个程序一点也没有改过对于 FORTRAN 来说, 这类问题就没那么严重 5. 注释尽管注释一定是被编译器忽略的, 但却是文件中十分重要的一部分, 因为注释是保证源码的可读性非常重要的手段在不同的语言里, 表示注释的方式非常不同, 甚至在一种语言里, 也可能有几种方法引入注释 : 在 C 语言程序中, 需要使用 /* 和 */ 这样的特殊标记来界定而不管行边界, 这时常常出现的错误就是漏掉结束的界定符, 使得后面的语句也变成了注解! FORTRAN 95 语言中的!,Ada 语言中的 -, 或是 C 十十语言中的 //, 都是在行的任意位置开始而直到行的末尾结束这种做法就更为合理方便 6. 空格在不同的语言里空格的使用规则非常不同这点需要引起注意在 FORTRAN 语言中, 空格在除了字符串数据以外的任何其他地方都没有意义而在很多语言当中使用空格来作为分界符, 这就使得空格在语法中有实际的含义对于初学者来说, 常常意识不到空格带来的问题

29 7. 定界符和括号定界符的作用就是简单地标志类似语句或表达式之类的语法元素, 目的就是增加源码的可读性, 并且使得语法分析更加简单特别需要注意的是, 成对的定界符用来清楚地界定特定语法结构的边界, 从而可以有效地消除二义性 8. 自由或固定格式严格的固定字段格式一般是应用在汇编语言当中而早期的 FORTRAN 则是使用了部分固定字段格式 ; 其实很多语言早期同样是具有部分固定字段格式, 不过现代语言的风格是完全排斥那种固定格式的, 因此几乎所有语言, 只要还没有被废弃, 都已经采用了自由字段格式第 5 章准备数据从本章开始, 我们将赋予语言实质性的语义, 也就是规定上章所描述的语言的每一个细节所具有的涵义这种涵义与其说是我们对于一种语言细节的定义, 不如说是算法的要求, 要求语言具有足够多的细节, 用来表达在算法当中有可能出现的精细情节对于任何的问题, 站在计算机的角度来看, 总是可以把它抽象为如下图所示的结构 : 输入数据计算过程输出数据因此要准备通过计算来解决一个问题, 首先要作到的是把该问题所涉及到的数据整理好, 也就是列出所有的数据, 然后根据数据的数学属性进行分类, 这个分类的过程就是对数据施加足够的标记的过程, 将来把这些数据输入到计算机, 计算机将能够依据这些标记, 辨识出数据所应该具有的数学属性, 从而施加相应的合法数学运算所以作为向计算机描述计算问题的 FORTRAN 语言, 它首先要作到的是约定如何给数据施加足够详细的标记对这个标记过程的第一个要求是保证准确性, 也就是说这个语言的标记系统必须正确地反映真实世界的问题里面, 数据所具有的数学属性, 因此这个标记系统必然是与数据的数学分类结构保持一致的从数学的观点来看, 世界上的所有数据, 总是可以被表示为整数, 实数, 复数等等基本的数据种类, 因此本章的内容就是讨论 : FORTRAN 语言如何把数据归结为一些基本数据类型 ; 然后为了足够详尽地描述每一个数据类型的属性,FORTRAN 是如何施加相应的标记的 ; FORTRAN 语言对于这些标记 ( 语法形式 ) 所约定的语义是什么然后我们就可以知道, 要想用 FORTRAN 来描述一个问题的算法, 并进而以问题算法的 FORTRAN 语言版本为媒介, 通过计算机来得到计算结果, 第一个步骤, 就是准备好数据的 FORTRAN 描述

30 5.1 数据是什么在上一章里, 据称计算机能够使用语言, 而且是非常类似于人类的语言, 至少从形式上看很象, 这难免会令某些人 ( 特别是看过 KUBRICK 的影片 2001: A Space Odyssey 的观众们 ) 感到恐惧别怕! 且先不讨论 FORTRAN 作为语言是否具有与人类语言等价的表达能力, 至少从自然语言的语义学的角度来看,FORTRAN 说出来的话其实是绝对空洞的, 因为 FORTRAN 语言的全部语义基础就只是数据, 而数据对机器而言, 只是意味着经过编码的符号一台计算机其实是由以下 6 个部分组成 : 数据也就是基本数据元素以及数据结构 ; 基本操作也就是一个对上述数据进行操作的基本操作集 ; 顺序控制也就是一个控制针对数据的基本操作执行的时间顺序的机制 ; 数据存取也就是一个如何给操作提供数据的机制 ; 存储管理也就是一个数据存储分配机制 ; 操作环境也就是一个支持程序和外部环境进行数据通讯的机制因此一台计算机在程序的使用者看来, 就是给它输入数据, 它再给你加工过的结果数据 ; 在程序的编制者看来, 就是把对数据的处理过程表示为计算机有限的一系列基本操作 ( 指令 ) 的集合, 使得计算机能够处理相应的数据 ; 因此, 计算机的一切可以说都是围绕着数据 ---- 如何表达数据, 如何处理数据而计算机语言所要具备的两个部分的功能, 首先就是完备的描述数据的性质, 然后就是描述数据的处理过程那么, 什么是数据呢? 数据就是符号化了的信息! 对于计算机来说, 任何信息都只有表示为符号, 才能被认可 ; 反过来说, 计算机只能输入符号, 而不会也不能理解符号的含义, 它的能力只是体现在按照既定规则来处理符号然后, 就是给出数据的表示, 即如何用符号来明确而无歧义地表达数据要使得符号具备数据的含义, 需要经过这么几个步骤 : 处理符号的第一步 : 给符号分类, 并给出描述符号性质的方法这个分类是人作为设计者给符号规定语义的第一步, 因为对于人来说, 数据不能只是符号, 而是具有来自真实世界的语义, 设计者正是根据符号的这种语义, 制定相应的处理符号的规则, 而计算机要想能够正确地处理符号, 基本的前提, 就是每当引入一个数据, 都得由人向机器声明这个数据是什么类型, 这个数据具备什么性质, 而且假设计算机已经被引入处理该种数据类型的规则处理符号的第二步 : 区分常量与变量这一对范畴反映了最基本的人类抽象能力, 也正是人类思维的基本模式要想让机器模拟这种能力, 最简单的做法就是 : 任何时候都必须首先声明, 哪些符号表示常量, 哪些符号表示变量, 而变量相应的取值范围必须规定好, 也就是说必须描述其取值为具有何种属性的常量值的集合 ; 或至少已经被机器默认处理符号的第三步 : 给每一类数据规定相应的合法运算对于一种数据可以执行什么样的运算, 来自于语言设计者对数据语义的规定, 只有当运算被表示为相应的机器指令或指令集合, 这时在表面看来, 机器才开始真正理解了数据的涵义

31 因此可以说, 数据的定义构成了计算机的灵魂按照上面讨论的步骤, 说明一个数据类型包括四个方面 : 命名的语法取值的范围与属性说明该数据类型的常量的表示方法定义合法的运算因此相应的一个数据类型的四个要素就是 : (1) 名字 ; (2) 值的集合 ; (3) 表示值 ( 相应的常量 ) 的方法 ; (4) 操作值的运算的集合对于这四个要素,FORTR AN 一方面要约定它们的语法形式, 从而可以构成符号描述的唯一性标记, 保证相应的描述语句能够被 FORTRAN 编译系统无歧义的辨识, 另一方面就是要给出这些语法形式所对应的含义 5.2 用 FORTRAN 来说明数据的性质真实世界的数据显然是多种多样的, 几匹马, 轴承的内径, 圆周长与直径的比值, 电子的波函数, 非各向同性电介质的电极化率,10 个被试每日的最高血压等等, 这些数据都具有非常不同的形式与性质, 如果我们每针对一种数据形式, 都把它定义为某一种新的数据类型, 则肯定是烦不胜举, 因此合理的途径是找到一种统一的数据描述方式, 而对于科学计算问题来说, 自然的数据分类方式是数学对数值数据的分类, 再加上非数值型数据, 会是非常适合于科学计算的数据表达方式当然, 如果是以描述其他类型的问题为目的, 如事务处理, 符号演算等, 则选用另外的数据分类方式会更有效至少从数学的观点来看, 我们常常需要处理的数据, 都可以表示为一些基本数据类型的组合, 例如我们知道向量实际上就是一个数组, 数组的每个元素为标量, 因此应用数组这种结构, 就可以自然地表示向量, 另外复数尽管也可表示为一个二元数组, 但是这种二元数组的乘法不同于二维向量, 因此为了避免这种歧义, FORTRAN 把复数当成一个基本数据类型而几种基本标量里面, 整数和实数都同样必须构成基本的数据类型由此可以建立 FORTRAN 的对数据的类似描述由于真实世界问题的要求的不同, 对数据的描述也有程度不等的情况, 最基本的情况就是直接说明数据的类型以及其他属性, 又由于数据表示的实现具有一个重要的参数, 即存储空间, 所以当问题要求的数据, 不能满足于默认的存储空间的时候, 这时, 就需要进一步给出数据的种别参数, 这是更加详细的数据描述如果在真实世界问题当中出现的的数据对象, 干脆不符合已有的固有数据类型以及数组的定义, 这时就还需要根据用户的要求构造一个依赖于问题的特定的数据结构, 这就是数据描述时会遇到的第三种情况对于这三种情况,FORTRAN 的解决方式如下 : 第一种情况 : 确定数据的类型以及相应的可能具有的属性

32 首先,FORTRAN 所能辨识的数据类型首先分为两大类 : 固有数据类型派生数据类型根据语义上的基本差别, 数据首先具有一些基本的类型, 这些基本类型一般是和构成真实世界里的信息的那些基本元素相对应, 比方说数字, 字符等然后其他情况下遇到的数据都可以由这些基本数据类型组合得到不过一种语言具体的规定哪些基本的数据类型, 往往受到该种语言主要应用的场合的影响, 由于 FORTRAN 主要用来进行科学计算, 因此它所定义的基本数据类型, 正是与我们在科学计算问题当中遇到的数据类型相契合的所谓固有类型, 是 FORTRAN 语言所定义的最基本的数据类型, 每一种固有类型是和该种数据类型相应的各种运算一起隐式定义的, 也就是说一旦声明引入某种固有数据类型, 则系统总是默认为对它进行相应的运算是合法的, 并且总是可访问的这样就做到了每种数据类型都和它相应的运算捆绑在一起, 使得问题的描述非常自然固有类型包括五种 : 整型 (INTEGER) 实型 (REAL) 复型 (COMPLEX) 逻辑型 (LOGICAL) 和字符型 (CHARACTER) 这个分类完全是遵循数据的数学分类, 即整型指整数, 实型指实数, 复型指复数, 逻辑型指逻辑值, 字符型则是语言的基本元素这样就可以把基本的数学语言一一对应的直接翻译为 FORTRAN 语言所谓派生类型是由用户定义的, 非隐式定义的类型, 只要用一个类型定义来声明其成员是何种固有类型, 或者是何种其它已经定义过的派生类型, 就能够被 FORTRAN 认可为一种数据类型由于派生数据类型正是由固有数据类型充当成员而构成的, 因此在结构关系上, 可以把固有数据类型看成原子, 而把派生数据类型看成分子由于语言的根本目的就是为描述算法服务的, 因此从这个角度出发, 派生数据类型本质上体现了非常重要的数据抽象与数组合的思想, 由于我们需要运用语言来描述的问题是开放性, 我们很难划定需要 FORTRAN 来描述的问题的范围, 因此通过构造派生数据类型, 使得我们可以很自然而简洁地建立新的数据类型这是 FORTRAN 在 FORTRAN77 标准之后的一个重大进步派生类型数据最重要的用途就是扩充了数组这种重要的数据结构, 由于数组在科学计算领域, 是一种极端重要的数据结构类型,FORTRAN 除了能够直接描述数组, 同时还能描述更为广泛的派生数据类型, 也就可以直接对一个数据集合的各个成员同时施加运算, 拥有了这种自然的数据类型, 就避免了象 FORTRAN 的早期版本那样, 需要通过特别设计的算法来实现这种运算所谓固有数据类型的固有, 对于 FORTRAN 来说, 就是为每一种固有数据类型规定了它的存储模式在 FORTRAN77 及其之前的标准里, 整型, 实型, 逻辑型数据都是使用了一个数值存储单元, 而复型和双精度数据则使用了两个数值存储单元, 字符型数据使用一个字符存储单元由于存储模式是非常底层的语言实现结构, 因此 FORTRAN 后续的标准要想保持兼容, 只有继承这个约定因此在 FORTRAN90 与 95 当中, 默认的整型, 实型, 逻辑型数据都是使用了一个数值存储单元, 而默认的复型和双精度数据则使用了两个数值存储单元, 默认的字符型数据使用一个字符存储单元而作为语言的一个发展, 在 FORTRAN90 之后的标准里, 开始允许在一个程序单元内, 由用户定义特定的不依赖于固有数据存储模式的数据类型, 这就是第 6 章的派生数据类型建立一种数据类型, 最大的好处就是可以把相关的运算和数据捆绑在一起, 对于一个特定问题当中的数据对象, 是否应该被明确地看成数据类型, 属于语言设计的权宜, 因为建立一种数据类型所能带来的好处可以用算

33 法来补偿, 而 FORTRAN77 之后的版本的选择是增加派生数据类型, 这样使得我们可以在进行科学计算时, 有更为自然的描述方式数据类型的全部分类总结如下 : 固有数据类型数值型数据整型实型复型非数值型数据逻辑型字符型派生数据类型就数据的属性而言, 类型当然是最重要的属性了在指定类型之后, 紧接着的就是根据实际情况, 看需要描述的数据是否还具有其他需要说明的属性对于数组来说, 具有一个基本的属性, 就是数组的大小, 相应的就是如何指定数组的存储空间的大小的问题由于 FORTRAN 具备可分配数组与指针的功能, 因此在程序开头并不一定需要指定数组的大小 ( 维度 ), 在程序执行过程当中, 数组的大小会作为输入或计算结果被读入, 这个指标可以针对具体的问题的要求, 以及运行的状况而定在 FOR TRAN 还不具备这种动态功能的时候, 就需要在数组声明里指定数组的维度, 而在事先又很难准确预料程序运行过程当中对数组储存空间的要求, 因此如果指定的数组过大, 就会大量地浪费当时非常宝贵的内存空间, 而如果指定的数据组过小, 则肯定会在程序运行过程当中导致错误所以为了避免这些问题, 现在一般不会在数据声明的时候精确指定数组大小, 而是把数组处理成一个动态对象, 从而有效地回避了这个问题数据的一个重要属性, 就是它的可访问性在 FORTRAN 语言里, 模块提供了对数据的访问控制任何数据对象只要想把自己局限在模块内使用, 模块就能够提供足够的保护, 使得外部程序无法访问该数据对象模块的这个功能使得 FORTRAN 成为一种安全可靠的语言是否打开数据的其他许多具体的属性, 取决于具体的数据应用环境, 因此要讨论数据的每一种属性, 在这里不太现实, 我们只有等到下面具体地说明每一种声明语句时再具体说明, 因为属性指定总是在出现在声明语句当中第二种情况 : 指定固有数据类型的种别参数对于计算机来说, 在确定数据的类型, 从而可以引导到相应的运算之后, 进一步就需要为数据在内存指定存储位置和存储空间, 实际上对于冯纽曼型计算机来说, 这个步骤是非常关键的, 因为冯纽曼型计算机的要点, 就是硬件之外的一切, 都必须表示为数据, 都必须存储在内存当中, 然后在程序的运行当中, 随时与 CPU 进行通讯, 因此在程序的开头就明确数据在内存当中的位置与每个数据所占有空间的大小, 是保证程序运行非常基本的要求用来指定程序当中需要使用的每一种固有数据类型所要求占据的内存空间大小的属性由种别参数表示给这个变量 ( 参数 ) 指定一个数值, 就可以说明数据所需要的存储空间的大小, 也就是程序允许的数值数据的位数和字符串的字符数目

34 KIND( 种类种别参数 ) 分别说明整数类型的十进指数范围, 实数类型和复数类型的十进制精度和指数范围, 字符类型和逻辑类型的表示方法 LEN( 长度种别参数 ) 对字符类型规定了字符的个数例 5-1 REAL(KIND=3)::ABC,X,LONG CHARACTER(LEN=40,KIND=GREECE)::NAME 具体的种别参数的约定是与语言的具体实现相关的, 因此具体的取值还是得参考编译器的文档如果没有声明数据的种别, 那么程序就会采用默认的参数, 由于 FORTRAN 的早期版本没有引入种别参数, 因此对于有不同精度要求的实型变量, 直接采用了两种不同的数据类型, 这就是 REAL 和 DOUBLE PRECISION, 从 FORTRAN90 以来的版本里, 通过引入种别参数, 对种别参数的不同取值, 就足够表达不同的精度, 而同时为了保证和早期版本的兼容, 单独的数据类型声明 DOUBLE PRECISION 还是被保存下来了, 这样一来, 就产生了一个有一定任意性的后果, 即新的语言标准对不同精度的实型数据, 可以通过使用同一个数据类型的不同的种别参数值来表示, 而同时用 DOUBLE PRECISION 作为数据声明也是有效的, 这样就保证了源码向前的兼容性, 却不具备向后的兼容性对于在指定种别参数的数值时, 一般是以字为单位, 这样对于字长不同的机器而言, 相互之间就会出现程序移植的困难, 下面分情况予以说明 : 实型 ---- 由于 DOUBLE PRECISION 是属于老式标准的遗留物, 因此使用 DOUBLE PRECISION 作为数据声明的程序就不具备良好的可移植性, 因为所谓双精度是针对具体的机器的字长而言的, 对于 32 位的机器, 双精度就是 64 位, 而对于 64 位机器, 双精度就意味着 128 位, 这样在不同字长的机器环境里, 双精度就具有不同的位数, 使得程序无法在不同字长的平台之间进行直接的移植因此在这种情况下, 最好还是统一使用 REAL 的种别参数来表达算法所要求的实数精度可以说种别参数一劳永逸地解决了实数精度的可移植性问题复型 ---- 由于所谓复型本质上就是由两个实数表达的, 因此按道理复型同样应该能够具有表达多种精度的能力, 而实际上早期的版本在这方面是有欠缺的, 不过随着 FORTRAN90 引入种别参数, 就可以在 COMPLEX 的声明语句里通过运用种别参数来实现多种精度的表达, 对于任何 FORTRAN 的实现, 至少能表达两种精度, 而一般来说是多于两种的字符型 ---- 对于字符, 一般的机器都是用单字节 8bits 来表示一个字符, 这样就可以总共表示 2 8 =256 个不同的字符, 这对于任何以字母写出来的语言都是足够的了, 不过对于汉语, 日语这样一些语言就不够用了, 一般得需要双字节, 即 16bits, 这样就可以表达 2 16 个字符因此字符型数据同样需要附加种别参数, 以便除了使用默认的基本字符之外, 还可以使用辅助字符集里的字符, 从而实现程序的本地化不过某个具体的编译器是否支持双字节字符, 必须参考相应的手册因为 FORTRAN 95 标准也没有强制要求 FORTRAN 的任何实现都必须支持双字节字符逻辑型 ---- 由于一切逻辑型数据都只有两个值, 因此如何确定逻辑型数据的存储空间应该是非常好办的, 不过不幸的是,FORTRAN 的早期版本规定逻辑型数据使用和实型数据一样大小的机器存储单位, 这样当机器的字长很大时, 就会非常的浪费机器的存储空间因此到了 FORTRAN90 和 FORTRAN 95, 除了作为默认的情形, 和旧的语言标准保持兼容之外, 还可以通过指定种别参数, 使得逻辑型数据的存储空间大小只有一个字, 甚至一个 bit 当然具体的使用方法需要参考相应编译器的说明

35 整型 ---- 显然在程序应用当中会出现几乎任何大小的整型数据, 因此无法在语言标准里面统一的规定整型数据的存储空间大小, 这就同样需要依靠种别参数来指定应该给具体问题当中的整型数据确定多大的存储空间具体地指定方式属于编译器设计者的选择, 需要参考相应编译器的语言说明第三种情况 : 派生数据类型数据的本义就是对真实世界里的事物的描述这种描述可以是简单的, 如一个标量, 也可以是复杂的, 如一个张量, 对于更复杂的对象, 在自然语言里有一种自然的描述方法, 就是使用一系列的词汇, 每个词汇都是对象在某个方面的属性的度量 ; 在计算机语言里, 可以采用类似的解决方案, 即把对象的每一个需要描述的性质用一个适当的基本数据类型来表示, 这样用一组基本数据类型就可以描述该对象而这一组数据可以看成是一个新的数据类型, 表示了一个变量这样构造出来的数据类型称为派生数据类型, 和固有数据类型一样, 在声明派生数据类型时, 需要给出名称, 描述它的每一个元素的固有数据类型以及相应属性和种别参数 ( 如果非默认的话 ), 当然也需要适当地定义其运算既然这种派生数据类型是由一组数组成, 就会出现两种情况 : 这组数据都是属于一个数据类型这样构成的派生数据类型就是数组, 显然对于数组的元素的描述就可以统一进行具体的用法会在后面专门说明这组数据的各个元素属于不同的数据类型这样构成的派生数据类型称为结构, 这时就需要对每个数据元素进行分别的说明, 即每一个元素的数据类型, 可能有的属性, 种别参数等等上面对派生数据类型的描述实际上是递归式的, 即一个派生数据类型的元素同样可以是另一种派生数据类型, 而没有限定必须是固有数据类型例 5-2 下面是一个典型的派生数据类型 TYPE SAMPLE REAL CURRENT COMPLEX (KIND = QUAD) PHASE CHARACTER (LEN = 50) SOURCE END TYPE SAMPLE TYPE (SAMPLE) SI401,SI402,SI403,SI404 在上面的例子里, 首先定义了一个名称为 SAMPLE 的数据类型, 每一个 SAMPLE 类型的数据由三个分量组成, 它们的名称分别为 CURRENT,PHASE,SOURCE, 分别属于实型, 复型和字符型, 其中复型和字符型还分别说明了种别参数和字符长度属性, 然后给出了程序当中需要使用的四个属于该种数据类型的变量 :SI401,SI402,SI403,SI404 上面例子当中派生数据类型的定义, 以 TYPE 开始, 以 END TYPE 结束

36 5.3 数据不同种类的存储模式对于计算机来说, 数据分类的第一个反应就是针对不同类型的数据约定不同的存储模式由于存储模式的规定涉及到编译环境的设置, 因此存储模式的约定是与系统环境相关的, 鉴于 Compaq Visual Fortran 的广泛应用, 本节特别针对 Compaq Visual Fortran 系统而言的说明了数据的各种存储模式下表 5-1 列出了 Compaq Visual Fortran 所有的固有数据类型的存储空间要求, 和相应的能够在这个空间里表达的数据规模表 5-1 固有数据类型的存储模式 : 数据类型单位存储空间能表示的数据规模 BYTE INTEGER(1) 1 byte (8 bits) BYTE 表示等价于 INTEGER(1) 的带符号的整型数据类型 INTEGER 参见 INTEGER(2), INTEGER(4), 以及 INTEGER(8). 带符号的整型数据, 包括 INTEGER(2), INTEGER(4), or INTEGER(8) 数据规模由编译器选项 /integer_size:nn 控制默认的规模控制选项为 /integer_size:32 ( 等价于 INTEGER(4)) INTEGER(1) 1 byte (8 bits) 从 -128 到 127 带符号的整数 INTEGER(2) 2 bytes (16 bits) 从 -32,768 到 32,767 带符号的整数 INTEGER(4) 4 bytes (32 bits) 从 -2,147,483,648 到 2,147,483,647 带符号的整型数据 INTEGER(8) 8 bytes (64 bits) 从 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 带符号的整型数据 REAL(4) REAL REAL(8) DOUBLE PRECISION 4 bytes (32 bits) 从 E-38 到 E38 的按照 IEEE S_floating 格式的单精度实型浮点值在 E-38 和 E-45 之间的值是非常态的 8 bytes (64 bits) 从 D-308 到 D308 的按照 IEEE T_floating 格式的双精度实型浮点值在 D-308 和 D-324 之间的值是非常态的 COMPLEX(4) 8 bytes (64 bits) 由一对从 E-38 到 E38 的按照 IEEE COMPLEX S_floating 格式的单精度实型浮点值组成的单精度复型浮点值在 E-38 和 E-45 之间的值是非常态的 COMPLEX(8) 16 bytes (128 bits) 由一对从 D-308 到 DOUBLE COMPLEX D308 的按照 IEEE T_floating 格式的双精度实型浮点值组成的双精度复型浮点值在 D-308 和 D-324 之间的值是非常态的 LOGICAL 参见 LOGICAL(2), 逻辑型值, 包括 LOGICAL(2), LOGICAL(4), 以及 LOGICAL(4), 以及 LOGICAL(8). LOGICAL(8). 数据规模由编译器选项 /integer_size:nn 控制默认的规模控制选项为 /integer_size:32 ( 等价于

37 LOGICAL(4)) LOGICAL(1) 1 byte (8 bits) 逻辑型值.TRUE. 或.FALSE. LOGICAL(2) 2 bytes (16 bits) 逻辑型值.TRUE. 或.FALSE. LOGICAL(4) 4 bytes (32 bits) 逻辑型值.TRUE. 或.FALSE. LOGICAL(8) 8 bytes (64 bits) 逻辑型值.TRUE. 或.FALSE. CHARACTER 每个字符 1 byte (8 根据约定的字符编码表示的字符数据, 通过字符数据的声 bits) 明形式 :CHARACTER(LEN=n) 或 CHARACTER*n, 其中 n 表示 byte 数, 来表示数据规模 HOLLERITH 每个 Hollerith 字符 1 Hollerith 常量 byte (8 bits) 表中的 INTEGER(4) 等价于 INTEGER(KIND=4) 以及 INTEGER* FORTRAN 数据类型描述的四个基本属性一个数据如何才是被完备描述了, 以及 FORTRAN 所要求的描述一个数据的要素是哪些, 是一个问题的两面这个问题对于程序的作者是很重要的, 因为 FORTRAN 现在允许用户自己定义合乎自己需要的派生数据类型, 这就要求我们知道一个派生数据类型的定义是否完备 FORTRAN 的数据类型必须包含如下四个部分 : 数据类型的名称数据取值的集合可以施加于数据的值的运算该数据类型的常量的表示形式数据类型的名称要能够说明数据的类型所属, 首先每种数据类型本身得有个名称, 才能在描述数据对象的时候, 说某个数据对象属于某个数据类型固有数据类型就只有 5 种, 它们的名称 :INTEGER,REAL,COMPLEX,LOGICAL, CHARACTER 是语言标准的规定但派生数据类型则完全是程序作者自定义的, 因此必须由作者使用 TYPE 来给出其构造的派生数据类型的名称, 也就是说只要一个数据或一个变量的取值符合 TYPE 与 END TYPE 之间的定义, 就被该程序单元识别为属于该数据类型, 就可以应用相应的运算如果一个程序单元里出现的数据不能被识别为该程序单元的数据声明里的诸种类型, 那么 FORTRAN 还会尝试运用一种方式来试图确定它的数据类型, 就是根据数据名称的第一个字符来进行判别, 这种方式属于 FORTRAN 的古老传统, 因为早期 FORTRAN 所处理的数据类型比较单纯, 顾可以如此简化处理,FORTRAN90 与 FORTRAN 95 都继承了这点数据取值的集合对于每种数据类型, 存在一个允许的具体取值的集合而属于该数据类型的变量的取值范围

38 必定是在这个集合内表面看起来数据类型的取值集合都是明确的数学意义, 但是由于本质上计算机的任何具体取值, 都必须是有限的, 因此数据类型表面的所谓数学涵义并不是很符合实际的固然整型必定是取整数值, 但只能取有限的整数值, 而且这个值还有上限, 即一个整型数据能够取多大的整数不仅在机器的硬件方面有制约, 在语言的具体实现上也进行了约束同样, 对于实型来说, 更不可能就是和实数集合等价, 实型数据的具体取值同样只能取可有限表示的实数, 即有限小数至于某些软件 ( 如 MATHEMATICA) 声称可以精确的引用无理常数, 例如欧拉常数, 实际上是使用了一个收敛级数来表达无理常数, 只有当用户指定有理表示的精度后, 计算机才对级数做相应的截断, 给出相应精度的有理表示, 而并不是说该常数的无限位表示完全存储在计算机里面逻辑型数据能够取得的值的个数是完全确定的, 即仅有真和假两个值 ( 即两个元素 ) 由此可见所有逻辑型变量都是某种判断, 而对该判断的取值只能或真或假, 这里实际上就规定了 FORTRAN 语言只能用来表述满足排中律的数学对于整型和实型来说, 既然只可能取有限值, 那么剩下的问题就是如何给某个具体取值分配存储空间了, 由于程序单元是根据数据声明当中对数据取值的规划来确定如何为数值分配存储空间的, 因此对于具有极大处理能力的现代计算机而言, 最好针对数值占用空间的大小进行分级, 以做到在保证数值表达需求的前提下, 尽量避免存储空间的浪费 FORTRAN 为了给数值占用空间的大小分级, 引入了种别参数 (K1ND), 使得在数据声明的时候, 就可以一致地规定该类数据在表达时, 允许占用空间的大小例如整型除了默认表示之外, 还可以标志以种别参数 SHORT, 这个参数意味着在整型的默认取值范围了划出了一个子集, 只要是属于这个子集的数据, 允许系统给它分配较为小的, 但更为合算的存储空间对于实型来所, 则完全可以根据算法的需要, 在开始的数据声明里, 就给程序单元里可能出现的数据划出三流九等, 使得程序对存储空间的占用更为合理当然 FORTRAN 语言标准只是规定了实型必须至少在默认精度种别之外, 还需要有一个双精度种别, 而在 FORTRAN 的各种编译实现里, 还可以规定更多的精度种别对于字符型数据来说, 它的存储空间完全和字符串长度成正比, 因此只要直接规定字符串的字符个数, 就可以一致地得到其存储空间分配标准至于复型和派生类型, 则完全以其他数据类型作为成员, 自身没有什么特别的规定, 因此也就没有独特的针对这两种数据类型的种别参数显然,FORTRAN 通过运用种别参数来明确地规定数据的表示, 使得 Fortran 的标准化程度得到了进一步提高, 从而提高了程序的可移植性数据类型的合法运算允许施加于数据的运算同样可以分为两类, 即与固有数据类型相应的固有运算, 还有自定义运算由于在 FORTRAN 里面, 运算的主要语法功能是构成表达式, 因此详细的关于运算的讨论, 参见有关表达式的章节 1. 固有运算固有运算就是固有数据类型在 FORTRAN 里面指定了表示符从而可以直接引用的那些固有运算, 根据运算所能施加的算元据的不同, 一共分为四类 :

39 1. 算术运算 2. 串联运算 3. 关系运算 4. 逻辑运算简述如下 : 算术运算针对三种数值型数据, 可以直接引用 7 种固有的算术运算 : 2 种一元运算 : 求反运算, 其运算符为 -; 求同运算, 其运算符为 + 这两种一元运算可以施加于任意数值型数据和种别参数的组合, 其运算结果的数据类型与种别参数和算元的数据类型和种别参数保持一致 5 种二元运算是 : 加法运算, 其运算符为 +; 减法运算, 其运算符为 -; 乘法运算, 其运算符为 *; 除法运算, 其运算符为 /; 乘幂运算, 其运算符为 ** 这 5 种运算的两个算元可以是数值型数据的任意数据类型与任意种别参数的任意组合如果参与运算的两个算元不是同一个类型或种别参数不同, 那么 FORTRAN 如何决定结果的数据类型或种别参数呢? 基本的原则就是向需要存储空间大的操作数看齐, 以免损失算元的信息具体地说, 就是 : 若两个算元是相同类型和相同种别参数, 则运算结果的类型与种别参数就是算元的类型与种别参数若两个算元都是整型但种别参数不同, 则运算结果的种别参数是取十进制幂范围大的那个算元的种别参数 ; 若范围一样大, 则由系统决定当一个算元是整型另一算元是实型或复型, 则运算结果的种别参数就取那个实型或复型的算元的种别参数若两个算元属于不同种别参数的实型或复型数据, 则运算结果的种别参数取十进制精度高的那个算元的种别参数 ; 若精度一样, 则由系统决定取舍规定了运算结果的属性, 具体的值就是通常的算术运算的结果, 即加法为两个算元之和 ; 减法为两个算元之差 ; 乘法为两个算元之积 ; 除法为两个算元之商, 如果两个算元都是整型数据, 它们相除时称为整除, 其结果商就是首先进行算术上的除法运算, 得到的商去掉小数部分, 取得的整数值即为整除的结果这是为了满足上面关于保持类型一致性的规则例如 :99/100 的值为 0;(-99)/100 的值为 0;58/3 的值为 19;(-58)/3 的值为 -19 乘幂为以第一个算元为底, 第二个算元为指数的乘幂值串联运算针对相同种别参数的字符型数据定义了串联运算, 其运算符是 // 串联运算的结果为保持种别参数不变的字符型数据运算结果的值为第一算元的字符值, 在

40 右边紧接第二个算元的字符值例如 :ABC//RTY 的值为 ABCRTY 关系运算关系运算是分别针对整型实型复型和字符型数据来定义的二元运算关系运算的结果为逻辑型数据, 即只能取.TRUE. 和.FALSE. 两个值之一 FORTRAN 95 定义了六种固有关系运算, 这六种固有关系运算根据其可以施加的操作数的不同, 又可以分为两类 : 可以施加于除复型之外的数值类型, 种别参数以及字符型的第一类 : 大于, 其运算符为.GT., 或 >; 大于等于, 其运算符为.GE., 或 >=; 小于, 其运算符为.LT., 或 <; 小于等于, 其运算符为.LE., 或 <=; 可以施加于所有数值型与字符型的第二类 : 等于, 其运算符为.EQ., 或 ==; 不等于, 其运算符为.NE., 或 /= 对于数值型数据来说, 关系运算具有通常的涵义, 并且两个算元可以是任意的数值型类型与任意种别参数的组合当然只有复型不能比较大小, 而只能比较是否相等对于字符数据来说, 关系运算具有独特的涵义首先要求两个算元具有相同的种别类型参数, 但是可以具有任意的长度其关系运算的执行可以理解为执行下列几个步骤 : (1) 首先使两个作为算元的字符串的字符长度变为一致, 如果相对来说有个字符的长度较短, 就在右边以空格字符填充, 直到两个算元长度相同为止 (2) 然后对两个算元按字符位置从左边第一个字符开始逐个进行比较判别, 直到足够判别关系是否成立为止 (3) 而字符的比较是按字符在字符集中排列序列的位置的先后来进行的 : 若字符 1 在字符 2 之前, 则认为满足小于关系, 小于等于关系和不等于关系 ; 若字符 1 在字符 2 之后, 则认为满足大于关系, 大于等于关系和不等于关系 ; 如果位置相同, 即为同一个字符, 则认为满足等于关系所有空串都是相等的等于关系和不等于关系的运算结果与字符集序列无关, 而其它四种关系的运算结果是依赖于字符集排列序列的由于 ASCII 的排列序列对于任何系统都是一致的, 所以一般而言可移植性是能得到保证的如果参与运算的默认字符数据值全是字母或全是数字, 则按语言的规定, 其顺序是严格确定的 ; 如果参与运算的默认字符数据值参杂了字母与数字, 则把其中的数字看成字符, 而排序则依赖于系统的具体规定所以在使用时要注意这点如果参与运算的字符数据值包含了非默认的字符型数据, 则同样依赖于系统的规定逻辑运算针对任意种别参数的逻辑型数据定义五种逻辑运算我们知道数值型数据和字符型数据进行关系运算后的结果是逻辑型数据, 此外还可以根据算法的需要自定义逻辑型数据, 逻辑运算就是施加于逻辑型数据, 而得到逻辑型数据值的运算根据算元的数目, 逻辑运算包含两种, 其中一元运算为 :

41 非运算, 运算符为.NOT.; 非运算的运算结果定义如下表 5-2: 表 5-2 非运算的运算结果.NOT. 的算元.TRU E..FALSE..NOT. 的运算值.FALSE..TRUE. 二元运算包括 : 与运算, 运算符为.AND.; 或运算, 运算符为.OR.; 逻辑等价运算, 运算符为.EQV.; 逻辑不等价运算, 运算符为.NEQV.; 各运算的结果定义如下列各表 : A.AND.B 表 5-3 与运算的运算.TRUE..FALSE. A.TRUE..TRUE..FALSE. B.FA LSE..FALSE..FALSE. A B 表 5-4 或运算的运算 A.OR. B A.TRUE. B.FALSE. A.TRUE..T RUE..TRUE. B.FALSE..TRUE..FALSE. A.EQV.B 表 5-5 逻辑等价运算的运算 A B.TRUE..FALSE. A.TRUE..TRUE..FALSE. B.FALSE..FALSE..TRUE. 表 5-6 逻辑不等价运算的运算 A.NEQV.B A.TRUE. B.FALSE. A.TRUE..FALSE..TRUE. B.FALSE..TRUE..FALSE. 逻辑运算的结果的种别参数的约定 : 当两个算元的种别参数相同时, 则结果的种别参数与算元的相同 ; 当两个算元的种别参数不同时, 则结果的种别参数依赖于系统的约定

42 2. 自定义运算由于上面列出的固有运算, 并不能满足我们在构造表达式时对运算的全部需求显然, 要使得语言具有开放性, 就不可能期望通过指定有限的对象来概括任意需求, 因此必然需要制定一个构造规则, 以便允许程序作者自定义运算所谓自定义运算就是需要程序作者根据算法的需要自己来定义的运算从语法的角度来讲, 一个运算的定义包括三个部分 : 符号的表示 ; 所谓符号的表示就是给出运算的名称, 命名规则为一个字符串的左右分别加一个小数点 ( 句点 ) 例 5-3.REMAINDER..REVERSE..INTEGRAL. 固有运算的表示符号除了通常的数学表示符号之外, 同时还有一套等价的字符串加左右句点的表示方法, 这就和自定义运算的符号表示统一起来了这样做的好处就是可以用符号串直接作为文字来表示运算的涵义,( 例如上面的三个名称就可以用来表示求余, 反号, 求积分这三种运算 ), 从而便于程序的写作和阅读这是一个值得遵循的良好的写作风格运用固有运算的组合给出的自定义运算的定义 ; 自定义运算的定义是通过函数用 OPERATOR 来完成的, 具体的说明见有关过程的章节自定义运算的算元集合的描述数学上定义一个函数, 必定要指出函数的定义域, 同样一种自定义的运算也需要指定能够施加于其上的算元的范围, 这里包括如下几种情况 : 定义在某个固有数据类型的真子集上 ; 如果对一个固有运算也做这样的限制, 那么就把这个固有运算看成自定义运算了定义在不止一个固有数据类型上, 例如数值型数据和字符型数据的某种组合上 ; 可以针对某个固有运算做这样的扩展, 同样视之为自定义运算定义在派生数据类型上 ; 这样得首先定义该派生数据类型定义在上述任意情形的组合而成的集合上数据类型的常量的表示形式数据在程序当中的行为, 除了以指定数据类型的变量形式出现之外, 还有就是以常量形式出现, 也就是给出某个数据类型的具体取值的形式因此对于数据类型的说明, 还包括给出该数据类型的常量的书写语法例 5-4 下面给出每一种数据类型的说明常量的例子 : 例子数据类型例子的取值

43 345 INTEGER 或 7.132E2 REAL (2.77,5.38).TRUE. SPACE_A SAMPLE(1.582,(3.2,5.5), CHENG ) COMPLEX LOGICAL CHARACTER 派生类型 i TRUE SPACE_A SAMPLE(1.582, i, CHENG ) 可以看出, 对于数值型数据, 直接给出常量数据, 就可以了, 而对于字符型数据则需要写在定界符里面, 对于派生类型则需要遵循派生数据类型的说明语法当然一个数据类型里的常量同样具有种别参数的属性, 只要给出的常量不是属于默认的种别, 就需要给常量加上种别参数, 而种别参数有两种情况 : 一种是采用整数, 由于不同的编译器对于这些整数的具体解释有可能是不同的, 因此会妨碍程序的可移植性 ; 一种是采用命名常量来作为种别参数, 那么只要这些命名常量一直被使用, 就能保证对它的解释的一致性例 5-5 类型 INTEGER REAL 例子 2_SHORT _QUAD COMPLEX ( _HIGH, 56.2) LOGICAL.TRUE._BYTE CHARACTER CHINESE_ 例子例子里 SHORT,QUAD,HIGH,BYTE,CHINESE 都是命名常量对于整型, 实型, 复型和逻辑型来说, 种别参数写在数据的右边, 以下划线隔开, 而字符型则是写在数据的左边, 同样以下划线隔开 5.5 数据的基本类型 : 固有数据类型对于计算机来说, 数据的意义无非就是要知道在存储空间为一个特定的数据划出多大的空间来装载它, 然后才谈得上给每一个数据编制地址, 从而随时可以对数据进行读入读出操作确定数据占用空间大小的自然方式就是统一地给一类数据指定固定的存储模式, 这就是 FORTRAN 早期的做法, 即整型, 实型, 逻辑型统一地用一个数值存储单位来存储, 而双精度实型与复型则统一采用两个数值存储单位来存储, 字符型数据则统一采用一个字符存储单位来存储由于数值存储与字符存储具有不一样的情况, 因此这两种存储单元的字节数大小不一样不过语言的进步, 毋宁说是算法的进步, 要求语言能够提供更加灵活的存储模式的可选择性, 这就是 FORTRAN90 引进的种别参数, 这样就扩充了固有数据类型的存储模式同时为了使得程序能够与旧的标准兼容, 一般采取在默认的情况下采取旧的存储模式, 而需要扩充时, 则额外加上种别参数数据的存储模式是通过对数据进行声明来指定的详尽的声明语句的使用参见数据的声明, 不过下面我们给出描述各个数据类型的四个基本属性的词法与句法, 以备寻检

44 5.5.1 整型何谓 FORTRAN 里的整数? 数学上的整数用整型数据来表示而所谓整数, 具体表示出来, 在数学上一般的表示形式如下 : l i = s w r k= 1 k 1 其中 : i 是一个任意的整数 s 表示正负符号 ( 可以取 +1 或 -1) l 是一个正整数, 表示 i 的位数, 即表示 i 需要多少个数字 r 是一个大于 1 的正整数, 表示 i 的进制的基数, 即逢 r 进一位的意思 w 是一个小于 r 的非负整数, 表示了 i 的每一位的值 k 例如一个形如 -41 的整数, 也可以表示为二进制形式 , 因为我们有 : ( 1) ( ) i = s w k = 41 要完全的描述整数 i, 显然 s,l,r,w k (k=1,2, l) 这些数值都是必须提供的例如给出十进制整数 -41, 实际上也就是提供了 s=-1;l=2;r=10;w 1 =1;w 2 =4 这一套完整的信息不过如果我们的目的是描述一个取整数值的变量 n 的数据类型, 显然 s 和 w k (k=1,2, l) 都无须给出, 而整型数据的分类都是围绕 l 和 r 来进行的例 5-6 下面的带种别参数的整型数据的声明语句 : INTEGER(4) i 实际上表示的是如下形式的整数 : 31 k=1 k 2 k 1 也就是取 l=31 和 r=2 下面我们就给出说明整型数据的四个基本属性的方式与相关功能函数 1. 整型的名称整型的名称就是 INTEGER 也可以说就是声明整型数据类型的语句的关键词声明一个数据对象属于整型数据的基本语句句法为 : INTEGER [ ( [ KIND = ] kind-parameter) ] [ [, attribute-list] :: ] entity-list 例 5-7 以下这些声明语句主要是要说明数据项 : INTEGER X INTEGER DIMENSION(:), POINTER :: days, hours INTEGER(SHORT)RED_BALL

45 INTEGER(2) POINTER :: k, limit INTEGER(1) DIMENSION(10) :: min 例 5-8 以下这些声明语句主要是要说明数据的属性 : INTEGER days, hours INTEGER(2) k, limit INTEGER(1) min DIMENSION days(:), hours(:), min (10) POINTER days, hours, k, limit 整型数据也可用于指出某个变量为整型也可以构成一个条件语句例 5-9 INTEGER I, X READ (*,*) I IF (I) THEN X = 1 END IF 2. 整型数据的取值取值为整数值的数据对象被定义为整型数据对象值得注意的是整型数据的取值范围, 无论如何都只能是整数集合的一个真子集, 因为计算机所能表示出来的整数的大小是受到一个有限数值的限制的至于某一个具体的编译器能够表示的最大的数值是多少, 并不是统一的, 需要具体的依据编译器的约定, 当然只有在我们需要考虑有可能取非常大的数值时, 才会注意到系统的这方面的限制更具体地考虑一下, 当我们要定义一个整型变量的时候, 我们不止是需要考虑它是否可能取非常大的数值, 更重要的是要在满足算法的数据精度要求与节约机器的内存空间之间取得某种折中因为尽管语言标准只要求编译器提供整数的一种存储标准, 但是现在一般的编译器都能提供多种存储模式, 针对算法的具体情况, 程序作者就可以选择不同的数据存储模式, 来获得高效的程序 FORTRAN 语言可以很方便地描述数据对象的具体的存储模式, 那就是种别参数, 实际上对于 F ORTRAN 来说, 每一个数据总是认为它不仅属于一个数据类型, 进一步还属于该数据类型的某个种别, 在种别参数没有表达出来的时候, 就会赋予默认的种别参数值由于 FORTRAN 标准只是规范了固有数据类型的定义, 对于每一个固有数据类型所定义的各个种别的具体存储模式, 则一般由具体的编译系统来约定, 因为给具有不同字长的数据规定适当的存储空间, 得依据系统不同具体情况来确定 FORTRAN 提供了三个固有函数, 可以用于查询具体的某个系统对整型数据的存储模式的设置 : KIND RANGE SELECTED_INT_KIND 固有函数 KIND 这个函数能够给出任意属于固有数据类型的数据对象的种别参数句法 :

46 result = KIND (x) 输入 x, 可以是任意属于固有数据类型的数据对象, 如变量或常量输出为一个属于默认整型数据的标量, 就是 x 的种别参数值例 5-10 KIND (0) 为默认整型的种别参数值 ; KIND (12) 同样为默认整型的种别参数值 ; 输出为一个属于默认整型数据的标量, 表示数据用十进制表示时的幂次范围对于一个整型变量, 输出值为 INT(LOG10( HUGE(x) )) 如果变量 X属于 REAL(4), 那么 RANGE (X) 的值为 37. ( 因为 HUGE(X) = ( ) x TINY(X) = 2 固有查询函数 RANGE 这个函数能够给出数据用十进制表示时的幂次范围一般句法为 : result = RANGE (x) 输入 x 是数值型数据由于机器的存储模式是以二进制的位数为单位的, 因此这个函数的作用就在于把二进制的幂次范围转换为十进制的幂次范围对于一个实型或复型变量, 输出值为 INT(MIN (LOG10( HUGE(x) ), -LOG10( TINY(x) ))). 例固有转换函数 SELECTED_INT_KIND 这个函数能够根据数据取值的十进制幂次范围, 给出其种别参数值一般句法为 : 输入十进制最大幂次 l, 而输出满足 -10 l < n < 10 l 的变量 n 的种别参数值如果系统不支持相应的整型种别, 就会返回数值 -1 如果该数据同时满足不止一个种别参数值, 则取具有最小十进制幂次范围的种别参数 INTEGER (SELECTED_INT_KIND (6))X! 等价于 INTEGER(4)X, 而 X! 的取值最大可以达到 10 6, 而最小 ) 值 result = SELECTED_INT_KIND (l) 由于很多情况下, 我们只知道数据取值的十进制幂次范围, 因此这个函数就提供了通过十进制幂次范围来指定种别参数的方法例 5-12! 可以达到 10-6 INTEGER (SELECTED_INT_KIND (5)) N,M! 声明了变量 N 和 M 的取! 值最大可以达到 10, 而最小可以达 5 ;

47 ! 到 10-5 i = SELECTED_INT_KIND(8)! 返回 4 i = SELECTED_INT_KIND(3)! 返回 2 i = SELECTED_INT_KIND(10)! 返回 -1, 因为系统不提供如此高! 的精度 3. 运算施加于整型数据的运算包括 : 一元固有算术运算 : 求反运算 -; 求同运算 + 二元固有算术运算 : 加法运算 +; 减法运算 -; 乘法运算 *; 除法运算 /; 乘幂运算 ** 二元固有关系运算 : 大于.GT. 或 >; 大于等于.GE. 或 >=; 小于.LT. 或 <; 小于等于.LE. 或 < =; 等于.EQ. 或 ==; 不等于.NE. 或 /= 固有算术运算的结果仍然为整型数据, 而固有关系运算的结果为默认种别类型的逻辑型数据 4. 常量的表示形式所谓常量, 可以理解为取了具体的定值的数据对象, 因此整型常量从形式上讲, 就是一串数字, 可能在前面 ( 左端 ) 加上正负号, 也可能在后面 ( 右端 ) 加上下划线, 然后跟一个种别参数整型字面常量的一般形式为 (R403): [s]n[n...][ _k] 其中 : s 表示正负号 ; 如果取负号 (-), 则这个负号是不可缺的, 如果取正号 (+), 则是可选的因此不带任何符号的数字串被默认为正数 n 表示数字 (0 到 9), 从左端开始第一个非 0 数字开始, 它左边的任何 0 都会被忽略在默认情形下, 这些数字都被认为是十进制表示形式的数值 k 是一个可选的种别参数, 必须用下划线 ( _ ) 和表示数据的数字串区分开种别参数的一般语法形式为 : digit-string scalar-integer-constant-name 即数字串, 或者是取整型标量值的命名常量例表示 INTEGER(1); 2 表示 INTEGER(2); 4 表示 INTEGER(4); 8 表示 INTEGER(8); LONG SHORT 其中 1,2,4,8 同样属于默认种别的整型数字, 而 LONG 和 SHORT 都是命名常量, 它们的具体取值完全依赖于编译系统在默认情形下, 整型常量总是被解释为十进制表示的数值, 除了这种默认的十进制表达形式之外, 还可以在 DATA 语句当中初始化表示为其他系统许可的进制形式

48 在 F ORTRAN 语言标准里面, 规定了十进制之外的三种进制形式 : 二进制常量形式 (R408): B digit [ digit ] B digit [ digit ] 其中的数字只能是 0 或 1. 即二进制常量表示为以字母 B 开头, 后跟用一对撇号或引号括起来的数字串, 而且每个数字不是 0 就是 l 八进制常量形式 (R409): O digit [ digit ] O digit [ digit ] 其中的数字只能是 0 到 7. 八进制常量表示为以字母 O 开头, 后跟用一对撇号或引号括起来的数字串, 而且每个数字是 0 到 7 之间的一个数字十六进制常量形式 (R410): Z digit [ digit ] Z digit [ digit ] 其中的数字只能是 0 到 9, 和 A 到 F 这五个字母, 用来表示 10 到 15. 十六进制常量表示为以字母 z 开头, 后服用一对撇号或引号括起来的数字或字母的串, 而且每个数字是数字 0 到 9 或字母 A 到 F 之一这里定义的二进制八进制和十六进制的字面常量形式只能用于 DATA 语句中如果要在 CVF 系统里面使用非十进制来表示数值, 除了属于 FORTRAN 标准的二进制, 八进制, 十六进制三种额外的进制形式之外, 还可以使用如下的语法形式表示更多的进制形式 : [s] [[base] #] nnn... 其中 : base 是从 2 到 36 的任意整数这表明 CVF 可以使用从 2 进制一直到 36 进制来表示整数而如果 base 省略了, 但是给出了符号 #, 那么表示后面的整型数据被看成 16 进制, 如果 base 和 # 都被省略了, 那么后面的整型数据就被看成默认的 10 进制为什么取能够表示的最大进制是 36 呢, 因为一般从英文 26 字母里面来取得符号来表示 0 到 9 之外的数字表示符号, 一般的约定就是按照字典顺序, 例如如果使用 11 进制, 那么 A 表示 10, 如果使用 36 进制, 那么 A 表示 10,B 表示 11,C 表示 12 等等一直到 Z 表示 35 这种表示方法里面, 字母的大小写是不加区别的例 5-14 下面的 7 个变量所赋予的整型数值都是表示十进制的 3,994,575: I = 2# m = 7# J = +8# K = #3CF3CF

49 n = +17#2DE110 L = index = 36#2DM8F 例 5-15 这些都是正确的整型常量 ; _ _8 31_SHORT _LONG 例 5-16 这些都是错误的整型常量 : ! 对于默认的种别参数来说, 这个数太大了 3.14! 不允许出现小数点 32,767! 不允许出现逗号 33_3!3 不是一个有定义的种别参数例 5-17 下面都是非十进制形式的整型常量 : FORTRAN 赋值 LOGICAL(1)X INTEGER(1)X 十进制值十六进制值 X = Z'80' X = Z'7F' X = Z'FF' X = Z'FF' X = Z'8000' X = Z'7FFF' X = Z'FFFF' 数字串后的下划线和种别参数是可选项如果省略, 就被认为是默认整型, 这时系统默认的种别参数值就是固有查询函数 KIND(0) 的结果 SHORT 是命名常量, 且具有常量值, 这个值必须是非负的, 而且与一种表示方法相对应非字面常量的数值数据都有一个名字, 对于名字要说明其类型, 具体说明的方法参见第 6 章实型何谓 FORTRAN 里的实数? 计算机显然也不能表示所有的实数, 因为计算机只能表示有限形式的数值, 并且表达一个数值所使用的数字数目也是受到限制的对于计算机来说, 只能用下面的形式来表示实数 :

50 l e k x = s r wk r k= 1 其中 : x 是一个实数 s 表示正负符号 ( 可以取 +1 或 -1) r 是一个大于 1 的正整数, 表示 x 的进制的基数, 即逢 r 进一位的意思 l 是一个大于 1 的正整数, 表示 x 的位数, 即表示 x 需要多少个浮点数字来表示显然这依赖于系统对 r 的选择 w 是一个小于 r 的非负整数, 表示了 x 的每一位的值, 而且 w 不能是 0 k 1 e 为幂次范围 e n 到 e 的一个整数 mi max 如果 x = 0, 那么 w k 和 e 定义为 0 从实型数据的数学表达式可以看出, 如果要对实型数据的存储模式进行分类的话, 在默认取十进制的情况下, 就一定是围绕 l 和 e 来进行的, 例如单精度实型 (REAL(4)) 的定义如下 : x=0, 或者 24 x k 2 [1/ 2 wk e k=2 = s + 2 ], 一个实型数据值最多可以用多少个浮点数字来表示, 依赖于系统的约定, 下表 5-7 是 CVF 在不同环境里的相应约定表 5-7 实型数据值的浮点数字 IEEE S_floating 24 Compaq ( 以前是 DIGITAL) VAX F_floating 1 24 IEEE T_floating 53 Compaq VAX D_floating Compaq VAX G_floating 仅限于 VMS 2 VAX D_floating 的内存格式是 56 位浮点数, 不过实际只有 53 位用于计算, 因此 Compaq Fortran 认为它是 53 位幂次范围 e min 到 e max 同样依赖于系统的约定, 下表 5-8 是 CVF 在不同环境里的相应约定 : 表 5-8 幂次范围的浮点数字 e min e max IEEE S_floating Compaq VAX F_floating IEEE T_floating Compaq VAX D_floating Compaq VAX G_floating VMS only

51 1. 名称实型数据的名称是 REAL, 不过实型数据还有一个种别, 拥有单独的名称, 即 DOUBLE PRECISI ON, 这属于历史的遗留, 是在 FORTRAN 没有出现种别参数的时候所增加的双精度实型数据的名称, 当然使用种别参数是完全可以代替使用这个名称实型数据的声明的语法形式如下 : REAL [ ( [KIND=] n) ] [,attribute-list::] entity-list DOUBLE PRECISION [,attribute-list::] entity-list 其中 : n 取值为种别参数 4, 8, 或 16 种别参数 16 只出现在 OpenVMS, Tru64 UNIX, 和 Linux 环境当中种别参数是可选的, 如果使用了种别参数, 那么给出的实型数据对象就属于相应的种别 ; 如果没有使用种别参数, 那么给出的实型数据对象就属于默认实型 DOUBLE PRECISION 实际上就是 REAL(8) 如果使用 DOUBLE PRECISION 就不能再使用种别参数如果要改变实型的默认指定可以使用编译选项 /real_size:size 给出实型数据对象的名称的例子如下例 5-18 这些声明语句主要说明数据项 REAL (KIND = high), OPTIONAL :: testval REAL, SAVE :: a(10), b(20,30) 这些声明语句主要说明数据属性 REAL (KIND = high) testval REAL a(10), b(20,30) OPTIONAL testval SAVE a, b 2. 实型的取值鉴于 FORTRAN 的所谓实型只是有限位有理数的集合, 因此同样有必要依据精度对实型数据进行分类, 以避免给任意的实型数据安排同一个存储模式, 从而有可能导致非常大的内存空间的浪费 FORTRAN 标准规定了实型至少要有两种精度形式, 一种是默认实型, 一种是在默认实型的基础上精度加倍, 得到双精度实型在 FORTRAN90 以后, 为了与早期的语言版本相容, 保留了说明默认双精度实型的关键词 DOUBL E PRECISION, 不过可以使用 REAL 加双精度种别参数 (REAL(8)) 的形式, 或直接使用指数符 D 加指数的形式代替和整型类似,FORTRAN 设置了四个固有函数, 可以用来查询具体的某个系统对实型数据在精度方面的约定这四个固有函数为 : KIND PRECISION RANGE

52 SELECTED_REAL_KIND 固有函数 KIND 这个函数用于查询变量的种别参数由于实型数据的双精度型被认为是一种单独的实型数据种别, 因此针对它的种别参数查询函数使用 KIND(0.0D0), 而对于默认实型则使用 KIND(0.0) 句法 : result = KIND (x) 输入 x 可以是任何属于固有数据类型的数据对象函数结果为一个属于默认整型的标量, 表示 x 的种别参数例 5-19 KIND (0.0) 为默认实型的种别参数固有函数 PRECISION 这个函数给出实数的有限十进制小数表示或近似表示的十进制精度函数输出为一个正整数 p, 表示数据取值至少含有 p 个有效数句法 : result = PRECISION (x) 输入 x 必须是实型或复型, 可以取值为标量或数组函数结果为一个属于默认整型的数值, 等于 INT( (DIGITS(x) - 1) * LOG10(RADIX(x))) 如果 RADIX(x) 等于 10 的某个整数次幂, 则结果加 1 如果 X 是一个 REAL(4) 值, 那么 PRECISION(X) 等于 6 因为 : INT ((24-1) * LOG10 (2.)) = INT ( ) 固有函数 RANGE 参见应用于整型数据的该函数的说明固有函数 SELECTED_REAL_KIND 这个函数能够根据数据的十进制精度和十进制幂次范围, 给出其种别参数值使用这个函数, 就可以在只了解数据的十进制表示的精度与幂次范围要求的情况下, 在数据说明当中指定其种别参数一般形式 : result = SELECTED_REAL_KIND ([p] [,r]) 其中 : p 作为可选输入, 属于默认整型的标量 ; r 作为可选输入, 属于默认整型的标量这两个可选量必须至少出现一个输入表示十进制精度的 p 或 ( 和 ) 十进制最大幂次 r 输出具有十进制精度的 p 或 ( 和 ) 满足 -10 r < n < 10 r 的变量 n 的种别参数值显然其中的 p 就是函数 PRECISION 返回的结果,r 就是函数 RANGE 返回的结果如果系统不支持相应的实型种别, 就会出现如下结果 : 如果系统不支持相应精度, 则得到 -1; 如果系统不支持相应幂次范围, 则得到 -2; 如果系统两者都不支持, 则得到 -3

53 如果该数据同时满足不止一个种别参数值, 则取具有最小精度的种别参数值例 5-20 REAL (SELECTED_REAL_KIND (5))X! 表示 X 具有至少 5 位有效数, 并且! 没有指定幂次范围 REAL (SELECTED_REAL_KIND (6, 50))X! 表示 X 具有至少 6 位有效数,! 并且指定幂次范围为到 REAL (SELECTED_REAL_KIND (6, 70))! 等价于 REAL (8) i = SELECTED_REAL_KIND(r=200)! returns 8 i = SELECTED_REAL_KIND(13)! returns 实型数据的运算施加于实型数据的运算包括 : 一元固有算术运算 : 求反运算 -; 求同运算 + 二元固有算术运算 : 加法运算 +; 减法运算 -; 乘法运算 *; 除法运算 /; 乘幂运算 ** 二元固有关系运算 : 大于.GT. 或 >; 大于等于.GE. 或 >=; 小于.LT. 或 <; 小于等于.LE. 或 <=; 等于.EQ. 或 ==; 不等于.NE. 或 /= 对实型数据施加固有算术运算的结果总是实型数据, 即使二元运算的某个运算元为整型, 结果仍然被视为实型固有关系运算的结果为属于默认种别类型的逻辑型数据实型常量的形式 FORTRAN 可以写出有限位的整数, 也可以写出有限位的小数, 然后可以再加上正负号, 到此为止, 实数里面的非有限小数就只能用有限小数来近似了带符号的实型字面常量的写法 (R412) 有以下几种形式 : 不含指数部分的实常量 : [s]n[n...][ _k] 含指数部分的实常量 : [s]n[n...]e[s]nn...[_k] [s]n[n...]d[s]nn... [s]n[n...]q[s]nn 其中 : s 表示正负号, 如果是负数必须有 (-), 如果是正数,(+) 可选 n 表示从 0 到 9 的数字 ( 默认实型的情况下 ) 如果不含指数部分, 则其中必须包含小数点在整数与小数部分的数字串遵循 R402, 指数部分的数字串遵循 R416 和 R401

54 k 是种别参数 :REAL(4) 是 4, REAL(8) 是 8, 种别参数前面必须有下划线 ( _ ) E,D 表示指数符 (R415) 后接指数表示 10 的幂次, 例如 1.0E6 表示 1.0 * 10**6 FORTRAN 只能表示实数的有限小数部分, 并且按十进制科学记数法解释, 即有效数乘以 10 的指数幂书写的有效数字个数可以多于系统约定的用来近似表示该常量值的位数在一个实型常量里同时出现种别参数与指数时, 使用 E 指数符使用 D, 表示常量为双精度实型数据 (REAL(8)), 由于这种精度的实型是单独定义的, 因此不能再带有种别参数它的种别参数值是固有查询函数 KIND(0.0D0) 的结果, 而且约定其表示方法的十进制精度要大于默认实型的精度带种别参数的实型常量受到其种别参数的约定既不带指数, 也没有种别参数的实型常量为默认的单精度常量, 即 REAL(4), 此时种别参数值是固有查询函数 KIND(0.0) 的结果应用种别参数来规定所谓的有效数的个数时, 数字串里第一个非 0 数字左边所有的 0 全被忽略例如里面,5 之前所有的 0 都不计入有效数如果实型常量不含指数部分, 则在数字串部分必须包含小数点, 如果有效数为不带小数点的数字串, 即整型字面常量时, 必须出现指数符及指数, 否则就变为整型数据了 ; 如果含指数部分, 则小数点不是必须的, 而指数部分的数字串里不能出现小数点在默认情况下, 指数符 E 指单精度实型 (REAL(4)), 而如果带有种别参数, 则依种别参数, 例如 -7.E2_8 为双精度实型常量, 也可以写为 -7.D2 如果实型常量的数字串当中出现指数符, 那么指数数字串不能省略, 但可以是 0 种别参数可以使用 HIGH,LOW,QUAD 等命名常量, 其具体取值由系统约定单精度实型 (REAL(4)) 的定义如下 : x=0, 或者 e k x = s 2 [1/ 2 + w 2 ], 125 e 128 k= 2 例 5-21 下面都是合法的实型常量 : E2-13.6E_ E7_QUAD.96D _ E3 2E-3_ D E+5_ D00 2E200_ Q Q k

55 例 5-22 下面都是不合法的实型常量 : 1,234,567.! 数字串当中不能含有逗号 325E-47! 对于 REAL 来说, 这个数太小 ; 但是属于合法的 DOUBLE PRECISION! 常量 -47.E47! 对于 REAL 来说, 这个数太大 ; 但是属于合法的 DOUBLE PRECISION 常! 量 625._6!6 不是合法的实型种别参数 100! 在不含指数部分的情况下, 没有小数点, 故只能是合法的整型常量 $25.00! 不允许含特许字符 -.25D0_2!2 不是合法的实型种别参数 ! 没写指数符 D, 不过在忽略 7 个有效数之外的数字之后, 可! 以视为合法的单精度实型常量 D45! 这个数对于 D_floating 格式来说太大 ; 但属于合法的 G_floating 和!T_floating 格式 D400! 这个数对于双精度格式来说太大 D-400! 这个数对于双精度格式来说太小 1.Q5000! 这个数对于三倍精度格式来说太大 1.Q-5000! 这个数对于三倍精度格式来说太小 5.6 复型两个实型数据就构成一个复型数据, 因为在数学上, 一个复数本质上就是一个实数二元组和实型值集合只是实数的一个子集一样, 复型值集合只是数学上复数的近似表示的一个子集复型的值运用实值的有序对来表示, 第一个实值称为实部, 第二个实值称为虚部复型数据的取值的写法如下 : (c,c) 其中逗号与括号不可或缺, 而 c 可以取 : 整型常量或 REAL(4) 常量, 得到 COMPLEX(4) 常量 ; 整型常量,REAL(4) 常量, 或 DOUBLE PRECISION (REAL(8)) 常量, 得到 COMPLEX(8) 常量 ; 正是由于复型本质上由实型组合成, 因此复型数据的存储模式依据实型而定名称复型的名称为 COMPLEX, 说明复型数据类型的句法为 : COMPLEX [([KIND = ] kind-parameter)] [,attribute-list::] entity-list 其中 : n 为种别参数 4 or 8, 同于实型由于复型数据种别参数是应用于实部和虚部两个实型数据的, 如果出现种别参数, 该种别参数指定实部和虚部两个实型数据的种别 ; 如果不带种别参数, 则称

56 此复型数据为默认复型, 即实部和虚部都属于默认实型例 5-23 COMPLEX ch COMPLEX (KIND=4),PRIVATE :: zz, yy! 等价于 COMPLEX*8 zz, yy COMPLEX(8) ax, by! 等价于 COMPLEX*16 ax, by COMPLEX ( kind(4)) y(10) complex (kind=8) x, z(10) 复型数据的取值复型数据对象的取值的种别完全由实型而来, 根据两个实型分量的组合, 可以分为如下情形 : 两个实型分量都是默认实型, 则相应复型也称为默认复型 ; 两个实型分量都是双精度实型, 则相应复型也称为双精度复型 ; 给复型对象指定一个种别参数, 意味着同时给它的两个实型分量指定了同样的种别参数 ; 两个分量都是整型对象, 则都转换成默认实型, 因而认为是默认复型的 ; 其中一个分量是整型对象, 另一个分量是实型对象, 则将整型的分量转换成与另一实型分量相同种别的实型对象, 其种别参数就是实型分量的种别参数如果两个实型分量的种别参数不同, 则具有精度高的分量的种别参数就是复型的种别参数, 并且把另一分量转换为这个精度高的种别形式这里显然符合 FORTRAN 对存储模式一致性处理的一般原则, 即当需要统一存储具有不同存储模式的几种数据时, 就一律采用需要存储空间最大的那种模式应用于复型的固有查询函数与实型相同, 其中有关 KIND,RANGE,PRECISION 的说明参见实型的相应说明 SELECTED_REAL_KIND 也可以直接用于复型对象, 用法与功能都与用于实型对象一致例 5-24 COMPLEX (SELECTED_REAL_KIND(5,50))CY!5 位有效数, 同时取值范围! 可达到 10 50! 表示复型变量 CY 至少具有复型的运算施加于复型数据的运算包括 : 一元固有算术运算 : 求反运算 -; 求同运算 + 二元固有算术运算 : 加法运算 +; 减法运算 -; 乘法运算 *; 除法运算 /; 乘幂运算 ** 二元固有关系运算 : 大于.GT. 或 >; 大于等于.GE. 或 >=; 小于.LT. 或 <; 小于等于.LE. 或 <=; 等于.EQ. 或 ==; 不等于.NE. 或 /= 这里的算术运算就是定义在复数集合上算术运算对复型数据施加固有算术运算的结果总是复型数据, 即使二元运算的某个运算元为整型, 或实型, 结果仍然被视为复型固有关系运算的结果为属于默认种别类型的逻辑型数据

57 5.6.4 复型常量的形式复型字面常量的句法 (R417) 为 : (real-part,imaginary-part) 其中实部和虚部可以是带号整型字面常量 (R403) 与带号实型字面常量 (R412) 的任意组合复型数据对象的种别如何确定, 参见上面的节例 5-25 下面是合法的复型常量 : (1,3)! 默认复型 (7.0,-7.0)! 默认复型 (0,3.6E5)! 默认复型 (0.5_4,+8.6E29)! 如果假定种别参数值 4 比 8 所表示的实数精度低, 则该复型数据具有! 种别参数值 8 例 5-26 下面是不合法的复型常量 : (1.23,)! 漏写了作为虚部的整型或单精度实型常量值 (1.0, 2H12)! 不能用 Hollerith 常量 (,1.23Q0)! 漏写了实部 (1.7039E0, D0)! 2 个常量都不属于 REAL(16), 但属于合法的双精度常量 5.7 逻辑型用来作为任何判断的结果的变量或常量, 就是逻辑型数据对象之所以把它单独归结为一种数据类型, 是因为它的取值只有是和否两个, 在存储方面可以非常简单, 为了充分显示这个特点, 有必要单独作为一种数据的类型名称逻辑型数据对象的名称为 LOGICAL, 它的声明语句的句法为 : LOGICAL [([KIND = ] kind-parameter n)] [,attribute-list::] entity-list 其中 n 可取种别参数 1, 2, 4, 或 8 种别参数是可选项, 如果没有使用种别参数, 则为默认逻辑型例 5-27 下面的声明语句主要说明逻辑型对象 LOGICAL, ALLOCATABLE :: flag1, flag2 LOGICAL (KIND = byte), SAVE :: doit, don t 例 5-28 下面的声明语句主要说明对象的属性 LOGICAL flag1, flag2 LOGICAL (KIND = byte) doit, dont ALLOCATABLE flag1, flag2

58 SAVE doit, dont 逻辑型数据取值逻辑型数据取值只有两个可能, 即表示真的 (.TRUE.) 和表示假的 (.FALSE.) 的两个值, 它们后面可以跟可选的下划线与种别参数一个系统至少要提供一种表示方法作为默认逻辑型, 在默认的情形下, 一个逻辑型值需要和默认实型值一样大的存储空间, 它的表示方法就是省略可选的下划线和种别参数, 此时种别参数值可以通过固有查询函数 KIND(.FALSE.) 获得大多数系统还提供其他存储模式, 例如一个逻辑型值采用一个 bit 或一个 byte 来存储, 具体的种别参数的约定依赖于具体的系统至于查询数值型数据的种别参数的固有函数 SELECTED_INT_KIND 和 SELECT ED_REAL_KIND 对于逻辑型没有相应的函数逻辑型数据的运算施加于逻辑型对象的运算包括 : 一元固有运算 : 非 (.NOT.) 二元固有运算 : 与运算 (.AND.); 或运算 (.OR.); 逻辑等值运算 (.EQV.); 逻辑不等值运算 (.NEQV.) 对逻辑型值施加上面的运算, 仍然得到逻辑型值逻辑型常量逻辑型常量只有两个, 它们也可以附加系统约定的种别参数, 句法为 :.TRUE.[_k].FALSE.[_k] 其中 k 为可选的种别参数 : LOGICAL(1) 是 1;LOGICAL(2) 是 2;LOGICAL(4) 是 4;LOGICAL(8) 是 8 注意种别参数前面一定要有下划线 ( _ ) 这里的种别参数是与实型数据的种别参数保持一致的例 5-29.TRUE._BIT.FALSE._LONG! 这里的 LONG 必须是已说明的有名常量, 并且具有非负的整常量值! 其存储模式必须是已经说明的. 5.8 字符型字符型数据对象在系统认可的字符集当中取值, 其唯一形式就是由有限个属于系统字符集当中的字符构成字符串

59 5.8.1 名称字符型数据的名词为 CHARACTER, 字符型对象的基本声明句法为 : CHARACTER [([LEN = ] length-parameter & [, [KIND = ] kind-parameter])] [,attribute-list::] entity-list 可以看到其中各种可选项的组合情况比较多, 为清晰起见, 分别写出如下 : CHARACTER CHARACTER([KIND=]n) CHARACTER([LEN=]len) CHARACTER([LEN=]len [, [KIND=]n]) CHARACTER(KIND=n [, LEN=len]) CHARACTER*len[,] 其中 n 取种别参数值 1; len 是字符长度值, 不是种别参数值, 一般取正整数值, 也可能取星号或特定表达式参见表达式有关 CHARACTER 声明语句, 还参见数据声明例 5-30 下面是不同形式的字符型数据的声明语句 CHARACTER (70) PROJECT CHARACTER (LEN=30, KIND=GERMAN)TRANSFORMATION CHARACTER (LEN=25,KIND=GREEK),DIMENSION(11)::Z 字符型的取值字符型能取的值的集合就是所有有限字符串的集合所谓一个有限字符串就是一个字符按照文字方式排列的有限序列, 如果从左到右对每一个字符进行编号, 得到 1,2,3.,n, 那么 n 就是该字符串的长度, 即该字符串所有字符 ( 包括重复字符 ) 的数目决定一个字符串变量的值的存储空间的因素有两个 : 字符串的长度 ; 字符的存储单位的大小因此这两个因素都是在描述字符型对象时, 系统需要知道的参数字符长度作为一种种别参数, 它的取值分为如下情形 : 可以等于 0, 这时称长度等于零的字符串为空串 ; 在没有指定 LEN 值的时候, 默认长度值为 1; 根据字符数目, 取大于 0 的整数当然这个整数存在上界, 由系统给出约定系统至少需提供一种定义字符型数据值的集合的表示方法, 一般是会有几种方法, 每种方法用不同的种别参数来区分种别参数的具体取值依赖于具体的系统的约定字符型数据还有一个需要仔细加以约定的属性是字符集的排序问题由于字符型数据的运算除了串联之外, 还有一类关系运算, 需要依据对字符集的字符顺序的

60 规定一般原则如下 : 首先出于可移植性的要求, 最好把字符集限制在 FORTRAN 的基本字符集空格优先于所有字母与数字 ; 字母按照英文字母表排序 ; 数字按照 0,1,2,,9 的顺序排序 ; 字母与数字不能间杂 ; 除了空格, 对其他特殊字符与下划线的位置都没有约束 ; 语言标准不要求系统支持 ASCII 编码, 但要求提供固有函数,ACHAR 和 IACHAR, 用来在系统编码和 ASCII 编码之间进行转换固有函数 LGT,LGE,LLE,LLT 可用来基于 ASCII 顺序进行排序比较运算运算可以施加于字符型数据的运算包括 : 串联运算 : 运算符是 //, 针对具有相同种别参数的字符型数据而定义其运算结果仍然为一个保持种别参数不变的字符型数据关系运算 : 大于, 其运算符为.GT., 或 >; 大于等于, 其运算符为.GE., 或 >=; 小于, 其运算符为.LT., 或 <; 小于等于, 其运算符为.LE., 或 <=; 等于, 其运算符为.EQ., 或 ==; 不等于, 其运算符为.NE., 或 /= 关系运算的结果为逻辑型数据, 即只能取.TRUE. 和.FALSE. 两个值之一字符型数据常量字符字面常量用可选的种别参数, 然后是下划线后跟用撇号或引号为界的, 由可表示字符组成的字符串来表示字符型字面常量的构成句法 (R420) 如下 : [k_]'[ch...]' [k_]"[ch...]" 其中 : k 为可选种别参数, 默认情形为 1, 后接下划线 ( _ ) 注意字符型数据的种别参数置于常量前面 ( 左边 ) ch 为 ASCII 字符, 或者说系统可表示字符前一个撇号或引号称为前定界符, 后一个称为尾定界符, 它们统称为定界符字符型常量的值限制在定界符之间, 而定界符本身不属于字符串定界符之间的任意字符, 包括空格和 Tab 键都属于字符串, 不过对于控制符得参考系统的约定字符串当中可以包含定界符本身, 不过就只能看成字符, 不能看成是字符型常量的定界符当用引号作定界符时, 则用一个撇号来表示该字符, 当用撇号作定界符时, 则用两个连续的撇号来表示, 且其间不夹有空格字符, 此时两个连续的撇

61 号计作一个字符对字符字面值中的引号也类似地处理长度为 0 的字符常量, 也就是空串, 由两个连续的同样的定界符表示, 中间不夹空格如果前定界符前不出现种别参数和下划线, 则该字符常量为默认字符型对于可表示字符的约定与源程序形式有关在固定源码形式中, 它依赖于系统字符集, 它是除一部分 ( 甚至全部 ) 控制字符外的所有字符 ; 在自由源码形式中, 它可以包含系统的附加图形字符例 5-31 下面是合法的字符常量 "WHAT KIND TYPE? " 'TODAY''S DATE IS: ' "The average is: " '' I m a student I m a student CHINESE_ 汉字的种别参数 CHINESE 作为命名常量已经被定义例 5-32 下面是不合法的字符常量 : 'HEADINGS! 缺少尾定界符 'Map Number:"! 定界符的首尾不配套第 6 章构造数据固有数据类型只是描述了问题当中出现的基本数据形式, 但在实际的计算当中, 计算对象往往并不只是限于那些固有数据类型, 而是一些数据结构例如 : 线性数学问题里面的计算对象很少是单纯的标量, 而是诸如行列式, 向量这样的由一系列标量组成的数据结构甚至在计算过程中, 还需要以这种数据结构的某个特定部分作为计算对象, 例如行列式或向量的单独的行与列, 或对角线, 部分块等又例如 : 样品的属性值可以是多方面的, 例如在测量一个导体样品的交流输运性质时, 需要考虑的物理量包括电流, 电压, 相位等, 如果以每个样品的属性值作为数据对象, 那么这种数据对象就至少包括 3 个成员 : 电流, 电压, 相位它们的取值的类型不同, 精度要求也可能不同, 这 3 个数值同样构成一个数据结构因此, 进一步 FORTRAN 95 需要以固有数据对象为基础, 能够构造一定的数据结构, 从而能够作到基于数据结构进行运算本章讨论的就是 FORTRAN 95 构造数据结构的几种方式 : 派生数据类型 ;

62 数据结构的子对象 ; 数据结构的成员 ; 数组 ; 指针特别的, 我们首先讨论 FORTRAN 95 关于数据对象的一个基本分类 : 变量与常量它们是数据在程序当中的 2 种基本行为方式, 是我们理解 FORTRAN 95 语言范畴的关键 6.1 数据的 2 种基本行为变量与常量首先我们给出几个抽象的基本概念, 在这里只是给出大意而不作更加形式化的讨论, 完全只是为了后面行文的方便读者不用深究它们的精确定义, 只需要在后面行文当中遇到这些概念时, 知道回到这里稍加体会即可数据对象 : 计算过程当中, 任何充当计算对象的数据内容, 都称为数据对象, 是最一般意义上的数据个体, 今后提到数据对象, 我们可以理解为一个固有数据类型, 一个属于某固有数据类型的变量, 一个常量, 一个标量, 一个数据结构, 一个数据结构的成员或子对象, 表达式求值的结果, 或函数引用的执行结果 ( 即函数值 ) 数据对象有数据类型 ( 固有的或派生的 ), 可以有数据值可以是一个数据的集合, 集合的元素数目称为秩, 每个数据对象有一个秩它可以是一个标量或是一个数组有名数据对象的类型可以显式或隐式地规定子对象 : 子对象是某些有名对象的一部分, 可由程序的其他部分引用和独立地定义包括数据组的部分, 字符串的部分 ( 子串 ) 和结构的部分 ( 成员 ) 作为子对象的来源的数据对象称为该子对象的父对象子对象只能用子对象描述符来引用变量的子对象是变量标量 : 任何单一的数据对象, 无论它是属于固有数据类型还是属于派生数据类型, 就称为标量数组 : 一个标量的集合, 如果其中每一个元素都具有相同的数据类型, 相同的种别参数, 那么无论它们组织成什么形式, 例如行, 列, 块, 甚至更高维度, 都把这种集合称为数组派生数据类型 : 一个标量的集合, 如果其中元素的种别参数不同, 或者数据类型不同, 那么把这个集合称为结构, 或派生数据类型从程序运行这么一个动态过程的角度来看, 特别是基于下面的基本计算模式 : 输入数据程序运行输出数据数据可以有 2 种基本行为方式 : 数据对象在整个程序运行过程当中保持不变 ; 数据对象在整个程序运行过程当中发生变化保持不变的称为常量, 发生变化的称为变量

63 FORTRAN 95 中常量与变量, 标量与数组这些概念与早期的 FORTRAN 版本有微妙的差异请熟悉 FORTRAN77 的读者注意常量有两种, 一种是字面常量, 早期的 FORTRAN 版本称为常量 ; 另一种是命名常量, 早期的 FORTRAN 版本称为常数符号名, 显然新的名称突出表达了该数据作为常量的特点, 它与字面常量的最大差别在于有一个名字这个名字可以在它的定义作用域当中任意引用它们的共同点在于, 它们的值在可执行程序执行期间是不变的字面常量是标量, 根据它的字面的句法构成来表明其数据类型, 种别参数以及值在一个可执行程序中, 所有具有相同形式的字面常量具有相同的值命名常量则是一个与具有 PARAMETBR 属性的名字相结合的常量它的数据类型, 种别参数和取值, 都需要预先定义, 而一旦定义之后, 在其定义的作用域内都不会改变, 而且这个名称也必须接受唯一解释的变量的值即使用 DATA 语句给以初始化也能在程序运行过程当中发生变化而 F ORTRAN 95 的变量包括了早期 FORTRAN 标准里面所谓的变量和数组具有 D IMENSION 属性的名字在 FORTRAN 95 标准里面也称为变量, 属于数组数组是标量的有序集合, 它在 FORTRAN 95 标准当中有许多新的扩充, 将在后面作详细讨论在程序运行过程当中, 对数据的使用首先必须是定义, 然后才能是引用, 所谓定义和引用的差别在于 : 对于一个变量, 当程序中确定其值时称为定义, 而使用其值时称为引用, 已经定义了的变量可以重定义或者回复为无定义例如, 在程序单元中使用 DATA 语句使得一个变量具有初值, 在程序执行过程中又可以对它赋值而得到重定义 ; 如果该变量不具有 SAVE 属性的话, 当该程序单元执行 RETURN 语句或 END 语句后, 它就回复为无定义状态对于一个常量, 它的值可以被引用但不能被重定义命名常量虽然出现的形式是一个名字, 而不是一个具体的值, 但它只是常量的一个便于引用的标记例 6-1 X = 0 N = X+1 在第一个语句当中, 变量 X 被赋值为常量值 0, 这个语句的执行与 X 是否在此之前被定义为其他值无关, 总之此时 X 得到一个定义, 此后只要 X 没有被重定义, 它就能用值 0 被程序引用在第二个语句当中, X 被引用, 并且在执行加 1 的运算之后, 得到的值被赋值给 N 在第一个语句当中的 X 和在第二个语句当中的 N 都不是被引用, 而是被定义, 而在第二个语句当中的 X 属于被引用变量 (variable) 的句法形式 (R601) 为 ; scalar-variable-name array- variable-name subobject 其中子对象 (subobject) 的句法形式 (R602) 为 : array-element array-section

64 structure-component substring 变量可以是任意的数据类型, 在一定的上下文当中, 变量也必须取一定的数据类型常量父对象的子对象不可能是变量 6.2 数据的结构 ---- 派生数据类型五个固有数据类型已经能够作到描述, 或者近似描述整数, 实数, 复数, 逻辑值, 字符串这五类常用数据对象考虑一下 FORTRAN 建立这五种相对独立的数据类型的出发点, 是有助于我们进一步理解语言的数据描述这个重要任务的首先考虑整数似乎整数是一切计算的基本出发点, 这里是没有省略的余地的, 想像一下, 没有了整数, 我们还能做什么计算呢? 别忘了 Kronecker 的名言 : 上帝创造了自然数, 其余都是人造的然后就是实数由于 FORTRAN 本质上只能表示有限位有理数, 因此实际上也可以通过整数的除法来得到实型数据的近似表示, 比方说用一个整数二元组 (37,71) 来表示 37/71 这个有理数, 相应的也可以用来近似地表示实数, 我们可以来衡量一下这样做的利弊 : 好处就是可以不用建立实型数据类型, 也就是不用引入小数点, 减少了一个数据类型, 也就简化了 FORTRAN 语言的实现 ; 但同时坏处就是把麻烦留给了程序作者, 在处理涉及实数的问题时, 肯定会因为不能直接表达实数而增加算法的复杂性, 甚至在语言本身, 也有可能不得不增加一些函数之类的语言成分, 用来解决由此产生的一些问题所以 FORTRAN 的解决方案就是直接引入实数的有限有理小数表示 ( 实际上一般的程序语言都是这样做的 ), 对于语言本身来说, 无非就是增加了对小数点的语义解释, 增加了对浮点数值的多种存储模式 (FORTRAN 使用种别参数来进行分类 ) 的建立等, 由此而可以在语言当中自然的使用有限有理小数所表示的实数再来分析一下复数本质上复数就是一个实数的二元组, 而且这个二元组与复数是一一对应的, 因此可以很完美的通过运用二元实数组来代替复数, 这也是大多数程序语言的处理方式但是 FORTRAN 的选择是建立一个独立的复型数据类型, 尽管得为这个独立的数据类型定义相应的运算, 但是由于 FORTRAN 主要就是面向科学计算的语言, 因此 FORTRAN 能够直接写出复数, 成为 FORTRAN 的一个优点, 极大地方便了程序作者由此可见, 建立一个数据类型的主要功能就是面向问题, 以能够直接描述算法为目的那么我们是否有可能从实际问题当中归纳出一些数据类型, 然后可以期望这些数据类型就可以满足任何问题的需要呢? 显然是不可能的一方面, 程序语言必须能够精确描述任何需要用它来解决的问题当中出现的数据 ; 另一方面我们不可能给每一个新问题当中出现的独特的数据结构形式规定一种相应的数据类型, 唯一的解决方法, 就是在 FORTRAN 里面约定一种语法机制, 可以依据这种语法机制来描述与问题要求相

65 适应的数据类型反过来只要是依据这个语法机制构造出来的语言结构都能被 FORTRAN 编译器辨认为一种数据类型, 从而知道按照什么存储模式来存储该数据, 也知道应该对该种数据施加什么运算这就是 FORTRAN 从 90 版标准以来设置派生数据类型的出发点鉴于固有数据类型被认为是真实世界最基本的数据类型, 任何的数据对象, 或者就是属于某种固有数据类型, 或者就是可以由一系列固有数据描述, 因此构造派生数据类型的基本思想就是认为一个派生数据等于一系列成员的集合, 这个集合构成一种数据结构, 而每一个成员或者仍然属于一个派生数据类型, 或者就是属于某种固有数据类型这样对一个派生数据类型的描述, 就归结到对它的成员的描述, 另外再加上给出该数据类型的名称, 并可选择性地描述其他属性这样得到的所谓派生数据类型, 和五种固有数据类型不同的地方主要在于 : 每一种固有数据类型都拥有一个特定的名称, 用来作为数据声明的关键词 ; 而派生数据类型则需要程序作者自己首先定义一个名称, 然后才能在后面作为关键词进行声明每一种固有数据类型都已经定义好了自己的常量书写方式 ; 而派生数据类型则依据其成员的常量形式来确定自己的常量的形式每一种固有数据类型都已经定义好了自己的特定的运算 ; 而派生数据类型则需要程序作者自己预先依据实际问题的需要来定义好相应的运算每一种固有数据类型都已经定义好了自己的取值范围以及相应的多种存储模式 ; 而派生数据类型, 则完全依据其成员的取值范围与存储模式, 来确定自己的取值范围和存储方式派生数据类型可以在数据类型的定义里, 就给出该数据类型的默认初始值, 使得今后属于该类型的数据对象都一定取该初始值 ; 而固有数据类型的定义里面不含有定义初始值的部分, 要想显式地给出变量初始值, 得需要使用数据类型声明语句或者 DATA 语句固有类型的名称是全局性的, 在任何环境总是可访问的, 而派生类型只可在其定义的作用域内访问它们 FORTRAN 定义的数组同样是数据对象的集合, 不过派生数据类型与数组的差别在于组成数组的各个成员必须是相同的数据类型, 而派生数据类型的特点就在于它的成员可以是属于不同的数据类型派生数据类型的成员可以仍然是某个派生数据类型, 但数组的成员就不能是数组要想让数组的成员为数组只能通过间接的方式, 即取数组的唯一成员为一个派生数据类型, 然后该派生数据类型的成员取为数组对于这样构造出来的与具体问题密切相关的派生数据类型, 由于其所具有的内部结构个性太强, 显然我们需要定义一些与这种结构相关的特征属性, 可以用来描述这种个性 : 正是由于一个已经定义好的派生数据类型具有完全个性化的内部结构, 因此如果一个派生数据类型是定义在一个模块内部的话, 自然的问题就是这个派生数据类型的面向模块外部的可访问性如何控制在默认情形下, 一个在模块内部定义的派生数据类型可以被模块外部的任意程序单元访问, 这个默认状态等价于使用 PUBLIC 语句反之, 也可以通过使用 PRIVATE 语句来阻止模块外程序单元的访问不过, 由于一个模块包含许多不同层次的数据对象, 因此 PRIVATE 的作用对象必须是精确指定的, 这里分为以下几种情况 : 每一个对象都可以单独地通过使用属性 PUBLIC 或 PRIVATE 来指定其可访问性对于一个派生数据类型, 可以在定义类型的语句当中设置可选的 PUBLIC 或 PRIVATE 描

66 述符使用单独的针对类型名称的 PRIVATE 语句或在类型定义当中使用 PRIVATE 描述符, 可以把对该类型访问控制在本模块之内在类型定义的内部使用单独的 PRIVATE 语句, 可以只控制该派生类型的特定的组元的模块可访问性, 而不影响整个类型的默认下的可访问性组成一个派生类型的各个成员可以按照一定的顺序进行存储, 这是通过在派生类型的定义当中运用 SEQUENCE 语句得到的一个派生类型的定义当中, 成员的叙述上的顺序并不表示它们具有相应的存储上的顺序, 只有在定义当中设置一个 SEQUENCE 语句, 才能对这些成员的存储进行排序从而可以进一步对这些成员应用 COMMON 语句或 EQUIVALENCE 语句一个派生数据类型的取值范围显然就是它的所有成员的取值范围的组合, 使用集合论语言就是各成员值集的乘积 FORTRAN 规定了一个语法机制来给派生数据类型构造值的形式, 例如用来定义命名常量, 这样就可以在类型声明语句或 PARAMETER 语句当中使用其命名常量这种语法机制称为派生数据类型的结构构造器至此我们可以看到 FORTRAN 语言对派生数据类型的定义, 不是以某种真实世界的自然的数据集合为依据, 而是提供一种描述方式, 并且在语言当中约定, 只有运用这种方式进行描述, 就可以成立为一种数据类型而对于通过这种方式成立的数据类型, 同样包含四个方面的基本属性 : 拥有名称, 以备引用 ; 取值在一定的集合上 ; 可以施加的运算 ; 常量的写法下面就从这四个方面来说明派生数据类型派生数据类型的构造给出一个派生数据类型的名称, 同时意味着要给出该派生数据类型的完整定义或着说描述一个完整的派生数据类型的句法形式 (R422) 为 : TYPE [[, access-specification] :: ] type-name [private-sequence-statement] component-definition-statement [component-definition-statement] END TYPE [type-name] 其中 : 可选的访问说明 (access-specification) 为关键词 PUBLIC 或 PRIVATE 类型名称 (type-name) 需要由程序作者自己给出, 最好是有意义的英文词汇或缩写私用序列语句 (private-sequence-statement) 为 PRIVATE 语句和 SEQUENCE 语句每一条成员定义语句 (component-definition-statement)(r425) 包含一个数据对象的类型说明 (R502), 其句法形式为 : type-specification[ [, component-attribute-list] :: ] component-declaration-list 其中 : 类型说明 (type-specification) 表示一个固有数据类型, 或者是一个已经定义过的派生数据

67 类型, 不过如果这个描述符后面带有 POINTER 属性, 由于指针的赋值特性, 那么该成员就可以表示任意可访问的派生类型, 包括正在被定义的派生类型自身成员属性 (component-attribute)(r426) 只能是 POINTER 或 DIMENSION, 即对于指针性质的成员, 使用可选的属性 POINTER; 而对于数组成员, 使用可选的属性 DIMENSION, 后面还可以再加上数组描述 POINTER 和 DIMENSION 这两个属性可以同时出现成员声明 (component-declaration) 给出成员的名称成员声明 (R428) 的句法形式为 : component-name[(component-array-specification)] & [*character-length] [component-initialization] 其中 : 成员数组说明 (component-array-specification) 是可选项, 放置在括号当中如果该数组具有指针属性, 那么它的形状未定, 否则就是显形状在显形状的描述当中, 数组的界都必须是标量整型常量表达式如果在这里没有指出数组的界, 那么一定要在后面的 DIMENSION 属性里说明字符长度参数 (character-length) 是一个可选的标量整型字面常量, 它必须以星号开头当然这个参数只能用于修饰字符型成员成员初始化 (component-initialization)(r429) 取下面 2 种形式之一 : =initialization-expression =>NULL() 其中 : 初始化表达式 (initialization-expression) 用来说明非指针成员的默认初始值 =>NULL() 即把成员作为指针赋值为不带变元的固有函数 NULL 的结果, 表示指针成员的未结合或空置这 2 种初始结合状态初始化指针状态的用处在于, 很多情形下, 要设置一个指针, 都必须首先要求该指针具有确定的结合状态构造了一个派生数据类型之后, 要使用这个派生类型, 自然需要声明属于该类型的变量, 对于派生类型来说, 变量的声明采用如下句法形式 : TYPE(type-name)[,attribute-list::] entity-list 注意这个 TYPE 语句和定义派生类型的 TYPE 语句在句法上有差别 : 声明变量时,TYPE 后面必须接括号里面的变量所属派生类型名称 ; 而定义派生类型时, 后接不带括号的派生类型名称构造了一个派生数据类型之后, 经常需要引用其中的成员, 引用的句法形式为 : parent-structure % component-name 其中父结构 (parent-structure) 指需要引用的成员所属的派生数据类型 ( 或数据结构 ) 派生数据类型构造的一般规则如下 : 派生数据类型的定义当中给出的类型名称不能与任何固有数据类型的名称重合, 也不能与任何本模块能够访问的其他派生数据类型的名称重合必须保证该名称在它的有效作用域内是指称同一个类型对象而派生数据类型内部成员的名称的作用域只局限于该派生类型内部, 因此不同派生类型的成员可以使用相同的名称, 即使这些不同的派生类型属于同一

68 个作用域同样的, 不同作用域当中如果出现了相同的派生类型名称, 那么它们实际上是不相干的数据对象 END TYPE 语句后面或者省略类型名称, 或者后接该类型的名称, 不能出现不一致的情况一个作用域内, 一个派生类型的名称只能定义一次在一个派生类型的定义当中,PRIVATE 语句只能出现一次在一个派生类型的定义当中,SEQUENCE 语句也只能出现一次只有当一个类型定义是放置于一个模块的规则说明部分时, 才能使用访问控制符 PUBLIC 或 PRIVATE 只要派生类型的定义当中出现 SEQUENCE 语句, 就说明该派生类型的所有成员都必须具有顺序属性 ( 即其中也必须出现 SEQUENCE), 并且在定义中成员定义的次序就说明了该类型的对象的存储序列在一个派生类型的定义当中, 必须至少包含一个成员的定义在成员定义当中, 任何特定的成员属性都只能出现一次一个成员只有在具有指针属性时, 才可声明为属于被定义的派生类型本身任何非指针的数组成员, 都必须表示为显形状形式, 其上下界都是整型常量表达式如果成员是指定了长度的字符型数据, 那么它的长度必须是整型常量描述表达式如果没有指定长度值, 那么默认值为 1 如果进行成员初始化, 那么必须使用双分号间隔符在 2 种初始化方式中, 初始化表达式只能用于非指针变量, 也可以说等价赋值符号 (=) 只能用于非指针变量而固有函数 NULL() 则是用于指针变量的初始化表达式只能在派生类型的作用域当中取值一个派生类型内部的成员当中, 可以只有部分成员是默认初始化的, 即取得默认初始值, 或取得默认初始结合状态, 而不是一定要求所有成员都必须初始化一个成员如果是数组, 那么它的默认初始值必须满足数组的定义, 可以是一个数组构造器, 也可以是一个标量, 这个标量表示了该数组成员的每个元素的初始值下面给出不同情形下构造派生数据类型的例子 : 例 6-2 TYPE SET INTEGER N, M END TYPE TYPE (SET), DIMENSION (2, 2) :: a, b(3) 在这个派生类型的定义当中,a 和 b 都是属于派生数据类型 SET 的数组变量例 6-3 TYPE CURRENT REAL::HIGH=5.5, LOW=1.2 END TYPE CURRENT 在这个派生类型的定义当中给出了其唯一实型成员的初始值. 例 6-4

69 TYPE employee_name CHARACTER(25) last_name CHARACTER(15) first_name END TYPE TYPE employee_addr CHARACTER(20) street_name INTEGER(2) street_number INTEGER(2) apt_number CHARACTER(20) city CHARACTER(2) state INTEGER(4) zip END TYPE 在上面 2 个派生类型的定义当中, 一个派生数据对象是另一个派生数据对象的成员例 6-5 例 6-4 中定义的数据对象还可以被第 3 个数据类型引用, 如 : TYPE employee_data TYPE (employee_name) :: name TYPE (employee_addr) :: addr INTEGER(4) telephone INTEGER(2) date_of_birth INTEGER(2) date_of_hire INTEGER(2) social_security(3) LOGICAL(2) married INTEGER(2) dependents END TYPE 例 6-6 TYPE ARTICLE CHARACTER(LEN=100)ABSTRACT INTEGER LINES CHARACTER,POINTER::TEXT(:) END TYPE ARTICLE 在这个派生数据类型里面包含一个指针成员例 6-7 TYPE LINK INTEGER VALUE TYPE(LINK),POINTER::PREVIOUS=>NULL() TYPE(LINK),POINTER::NEXT=>NULL() END TYPE LINK TYPE (LINK),POINTRE::A_LINK ALLOCATE(LINK)

70 在这个派生数据类型当中, 指针成员的类型已经被定义, 这种派生数据类型被广泛应用于链表与树结构例 6-8 TYPE,PRIVATE::FILE INTEGER FILE_NO CHARACTER(LEN=30) FOLDER_NAME CHARACTER(LEN=10) ACCESS_LEVEL END TYPE 这个派生数据类型定义在一个模块当中, 但是对这个模块保持私用状态派生数据类型的取值, 运算, 以及常量表达式一个派生数据类型的值集就是它的成员的值集的乘积, 也就是它的成员的所有可能取值的所有可能的组合. 我们知道每个固有类型都有一个固定的值集, 在任何环境下引用固有类型, 这个值集都是一致的, 而派生类型的数据值集则完全是根据它的成分的数据值集确定的由于派生数据类型本质上是一种数据结构, 因此对派生类型对象的运算的定义, 需要使用具有 OPERATOR 界面的函数, 而赋值则使用具有 ASSIGNMENT 界面的子例行程序详细的有关子例行程序及其界面的讨论参见第 13 章上面给出的派生数据类型的定义过程, 实质上就是给出了一个语法机制, 根据这个语法机制构造出来的语言结构肯定能够被 FORTRAN 编译器识别为派生数据类型对象, 即或者是属于该派生数据类型的变量, 或者是属于它的变量的具体取值因此派生数据类型的定义自动给出它的取值的结构构造器, 该结构构造器生成一个数据序列, 其中每一个数据对应着该类型数据对象的一个成员的取值而该类型数据对象的所有成员的所有取值的任意组合, 正是该结构构造器所能生成的所有常量通过这样的结构构造器生成的常量, 也可以用来给定义为该派生类型的命名常量赋值由于派生数据类型的成员除了可以是固有数据类型之外, 还可以是任意的数据结构, 特别是设置为 FORTRAN 的一种重要的数据结构 - 数组在这种情况下, 特别定义了一种用来描述派生类型的数组成员的语法机制, 称为数组构造器当数组构造器的取值全是常量表达式时, 得到数组值常量表达式, 这样一个表达式可以作为一个命名常量的数组成员数组构造器不仅是可以用来给出一个数据结构的成员的值, 也可以用来给出任意数据类型的数组值数据结构构造器一个属于派生数据类型的常量的句法形式 (R431) 为 : type-name (expression-list) 其中类型名称 (type-name) 为某个派生数据类型的名称表达式列表 (expression-list) 为给出派生数据类型的各个成员值的表达式序列结构构造器的一般规则如下 :

71 结构构造器不能在它所代表的派生数据类型被定义之前出现, 也就是说它给出的派生类型名称不能置空结构构造器给出的值必须与 type-name 所指的派生类型的成员一一对应, 书写顺序也必须和派生类型定义里各成员的排列顺序保持一致为了保证与各个成员在类型, 种别参数, 长度以及秩的一致, 有时可能需要对值进行适当的转换如果派生类型包含数组成员, 那么在各个成员值的表达式序列当中数组的形状, 必须与类型定义当中的该数组成员的形状保持一致如果派生类型包含指针成员, 那么在各个成员值的表达式序列当中, 该指针所对应的值, 必须是相应指针赋值语句当中的有效目标如果结构构造器的所有成员值都是常量表达式, 那么该构造器实质上就构成一个派生类型的常量表达式例 6-9 考虑下面的派生数据类型 : TYPE EMPLOYEE INTEGER ID CHARACTER(LEN=40) NAME END TYPE EMPLOYEE 可以得到下面的结构构造器 : EMPLOYEE(5645, " 陈辉 ") 例子 6-10 下面的派生数据类型包含另外的派生类型作为成员 : TYPE ITEM REAL COST CHARACTER(LEN=30) SUPPLIER CHARACTER(LEN=20) ITEM_NAME END TYPE ITEM TYPE PRODUCE REAL MARKUP TYPE(ITEM) BOOK END TYPE PRODUCE 这时, 就需要使用内嵌的结构构造器来得到成员取值 : PRODUCE(.70, ITEM (.25, "XIN HUA", "A BOY")) 6.3 子串从符号的意义上来看, 下面两个数据对象都是属于字符串 : ASDFJASDF

72 如果我们把看成是标量, 那么没有理由不把 ASDFJASDF 也看成是标量然后进一步由标量构造成数组, 同样可以用字符串作为数组的分量, 由于字符串的参数就是它的长度, 因此在用字符串构成数组时, 有必要限制它们的长度保持一样要以长度为参数构造字符串, 一个自然的途径就是从一个字符串当中, 按照长度截取其连续的某个部分, 这就提出了子串的概念子串的句法形式 (R609) 为 : parent-string(substring-range) 其中父串 (parent-string) 的句法形式 (R610) 为以下诸种形式之一 : scalar-variable-name array-element scalar-structure-component scalar-constant 子串范围 (substring-range) 的句法形式 (R611) 为 : [starting-position]:[ending-position] 其中子串的始点和终点为标记父串里字符位置的下标的整型表达式, 始点为子串最左边的字符在父串里所处的下标表达式, 终点为子串最右边的字符在父串里所处的下标表达式, 显然, 始点和终点都处于 1 到 LEN 之间,LEN 为父串的长度如果始点值大于终点值, 那么系统认为该子串的长度为 0 给出始点和终点, 就能从父串截取到相应的子串子串的一般规则如下 : 字符串属于字符型数据类型, 父串与子串都是字符串字符串的下标是按照从左到右的顺序, 从 1 开始, 一直到 LEN,LEN 为字符串的长度子串是父串里从第 i 个字符开始, 到第 j 个字符结束的连续的一段字符串,I 和 j 都大于等于 1, 小于等于 LEN, 下标为 i 的字符称为子串的始点, 下标为 j 的字符称为子串的终点如果始点与终点的下标表达式的值不是整型, 则必须转换为整型如果 i 没有给出, 默认 i 为 1; 如果 j 没有给出, 默认 j 为 LEN 子串的长度可以是 0, 但不能是负值, 如果给出的 i 大于 j, 则系统认为子串的长度为 0 计算子串的长度使用函数 MAX, 公式为 : MAX(ending-position - starting-position + 1,0) 如果父串的长度为 0, 那么它的任意子串的长度都是 0 例 6-11 CHARACTER(10)signal_peptide signal_peptide = HLA-A*0301 signal_peptide(1:3) = HAI PRINT *, signal_peptide(7:10) 在这个例子里,signal_peptide 被定义为长度为 10 个字符的字符型变量, 在第一个赋值语句里, 该变量被赋值为字符串 HLA-A*0301, 在第二个赋值语句里, 该变量的下标从 1 到 3 的子

73 串被引用, 并且被赋值为字符串 HAI, 这样 signal_peptide 的值就变成了 HAI-A*0301, 接下来的打印语句的执行结果是打印下标从 7 到 10 的子串, 为 0301 例 6-12 CHARACTER*8 A, Asteroid Asteroid = '2000 DG8' A = Asteroid (1:4) 在这个例子里, 首先定义了长度为 8 的 2 个字符型变量 A 和 Asteroid, 然后给出 2 个赋值语句, 对字符型变量 Asteroid 赋值为 '2000 DG8', 而对 A 赋值为 Asteroid 的一个子串 '2000' 例 6-13 TYPE nearly_isotropic_comets INTEGER inclination REAL semi-major_axis, eccentricity, perihelion_distance, Absolute_Magnitude CHARACTER*12 designation END TYPE nearly_isotropic_comets TYPE(nearly_isotropic_comets) 2000YEAR CHARACTER*12 ASTEROID, BIG_INCLINATION(5) 由上面定义的字符串, 可以得到如下合法子串 : BIG_INCLINATION(2) (1:4)! 父串为数组元素 2000YEAR % designation(6:12)! 父串为结构成员 ASTEROID (1:4)! 父串为标量变量 ABCDEFGH (N:N+1)! 父串为字符常量如果一个数组的分量为字符串, 那么由这个数组构造子串, 可以有很多种合法的可能性, 例如, BIG_INCLINATION(:) (1:4), 表示对一个由子串组成的数组片断的引用 ; BIG_INCLINATION(1:4) (1:4), 同样表示一个由子串组成的数组片断的引用因此如果要从一系列长度一致的字符串构造相同下标范围的子串, 可以通过对数据组的片断引用而实现不过必须注意数组片断下标放置于子串下标之前由于表示数组片断的句法形式和表示子串下标范围的句法形式一样, 因此必须使用这个顺序安排, 才能得到无歧义的表示例 6-14 下面 2 个引用含义完全不同 : BIG_INCLINATION(:) (1:4) BIG_INCLINATION (1:4) 前者表示由 5 个子串构成的数组, 后者表示由 4 个父串构成的数组由 ABCDEFGH (N:N+1) 得到的子串既非常量, 也非变量, 因为它的下标是一个变量, 得到的子串称为常量子对象参见表达式的形式

74 6.4 结构成员所谓结构就是一个集合, 其元素可以是任意数据类型, 也可以是标量或数组, 一个结构至少包含一个元素, 这样的结构本身就是一种派生数据类型, 由同一类型的多个结构又可以组成一个数组因此我们可以看到, 结构的定义包含递归的成分, 这样能够保证提供最大的灵活性, 以便足够充分地描述实际问题当中出现的数据结构, 减少因为数据结构复杂而导致算法复杂的压力定义一个结构之后, 如果要引用其成员, 可以直接使用如下形式 : parent [%component [(section-subscript-list)]]... %component [(section-subscript-list)] 其中 : parent 为父结构名称百分符号 (%) 称为成员选择符 component 为其左边邻接父结构或成员的成员 section-subscript-list 表示片断下标列, 如果该下标列包含下标三元组或者向量下标, 那么就表示引用一个数组片断由于结构定义具有递归成分, 因此要引用结构的成员, 就会出现很多的情形, 更加抽象的理解是把结构成员的引用 (R614) 看是一种数据引用 (R612) 的形式所谓数据引用, 是把任何被引用的数据看成某个数据集合的部件, 这种包含关系可以任意多层地嵌套, 因此结构成员的引用也可以运用句法形式 ( 参见附录 B) 递归定义如下 : part-reference [%part-reference] 其中部件引用 (part-reference)(r613) 的形式定义为 : part-name [(section-subscript-list)] 其中片断下标 (section-subscript)( R618) 的形式定义为以下几种情况之一 : subscript subscript-triplet vector-subscript 有关数组片断的下标参见节结构成员引用的一般规则如下 : 结构成员的引用作为数据部件的引用, 要求被引用的部件是属于多个部件之中的一个作为结构成员引用的数据引用的最右边的被引用的部件, 必须是一个部件名称, 如果该部件引用具有形式 : part-name (section-subscript-list) 那么被引用的就是一个数组片断, 在最简单的情形下, 是一个数组元素在上述数据引用定义里, 除了最右边的部件名之外, 每一个部件名称都必须是指称一个派生类型数据对象数据引用时, 除了最左边的部件名之外, 每一个部件名称都必须是其左边邻接部件名称所表示的派生类型的成员在上述数据引用定义里, 任意位置的部件都可以是数组, 一个数组右边邻接

75 的成员不能具有指针属性如果父结构具有 INTENT, TARGET, 或 PARAMETER 属性, 则其结构成员也具有同样的属性在父结构还没有被声明之前, 其结构成员不能被引用结构成员如果含有非 0 秩的部件, 那么它的秩就是非 0 秩的部件的秩, 否则秩为 0 结构成员的类型和类型参量 ( 如果存在的话 ), 与最右边的部件保持一致例 6-15 下面定义一个包含 2 个成员的派生数据类型 : TYPE EMPLOYEE INTEGER ID CHARACTER(LEN=40) NAME END TYPE EMPLOYEE 然后声明变量 CONTRACT 属于派生数据类型 EMPLOYEE, 并且引用该变量的一个成员 TYPE(EMPLOYEE) :: CONTRACT CONTRACT%ID 例 6-16 下面定义一个派生类型作为另一个派生类型的成员 : TYPE DOT REAL X, Y END TYPE DOT... TYPE SCREEN TYPE(DOT) C, D END TYPE SCREEN 然后声明变量 M 属于派生类型 SCREEN, 并且引用该变量的几个成员 : TYPE(SCREEN) M M%C M%D (both of type DOT); M%C has components M%C%X M%C%Y of type REAL. 例 6-17 下面定义一个包含数组成员的派生类型 : TYPE CAR_INFO INTEGER YEAR CHARACTER(LEN=15), DIMENSION(10) :: MAKER CHARACTER(LEN=10) MODEL, BODY_TYPE*8 REAL PRICE END TYPE... TYPE(CAR_INFO) MY_CAR

76 例 6-18 下面定义派生类型以及属于该类型的 2 个变量 : TYPE CHARGE INTEGER PARTS(40) REAL LABOR REAL MILEAGE END TYPE CHARGE TYPE(CHARGE) MONTH TYPE(CHARGE) YEAR(12) 如下引用的数组都是合法的 : MONTH%PARTS(I)! An array element MONTH%PARTS(I:K)! An array section YEAR(I)%PARTS! An array structure component (a whole array) YEAR(J)%PARTS(I)! An array element YEAR(J)%PARTS(I:K)! An array section YEAR(J:K)%PARTS(I)! An array section YEAR%PARTS(I)! An array section 例 6-19 下面定义的派生类型包含一个已有定义的指针成员 : TYPE NUMBER INTEGER NUM TYPE(NUMBER), POINTER :: START_NUM => NULL( ) TYPE(NUMBER), POINTER :: NEXT_NUM => NULL( ) END TYPE 这样的结构可以用来构造链表, 注意其中的指针为默认的非结合初始状态例 6-20 下面定义一个私用派生类型 : TYPE, PRIVATE :: SYMBOL LOGICAL TEST CHARACTER(LEN=50) EXPLANATION END TYPE SYMBOL 这个派生类型属于模块私用类型, 该模块可以被其他作用域访问, 但该类型只能被本模块引用 6.5 数组数组同样是一个集合, 它的元素必须是标量, 其标量元素可以属于任何的固有数据类型, 派生数据类型, 甚至是结构, 但数组最关键的一个特征是 : 数组的所有标量元素必须属于同一个数据类型, 并且具有同样的种别参数

77 这个特征决定了数组是一种功能强大的数据结构, 因为存在大量的实际问题, 需要用同一个计算过程来处理大规模的同种类型的数据, 因此 FORTRAN 95 提供了强大的内部运算和固有函数, 专门用来处理整个数组, 或者数组元素, 或者数组片断, 同时硬件的并行化发展, 也为这一类通常是极大规模的运算, 提供了优化的解决方案在 FORTRAN 的早期版本里面, 数组是作为数据的一种属性加以描述的, 所使用的关键词为 DIMENSION 这个规则一直被保留下来, 因此任何数据对象只要是具有 DIMENSION 属性, 就一定为数组数组的结构数组的结构可以抽象地理解为多维离散空间的点的集合, 即这些点都有相同的维度, 在每一维上的坐标取值都是离散的标量格 : 一个具体的例子就是表格实际上表格总是可以用二维数组加以描述, 例如取上章的如下表表 6-1 表格可以看成数组作用单元的种类语句主程序模块数据块外部子程序模块子程序内部子程序接口块 USE 语句 Y Y Y Y Y Y Y ENTRY 语句 N N N Y Y N N FORMAT 语句 Y N N Y Y Y N 其他声明 Y Y Y Y Y Y Y DATA 语句 Y Y Y Y Y Y N 导出类型定义 Y Y Y Y Y Y Y 接口块 Y Y N Y Y Y Y 语句函数 Y N N Y Y Y N CONTAINS Y Y N Y Y N N 可执行语句 Y N N Y Y Y N 如果该表格的行, 即作用单元的种类看成是一个维度 a; 把该表格的列, 即语句的种类, 看成是另一个维度 b, 那么该表格的每一个元素都可以用符号 E 作用单元的种类, 语句的种类, 或者 E a,b, 来表示, 其中 a 可以取 7 个值 : 主程序, 模块, 数据块, 外部子程序, 模块子程序, 内部子程序, 接口块 b 可以取 10 个值 : USE 语句,ENTRY 语句,FORMAT 语句, 其他声明,DATA 语句, 导出类型定义, 接口块, 语句函数,CONTAINS, 可执行语句而每个元素 E a,b 取值为符号 Y 或 N 这样我们就把一个表格完全的用一个数组加以描述了从上面的例子可以看到, 数组的结构是由维度, 和每个维度的取值数目决定的其中 : 一个数组的维度的数目称为该数组的秩 ; 每个维度的坐标数目称为数组在该维度的宽度 ; 那么一个数组的秩和每个维度的宽度就决定了该数组的形状 ;

78 一个数组的所有维度的宽度的乘积, 称为该数组的尺度, 也就是该数组的元素的数目数组的秩至少可以达到 7, 这是 FORTRAN 标准所要求的任何编译器都必需达到的数组处理规模, 当然实际的编译器所能处理的数组的秩都要大于 7 同时 FORTRAN 标准对于宽度的大小没有限制数组的形状可以用类似于向量的形式表示, 即括号当中的一串标量数值, 用逗号相隔, 每个数值表示相应的维度的宽度例如 : REAL A(2,25,10) 这个数组可以用上面的语句来描述, 但是这里的描述方式更加具体地说明了数组的第 2 个维度的下标标示方式, 即用从 0 到 24 的下标了标示 25 个该维度的坐标显然数组 A 的尺度为可以用别的形式加以说明例 6-21 TARGET A(2,0:24,10), 即数组 A 包含 500 个元素同样形状的数组 A 还由于机器表达数据的有限性, 数组在每个维度上的坐标都必定有上下界, 当在数组描述时使用了下标, 那么最小下标值就是数组在该维度的下界, 最大下标值就是数组在该维度的上界必需注意的是这时数组的下标范围可以取任意的整数值范围, 而如果没有在数组说明当中说明下标范围, 只是给出其宽度 n, 那么数组在该维度的默认下标范围是 1:n, 即从 1 到 n 的自然数表示以实型数值为元素的数组 A, 含有 3 维, 每个维度的宽度分别是 2,25,10 在描述每个维度的宽度时, 可以使用下标范围的形式, 也就同时说明了该维度的元素的下标表示方法, 例如 : REAL A(2,0:24,10) DIMENSION A(2,0:24,10) 因此与上面同样形状的数组 A 还可以表示为 : REAL A(2, 5:29,10) 关于形状的描述里面的上下界的表示, 参见第 8 章的有关小节全数组 = 500 REAL,DIMENSION(2,0:24,10):: A COMMON A(2,0:24,10) REAL A(2,-5:19,10) 由于数组是一个数据结构, 因此对于数组的引用, 可以是引用整个数组, 也可以是引用数组的某个元素, 某些元素, 或数组的片断, 具体的分别在于, 如果是引用了数组的名称, 无论是一个常量数组的名称, 还是一个变量数组的名称, 只要在引用该数组名称时, 不包含该数组的下标列, 或数组片断的下标列, 那么就是把该数组作为一个整体加以引用, 即作为一个全数组一个全数组如果具有 INTENT,TARGET,PARAMETER 这些属性, 那么它的任意元素和片断都具有相应的属性 ;

79 一个全数组如果具有 POINTER 属性, 注意, 它的任意元素和片断都不具有相应的 POINTER 属性数组元素数组元素的引用很简单, 直接用下标给出该元素在每一个维度上的坐标即可例 6-22 声明 1 维数组 X 如下 : INTEGER,DIMENSION(25)::X 那么对 X 的元素的引用例子为 : X(3),X(12),X(24) 声明 3 维数组 A 如下 : REAL,DIMENSION(2,25,10):: A 那么对 A 的元素的引用例子为 : A(1,12,5),A(2,22,8),A(1,17,10) 这里的 (1,12,5) 等称为下标列数组片断数组最灵活的功能体现在能够以数组的任意部分为对象作运算, 把一个数组的任意指定部分作为一个新的数组, 称为数组片断, 而其所属的数组称为该数组片断的父数组数组片断的引用, 首先是一个父数组变量名称, 然后是下标列, 不过这里的下标列里面, 必需至少包含一个下标是用下标三元组, 或者是下标向量来表示的, 否则这个引用就成了对数组元素的引用下标三元组和下标向量的定义见下节例 6-23 下面是引用了一个数组片断 : INTEGER,DIMENSION(25)::X X(10:16)=78 上面定义了 1 维整型数组 X, 其宽度为 25, 后面引用了 X 的一个片断, 由 X 的第 10 个坐标到第 16 个坐标这 7 个元素组成, 在这个引用当中,X 所指定的这 7 个元素都被赋值为 78 注意这里的坐标引用 (10:16) 为一个省略了第 3 项的下标三元组数组元素和数组片断的句法形式数组元素的引用实质上就是数据引用, 因此数组元素的一般句法形式就是 R612 数组片断的一般句法形式 (R616) 为一个数据引用, 后接一个可选的包含在括号当中的子串范围子串范围的句法形式见 6.3 节的 R611 数据引用当中的组分名称可以后接一个可选的片断下标列, 片断下标的句法形式 (R618) 可以

80 是如下 3 种之一 : subscript subscript-triplet vector-subscript 其中下标三元组 (subscript-triplet) 的句法形式 (R619) 是 : [subscript]:[subscript]:[stride] 下标向量 (vector-subscript)(r621) 则就是一般的秩为 1 的整型数组表达式这里的下标和步长 (stride) 都必须是整型标量表达式一般规则如下 : 如果被引用数据是一个数组元素, 那么这个数据引用的每个部件引用都必需是秩为 0, 而最后的部件引用必需包含一个下标列如果被引用数据是一个数组片断, 那么必须有一个部件引用为非 0 秩, 并且或者是最后的部件引用非 0 秩的片断下标列, 或者是另外一个部件引用具有非 0 秩如果一个数组片断以后接子串范围的数据引用的形式出现, 那么最右边的部件名称必须是字符型在数组的每一个维度上, 片断的下标都必须给出例 6-24 下面都是合法的数组元素与数组片断的引用 : X(2,3) X(1:N:2,M) Y(:, :, :)(1:3) SCALAR_A % ARRAY_D(L) SCALAR_A % ARRAY_D(1:L) SCALAR_A % ARRAY_E(1:N)%SCALAR_D ARRAY_F(1:N:2) % ARRAY_G(I,J) % STRING( K)(:) TYPE REPAIR_BILL REAL PARTS (30) REAL LABOR END TYPE REPAIR_BILL TYPE VEHICLE CHARACTER(LEN=35)OWNER INTEGER MILEAGE TYPE(REPAIR_BILL)COST END TYPE VEHICLE TYPE(VEHICLE)BLACK_BURK YELLOW_XIALI PRINT*,BLACK_BURK % COST % PARTS PRINT*,YELLOW_XIALI % COST % LABOR PRINT*,BLACK_BURK % OWNER

81 TYPE(REPAIR_BILL)FIRST TYPE(REPAIR_BILL)FOR2000(10) 例 6-25 下面都是合法的标量父结构 : FIRST % LABOR FIRST % PARTS(I) FIRST % PARTS FIRST % PARTS(I:J) FOR2000(K)% LABOR FOR2000(K)% PARTS(I) FOR2000(K)% PARTS FOR2000(K)% PARTS(I:J) 例 6-26 下面都是合法的向量父结构 : FOR2000 % LABOR FOR2000 % PARTS(I) FOR2000(K:L)% LABOR FOR2000(K:L) % PARTS(I) 例 6-27 下面都是非法的向量父结构 : FOR2000(K:L) % PARTS! 非法 FOR2000(K:L) % PARTS(I:J)! 非法 FOR2000 % PARTS! 非法 FOR2000 % PARTS(I:J)! 非法 1. 下标在对数组元素作引用时, 每一个下标都必须处于该元素所属维度的下标上下界之中如果下标出现在数组片断的引用当中, 那就意味着该被引用的片断相对于其父数组缺少了相应的维度, 因此片断的秩也就相应地要减少 1, 因此在引用数组片断时, 如果父数组的某个维度只是以其上下界的某个坐标出现在其片断引用当中, 显然该维度实际上在其片断里就被压缩为 1 点了, 也就是减少了一个维度 2. 下标三元组所谓下标三元组是一种表示从在某个维度上连续取值的数组里, 有规律地按照固定间隔取数组片断的表达形式下标三元组的一般形式 (R619) 见上其中第一个数值表示取片断的相应维度上的下界 ; 第二个数值表示取片断的相应维度上的上界 ; 第三个数值表示在从上界到下界, 按照固定间隔取坐标时的步长下标三元组的一般规则如下 : 如果下界被省略了, 那么所取默认值为父数组所声明的下界 ; 如果上界被省略了, 那么所取默认值为父数组所声明的上界 ; 如果步长被省略了, 那么所取默认值为 1; 如果上下界和步长都被省略了, 而只剩下冒号 (:), 那么就是取整个维度范围 ;

82 如果步长为正整数, 那么该片断的下标为一个数列, 取值为从下界开始, 以步长为间隔, 递增直至不大于上界的最大下标值 ; 这时如果下界大于上界, 那么该片断的下标数列为空集 ; 如果一个片断的下标数列为空集, 那么该数组片断的尺度为 0; 步长不能取 0; 如果步长为负整数, 那么该片断的下标为一个数列, 取值为从下界开始, 以步长为间隔, 递减直至不小于上界的最小下标值 ; 这时如果下界小于上界, 那么该片断的下标数列为空集 ; 只要按照三元组所取的数组元素都包含在父数组的某个维度范围里面, 那么该三元组所给出的范围可以超出父数组所声明的相应维度范围例 6-28 如果数组 A 声明如下 : A(7,8,9) 而 A 的一个片断为 : A(4:7,5,3:4) 那么该片断的秩为 2, 比其父数组 A 的秩小 1, 因为该片断引用当中的第 2 个维度出现了一个单独的下标, 故维度减小了 1; 而片断的形状为 (4,2), 尺度为 8, 它的 8 个元素为 : A(4,5,3) A(4,5,4) A(5, 5,3) A(5,5,4) A(6,5, 3) A(6,5,4) A(7,5,3) A(7,5,4) 例 6-29 给出数组 A(100), 而它的一个片断为 A(45:28:-5), 那么该片断的秩为 1, 形状为 (4), 尺度为 4, 它的所有元素为 : A(45) A(40) A(35) A(30) 而如果取其片断为 A(45:28), 这时默认步长为 1, 显然其尺度为 0; 如果取其片断为 A(25:110:35), 尽管第 2 个下标超出了父数组 A 的下标范围, 但是该片断的元素却没有超出父数组的元素范围, 因此这种片断取法是合法的, 它的所有元素为 : A(25) A(60) A(95) 3. 下标向量鉴于依靠下标三元组所截取的数组片断是具有规则形式的数组片断, 当我们需要其他形式的

83 数组片断时, 三元组就无法胜任相应的描述数组的任务了, 因此 FORTRAN 给出了一种具有最大的灵活性的截取数组片断的方式, 即下标向量所谓下标向量, 就是由一些下标值构成的一个向量, 这些下标值取自父数组在某个维度上的下标范围, 由与这些下标值相应的坐标就构成了父数组的一个数组片断例 6-30 INTEGER I(10) REAL A(100) I=(/ 23,35,11,46,57,65,78,89,90,1/) A(I)=3.34 这段例程里首先定义了 2 个秩为 1 的数组变量 I(10) 和 A(100), 也即向量, 然后在后面用赋值语句给出 I 的一个具体赋值, 接着以 I 为数组下标变量, 给出了数组 A 的部分元素的一个具体赋值, 实际上, 这里 I 就是下标向量, 而 A(I) 则是由下标向量 I 所给出的父数组 A(100) 的一个数组片断注意其中根据向量 I 的赋值,A 的片断截取是任意顺序的, 这就体现了利用下标向量来截取数组片断的特点不过虽然由下标向量来截取数组片断具有极大的灵活性, 但是根据下标向量而得到的数组片断具有如下限制 : 1. 不能作为外部文件 ; 2. 不能作为指针目标 ; 3. 不能作为哑元 INTENT(OUT) 或 INTENT(INPUT) 的实元下标向量的构成允许出现重复的元素, 例如在上面的例子里面, 下标向量 I 可以赋值为 : I=(/ 23,35,23,46,57,65,78,89,90,1/) 这样 A(23) 就会被访问 2 次, 即 A(I(1)) 和 A(I(3)), 这样得到的数组片断仍然是合法的, 被称为多对一数组片断, 这样的数组片断不能出现在如下场合 : 赋值语句当中等号的左边 ; READ 语句的输入项下标, 下标三元组和下标向量的混合使用上面说明了如何分别使用下标, 下标三元组和下标向量这三种方式来截取数组片断, 实际上, 这三种方式可以根据具体问题的要求来混合使用, 下面是 1 个例子例 6-31 给出父数组 A 如下 : A(20,10,20) 可以构造 A 的一个数组片断如下 : A(4:22:7, 9, 10:15:3) 该片断的所有元素如下 : A(4,9,10) A(11,9,10)

84 A(18,9,10) A(4,9,13) A(11,9, 13) A(18,9,13) 然后我们还可以给出下标数组 ( 向量 ): INTEGER DIMENSION(4)::I=(/3,7,3,9/) 运用这个下标向量可以构造数组片断 : A(10:20:8, I, 14) 该数组片断的所有元素为 : A(10,3,14) A(18,3,14) A(10,7,14) A(18,7,14) A(10,3,14) A(18,3,14) A(10,9,14) A(18,9,14) 可以看到其中包含了重复的元素, 即多对一数组片断数组元素序由于计算机在实质上只能按照一维的串行顺序来处理数据, 因此对于高于 1 维的数组, 就产生一个如何表达其中数据的问题, 这就需要约定一个统一的把多维数组转化为一个便于计算机处理的数据序列的方法, 按照这个统一约定得到的数列就表示了数组元素的顺序, 即数组元素序由于一个多维数组的各个维度是可以用序列的方式表示出来的, 因此一个自然的表达数组元素序的方法就是, 规定数组维度的顺序即各个维度被依次遍历的顺序, 例 6-32 取如下 2 维数组 : A(2,3) 按照它的形状的表示方法, 它的第 1 维有 2 个下标, 第 2 维有 3 个下标, 那么这个数组的元素的排列顺序就是 : A(1,1),A(2,1),A(1,2),A(2,2),A(1,3),A(2,3) 即先遍历第 1 维的 2 个下标而保持第 2 维的下标不变, 然后再遍历第 2 维的下标, 直观地看, 就是依照数组元素顺序排列下来后, 第 1 维的下标的变化最快, 而最后 1 维的下标变化最慢, 其他维度的下标的变化依次类推对于按照数组元素序排列的数组元素数列, 可以给以这个数列本身的下标标记, 这个下标称为下标顺序值按照上面约定的从多维数组到串行序列的转换规则, 可以给出一般的多维数组的元素的下标顺序值的计算公式

85 当然, 对于一个数组片断, 它的元素的下标顺序值不能指定为其所在父数组里的下标顺序值, 而只能是把该片断本身看成一个数组之后, 重新给出的下标顺序值例如对于数组 A(10), 取其片断 A(2:9:3), 该片断元素包括 A(2),A(5),A(8), 对于 1 维数组 A(10) 来说, 这些元素的下标顺序值就是它们的下标, 即 2,5,8 而对于数组 A(2:9:3) 来说, 它们的下标顺序值却分别是 1,2, 数组构造器所谓数组构造器就是给数组元素赋值时的句法形式, 即数组元素的写法由于语言的表述在本质上只能是一个字符串, 因此数组元素的取值的写法只能是针对 1 维数组而言, 因此数组构造器在形式上得到的是一个秩为 1 的数组的元素具体取值作为一个秩为 1 的数组的元素, 自然的形式就是一个元素组成的序列, 但是为了在句法上标志其构成一个数组, 约定使用一对括号与斜线把所有元素值和其上下文区分开, 因此一个数组构造器的句法形式 (R432) 为 : (/ ac-value-list /) 数组构造器元素取值列 (ac-value-list) 中的元素取值作为数据对象, 可以是表达式 (R723), 或者是隐性 do 变量取值 (R434), 所谓隐性 do 变量取值是直接以变量的形式来表示 do 结构含义的变量的具体取值例 6-33 ( SQRT(REAL(K)),K=10,13) 这里 REAL(K) 为变量形式,(SQRT(REAL(K)),K=10,20) 则具有 do 结构的含义, 经过 K 的具体取值, 得到一个数组 : (/ 3.162,3.317,3.464,3.606 /) 它的一般句法为 : (ac-value-list,ac-do-variable=scalar-integer-expression,& scalar-integer-expression [,scalar-integer-expression]) 其中数组构造器值可能有三种形式 : 标量表达式例 6-34 /2.4,6.4,2.4,2.5,9.8/) 数组表达式例 6-35 (/X(1:10,I),X(30:30,I-2)/) 隐式 do 变量例 6-36 (/(SQRT(REAL(I)),I=0,10)/)

86 数组构造器的一般规则为 : 数组构造器里的每一个元素取值都必须是相同的数据类型, 相同的种别参数, 相同的长度参数数组构造器的数据类型与种别参数就是它的表达式取值的数据类型与种别参数如果数组构造器不含有表达式或者其隐性 do 变量无法实际取值, 那么得到一个秩为 0, 尺度为 0 的数组数组构造器 do 变量必须是标量整型命名变量, 该变量具有数组构造器 do 变量的作用域如果一个数组构造器 do 变量包含在另一个数组构造器 do 变量里面, 它们不能是同一个变量第 7 章属性的声明最后, 对于数据我们剩下的工作, 就是如何运用 FROTRAN 语言来完整地加以描述 FORTRAN 语言完成对数据的描述的语法单位是数据声明语句, 在前面 2 章里面, 我们整理好问题当中需要涉及的数据及其结构之后, 要以 FORTRAN 语言写下来, 就是使用 FORTRAN 的声明语句, 这些语句的句法设计保证能够完备的描述我们关于数据所需要说明的一切属性数据对象首先需要予以说明的当然就是它的类型, 因此我们首先给出对象的类型声明语句, 特别地, 需要说明在最初 FORTRAN 标准里面遗留下来的一种数据类型描述方法隐式类型描述法, 然后讨论各种数据对象所可能具有的属性数组属性 ; 指针属性 ; 值特征 ; 对象可访问性与使用属性 ; 特征兼容性 ; 自动数据对象 ; 存储关联由于本章集中讨论 FORTRAN 的声明语句, 而声明的对象除了数据之外, 其他的程序对象, 例如函数, 过程等也需要声明其类型或属性, 因此本章一并讨论对其他程序对象的声明 : 过程属性 ; NAMELIST 语句 ; 7.1 属性及其声明方式所谓一个对象的属性, 就是程序使用该对象的方式本章所讨论的属性的大体分类与作为其名称的关键词见表 7-1:

87 表 7-1 属性的分类及其关键词数据类型 INTEGER REAL( 以及 DOUBLE PRECISION) COMPLEX LOGICAL CHARACTER TYPE( 派生类型的名称由用户命名 ) 数组属性 DIMENSION ALLOCATABLE 指针属性 POINTER TARGET 值设置 DATA PARAMETER 对象可访问性与调用 PUBLIC PRIVATE INTENT OPTIONAL SAVE 过程属性 EXTERNAL INTRINSIC 对象关系属性 NAMELIST EQUIVALENCE COMMON 这些关键词的使用, 或者说属性的声明有 2 种方式 : 在类型声明时附加属性说明, 这种语句形式侧重在给出数据对象, 属性说明是附加的 ; 使用单独的属性声明语句, 这种语句形式侧重在说明属性本身之所以会出现 2 种声明方式, 完全是历史的缘故 FORTRAN 的早期版本里, 任何的对象属性说明, 都是运用单独的属性声明语句, 如果一个数据对象同时具有多种属性, 就需要使用相应的多个属性声明语句, 从程序阅读的角度来看, 会显得很烦琐, 因此到了 FORTRAN90 和 95 版本, 只要在程序单元当中需要声明一个数据对象的类型, 那么就可以把它的其他所有属性都附加到它的类型声明语句当中, 使得程序显得更加紧凑例 7-1 我们要定义 2 个实型变量 X,Y, 同时还要声明它们都具有指针属性, 在早期 FORTRAN 语言里写为 : REAL X,Y POINTER X,Y 换一种更加紧凑的写法就是把这 2 条语句写为 1 句 : REAL POINTER::X,Y 之所以我们还需要讨论单独的属性语句, 主要是有时候需要保持源码的向前兼容性, 而且在少数情况下, 这 2 种形式也并完全等价因此在本章在讨论各种属性的声明方式的时候, 将首先

88 给出面向数据对象的声明方式, 然后给出等价的面向属性的声明方式在这 2 种表示属性的方式里, 同样由于历史的缘故, 数组的维度属性 DIMENSION 既可以附加在类型声明语句当中表述, 也可以单独声明, 实际上 DIMENSION 这个关键词属于老式 FORTRAN 的遗留物, 在新的表述方式里面, 完全可以省略它例 7-2 COMPLEX X DIMENSION X(35) SAVE X COMPLEX X(35) SAVE X COMPLEX,DIMENSION(35),SAVE::X COMPLEX,SAVE::X(35) 以上 4 种表述方式是完全等价的, 显然最后一种最简洁在一个程序单元里面, 引用一个数据对象的前提是已经声明了它的种种必需属性, 数据对象的各种属性里面, 最为基本的当然是数据对象的类型, 然后还需要声明其各种必需的属性, 这样该数据对象才能被程序正确地调用访问然而在一个实际的程序里面, 数据对象的声明在表面上可能并不是完备的, 同时又不是非法的语法, 出现这种情况的原因如下 : 在 FORTRAN 的早期版本里, 为了求简化的缘故, 使用了一种隐式约定数据类型的方式, 即通过数据对象的名称的第一个字母来分辨其所属类型, 这种类型声明方式被后来的 FORTRAN 版本一直沿用下来了, 因此如果一个程序单元里出现的数据对象没有经过类型声明语句的专门声明, 则需要考虑其是否属于隐式声明相反, 如果想排除这种隐式声明的影响, 则需要另外单独加以 IMPLICIT NONE 语句作为声明任何其他的属性如果没有出现的话, 或者是因为该数据对象不需要某种属性, 或者是该数据对象的某种属性采取了默认设置从上面的分类表 7-1 可以看到,FORTRAN 的属性除了用来说明数据类型的属性之外, 其他属性都是针对不同的数据类型或程序对象, 以及它们的各种特征的例如数组属性只是用来说明数组, 指针属性只是用来说明指针, 而过程属性只是用来说明过程, 下面将分类讨论这些属性 7.2 类型声明语句我们在讨论第 5 章讨论数据类型的时候给出数据类型的基本声明语句的句法形式, 这里将侧重于数据类型的声明与其他相关属性的兼容, 因为从语言的简洁与自然的角度出发, 把一个数据对象的类型和其他属性都归结为一条数据声明语句是非常可取的, 所以我们得到如下的一般的类型声明句法形式 (R501): type-specification [[,attribute- specification] :: ] entity-declaration-list 即作为选项, 在一条数据对象的类型声明 (type-specification) 语句当中, 在数据项声明的列表 (entity-declaration-list) 之前, 给出相应的属性说明 (attribute- specification), 方括号 [] 表示可选

89 类型说明 (type-specification) 的一般句法形式 (R502) 是如下几种形式之一 : INTEGER [kind-selector] REAL [kind-selector] DOUBLE PRECISION COMPLEX [kind-selector] CHARACTER [character-selector] LOGICAL [kind-selector] TYPE(type-name) 其中种别选择符 (kind-selector) 的句法形式 (R506) 为 : ([KIND = ] kind-value) 其中种别值 (kind-value) 是一个标量整型表达式属性说明 (attribute- specification) 的一般句法形式 (R503) 为如下几种形式之一 : PARAMETER ALLOCATABLE DIMENSION(array- specification) EXTERNAL INTENT(intent-specification) INTRINSIC OPTIONAL POINTER SAVE TARGET access- specification 其中的可访问性说明 (access- specification) 包括 PUBLIC 和 PRIVATE 数据项声明的一般句法形式 (R505) 为如下 2 种形式之一 : object-name [(array- specification)] [*character-length] [initialization] function-name [(array- specification)] [*character-length] 其中初始化 (initialization) 的一般句法形式 (R505) 为如下 2 种形式之一 : = initialization-expression =>NULL() 类型声明的一般规则如下 : 对数据对象的说明优先于隐式类型描述, 即隐式类型描述法永远只是在数据对象没有获得任何说明的情况下的默认法则, 而显式说明既可以与隐式法则一致, 也可以不一致在一个类型声明语句当中, 同一个属性只能出现一次在一个作用域内, 一个数据项的任何属性只要约定了一次, 就不可再次约定种别选择符所取的种别值只能是编译系统所许可的相应类型的种别参数之一字符长度 (character-length) 选项只能出现在 CHARACTER 类型的声明语句当中

90 如果使用初始化语句, 则必须在数据项声明前使用双冒号 (;;) 如果数据变量被初始化设置为数组, 那么该数组的形状一定要得到说明, 或者是在类型声明语句当中, 或者是在同一个作用域内此前的属性声明语句当中如果数据对象被赋予 PARAMETER 属性, 那么其中必须包含初始化语句如果在初始化语句当中出现符号 =>, 那么该被初始化的对象必定具有 POINTER 属性 ; 如果在初始化语句当中出现符号 =, 那么该被初始化的对象肯定不具有 POINTER 属性所谓函数名称 (function-name), 或者是一个外部函数的名称, 或者是一个固有函数的名称, 或者是一个函数哑过程的名称, 或者是一个语句函数的名称一个数组函数名称或者是被指定为显形数组, 或者是具有 POINTER 属性, 从而被指定为待定形数组有关属性声明的其他规则以及属性之间的兼容性在后面会详悉讨论例 7-3 下面是一些附加了其他属性的数据类型声明语句 : REAL, INTENT(IN) :: COS REAL, INTRINSIC :: SIN INTEGER X(25) LOGICAL,DIMENSION(10,15)::RESULT1,RESULT2 INTEGER,PARAMETER::SHORT=SELECTED_INT_KIND(4) COMPLEX :: SQUARE_ROOT = ( 2.76, -0.85) REAL, ALLOCATABLE :: X( :, : ) TYPE, POINTER :: CURRENT_OF_SAMPLE => NULL() 整型 INTEGER 语句声明了整型数据对象的名称, 同时也可以附加种别参数以及其他属性如果给出种别选择符, 即说明该整型数据的表示方法声明一个数据对象属于整型数据的基本语句句法为 : INTEGER [ ( [ KIND = ] kind-value ) ] [ [, attribute-list] :: ] entry-list 例 7-4 以下这些声明语句主要是要说明数据项 : INTEGER X INTEGER DIMENSION(:), POINTER :: days, hours INTEGER(SHORT)RED_BALL INTEGER(2) POINTER :: k, limit INTEGER(1) DIMENSION(10) :: min 例 7-5 以下这些声明语句主要是要说明数据的属性 : INTEGER days, hours INTEGER(2) k, limit INTEGER(1) min DIMENSION days(:), hours(:), min (10)

91 POINTER days, hours, k, limit 实型 REAL 语句声明了实型数据对象的名称, 同时也可以附加种别参数以及其他属性如果给出种别选择符, 即说明该实型数据的表示方法双精度实型数据还可以使用 DOUBLE PRECISION 语句加以声明, 当然与在 REAL 语句当中使用种别参数是完全等价的由于 DOUBLE PRECISION 本身指出了精度表示方法, 因此不能再在后面附加种别选择符不过 DOUBLE 这个词也可以作为一个命名整型常量, 取双精度实型的种别参数值, 这样就可以使用 REAL(DOUBLE) 来声明双精度实型数据了实型数据的声明的格式如下 : REAL [ ( [KIND=] kind-value ) ] [ [, attribute-list] :: ] entry-list DOUBLE PRECISION [,attribute-list] :: ] entry-list 例 7-6 下面是各种形式的主要说明数据项的声明语句 : REAL (KIND = high), OPTIONAL :: testval REAL, SAVE :: a(10), b(20,30) DOUBLE PRECISION,POINTER::A,B(:,:) DOUBLE PRECISION,DIMENSION(5,10)::TABLE1,TABLE2 REAL(DOUBLE),POINTER::A,B(:,:) REAL(DOUBLE),DIMENSION(5,10)::TABLE1,TABLE2 例 7-7 下面是各种形式的主要说明数据属性的声明语句 : REAL (KIND = high) testval REAL a(10), b(20,30) OPTIONAL testval SAVE a, b DOUBLE PRECISION TABLE1,TABLE2 DIMENSION TABLE1(5,10),TABLE2(5,10),B(:,:) POINTER A 可以比较什么两种表示方法, 在说明了同样的意思的前提下, 把属性说明附加在数据类型说明语句当中, 比每一种属性单独一个语句加以说明要简洁自然得多复型 COMPLEX 语句声明了复型数据对象的名称, 同时也可以附加种别参数以及其他属性如果给出种别选择符, 即说明该复型数据的表示方法说明复型数据类型的句法为 : COMPLEX [([KIND = ] kind-value ) ] [ [, attribute-list] :: ] entry-list 例 7-8 下面是各种形式的复型数据对象声明语句 :

92 COMPLEX ch COMPLEX (KIND=4),PRIVATE :: zz, yy! 等价于 COMPLEX*8 zz, yy COMPLEX(8) ax, by! 等价于 COMPLEX*16 ax, by COMPLEX (kind(4)) y(10) complex (kind=8) x, z(10) 逻辑型 LOGICA 语句声明了逻辑型数据对象的名称, 同时也可以附加种别参数以及其他属性如果给出种别选择符, 即说明该逻辑型数据的表示方法说明逻辑型数据类型的句法为 : LOGICAL [([KIND = ] kind-value ) ] [ [, attribute-list] :: ] entry-list 例 7-9 下面是各种形式的主要说明逻辑型对象的声明语句 : LOGICAL, ALLOCATABLE :: flag1, flag2 LOGICAL (KIND = byte), SAVE :: doit, dont 例 7-10 下面是各种形式的主要说明对象的属性的声明语句 : LOGICAL flag1, flag2 LOGICAL (KIND = byte) doit, dont ALLOCATABLE flag1, flag2 SAVE doit, don t 字符型 CHARACTER 语句声明了字符型数据对象的名称, 同时也可以附加种别参数以及其他属性如果给出字符选择符, 即说明该字符型数据的最大字符长度说明字符型数据类型的句法为 : CHARACTER [character-selector] [, attribute-list :: ] entry-list 其中的字符选择符 (character-selector) 的句法形式 (R507) 可以为如下几种 : length-selector (LEN =length-value, KIND = kind-value ) (length-value, [ KIND = ] kind-value ) (KIND = kind-value [,LEN =length-value] ) 其中长度选择符 (length-selector) 的句法形式 (R508) 可以是 : ([LEN =] length-value) * character-length[,] 其中字符长度 (LEN)(R509) 可以是 : (length-value) scalar-integer-literal-constant 其中长度值 (length-value)(r510) 可以是 :

93 specification-expression * 在上面的类型说明当中, 使用星号 * 来标志字符长度的方式属于过时的方式, 不过不是指在数据项里面使用的星号 * 字符型数据对象类型声明语句的一般规则如下 : 只有在没有使用双冒号的情况下, 在长度选择符里才可以使用逗号字符型数据对象的字符长度在一定的情形下, 是可以发生动态变化的, 即当一个字符型数据的声明语句出现在一个过程或者是过程界面当中, 同时该数据对象又不是某个派生数据对象的成员, 那么它的字符长度可以使用非常量表达式, 该表达式的具体取值只有当访问该过程时才被确定, 并且当该过程的运行时, 表达式里变量的变化并不影响字符长度值这样一种数据对象如果不属于哑元, 则属于自动数据对象的范畴字符长度的说明有三种情形 : 首先在数据项或数据项列的成员里给出字符长度 ; 如果没有上面的长度说明, 则在数据类型说明部分给出命名字符数据项或派生类型定义当中的字符成员的字符选择符, 用来给出长度属性 ; 如果一个字符型数据既没有使用字符选择符, 也没有使用字符长度来说明其长度, 那么默认的字符长度为 1 如果长度参数取负值, 那么相应的字符项长度为 0 给定了字符长度的标量整型文字常量不能再附加任何种别参数, 否则在固定源码形式里面就会导致歧义采用带星号 * 的长度说明只能使用于以下几种情形 : 可以应用于过程的哑元, 当过程被调用时, 哑元就被赋予相应实元的长度 ; 可以用于声明命名常量, 这时它的长度是一个常量值 ; 可以用于声明一个外部函数的结果变量的长度任何调用该函数的作用域单元如果使用带星号的长度说明, 就意味着主程序可以访问该声明当函数被调用的时候, 结果变量的长度的取值由引用该函数的程序单元里面的相应声明语句决定本规则暗示了在 IMPLICIT 语句当中不能使用带星号 * 的长度说明方式如果一个函数属于内部函数或模块函数, 或者该函数的值为数组, 指针或递归形式, 那么该函数名不能使用带星号 * 的长度声明字符值语句函数或字符型语句函数哑元的长度必须是整型常量表达式例 7-11 下面是各种形式的主要说明字符型数据对象的声明语句 : CHARACTER (LEN=25,KIND=GREEK),DIMENSION(11)::Z1 CHARACTER (LEN=20,KIND=KANJI),SAVE::GREETING(2) CHARACTER (10)::QUESTION= WHERE? CHARACTER (LEN=*,KIND=CHINESE),PARAMETER::MESSAGE = & 简朴是语言的一种美德 CHARACTER (*),INTENT(IN)::SCHOOL, HOME CHARACTER *3, SAVE :: COMPONENT_1, LONGER(9) *20, COMPONENT_2 CHARACTER :: RESULT = PASS 例 7-12: 下面是各种形式的主要说明字符型数据的属性的声明语句 : CHARACTER (70)PROJECT

94 CHARACTER (LEN=30, KIND=GERMAN)TRANSFORMATION CHARACTER (LEN=25,KIND=GREEK)Z1 CHARACTER (LEN=20,KIND=KANJI)GREETING(2) CHARACTER (10)QUESTION CHARACTER (*)SCHOOL, HOME CHARACTER *3 COMPONENT_1, LONGER(9) *20, COMPONENT_2 CHARACTER RESULT SAVE GREETING(2) INTENT(IN)SCHOOL, HOME DAT A QUESTION / WHERE? / CHARACTER (*)MESSAGE PARAMETER( MESSAGE = & 简朴是语言的一种美德 ) 派生类型 TYPE 语句声明了用户派生数据类型对象的名称, 派生类型的名称写在紧跟 TYPE 后面的一对括号当中, 声明派生类型的数据对象的一般句法为 : TYPE(type-name)[, attribute-list :: ] entry-list 派生类型声明语句的一般规则如下 : 如果一个派生类型对象是私有的话, 就不能附加 PUBLIC 属性结构构造器必须用来初始化派生类型数据对象, 结构构造器里的表达式必须是初始化表达式如果需要声明的派生数据对象是一个函数的结果, 那么它就可以在 FUNCTION 语句当中予以说明例 7-13 下面是各种形式的主要说明派生数据对象的声明语句 : TYPE(SAMPLE),DIMENSION( :),ALLOCATABLE::STOVE TYPE(STUDENT),SAVE::GRAD(5) TYPE(HOMEWORK),SAVE::QUESTION,TAPE,WORD_SHEET 例 7-14 下面是各种形式的主要说明派生数据对象的属性的声明语句 : TYPE(SAMPLE)STOVE TYPE(STUDENT)GRAD(5) TYPE(HOMEWORK)QUESTION,TAPE,WORD_SHEET DIMENSION STOVE( :) ALLOCATABLE STOVE SAVE GRAD(5), QUESTION,TAPE,WORD_SHEET 注意上面这两种说明方法里面标点的不同用法 7.3 隐式类型描述法当初 FORTRAN 使用隐式类型声明方法, 是与语言的简朴形态相适应的, 在硬件资源相对紧

95 缺的时代, 简朴也能成为语言的一种美德, 不过如果到了硬件资源相对富余的今天, 还吝啬于增加几个关键词和几条声明语句, 就会显得很落伍了, 所以后来就增加了更为接近自然语言的声明语句, 不过, 为了缅怀 FORTRAN 语言作为祖母级高级语言的荣耀, 隐式类型声明方式还是保留下来了, 甚至默认为总是起作用, 除非首先声明了 IMPLICIT NONE 语句当然, 只要你乐意使用, 这种类型声明方式在某些情况下, 还是非常方便简明的隐式类型声明方法的出发点, 是考虑到任何需要加以类型声明的对象, 如变量, 命名常量, 函数等, 都需要一个名称来指称, 那么就可以把它的类型这个信息负载在它的名称上, 最简单的约定, 就是让名称的第一个字母来标记它的类型, 例如在默认的情形下 : REAL: A B C D E F G H INTEGER: I J K L M N REAL: O P Q R S T U V W X Y Z 可以发现, 上面对字母的默认分配并不是很难记忆,FORTRAN 沿用了数学里的很多习惯, 这里使用 I,J,K,L,M,N 来表述整数, 就是一个明显的数学习惯除了上面默认的首字母隐式类型法则, 隐式类型声明方法还有很灵活的一面, 即利用 IMPLICIT 语句来自定义字母分配模式, 一般的 IMPLICIT 语句的句法形式 (R541) 有 2 种, 分别行使不同的功能 : IMPLICIT type-specification(letter-specification-list) IMPLICIT NONE 其中的字母分配说明列表的句法形式 (R543) 为 : letter[-letter] 这里 IMPLICIT 后面的字母分配表定义可以完全是自由定义, 并且只是在该语句的作用域内有效, 而任何名称在它的作用域内只要是没有专门的类型声明语句, 也没有 IMPLICIT 语句, 那么它就遵循上面的默认首字母隐式类型法则隐式类型的一般规则如下 : 如果要使用 IMPLICIT NONE 语句, 那么它必须放置在任何 PARAMETER 语句之前, 并且在其作用域内, 再也不能出现其他 IMPLICIT 语句 IMPLICIT 语句当中出现的表述字母范围的 letter-letter, 左边的字母绝对不能是右边字母的按照字母表顺序的后面的字母 letter-letter 的字母之间为减号, 而非下划线, 表示按照字母表顺序从左边字母到右边字母的所有字母在一个作用域里面的 IMPLICIT 语句里面, 同一个字母不能出现在字母分配说明列表里面的不同项里, 例如作为单个字母出现了, 又同时处于另一个字母范围之中, 或同时处于 2 个不同的字母范围里面 IMPLICIT 语句同样可以用来为派生数据类型分配首字母作为类型标记默认的首字母隐式类型法则与 IMPLICIT 语句之间的关系值得特别加以注意例如给出约定 : IMPLICIT COMPLEX(E-G,W-Z) 然后在该语句的作用域里再也没有其他 IMPLICIT 语句, 也没有类型声明语句, 那么在该作用域内具有不属于 (E-G,W-Z) 这个范围的首字母的变量, 将遵循默认首字母分配表, 即首字母在

96 范围 (A-D,H,O-V) 内的变量属于实型, 而首字母在范围 (I-N) 内的变量属于整型 IMPLICIT NONE 可以用来检查名称的错误拼写, 因为如果不加以这个语句的话, 即使错误拼写的名称, 也会被看成遵循首字母隐式类型声明方法的具有确定数据类型的变量, 从而能够通过语法检查, 反之使用该语句, 就可以避免这种误解例 7-15 下面的 IMPLICIT 语句都是合法语句 : IMPLICIT CHARACTER*30(B,T),COMPLEX(W-Z) IMPLICIT LOGICAL(KIND=BIT)(Q) IMPLICIT REAL(QUAD)(X-Z) IMPLICIT TYPE(NUMBER)(A-E) IMPLICIT TYPE(ARTICAL)(A,V),CHARACTER*100(B) 例 7-16 下面的 IMPLICIT 语句都是非法语句 : IMPLICIT CHARACTER*30(B,T),COMPLEX(Z -W)!W 应该放置在 Z 之! 前 IMPLICIT LOGICAL(KIND=BIT)(Q),REAL(QUAD)(P-T)!Q 同时表! 示 2 种类型 IMPLICIT TYPE(ARTICAL)(A-H),CHARACTER*100(B,Q)!B 同时表! 示 2 种类型使用隐式类型声明在一个嵌套作用域里面所导致的变量作用域混乱问题在有关作用域之间通讯时再讨论 7.4 数组属性数组的概念来源于数学的向量概念, 最大的特点就是数组的各个分量必须是同一种数据类型, 同样的种别参数, 具有同样的属性, 因此数组本身作为一个数据对象, 最主要的属性就只剩下它的维度, 也就是它的秩作为一个变量的数组可以有多种形式, 除了它的分量可以发生变化之外, 它的维度也可以发生变化, 有 3 种情形需要数组的维度不予固定 : 在程序运行当中, 数组所占据的存储空间不是固定的, 而是可重新分配的, 这意味着该数组必定具有 ALLOCATABLE 属性 ; 该数组被赋予指针的属性, 使得它的维度无法预先固定下来 ; 该数组本身就是一个哑元, 它的维度依赖于别的变量对它的赋值情况因此数组本身形状的说明出现了 4 种形式, 而数组所特有的属性, 主要就是 DIMENSION 和 ALLOCATABLE, 下面分小节予以说明数组描述的 4 种形式数组描述的 4 种形式的句法形式 (R513) 为 : explicit-shape-specification-list deferred-shape-specification-list assumed- shape-specification-list assumed-size-specification 这四种形式分别用来描述数组在程序当中出现的四种可能情形 :

97 首先是最基本的显形数组 (explicit-shape arrays), 即在定义数组的时候就已经给出它的形状 ; 当一个数组具有指针属性, 或具有可分配属性时, 它的形状就没法预先给定, 需要在程序运行过程当中通过指针或分配过程予以确定, 这时就需要使用待定形数组 (deferred-shape arrays) 的形式来加以描述 ; 当数组本身属于哑元时, 它的形状就需要实元来赋予, 这样就需要使用哑形数组 (assumed- shape arrays) 的形式来加以描述 ; 如果实元赋予一个作为哑元的数组时, 只是决定它的尺度, 而没有给定其他形状要素, 那么就需要使用哑尺度数组 (assumed-size arrays) 的形式来加以描述下面我们将分节说明这四种数组的描述方式数组的描述的一般规则如下 : 按照 FORTRAN 标准, 数组的秩至少可以达到 7, 尽管一般应用环境里, 秩为 2 或 3 是最常见的, 但是对于一些特定的计算问题, 可能需要用到非常高的维度的数组, 所以一般的 FORTRA N 编译器都能支持远大于 7 的秩一个标量的秩为 0 待定形数组必定或者具有 POINTER 的属性, 或者具有 ALLOCATABLE 的属性哑形数组和哑尺度数组必定属于哑元必须注意待定形数组和哑形数组的表示形式可能出现雷同的时候, 即都是使用一个冒号表示显形数组顾名思义, 所谓显形数组就是对于数组的每一个维度都给出了具体的上下界, 每个维度的显形说明的句法形式 (R514) 如下 : [ low-bound :] upper-bound 其中的上界 (upper-bound) 和下界 (low-bound) 为说明表达式参见表达式显形数组的一般规则如下 : 显形数组的说明列表里所给出的上下界对的数目必须与该数组的维度数目一致如果下界被省略了, 则表明取默认值 1 上下界可以是正整数, 也可以是负整数, 还可以是 0 数组的下标范围就是在上下界之间, 包括上下界本身的所有整数集合, 并且上界不能小于下界, 如果出现这种情况, 表明下标范围为空集, 或者说其相应维度的宽度为 0, 而且数组的尺度也为 0 如果上下界是以表达式的形式出现, 那么可能包含变量, 使得上下界的具体取值在数组所处的过程运行当中发生变化, 这时, 该数组必定是一个哑元, 或者是一个函数结果, 或者是一个动态数组例 7-17 下面是主要说明数据项的声明语句 : INTEGER X(20:30,5,-10:40). SUBROUTINE AAA(I,J,K) REAL,DIMENSION(10:I+2,J)::K

98 . 例 7-18 下面是主要说明属性的声明语句 : INTEGER X(20:30,5,-10:40). SUBROUTINE AAA(I,J,K) REAL K DIMENSION K(10:I+2,J) 待定形数组待定形数组用来表示具有指针属性和可分配属性的数组对于指针数组来说, 数组的每个维度的宽度是在指针被分配或指针赋值语句被执行之后才给定的 ; 对于可分配数组来说, 它的上下界只是在被分配之后才给出因此对于这种数组的形状说明, 只能使用一个冒号, 即如下的句法形式 (R518): : 待定形数组的一般规则如下 : 待定形数组的秩等于它的说明列表当中出现的冒号的数目当待定形数组完成存储分配之后, 它的上下界在 ALLOCATE 语句当中被确定对一个指针数组的目标数组的每个维度执行固有函数 LBOUND, 就能得到指针数组的相应维度的下界 ; 同样的, 对一个指针数组的目标数组的每个维度执行固有函数 UBOUND, 就能得到指针数组的相应维度的上界因此, 如果上下界是由指针的分配决定, 那么该数组的形状就可以由用户来指定 ; 如果上下界是由指针的赋值决定, 那么该数组的形状就可以有二种情形 : 如果指针目标是一个命名全数组, 那么上下界就由该数组的声明决定, 或者在该数组被分配之后给出 ; 如果指针目标是一个数组片断, 那么它的下界为 1, 而上界为所处维度的宽度如果指针数组或可分配的上下界里面包含变量, 那么当变量在随后有了重定义与去定义的情形的话, 上下界不受这种变化的影响例 7-19 下面是主要说明数据项的声明语句 : REAL,POINTER::A( :, : ),B( :, : ) REAL,ALLOCATABLE::A( :, : ) 例 7-20 下面是主要说明属性的声明语句 : REAL A( :, : ),B( :, : POINTER A,B ALLOCATABLE A )

99 7.4.4 哑形数组所谓哑形数组, 就是一个哑元, 它的形状只有在与一个实元相结合时才能定下来, 哑形数组的说明句法 (R517) 为 : [ low-bound] : 即只是可选地给出一个下界, 然后就是一个冒号, 下界阙如, 表示未定哑形数组的一般规则如下 : 哑形数组的说明列表当中出现的冒号的个数, 就等于该数组的秩下界或者明确给出, 或者省略, 表示下界取默认值 1 上界等于数组在相应维度上的宽度加下界值减 1 哑形数组不能具有 POINTER 或 ALLOCATABLE 这二种属性未结合指针数组的尺度, 界和形状都是未定义的, 这样一个数组的任何部分都不能被引用或定义, 不过这样的数组可以作为固有查询函数的变量出现, 从而可以查询变量状态, 数据类型性质, 类型参数, 或者结合状态例 7-21 下面是主要说明数据项的声明语句 : SUBROUTING AAA(X,Y,Z) REAL,DIMENSION(5:,:)::A REAL,INTENT(IN)::X( :),Y(5:) 例 7-22 下面是主要说明属性的声明语句 : SUBROUTING AAA(X,Y,Z) REAL X( :),Y(5:),Z DIMENSION A(5:,:) INTENT(IN)X,Y 哑尺度数组一个哑尺度数组就是一个哑元, 而它的尺度由与它相关联的实元设定, 因此在声明哑尺度数组时, 就给定了它的尺度, 即秩, 宽度和界 ( 最后一个维度的上界和宽度除外 ) 对于哑尺度数组和实元之间的关联有如下规则 : 二者具有相同的初始数组元素后继数组元素是按照存储顺序排列的哑元的声明就需要给出数组的秩, 所有维度的下界, 以及除了最后一个维度之外的所有的上界与宽度实元的尺度哑元的尺度哑尺度数组的最后一个维度的上界不能给出, 因此使用星号 (*) 表示哑尺度数组的句法形式 (R519) 为 : [ explicit-shape-list,] [ low-bound:] * 可见, 哑尺度数组与显形数组在形式上的主要差别就是最后一个维度的上界有待给出

100 哑尺度数组的一般规则如下 : 哑尺度数组的秩就是它的显形数组的说明列表当中的说明数目加 1 哑尺度数组的尺度根据以下途径来决定 : 如果与哑元相关联的实元是非默认字符类型的任意其他类型数组, 那么哑元的尺度就是实元的尺度如果与哑元相关联的实元是非默认字符类型的任意其他类型数组元素, 并且它的下标顺序值是一个尺度为 x 的数组当中的 v, 那么该哑元的尺度为 x-v+1 如果与哑元相关联的实元属于默认字符类型数组, 或者属于默认字符型数组元, 或者属于默认字符型数组元素子串, 假设它开始于一个以 c 作为字符存储单位的数组的第 t 个字符存储单位, 那么哑元的尺度为 : MAX(INT((c-t+1)/e),0) 其中 e 是哑字符数组里的元素的长度设数组的秩为 r, 那么前 r-1 维的界都由相应的显形数组说明给定, 最后一个维度的下界则由声明中给出的下界给定, 如果没有给出, 则取默认值 1 如果界的表达式里面包含变量, 那么当相应过程执行时, 就会导致表达式取值发变化, 但是当变量在随后如果是有了重定义与去定义的情形的话, 上下界则不受这种变化的影响函数结果不能成为哑尺度数组除了以下两种情形, 哑尺度数组不能作为全数组引用 : 在过程引用当中没有要求实元的形状 ; 引用到固有函数 LBOUND 例 7-23 下面是主要说明数据项的声明语句 : SUBROUTING PRO(A,B, C) RE AL,DIMENSION(A, *)::B REAL C(100,20,*). 例 7-24 下面是主要说明属性的声明语句 : SUBROUTING PRO(A,B,C) RE AL B, C(100,20,* ) DIMENSION B(A, *): 数组的四种声明形式的兼容性数组的四种声明形式可以在程序里扮演的脚色有各种限制, 也就是说具有不同的语法作用下面的表 7-2 给出这四种形式与不同语法单位的兼容性限制 : 表 7-2 数组的四种声明形式的兼容性数组声明的形式数组的语法单位显形数组待定形数组哑形数组哑尺度数组

101 表达式的主项可可可否下标向量可可可否哑元可可可可实元可可可可等价对象可否否否公用对象可可否否名称列表对象可否否否保留对象可可否否初始化数据对象可否否否 I/O 列表项可可可否格式可可可否内部文件可可可否分配对象否可否否指针赋值语句里的指针对象否可否否指针赋值语句里的目标对象可可可否 DIMENSION 属性和 DIMENSION 语句数组的维度除了可以在数组声明语句当中, 通过数组名称的说明来给出之外, 还可以使用 DIM ENSION 属性语句来给出, 实际上,DIMENSION 语句属于 FORTRAN 早期标准的遗留物, 现在既可作为单独的属性语句出现, 也可以附加在数据声明语句里面附加 DIMENSION 属性的数据类型声明语句的句法形式为 : type-specification,dimension(array-specification)[,attribute-list]::& entity-list 可以跟在 DIMENSION 属性语句后面的其他属性有 : initialization ALLOCATABLE INTENT OPTIONAL PARAMETER POINTER PRIVATE PUBLIC SAVE TARGET 另外, 数组说明可以使用一个数组名称, 然后后面附加其他语句来声明一个数组, 这些语句可以是 DIMENSION 语句, 类型声明,ALLOCA TABLE,POINTER,TARGET,COMMON 等语句如果以说明 DIMENSION 属性为主给出数组定义, 那么可以采用如下的句法形式 (R526): DIMENSION[ ::] array-name(array-specification) & [,array-name(array-specification)]

102 例 7-25 下面是主要说明数据项的声明语句 : REAL,ALLOCATABLE,TARGET: :X( :,:) REAL,DIMENSION(30),TARGET,SAVE::METER 例 7-26 下面是主要说明属性的声明语句 : REAL X( :,:),METER DIMENSION METER(30) TARGET X,METER ALLOCATABLE X SAVE METER 例 7-27 下面是在其他声明语句当中使用数组说明的例子 : REAL X,METER TARGET X,METER(30) ALLOCATABLE X( :,:) SAVE METER 例 7-28 下面是在 COMMON 语句当中使用数组说明的例子 : COMMON / MOTION / TIME(30),SPACE(1000, 1000,1000) ALLOCATABLE 属性和 ALLOCATABLE 语句一个数组可分配是指它的界只有在执行 ALLOCATE 语句之后才能确定这样一个数组必定是一个待定形数组 ALLOCATABLE 属性只是针对数组而言才成立一个具有 ALLOCATABLE 属性的数组的类型声明的句法形式为 : type-s pecification,allocatable [,attribute-list]::entity-list 能与 ALLOCATABLE 兼容的属性有 : DIMENSION(deferred-shape- specification-list) PRIVATE PUBLIC SAVE TARGET 单独的 ALLOCATABLE 属性语句的句法形式 (R527) 为 : ALLOCATABLE[::] array-name [(deferred-shape- specification-list)]& [,array-name [(deferred-shape- specification-list)]] ALLOCATABLE 属性声明的一般规则如下 : 具有 ALLOCATABLE 属性的数组就不能是哑元或函数结果如果给定具有 ALLOCATABLE 属性的数组, 再在任何位置给出具有 DIMENSION 属性, 都必须使用单独的冒号来表示为待定形数组例 7-29 下面是主要说明数据项的例子 :

103 REAL,ALLOCATABLE,SAVE::X(:,:) INTEGER,ALLOCATABLE,DIMENSION(:)::Y 例 7-30 下面是主要说明属性的例子 : REAL X(:,:) INTEGER Y DIMENSION Y(:) ALLOCATABLE X,Y SAVE X 7.5 指针属性一般说来, 我们给一个数据对象附加一种属性, 总是意味着给该数据对象增加某种它本来没有的性质, 但是指针 (POINTER) 属性则不然, 当我们把 POINTER 属性附加给某个数据对象, 实际上是把该数据对象本来具有的存储空间给拿掉了由于我们要引用一个数据对象, 前提必然是已经确定了该数据对象的存储空间, 才能准确地加以访问, 那么显然, 对于一个具有 POINTER 属性的数据对象, 既然它不具有了初始的存储空间, 也就无法加以引用, 除非再给该数据对象关联上一个存储空间给 POINTER 对象关联到一个存储空间, 可以通过如下方法 : 使用 ALLOCATE 语句为 POINTER 对象创造一个新的存储空间 ; 使用指针赋值语句使得 POINTER 对象从另外一个具有存储空间的数据对象那里借用其存储空间, 那个被借用存储空间的数据对象称为指针的目标目标数据对象在程序运行时是可以发生变化的, 它有两种来源 : 赋予了 TARGET 属性的数据对象, 或者它的某个部分 ; 指针通过分配而创造出来的新的数据对象, 或者它的某个部分指针可以被关联到另外一个指针的目标, 或者目标的某个部分对于一个数组来说, 要使得它成为某个指针的目标, 除了具有 ALLOCATABLE 属性之外, 还必须具有 TARGET 属性在一个程序里, 最初建立一个指针对象之后, 还必须对它进行初始化, 也就是定义它的初始状态 ( 参见 7.5), 然后才可以使用固有函数 ASSOCIATED 来查询指针的状态, 否则, 该指针既不能被引用, 也不能出现在 DEALLOCATE 语句当中所谓指针的经过定义了的状态有两种 : 关联与去关联通过 ALLOCATE 与指针赋值语句, 可以使得指针具有关联状态 ; 通过 DEALLOCATE 或者 NULLIFY 语句, 或者让指针赋值给另外一个本来处于去关联状态的指针, 可以使得指针具有去关联状态一个指针无论是处于关联状态还是去关联状态, 总之是已经被定义的状态, 因此可以使用固有函数 ASSOCIATED 来查询它是否处于关联状态实际上, 对于指针我们还可以看成是一个描述符, 这个描述符所占据的空间里存储了有关它所指称的对象的数据类型, 种别参数, 秩, 宽度, 以及目标的位置等这类信息因此一个实型标量对象指针必然和一个派生类型的数组指针具有完全不同的存储空间单位, 那么给出一个指针必然无法预先给定它的存储单位, 当我们要在一个公用块里声明指针属性的时

104 候, 就相当于给出存储的描述符, 因此每当我们声明一个包含指针的公用块时, 都必定指定相同的存储单位序列 POINTER 属性和 POINTER 语句附加了 POINTER 属性说明的类型声明的句法形式为 : type-specification,pointer [,attribute-list]::entity-list 可以与 POINTER 兼容的其他属性包括 : initialization DIMENSION(deferred-shape- specification-list) OPTIONAL PRIVATE PUBLIC SAVE 单独的 POINTER 语句也可以用来声明一个指针对象, 它的句法形式 (R528) 为 : POINTER [::] object-name [(deferred-shape- specification-list)]& [,object-name [(deferred-shape- specification-list)]] 指针声明的一般规则如下 : 指针的目标可以是标量, 也可以是数组指针数组必须被声明为待定形数组一个指针不能被引用或定义, 除非它已经被关联到一个可以引用或已定义的目标 ( 在指针赋值语句的右边的指针不能被视为一个引用 ) 例 7-31 下面是主要说明数据项的例子 ; TYPE(SAMPLE),POINTER::CAPACITANCE REAL,POINTER::A(:,:),B(:,:) 例 7-32 下面是主要说明属性的例子 : TYPE(SAMPLE) CAPACITANCE REAL A(:,:),B(:,:) POINTER CAPACITANCE,A,B TARGET 属性和 TARGET 语句被赋予 TARGET 属性的数据对象在程序运行当中, 就可能成为某个指针的目标 ; 如果一个数据对象不具有 TARGET 属性或者没有经过分配, 那么它的任何部分都不能被指针访问在一个类型声明语句当中附加 TARGET 属性说明的句法形式为 : type-specification,target [,attribute-list]::entity-list 可以与 POINTER 兼容的其他属性包括 :

105 initialization ALLOCATABLE DIMENSION INTENT OPTIONAL PRIVATE PUBLIC SAVE 单独的 TARGET 语句也可以用来指定指针目标, 句法形式 (R529) 为 : TARGET [::] object-name [(array-specification)]& [,object-name [(array-specification)]] 例 7-33 下面是主要说明数据项的例子 : TYPE(SAMPLE),TARGET::CAPACITANCE REAL,TARGET, DIMENSION(100,100)::A,B(100) 例 7-34 下面是主要说明属性的例子 : TYPE(SAMPLE) CAPACITANCE REAL A,B(100) DIMENSION A(100,100) TARGET CAPACITANCE,A,B 7.6 值特征所谓值特性就是描述一个变量, 或者一个指针, 或者一个命名常量的取值状态的属性针对不同的数据对象, 值特性的说明分为如下两种情形 : 对于变量与指针, 可以通过 2 种途径赋予初始化值特性 : 给一个变量赋予初始值, 或者使一个指针无效化 ( 或者说置空 ), 都可以通过采用一个主要说明数据项的类型声明语句而获得这个类型声明语句包含如下的数据项声明形式 : obiect-name = initialization-expression pointer-name =>NULL() 使用 DATA 语句然后这些变量与指针的取值, 就可以在程序随后的运行当中发生变化这样一种在类型声明语句当中附加数据项初始化声明形式的值的初始化的方式称为显式初始化对于命名常量的取值, 也可以通过如下两个途径 : 通过采用一个附加了 PARAMETER 属性说明的主要说明数据项的声明语句来取值, 而且该语句包含如下数据项声明形式 : obiect-name = initialization-expression 使用 PARAMETER 语句

106 命名常量通过如此方式给定的取值, 不能在随后的程序运行过程当中发生变化, 例如我们经常对一些数学常数使用固定的容易辨认的命名, 然后在程序运行的开始给定一个固定的取值, 比如说, 取 PI=3.14, 那么这个命名常量的取值在随后的程序运行过程当中保持不变命名常量也可以用来给一些固定的数值加以命名, 这样的数值在一定情况下保持不变, 但也可能在某些情况下需要加以改变, 例如利率, 这时就需要在不同的地方加以不同的取值定义下面我们分两节来分别讨论值特性的两种情形数据初始化和 DATA 语句对于变量与指针, 可以通过数据初始化和 DATA 语句这 2 种途径来进行值的初始化, 其中 DAT A 语句作为一种属性, 是唯一不能附加到类型声明语句当中去的一种属性除了单独使用 DATA 语句来给出变量与指针的值的初始化之外, 还可以在类型声明语句当中, 使用特定的数据初始化形式来给出变量与指针的值的初始化上面这两种说明变量与指针的值的初始化的方法, 都称为显式初始化, 相对而言, 如果在一个程序当中没有出现显式初始化, 那么通过类型声明语句, 实际上就按照默认的约定而进行了隐式初始化 ( 参见第 5 章 ), 那种隐式初始化对于同一类型的所有对象是一致的显式初始化总是优先于隐式初始化对于变量来说, 初始化的结果并不改变变量本身的类型属性例如给一个实型变量赋予一个整型值, 那么变量仍然保持为实型, 而那个整型值被潜在地转换为相应的实型值, 一般而言, 只要出现取值与变量的类型以及种别不一致的情形, 取值总是潜在地被转换为与变量一致的类型以及种别对于指针来说, 只有经过初始化, 才能获得关联状态, 即或者是关联, 或者是去关联, 否则, 没有经过初始化的指针, 即无定义的指针不能出现在很多的上下文当中例如它不能被引用, 不能出现在 DEALLOCATE 语句当中, 也不能通过使用固有函数 ASSOCIATED 来查询其关联状态给出显式初始化的类型声明语句的句法形式为 : type-specification [,attribute-list]::object-name [(array-specification)]& [*character-length] initialization 而其中的初始化 (initialization) 为以下形式之一 : obiect-name = initialization-expression pointer-name =>NULL() 其中第一种形式用于指定非指针对象的初始值, 第二种形式用于使得指针置空能够与变量初始化兼容的其他属性有 : DIMENSION POINTER PRIVATE PUBLIC SAVE TARGET 变量通过类型声明语句而获得的初始化, 或者变量的任意部分通过 DATA 语句而获得的初始化, 都意味着变量自动具有了 SAVE 属性, 除非这个变量是处于一个命名公用块当中

107 这种自动获得的 SAVE 属性还可以通过单独的 SAVE 语句, 或者在类型声明语句当中附加 SAVE 属性说明, 来得到更加明确的表示 DATA 语句的句法形式 (R532) 为 : DATA data-object-list / data-value-list / & [[,] data-object-list / data-value-list / ] 其中数据对象 (data-object) 有以下形式 (R534): varible data-implied-do 数据值 (data-value) 的形式 (R538) 为 : [repeat-factor * ] data-constant 其中重复因子 (repeat-factor) 为一个标量整型常量, 数据常量 (data-constant) 的形式 (R540) 有以下几种 : scalar-constant scalar-constant-subobject signed-integer-literal-constant signed-real -literal-constant NULL() structure-constructor boz-literal-constant 隐式 do 数据 (data-implied-do) 的形式 (R535) 为 : (data-implied-do-object-list,scalar-integer-variable = & scalar-integer-expression,scalar-integer-expression & [,scalar-integer-expression]) 隐式 do 数据对象 (data-implied-do-object) 的形式 (R536) 有如下几种 : array-element scalar-structure-component data-implied-do 数据初始化的一般规则如下 : 如果需要进行初始化的数据对象为字符型或逻辑型, 那么用于初始化的常量必须是同一个类型如果需要进行初始化的数据对象为实型或复型, 那么用于初始化的常量必须是整型, 实型或复型如果需要进行初始化的数据对象为整型, 那么用于初始化的常量必须是整型, 实型或复型如果初始化是在 DATA 语句当中指定, 那么相应的常量可以是二进制, 八进制, 或十六进制的字面常量如果需要进行初始化的数据对象为派生类型, 那么用于相应的常量必须是同一个派生类型如果 NULL() 出现在初始化说明里面, 或者表现为 DATA 语句的常量, 那么相应的被初始化的对象必须具有 POINTER 属性相应于非指针对象的初始表达式的值, 或者是 DATA 语句里的常量, 必须可以通过使用固有赋值语句而赋值给相应对象, 从而使得相应对象获得初始值

108 类型声明语句当中进行的初始化优先于类型定义当中默认的初始化, 只要进行了显式初始化, 就可以认为不存在默认初始化具有默认初始化的派生类型的对象不能在 DATA 语句当中进行初始化在一个可执行程序里, 同一个对象, 或者是一个对象的同一个部分, 只能进行一次显式初始化以下数据对象不能进行数据初始化 : 哑元可被用户或主程序访问的对象函数结果动态对象可分配数组命名公用块当中的对象, 除非该对象的数据初始化是在一个数据块程序单元中进行的空公用块里的对象外部过程或固有过程如果一个对象被初始化, 那么它的所有下标, 片断下标, 子串始点和子串终点都必须是满足以下条件的表达式 : 表达式的所有算元都必须是常量, 常量的子对象, 或隐式 do 变量 ; 表达式的所有运算都必须是固有运算结构构造器的每一个用于初始化的成员都必须是初始化表达式出现在 DATA 语句当中的经过显式的类型声明的变量, 可以出现在随后的其他类型声明语句当中的唯一前提就是 : 随后的声明不与它的显式声明冲突出现在 DATA 语句当中的数组名, 数组片断, 数组元素都同样地具有此前该数组被定义时所具有的性质如果一个数组元素或结构成员为隐式 do 数据对象, 那么就不能拥有父常量 DATA 语句的重复因子必须是正数或 0; 如果是一个命名常量, 那么当 DATA 语句进行计数时, 它的值必须在同一个作用域单位里的处于 DATA 语句之前的其他语句里被指定隐式 do 结构里的标量整型表达式的运算元只能是常量, 常量的子对象, 或隐式 do 变量 ; 表达式的所有运算都必须是固有运算数据对象列表可以扩张为一个标量变量序列而一个数组或数组片断等价于它的元素按照数组元素序排列得到的序列一个隐式 do 数据在隐式 do 变量的控制下, 可以扩张为一个由数组元素组成的序列一个尺度为 0 的数组, 或一个重复计数为 0 的隐式 do 变量对于扩张出来的序列没有任何影响, 但是一个具有 0 长度的字符变量却能够对序列产生影响数据值列表可以扩张为一个属于固有类型的标量常量值序列当 DATA 语句被计数时, 每一个得到的数据值都必须是编译器认可的数据常量 DATA 语句的重复因子实际上表示了进入序列的后续的数据常量的数目如果重复因子为 0, 则后续的数据常量就不进入序列了标量变量和扩张序列当中的数据常量必须是一一对应的, 扩张序列当中的每一个数据常量都表示相应变量的初始值或初始状态两个扩张序列的长度一定是相同的例 7-35 下面是主要说明数据项的例子 : CHARACTER(LEN= 20)::SYMBOL = AIPHA INTEGER,DIMENSION(1:10)::COUNT = (/(1,I=2,11)/) TYPE(LINK),POINTER::START=>NULL() TYPE(SAMPLE)::SAMPLE1 = SAMPLE(33, BETA )& SAMPLE2= SAMPLE(45, BETA ) REAL::OVERFLOW(100,100)=RESHAPE((/((1.0,J=1,K-1),&

109 (0.0,J=K,100),K=1,100)/),(/100,100/)) 例 7-36 下面是主要说明属性的例子 : CHARACTER(LEN= 20)SYMBOL INTEGER COUNT DIMENSION OUNT(1:10) TYPE(LINK)START POINTER START DATA START /NULL()/ DATA SYMBOL /AIPHA /,COUNT /10*0/ TYPE(SAMPLE)SAMPLE1,SAMPLE2 DATA SAMPLE1 / SAMPLE(33, BETA )/ DATA SAMPLE2 / SAMPLE(45, BETA )/ REAL OVERFLOW(100,100) DATA ((OVERFLOW(J,K),J=1,K-1),K=1,100)/4950*1.0/ DATA ((OVERFLOW(J,K),J=K,100),K=1,100)/5050*0.0/ 在上面的例子里, 字符变量 SYMBOL 的初始化值为 AIPHA 整数数组 COUNT 的 10 个元素都始化为 0, 在主要说明数据项的例子里使用了数组构造器, 而在主要说明属性的例子里使用了重复因子指针 START 开始被置空 SAMPLE1 和 SAMPLE2 是属于派生类型 SAMPLE 的数据对象, 其中 SAMPLE1 的初始化使用了结构构造器, 而 SAMPLE2 的初始化是通过给定它的每个成员的值而得到的在主要说明数据项的例子里还使用了固有函数 RESHAPE, 因为数组 OVERFLOW 的秩为 2, 而在主要说明属性的例子里则是使用了重复因子 PARAMETER 属性和 PARAMETER 语句在类型声明语句附加 PARAMETER 属性说明或者单独使用 PARAMETER 语句, 可以给常量赋予一个名称在类型声明语句当中附加 PARAMETER 属性说明的句法形式为 ; ty pe-specification,parameter [,attribute-list]::name= initialization-expression 在一个类型声明语句当中可以对多个常量命名与 PARAMETER 属性兼容的其他属性有 : initialization( 一定要有 ) DIMENSION PRIVATE PUBLIC SAVE 根据固有赋值规则, 由初始化表达式给出常量的名称而出现在初始化表达式当中的命名常量只能属于以下情形 : 在本类型声明语句的前面已经被定义, 或者在前面的类型声明语句当中已经被定义

110 编译器已知的命名常量单独的 PARAMET ER 语句也可以用来给出命名常量, 其句法形式 (R530) 为 : PARAMETER (name-constant= initialization-expression & [,name-constant= initialization-expression ] ) PARAMETER 语句的一般规则如下 : 哑元, 函数, 或公用块里的对象不能具有 PARAMETER 属性出现在 PARAMETER 语句当中的经过显式的类型声明的命名常量, 可以出现在随后的其他类型声明语句当中的唯一前提就是 : 随后的声明不与它的显式声明冲突出现在 PARAMETER 语句当中的数组常量具有该数组此前被定义时所具有的一切性质为避免出现歧义, 命名常量不能出现在格式说明当中例 7-37 下面是主要说明数据项的例子 : INTEGER,PARAMETER::LOCAL=100 INTEGER,PARAMETER::A=COUNT(20,10),& TEST=100+LOCAL 例 7-38 下面是主要说明属性的例子 : INTEGER LOCAL,A, TEST PARAMETER (LOCAL=100) PARAMETER(A= COUNT(20,10),& TEST=100+LOCAL) 7.7 对象可访问性以及使用属性有一类属性是专门用来描述数据对象是否具有访问限制, 以及如何使用相应的数据对象的, 当然也不是所有的数据对象都可以具有这样的属性, 只有三类数据对象可以进行访问控制 : 模块中的对象 ; 哑元 ; 子程序里声明的变量相关的属性包括 : PUBLIC 和 PRIVATE 属性用来控制模块当中的数据对象的可访问性 ; INTENT 用于控制子程序当中的哑元的使用 ; OPTIONAL 用于控制子程序当中变量在进行子程序引用时的使用 ; SAVE 用于控制子程序里变量的值在进行子程序引用时的使用 PUBLIC 属性和 PRIVATE 属性在类型声明语句里附加的 PUBLIC 属性和 PRIVATE 属性控制了对模块里的类型定义, 变量, 函数, 以及命名常量的访问 PUBLIC 属性表明了模块里的数据对象可以通过关联被模块外部访问 PRIVATE 属性则刚好相反, 防止了模块外部通过关联来访问模块里的数据对象

111 在类型声明里附加 PUBLIC 属性和 PRIVATE 属性说明的句法形式为 ; type-specification,public [,attribute-list]::entity-list type-specification,private [, attribute-list]::entity-list PUBLIC 属性和 PRIVATE 属性说明也可以用于派生数据类型的声明当中 : TYPE,PUBLIC::type-name TYPE,PRIVATE:: type-name 如果在类型声明当中使用了 PRIVATE 属性, 但是却没有包含访问 id 列表, 那么就说明尽管从模块外部可以访问该类型的数据, 但是却不能访问数据的成员可以与 POINTER 兼容的其他属性包括 : initialization ALLOCATABLE DIMENSION EXTERNAL INTRINSIC PARAMETER POINTER TARGET SAVE 单独的 PUBLIC 语句和 PRIVATE 语句也可以用来控制对数据对象的访问除了可以作用于类型定义, 变量, 函数, 和命名常量之外, 它们还可以用来控制一些不能通过类型说明来定义的对象, 例如子例行程序, 通用描述符, 以及名称列表集合 PUBLIC 语句和 PRIVATE 语句的句法形式 (R522) 为 : PUBLIC [ [ ::] access-id-list ] PRIVATE [ [ ::] access-id -list ] 其中访问 id(access-id) 的形式 (R523) 为以下几种 : use-name generic-specification 其中类说明 (generic-specification) 的形式 (R1207) 为以下几种 : generic-name OPERATOR( 已定义算符 ) ASSIGNMENT(=) 类说明的具体讨论参见第 13 章的过程界面例 7-39 下面是使用类说明的 PUBLIC 和 PRIVATE 语句的例子 : PUBLIC HYPERBOLIC_COS, HYPERBOLIC_SIN! 类名称 PRIVATE HY_COS_RAT, HY_SIN_RAT! 种名称 PRIVATE HY_COS_INF_PREC! 种名称 PUBLIC :: OPERATOR(.THAT.), OPERATOR(+), ASSIGNMENT(=)

112 PUB LIC 和 PRIVATE 语句的一般规则如下 : PUBLIC 和 PRIVATE 只能用于模块有效名称 (use-name) 可以是变量, 过程, 派生数据类型, 命名常量, 以及名称列表集合这些对象的名称在一个模块的作用域单位里只能存在一个省略了访问 id 的 PUBLIC 语句或 PRIVATE 语句, 该语句决定了对于模块的默认可访问性在派生数据类型的声明里面可以使用 PRIVATE 语句, 来表明该种类型的结构成员不能被模块外部访问这种情况不能使用相反的 PUBLIC 语句具有公共的通用标识符的过程, 可以通过通用标识符而被访问, 尽管它的特指名称是不可访问的一个模块过程如果包含私有类型的变量, 或私有类型的函数结果, 则过程本身也就是私有的, 就不能具有公共的通用标识符模块中定义的对象在默认情形下, 都是具有 PUBLIC 属性的可以在模块里给出一个缺乏访问 id 列表的 PUBLIC 属性说明来明确表明模块内部对象的默认可访问性质在模块里使用不含访问 id 列表的 PRIVATE 属性说明可以改变这种默认 PUBLIC 属性例 7-40 下面是主要说明数据项的例子 : REAL,PUBLIC::GLOBAL_1 TYPE, PRIVATE :: LOCAL_DATA LOGICAL :: ANSWER REAL,DIMENSION(20) :: DENSITY END TYPE LOCAL_DATA 例 7-41 下面是主要说明属性的例子 : REAL GLOBAL_1 PUBLIC GLOBAL_1 TYPE, LOCAL_DATA LOGICAL ANSWER REAL DENSITY (20) END TYPE LOCAL_DATA PRIVATE LOCAL_DATA 例 7-42 下面是一个具有私有成员的公有类型的例子 : TYPR LIST_ELEMENT PRIVATE REAL VALUE TYPE (LIST_ELEMENT), POINTER:: NEXT, FORMER END TYPR LIST_ELEMENT 例 7-43 下面是一个改变默认访问性质的例子 : MODULE M PRIVATE REAL A, B, TEMP(20) REAL, PUBLIC :: X(20), Y(20)

113 END MODULE M INTENT 属性和 INTENT 语句针对哑元的 INTENT 属性更多的是为了方便程序作者或用户, 通过给哑元附加 INTENT 属性, 就可以有意地使用哑元, 从而便于检查错误, 可以为程序读者提供有用的信息, 为调试修改源码提供方便, 从而可以改善源码的效率哑元的运用分三种情形 : 被引用但在子程序里还没有被重定义 ; 在子程序里被引用之前已经定义 ; 在重定义之前被引用相应的,INTENT 也有三种形式, 分别用于上面的哑元运用的三种情形 : IN; OUT; INOUT 如果变量的意向属性是 IN, 那么子程序不能改变变量的值, 也不能成为无定义变量如果变量的意向属性是 OUT, 那么子程序在变量被定义之前都不能使用该变量, 并且该变量必须是可定义的如果变量的意向属性是 INOUT, 那么变量就可以用于和子程序通讯, 并且返回信息在进入子程序时, 它必须是已经定义好了的, 而且必须的可定义的如果不使用 INTENT 属性, 那么哑元的使用由相关联的实元决定, 实元所受到的限制同样是哑元的限制例如如果实元是一个常量, 那么相应的哑元就只能被引用, 而不能被定义附加 INTENT 的类型声明语句的形式为 : type-specification,intent(intent- specification) [,attribute-list]::& dummy-argument-name-list 其中的 INTENT 的属性是 IN,OUOT,INOUT 之一与 INTENT 兼容的其他属性有 : DIMENSION OPTIONAL TARGET 单独的 INTENT 语句也可以给出 INTENT 属性, 其句法形式 (R520) 为 : INTENT(intent- specification) [ ::] dummy-argument-name-list 其中的 INTENT 的属性是 IN,OUOT,INOUT 之一 INT ENT 语句的一般规则如下 : INTENT 属性只能用于哑元 INTENT 语句只能在子程序的说明部分或界面体出现 INTENT 属性不能应用于作为哑过程的哑元, 因为哑过程的定义是无法改变的, 而且

114 INTENT 属性也不能应用于哑指针, 因为无法明确 INTENT 属性是应用于指针还是应用于指针的目标如果哑元属于给出了默认初始化是数据类型, 则只有当该哑元具有 INTENT(OUT) 属性的时候, 才获得初始化定义例 7-44 下面是主要说明数据项的例子 : SUBROUTING MOVE(FROM,TO) USE PERSON_MODULE TYPE(PERSON), INTENT(IN) :: FROM TYPR(PERSON), INTENT(OUT) :: TO SUBROUTING SUB (X, Y) INTEGER, INTENT(INOUT) :: X, Y 例 7-45 下面是主要说明属性的例子 : SUBROUTING MOVE(FROM,TO) USE PERSON_MODULE TYPE(PERSON) FROM, TO INTENT(IN) FROM INTENT(OUT) TO SUBROUTING SUB (X, Y) INTEGER X, Y INTENT(INOUT) X, Y OPTIONAL 属性和 OPTIONAL 语句使用 OPTIONAL 属性, 可以使得具有该属性的哑元在包含该哑元的过程被引用的时候被省略掉, 而直接采用默认值来代替那些被省略的哑元, 这样就可以节省那些在被引用后并不需要使用变量形式的哑元这就意味在该过程在某个特定的引用里, 减少了变量的数目, 这样就能够有效地改善程序的执行效率之所以引入这样一种属性, 是根据科学计算的实际需要因为经常会出现这样一种情况 : 对于一个专用的过程, 为了能够对付尽可能多的调用需求, 往往要设置足够多的哑元, 但是在该过程得到某个具体调用时, 往往发现在一个具体的问题当中, 其中很多哑元并没有起到变量的作用, 而是一直取常量, 因此可以在引用该过程时, 一开始就省略不起作用的哑元, 直接采用默认常量替代它, 这样能够很大的节省程序运行的资源消耗因此在调用某个过程之前, 我们可以根据实际情况, 给其中的某些哑元附加 OPTIONAL 属性, 使得该过程进入调用后, 自动省略这些哑元, 而直接采用默认值附加 OPTIONAL 属性说明的类型声明语句的形式为 : type-specification,optional [,attribute-list]::dummy-argument-list 与 O PTIONAL 属性兼容的其他属性有 :

115 DIMENSION EXTERNAL INTENT POINTER TARGET 单独的 OPTIONAL 语句也可以给出 OPTIONAL 属性, 其句法形式 (R521) 为 : OPTIONAL [ ::] dummy-argument-name-list OPTIONAL 语句的一般规则如下 : OPTIONAL 属性只能用于哑元 OPTIONAL 语句只能在子程序的作用域单位或界面体出现例 7-46 下面是主要说明数据项的一个程序片断例子 : CALL SORT_X (X= VECTOR_A) SUBROUTING SORT_X (X,SIZEX, FAST) REAL, INTENT(INOUT) :: X(:) INTEGER, INTENT(IN),OPTIONAL :: SIZEX LOGICAL, INTENT(IN), OPTIONAL :: FAST INTEGER TSIZE IF (PRESENT (SIZEX)) THEN TSIZE= SIZEX ELSE TSIZE= SIZE(X) END IF IF (.NOT. PRESENT (FAST).AND. TSIZE > 100) THEN CALL QUICK_SORT(X) ELSE CALL BUBBLE_SORT(X) END IF 例 7-47 下面是主要说明属性的例子 : SUBROUTING SORT_X (X,SIZEX, FAST) REAL X ( : ) INTENT (INOUT) X INTEGER SIZEX LOGICAL FAST INTENT (IN) SIZEX, FAST OPTIONAL SIZEX, FAST INTEGER TSIZE

116 7.7.3 SAVE 属性和 SAVE 语句当子程序完成运行之后, 其中定义的具有 SAVE 属性的变量能够保持它的值, 它的定义, 它的关联与分配状态而不具有 SAVE 属性的变量则不能保证能够保持它们的值, 定义和关联分配状态, 尽管在一些 FORTRAN 的实现里, 所有的局部变量和公用块被认为是具有 SAVE 属性保险而言, 如果一定要求对象或对象的公用块能够保持它的值, 定义以及状态, 那么就一定要事先赋予其 SAVE 属性在模块里声明的对象也可以赋予 SAVE 属性, 这样它将在使用该模块的过程完成运行之后, 还能保持其值, 定义以及状态递归子程序里的对象也可以赋予 SAVE 属性, 该对象能够被子程序的所有分支共享任何获得数据初始化的对象都默认为具有 SAVE 属性, 但是一个派生数据类型的结构, 即使它的所有成员都具有默认的初始化, 它本身并不认为具有 SAVE 属性附加 SAVE 属性说明的类型声明语句的形式为 : type-specification,save [,attribute-list]::entity-list 与 SAVE 属性兼容的其他属性有 : initialization ALLOCATABLE DIMENSION POINTER TARGET PUBLIC PRIVATE 由于具有 PARAMETER 属性的对象为命名常量, 因此对于它也就无所谓保持值定义以及状态的不变, 没必要再去赋予它 SAVE 属性, 实际上也不允许对具有 PARAMETER 属性的对象赋予 SAVE 属性单独的 SAVE 语句也可以给出 SAVE 属性, 其句法形式 (R524) 为 : SAVE [[ ::] saved- entity-list] 其中保留项 (saved- entity) 的形式 (R525) 为下面二种 : data-object-name / common-block-name / SAV E 属性的一般规则如下 : 一个不包含保留项列表的 SAVE 语句意味着在作用域内的所有项都具有保留性质, 而在这个作用域内再也不能出现 SAVE 语句如果 SAVE 作为属性或语句出现在主程序, 那它是无效的以下数据对象不能被保留 : 函数结果哑元动态数据对象公用块里的对象

117 公用块里的变量不能单独地赋予 SAVE 属性, 如果整个公用块被赋予 SAVE 属性, 那么它的所有变量都具有了 SAVE 属性如果一个公用块在一个程序的某个作用域里被赋予了 SAVE 属性, 那么它在自己被定义的程序的所有作用域里, 都具有 SAVE 属性 ( 除了主程序 ) 如果一个命名公用块是在主程序里给出的, 那么程序的任何作用域都可以访问它, 这样它就不需要被赋予 SAVE 属性了例 7-48 下面的声明语句主要说明数据项 : REAL,DIMENSION(10),SAVE::A 例 7-49 下面的声明语句主要说明属性 : REAL A DIMENSION A(10) SAVE A 例 7-50 下面的声明语句说明保留对象及公用块 : SAVE X,Y,/BLOCKA/,Z,/BLOCKB/ 7.8 过程属性我们上面讨论的一些属性已经不限于描述数据对象, 也可以用来描述模块, 过程等程序单位, 例如 PUBLIC,PRIVATE, SAVE 等本节我们讨论两个只针对函数与程序单位的属性 : EXTERNAL 和 INTRINSIC 如果一个哑过程或一个外部过程是一个子程序的实元, 那么该过程名称就必须声明为具有 EXTERNAL 属性 ; 如果一个外部过程与某个固有过程拥有相同的名称, 那么就需要对该名称赋予 EXTERNAL 属性, 同时具有这个名称的固有过程就不能被该程序单位访问了如果一个固有过程是一个实元, 那么它的名称就必须声明为 INTRINSIC 由于只有函数具有类型的定义, 而子例行程序不具有类型的定义, 因此作为类型声明的附加属性的 EXTERNAL 和 INTRINSIC 只能用于函数, 而对于子例行程序, 则需要使用语句形式的 EXTERNAL 和 INTRINSIC 下面我们分别讨论这两个属性与相应语句 EXTERNAL 属性和 EXTERNAL 语句 EXTERNAL 属性用于描述一个名称是一个外部函数, 或一个哑函数的名称, 并且该名称可以用于作为实元附加 EXTERNAL 属性说明的类型声明语句的形式为 : type-specification,external [,attribute-list]::function-name-list 与 EXTERNAL 属性兼容的其他属性有 : OPTIONAL

118 PUBLIC PRIVATE 如果一个函数返回一个数组或指针, 那么该函数的界面必定是显形的, 所谓界面块就是用来描述外部函数的界面的, 如果一个函数被描述为界面块, 那么它已经具有默认的外部属性, 因此也就没必要再去显形地赋予它 EXTERNAL 属性单独的 EXTERNAL 语句可以声明子例行程序与数据块程序单位具有外部属性, 其句法形式 (R1208) 为 : EXTERNAL[ ::] external-name-list EXTERNAL 属性的一般规则如下 : 每个外部名称必须是一个外部过程, 或一个哑元, 或一个数据块程序单位的名称如果一个哑变量被描述为 EXTERNAL 的, 那么该哑变量是一个哑过程除了在块内具有 MODULE PROCEDURE 语句的模块过程之外, 一个界面块对于其中的所有过程具有外部属性例 7-51 下面是主要说明数据项的例子 : SUBROUTING SUB(DESIGN) INTEGER,EXTERNAL::DESIGN LOGICAL,EXTERNAL::SIN 例 7-52 下面是相应的主要说明属性的例子 : SUBROUTING SUB(DESIGN) INTEGER DESIGN LOGICAL SIN EXTERNAL DESIGN,SIN INTRINSIC 属性和 INTRINSIC 语句 INTRINSIC 属性用于描述一个名称是一个固有函数的名称, 并且该名称可以用于作为实元附加 INTRINSIC 属性说明的类型声明语句的形式为 : type-specification,intrinsic [,attribute-list]::intrinsic-function-name-list 与 I NTRINSIC 属性兼容的其他属性有 : PUBLIC PRIVATE 单独的 INTRINSIC 语句可以用来声明固有子例行程序, 其句法形式 (R1209) 为 : INTRINSIC [ ::] intrinsic-procedure-name-list INTRINSIC 属性的一般规则如下 : 每个固有过程名称必定是一个固有过程的名称在一个作用域内, 一个名称只能声明 INTRINSIC 一次在一个作用域内, 一个名称不能既声明为 INTRIN SIC, 又声明为 EXTERNAL

119 一种具体的编译器可能支持 FORTRA N 标准之外的更多的固有过程, 当然在相应编译器看来, 这些固有过程与标准固有过程具有相同的地位, 但是使用了这样的过程的程序可能导致程序的可移植性变差例 7-53 下面是主要说明数据项的例子 : REAL,INTRINSIC::SIN, COS 例 7-54 下面是相应的主要说明属性的例子 : REAL SIN, COS INTRIN SIC SIN,COS 7.9 属性兼容性属性兼容性表 7-3 如下 : 如果两个属性可以同时在一个声明语句当中赋予, 则用可表示, 否则, 用否表示表 7-3 各种属性的相互兼容性 ALLOCA DIMEN POINT TARG PARAM PUB PRIVA INTEN OPTIO SAV EXTER INTRI TABLE SION ER ET ETER LIC TE INITIALIZA TION 否是是是是是是否否是否 ALLO CATABLE 是否是否是是否否是否 DIM ENSION 是是是是是是是是否 P OINTER 否否是是否是是否否 TARGET PARAMETER PUBLIC T NAL E NAL 否是是是是是否是是否否否否否否否是是 PRIVATE 否否是是是 INTENT 是否否否 OPTION AL 否是 SAVE 否否 EX TERNAL 否 NSIC 否否否否否是否 7.10 动态数据对象有两类数据对象在确定其存储空间时, 会产生非常复杂的现象, 这就是数组和字符型对象因为这两种数据对象在某些情况下, 不能预先确定它的存储空间, 为了解决这个问题,FORTRAN 干脆提供一种动态数据对象的概念, 可以专门用来描述在特定情形下, 存储空间总是发生变化的数据对象动态数据对象可以只是在过程或过程界面声明, 这样只有在过程被进入的时候, 动态数据对象的存储空间才开辟出来, 而当过程完成运行后, 它们所占据的存储空间就消失了, 它们可以被

120 开辟成和过程里的变量一样大的空间, 就能在每次调用时量体裁衣, 获取适当大小的存储空间这样既能满足这些对象对于存储空间的需要, 又能在不使用它们的时候, 有效地释放空间两种动态数据对象为 : 任意类型的动态数组对于数组来说, 发生动态变化的是每个维度上的宽度, 所采取的表达形式是把数组每个维度上的界表示为一个包含变量的表达式, 这样当数组取可分配数组或指针数组的形式时, 这样当程序运行进入到其所在过程时, 它的界才被确定下来字符型对象对于字符型对象来说, 发生动态变化的是它的字符长度, 所采取的表达形式是把字符型对象的长度表示为一个包含变量的表达式, 这样当程序运行进入到其所在过程时, 它的长度才被确定下来注意作为动态数据对象的字符型对象不是哑变量除了在类型声明当中包含的默认初始化之外, 动态数据对象不能被初始化或被保留例 7-55 SUBROUTING SWAP_ARRAYS (X, Y, X_NAME, Y NAME) REAL, DIMENSION(:), INTENT(INOUT) :: X, Y CHARACTER (LEN= *), INTENT(IN) :: X_NAME, Y_NAME REAL C (SIZE(X)) CHARACTER (LEN= LEN(X_NAME) + LEN(Y_NAME) +20) MESSAGE C=X X=Y Y=C MESSAGE = X_NAME // and //Y_NAME// are swapped. PRINT *, MESSAGE END SUBROUTING SWAP_ARRAYS 其中 C 是一个动态数组, 而 MESSAGE 是一个动态字符型对象 NAMELIST 语句 NAMELIST 语句能够用来给一系列对象的集合命名, 然后就可以在一些输入输出语句当中通过引用该名称而达到引用相应的对象集合的目的 NAMELIST 语句的句法形式 (R544) 为 : NAMELIST / namelist-group-name / variable-name-list & [[,]/ namelist-group-name / variable-name-list ] NAMELIST 语句的一般规则如下 : 变量名称列表 (variable-name-list) 当中的变量不能是如下几种情形 : 带非常量界的数组哑变量具有待定字符长度的变量动态对象指针

121 在任意层次上包含指针成员的派生类型对象可分配数组以上对象的任意子对象如果整个名称列表集合的名称具有 PUBLIC 属性, 那么它的每一个元素都不能具有 PRIVATE 属性, 每个元素也不能包含具有 PRIVATE 属性的成员在 NAMELIST 里的对象的排列顺序, 决定了在输出时值的排列顺序一个名称列表集合名称可以出现在一个作用域单位里的多条 NAMELIST 语句里面一个变量可以是多个名称列表集合的元素一个变量在进入变量名称列表之前, 必须在同一个作用域里被说明了类型, 种别参数以及形状, 或者是通过隐式规则被默认具有相应的类型属性, 而当它在随后的可能的类型说明语句当中出现时, 必须与其默认隐式规则所规定的类型属性保持一致例 7-56 NAMELIST / X_LIST / I, J, K, L, M, N NAMELIST / Y_LIST / A, B, C 7.12 存储关联对于 FORTRAN 这样的高级语言而言, 一般说来很少提供对程序的物理底层的控制, 但是由于数据对象的物理存储空间的问题, 对于程序的空间利用效率有很大的影响, 所以 FORTRAN 还是提供了一些语句可以用来控制数据对象的物理存储 FORTRAN 里面用来控制物理存储单位, 存储的顺序, 以及对存储单位的共享的语句有 : COMMON EQUIVALENCE SEQUENCE 在 FORTRAN 的早期版本里,COMMON 和 EQUIVALENCE 这两个语句提供了足够强大的控制存储空间的功能 COMMON 专门用来处理不同程序单位之间的数据共享问题, 而 EQUIVALENCE 则用来处理多个对象共享一个存储空间的问题但是正是因为这两个语句的功能过于强大, 使得它们的滥用会导致对程序的理解和维护变得非常困难在 FORTRAN 的现代版本里, 为了解决这个问题, 使用了更加明确而专门的方法来获得对存储空间的控制, 诸如模块, 指针, 可分配数组, 动态数据对象都可以非常有效而清晰地进行存储空间管理, 因此上面的两条语句的作用逐渐减小同时在 FORTRAN90 里面, 还引入了 SEQUENCE 语句, 用来定义结构的成员存储顺序关于存储单位与存储顺序的一个中心概念就是存储关联, 这个概念能让我们理解 COMMON 和 EQUIVALENCE 这两个语句的运行机制但是 FORTRAN 的存储关联并不对实际的物理内存分配作出要求, 只是在功能层面的描述存储单位在早期的 FORTRAN 版本里, 只存在两种非常明确的存储单位, 即用于存储数值的存储单位, 和用于存储字符的存储单位, 那时侯任何的数据对象都被归结为这两种存储形式在 FORTRAN 的现代版本里, 引入了很多非默认类型, 派生类型以及指针, 显然这些数据对

122 象已经无法只使用两种存储单位了, 它们的结构的复杂性甚至使得靠增加存储单位的种类也无法很好地满足这些经常表现出动态性质的数据对象对存储的要求因此 FORTRAN 的解决方法就是提出一种统一的不定存储空间, 每一个非传统对象都可以认为是占据了一个不定存储空间, 但是实际上对于不同的种类, 它们的物理存储空间是非常不同的对于那些非传统数据对象, 根据它们的类型定义是否包含 SEQUENCE 语句, 而分为两种 : 非序列结构具有这种结构的对象占据一个单独的不定存储空间单位, 这种单位的实际物理存储空间常常对于不同的对象都是非常不同的例如一个十六位精度的实型数值与一个具有最小长度的逻辑型数据, 尽管它们都声称占据了一个单独的不定存储空间单位, 但它们的实际物理空间的大小是非常不同的序列结构所谓序列结构是由一系列具有明确的类型与属性的数据结构组成的序列, 其中的每个成员都占据了一个存储单位序列结构分为三种 : 数值序列结构只包含默认类型的数值和逻辑型对象字符序列结构只包含默认类型的字符型对象序列结构包含各种成员的混合结构, 例如占据数值存储单位, 字符存储单位, 不定存储空间单位的各种成员下面的表 7-4 列出了各种不同的类型与属性的数据对象所占据的存储单位表 7-4 不同的类型与属性的数据对象所占据的存储单位对象的类型与属性默认整型存储单位 1 个数值存储单位默认实型 1 个数值存储单位默认逻辑型 1 个数值存储单位双精度 2 个数值存储单位默认复型 2 个数值存储单位长度 1 的默认字符型 1 个字符存储单位长度 s 的默认字符型 S 个字符存储单位非默认整型 1 个不定存储单位默认实型与双精度实型之外的实型 1 个不定存储单位非默认逻辑型 1 个不定存储单位非默认复型 1 个不定存储单位长度 1 的非默认字符型 1 个不定存储单位长度 s 的非默认字符型 S 个不定存储单位非序列结构 1 个不定存储单位数值序列结构 n 个数值存储单位 ( 包含 n 个成员 ) 字符序列结构 n 个字符存储单位 ( 包含 n 个成员 ) 序列结构 1 个不定存储单位

123 具有指针属性的任意类型 1 个不定存储单位具有维度属性的任意固有或序列类型数组的尺度乘该类型存储单位的数目 ( 按照数组元素顺序 ) 具有维度属性的任意非固有或非序列类型非指定个不定存储单位具有指针属性与维度属性的任意类型 1 个不定存储单位存储序列所谓存储序列就是一个存储单位的排序一个存储单位可以是数组的一个元素, 字符变量里的字符, 序列结构里的成员, 或者是公用块里的变量一个存储序列的序列构成一个复合的存储序列这个复合存储序列里面存储单位的排序保持每个层次的序列顺序不变, 同时忽略 0 长度的序列当两个不同对象共享了部分存储时, 被称为存储关联通过关联就可以使得多个变量共享存储空间如果两个对象具有相同的存储序列, 那么它们称为完全关联如果两个对象共享部分存储空间而不是完全关联, 那么它们称为部分关联第 8 章构造表达式完成了数据描述的任务之后, 一个程序就进入了数据处理的阶段也就是一系列的以数据为对象的操作语句, 访问经过声明的数据对象, 施加计算处理之后, 获得新的数据结果 FORTRAN 语言里面访问数据对象然后返回值的一个基本指令形式是表达式, 而通过表达式所得到的计算结果被用来赋值给某个变量, 完成这个操作的是赋值语句本章与下一章我们将讨论表达式与赋值语句这两个相续的改变机器的数据状态的基本操作一个科学计算程序的基本任务就是进行计算, 而计算的最基本的单位就是表达式 FORTRAN 作为一门最早的高级语言, 其初衷就是公式翻译 (FORMULA TRANSLATION), 即希望运用这个语言, 能够把数学公式最好是原封不动地搬到 FORTRAN 语言的环境里, 而计算机能够忠实地理解公式的含义, 并进行公式所要求的运算当然, 要求把能够把数学公式原封不动地搬到 FORTRAN 语言的环境里, 就能够被 FORTRAN 理解是不可能的, 因为首先是公式的输入受到键盘的限制, 然后作为一种程序语言, 我们在第 4 章已经讨论过, 它所使用的字符集必定是有限的, 而数学符号的集合则基本上是开放性的而从计算的实质上来考虑, 我们知道计算机在物理层面所能够做到的计算其实是非常简单的加减法而已, 因此我们希望运用计算机来完成任意的计算任务, 所面临的挑战, 正是如何把我们的实际计算任务分解为等价的简单计算过程的组合,FORTRAN 作为一种语言, 显然只能在很初步的层次上完成这个任务, 即直接在语言里使用数学基本运算, 例如 : 加法, 减法, 乘法, 幂运算等, 然后在此基础上, 再定义一些基本的数学函数作为语言的固有函数, 可以供人直接引用, 对它的解释则完全交给 FORTRAN 编译器 FORTRAN 所能够做到的基本上也就到此为止了更进一步的计算的分解任务, 则必须由程序来完成因此 FORTRAN 能够做到的就是尽量以符合数学的书写习惯的方式来规范表达式的格式

124 一般说来, 我们把表达式理解为语句 ( 甚至是程序 ) 的语法结构的单位在其他的语言里, 表达式同样具有非常关键的语法地位, 例如在 C 语言中, 表达式组成了允许每一语句改变机器状态的基本操作在 LISP 语言这样的高级应用语言中, 表达式构成了驱动程序执行的基本顺序控制而在 FORTRAN 这样的以科学计算为主要目的的语言当中, 表达式更是构成了完成计算任务的基本成分本章的讨论就是围绕着表达式的构造如何贴切地合乎我们对于计算任务的要求分为三个部分 : 有效合法的表达式的格式也就是构造表达式的语法按照我们在前面经常根据语法规则来构造语言所获得的经验, 合乎格式的语句不一定是有实际意义的语句, 因此我们接着就需要讨论对表达式的理解问题, 即 : 对表达式的解释可以理解为表达式的语义, 也就是一种规范, 按照这种规范, 计算机读入合法的表达式之后, 能够无歧义地转化为一系列指令, 从而采取相应的动作计算机对表达式的含义的理解建立在表达式的构造语法的规范性上, 一旦完成这个步骤, 接着就是完成表达式的最终任务 : 表达式的计算过程计算机对于表达式的实际计算过程未必与人的计算过程一致, 对于计算机来说, 最为重要的是根据机器计算的特点, 对计算过程进行优化, 相应的作为程序作者, 我们需要了解机器的优化原则, 以便在程序写作与算法设计上配合机器的计算优化能力 FORTRAN 表达式的构造, 需要解决两大问题 : 构造算元与算符的规则 ; 运算优先级的规则在构造合法的 FORTRAN 表达式的过程中, 最主要的问题就是如何在 FORTRAN 有限的构造表达式的规则下, 能够构造具有开放性的数学公式由于一个表达式的基本成分就是算元, 算符和括号, 因此上面的问题可以分为两个部分 : 在固有算元类型的基础上, 能够构造派生类型的算元 ; 在固有算符的基础上, 能够扩展固有算符的适用范围, 能够构造派生类型的算符因此所谓构造表达式的规则, 除了规定固有算元与固有算符之外, 还必须给出对固有算元与固有算符的扩展与派生定义的规则接下来需要考虑的问题, 就是如何表达运算优先级, 也就是括号所具有的功能在数学运算的过程当中, 运算优先级是一个很自然的问题, 在数学公式的写作中, 我们使用了很多隐含的规则, 基本能够保证数学公式的读者不会产生歧义, 把数学公式转换到 FORTRAN 语言当中, 就不能够再依靠那些隐含的规则, 而是需要把那些规则明确的形式化出来, 有时候还得制定适应于机器语言的独特规则尽管我们可以使用尽可能多的括号来做到明确的优先级描述, 但是从方便写作的角度来看, 在不导致歧义的前提下, 可以通过形式规则来省略很多括号 8. 1 表达式的构造本节可以说是书写表达式的语法从语言的角度来看, 我们前面章节所讨论的数据对象, 可以说是语言的词汇, 而且是语法意义上比较简单词汇, 即使很多数据对象可以具有非常复杂的数

125 据结构, 但在语法意义上, 则仍然可以看成是单词但表达式就不同了, 它所隐含的指令性质使得它可以看成是复合性质的词汇实际上表达式是访问程序中的数据对象并返回值的函数这就要求它具有比数据对象更为复杂的语法结构表达式包含三个基本成分 : 算元 ; 算符 ; 括号其中算元具有最基本的实质含义, 因此最简单的表达式就是一个常量, 或一个变量例 8-1 下面的例子都可以看成是最简单的表达式 : ! 一个实型常数 A! 一个标量变量 X! 一个数组变量.TURE.! 一个逻辑型常量 X(I)! 作为数组 X 的元素的变量 X(10:100:5)! 作为一个数组片断的变量 A%B! 作为结构 A 的成员的变量 X(I)(K:K+100)! 作为数组元素 X(I) 的子串的变量算元遵循变量的数学精神, 我们可以把表达式看成是一个递归结构, 即表达式里的变量总是可以代表任意的由变量构成的结构, 或者说表达式, 因此可以如下规定算元的构成一个算元可以是如下形式的表达式 : 一个常量或常量的子对象 ; 一个变量 ; 一个数组构造器 ; 一个结构构造器 ; 一个函数引用 ; 另一个括号里的表达式注意另一个表达式!, 如果使用同一个表达式, 必然导致死循环例 8-2 下面是算元的例子 : X Y(3) Z(10:100) (X+SIN(Y)) (/5.52,4031/) EULER(5,9) RT!

126 8.1.2 一元算符与二元算符根据算符所作用的算元数目, 算符分为一元算符与二元算符下面的表 8-1 给出了 FORTRAN 的固有算符, 除此之外, 用户可以运用函数子程序来给出自定义算符, 然后使用一个名称来标志该自定义算符, 在 FORTRAN 语言里, 则还需要在名称的两边分别加上一个句点, 以便 FORTRAN 辨识为自定义算符无论是固有算符还是自定义算符, 总是分为一元算符与二元算符一元算符作用于一个算元, 形式为 : operator x 即算符写在算元之前例 A - G.NOT. B 上面的一元算符里面,+ 和 - 都可以成为二元算符, 而.NOT. 则是唯一的只能作一元算符的固有算符加号 + 运算实际上并不影响算元的值二元算符作用于 2 个算元, 形式为 : x operator y 即算符写在 2 个算元之间例 8-4 A+B D**3 X.AND. Y A.GT. B C.NE. D PROGRAMER // CALCULATE A == B C-D 固有算符与自定义算符算符分为两类 : 固有算符所谓固有算符就是直接使用相应符号, 能够被 FORTRAN 编译器所辨识的算符下面的表 8-1 给出了 FORTRAN 的固有算符以及相应的算元类型表 8-1 FORTRAN 的固有算符以及相应的算元类型算符类别固有算符算元类型

127 算术运算 +,-( 一元算符 ) 任意数值类型与任意种别参数的数值的组 **,*,/,+,-( 二元算符 ) 合字符运算 // 具有相同种别参数的任意长度的字符串关系运算. EQ.,.NE., ==,/= 两个算元或者同时是任意数值类型与任意种别参数的数值, 或者同时是具有相同种别参数的任意长度的字符串关系运算.GT.,.GE.,.LT.,.LE., 两个算元或者同时是除了复型之外的任意 >,>=,<,<= 数值类型与任意种别参数的数值, 或者同时是具有相同种别参数的任意长度的字符串逻辑运算.NOT.( 一元算符 ) 同时是任意种别参数的逻辑型数据的组合.AND.,.OR.,.EQV.,NEQV. ( 二元算符 ) 关系算符 ==,/=,>,>=,<,<= 是为了向数学公式的写法靠近, 而在 FORTRAN 里面最新引入的算符写法, 分别等价于.EQ.,.NE.,.GT.,.GE.,.LT.,.LE. 自定义算符显然上面那些固有算符不够用, 所以为了获得算符表示的开放性,FORTRAN 约定了通过函数子程序定义自定义算符的规则首先自定义算符必须拥有一个名称, 而这个名称的写法必须满足一定的形式规则, 以便 FORTRAN 编译器的辨识自定义算符的形式为 :.XXX. 即在两个句点之间有 n 个字母,n 不大于 31 中间的字母串最好是一个表达该运算含义的英文单词这个单词不能与固有运算符或者逻辑常量里面已经使用了的单词重复自定义算符可以是基于已经定义的算符和固有算符, 完全重新定义的算符, 因此需要给出一个新的名称, 也可以是对固有算符的作用算元的类型的扩展, 这时仍然可以使用固有算符的符号, 但是扩展定义需要预先给出一元自定义算符具有最高的运算优先级, 而二元自定义算符具有最低的运算优先级构造表达式的规则所谓构造表达式的规则, 就是一系列的语句规则, 按照这个规则把算元和算符组合起来得到的就是合法的表达式当然这里包含了一定的任意性, 即只要按照这个规则构造出来的表达式都是被 FORTRAN 认可的语法规则除了给出算元与算符的顺序之外, 还能够表达运算顺序, 而这个运算顺序是以运算优先级形式给出的, 当然 FORTRAN 表达式的运算优先级必须和我们的数学公式里的运算优先级一致直观来看, 表达式就是变量的运算结构, 而变量本身具有递归的含义, 因此表达式的定义必然是具有递归的结构也就是首先我们定义最底层的基元, 即最简单的表达式, 然后对基元的运算构成更加复杂的

128 表达式, 而递归的体现就是在基元里面包括括号里面的表达式 1. 基元基元的形式定义 (R701) 为 : constant constant-subobject variable array-constructor structure-constructor function-reference (expression) 以上任何一种对象都可以成为基元所谓常量子对象 (constant-subobject), 就是一个父结构为常量的子对象作为基元的变量, 不能是哑尺度数组, 或者一个哑尺度数组的片断, 除非数组的最后一个下标已经明确给出为一个标量下标, 或上界确定的下标三元组, 或下标向量例 8-5 基元的例子如下 : PI LENGTH 实型常量命名常量命名常量 WHOLE (I:I) 常量子对象 X 变量 X(K) 数组元素 X(:,1:K) 在最后一维具有上界的哑尺度数组 STRING(I:J) 子串 (/I,5,100/) 数组构造器 BESSEL1(A,B) 结构构造器 F(X) 函数引用 ( WHOLE (I:I)//BUT) 括号里的表达式作为一个命名常量,PI 明显地表示圆周率, 使用这类含义明确的英文单词来表示常量是一个很好的习惯当 LENGTH 具有 PARAMETER 属性, 或出现在 PARAMETER 语句当中时, 同样是一个命名常量 WHOLE (I:I) 实际上是一个常量子对象, 尽管其中 I 可能是一个变量, 但它的父结构是一个常量 BESSEL1 (A,B), F(X) 都属于自定义类型对象, 它们在程序里出现时, 都需要预先加以定义 2. 自定义一元表达式一个已经自定义的一元算符后接一个算元构成一个自定义一元表达式, 句法形式 (R703) 为 : [defined-operetor]primary 其中自定义算符 (defined-operetor) 的句法形式 (R704) 为 :.letter[ letter]. 注意自定义算符是可选的, 即单独的基元也可以构成一元表达式构成自定义算符的字符数目不能够超过 31 自定义算符不能与固有算符以及逻辑字面常量雷同

129 例 8-6.AB EL.G G 自定义一元表达式,.ABEL. 为自定义算符单独的基元也可以构成一元表达式 3. 幂运算表达式幂运算表达式的句法形式 (R705) 为 : defined-unary-expression[**exponentiation-expression] 以上形式表明了幂运算表达式 (exponentiation-expression) 是右边递归的, 即幂运算算符右边的幂运算表达式正是上面所定义的表达式本身, 这意味着会出现多个幂运算连在一起的情形, 这时的优先级是从右到左, 即 X**Y**Z 被解释为 X* *(Y**Z) 注意其中的幂运算表达式与幂运算算符都是可选的, 即单独的自定义一元表达式从语法角度而言, 也是幂运算表达式例 8-7 X**Y X**Y **Z.ABEL.G G 幂运算表达式表示从右到左优先级的幂运算表达式自定义一元表达式也是幂运算表达式单独的基元也可以构成幂运算表达式 4. 乘法表达式乘法表达式的算元为 * 和 /, 句法形式 (R706) 为 : [multiplication-expression*]exponentiation-expression multiplication-expression / exponentiation-expression 以上形式表明了乘法表达式 (multiplication-expression) 是左边递归的, 即乘法算符左边的乘法表达式正是上面所定义的表达式本身, 这意味着会出现多个乘法运算连在一起的情形, 这时的优先级顺序是从左到右, 即 X*Y*Z 被解释为 (X*Y)*Z 在以后的二元运算里, 除了关系运算, 同级优先级顺序都是从左到右注意使用算符 * 的乘法运算表达式与乘法运算算符都是可选的, 即单独的幂运算表达式从语法角度而言, 也是幂运算表达式例 8-8 X*Y 乘法运算表达式 X*Y*Z 表示从左到右优先级顺序的乘法运算表达式 X / Y 乘法运算表达式 X / Y / Z 表示从左到右优先级顺序的乘法运算表达式 X**Y 幂运算表达式也是乘法运算表达式.ABEL.G 自定义一元表达式也是乘法运算表达式 G 单独的基元也可以构成乘法运算表达式 5. 加法表达式加法表达式的算元为 + 和 -, 句法形式 (R707) 为 : [summation-expression + ] multiplication -expression summation-expression - multiplication expression

130 + multiplication -expression - multiplication expression 多个加法运算的优先级顺序是从左到右, 例如 X+Y+Z 被解释为 (X+Y)+Z 注意使用算符 + 的加法运算表达式与加法运算算符都是可选的, 即单独的乘法运算表达式从语法角度而言, 也是加法运算表达式例 8-9 X+Y 加法表达式 X-Y+Z 表示从左到右优先级顺序的加法表达式 -X-Y- Z 表示从左到右优先级顺序的加法表达式 -X 使用一元算符 - 的加法表达式 +X 使用一元算符 + 的加法表达式 X*Y 加法表达式 X / Y / Z 加法表达式 X**Y 幂运算表达式也是加法表达式.ABEL.G 自定义一元表达式也是加法表达式 G 单独的基元也可以构成加法表达式 6. 串联表达式串联表达式的算元为 //, 句法形式 (R711) 为 : [concatenation-expression // ] summation-expression 例 8-10 X//Y 串联表达式 X//Y//Z 表示从左到右优先级顺序的串联表达式 X+Y 加法表达式也是串联表达式 -X-Y-Z 串联表达式 -X 串联表达式 X*Y 串联表达式 X / Y / Z 串联表达式 X**Y 幂运算表达式也是串联表达式.AB EL.G 自定义一元表达式也是串联表达式 G 单独的基元也可以构成串联表达式 7. 比较表达式比较表达式的算元为关系算符, 句法形式 (R713) 为 : [concatenation-expression relation-operator ] concatenation-expression 关系算符 ==,/=,>,>=,<,<= 在任何情况下总是分别等价于.EQ.,.NE.,.GT.,.GE.,.LT.,.LE. 注意关系表达式的定义不具有递归性, 即关系表达式本身不出现在上面的形式定义当中, 所以不会出现多个关系算符连在一起的情形例 8-11 X.NE. Y 关系表达式

131 X <=Y 关系表达式 X//Y 关系表达式 X+Y 加法表达式也是关系表达式 -X 关系表达式 X / Y / Z 关系表达式 X**Y 幂运算表达式也是关系表达式.ABEL.G 自定义一元表达式也是关系表达式 G 单独的基元也可以构成关系表达式 8. 非运算表达式非运算表达式的算元为.NOT., 是一元算符, 句法形式 (R715) 为 : [.NOT. ] comparision-expression 注意非运算表达式的定义不具有递归性, 即非运算表达式本身不出现在上面的形式定义当中, 所以不会出现多个算符.NOT. 连在一起的情形例 8-12.NOT. X X.NE. Y X <=Y X//Y X+Y X / Y / Z X**Y.ABEL.G G 非运算表达式关系表达式也是非运算表达式非运算表达式非运算表达式加法表达式也是非运算表达式非运算表达式幂运算表达式也是非运算表达式自定义一元表达式也是非运算表达式单独的基元也可以构成非运算表达式 9. 与运算表达式与运算表达式的算元为.AND., 是二元算符, 句法形式 (R716) 为 : [conjunct-expression.not. ] not-expression 注意与运算表达式的定义具有左边递归性, 即与运算表达式本身出现在上面的形式定义当中, 所以会出现多个算符.AND. 连在一起的情形, 这时的优先顺序是从左到右即 X.AND. Y.AND. Z 的优先顺序是 (X.AND. Y).AND. Z 例 8-13 X.AND. Y 与运算表达式 X. AND. Y.AND. Z 优先顺序是从左到右的与运算表达式.NOT. X 非运算表达式也是与运算表达式 X.NE. Y 关系表达式也是与运算表达式 X <=Y 与运算表达式 X//Y 与运算表达式 X+Y 加法表达式也是与运算表达式 X / Y / Z 与运算表达式 X**Y 幂运算表达式也是与运算表达式.ABEL.G 自定义一元表达式也是与运算表达式

132 G 单独的基元也可以构成与运算表达式 10. 或运算表达式或运算表达式的算元为.OR., 是二元算符, 句法形式 (R717) 为 : [disjunct-expression.or. ] conjunct -expression 注意或运算表达式的定义具有左边递归性, 即或运算表达式本身出现在上面的式定义当中, 所以会出现多个算符.OR. 连在一起的情形, 这时的优先顺序是从左到右即 X.OR. Y.OR. Z 的优先顺序是 (X.OR. Y).OR. Z 例 8-14 X.OR. Y 或运算表达式 X.OR. Y.OR. Z 优先顺序是从左到右的或运算表达式 X.AND. Y 与运算表达式也是或运算表达式.NOT. X 非运算表达式也是或运算表达式 X.NE. Y 关系表达式也是或运算表达式 X <=Y 或运算表达式 X//Y 或运算表达式 X+Y 加法表达式也是或运算表达式 X / Y / Z 或运算表达式 X**Y 幂运算表达式也是或运算表达式.ABEL.G 自定义一元表达式也是或运算表达式 G 单独的基元也可以构成或运算表达式 11. 等价运算表达式等价运算表达式的算元为.EQV. 或者是.NEQV., 是二元算符, 句法形式 (R718) 为 : [equivalence-expression.eqv. ] disjunct -expression equivalence-expression.neqv. disjunct expression 注意等价运算表达式的定义具有左边递归性, 即等价运算表达式本身出现在上面的形式定义当中, 所以会出现多个算符.EQV. 或与.NEQV. 连在一起的情形, 这时的优先顺序是从左到右即 X.NEQV. Y.EQV. Z 的优先顺序是 (X.NEQV. Y).EQV. Z 例 8-15 Y.EQV. Z 等价运算表达式 X.NEQV. Y 等价运算表达式 X.NEQV. Y.EQV. Z 优先顺序是从左到右的等价运算表达式 X.OR. Y 或运算表达式也是等价运算表达式 X.AND. Y 与运算表达式也是等价运算表达式.NOT. X 非运算表达式也是等价运算表达式 X.NE. Y 关系表达式也是等价运算表达式 X <=Y 等价运算表达式 X//Y 等价运算表达式 X+Y 加法表达式也是等价运算表达式 X / Y / Z 等价运算表达式 X**Y 幂运算表达式也是等价运算表达式.ABEL.G 自定义一元表达式也是等价运算表达式

133 G 单独的基元也可以构成等价运算表达式 12. 表达式最一般的表达式的句法形式 (R723) 为 : [ expression defined-operator ] equivalence-expression 注意表达式 (expression) 的定义具有左边递归性, 即表达式本身出现在上面的形式定义当中, 所以会出现多个相同优先级的算符连在一起的情形, 这时的优先顺序是从左到右例 8-16 X.CROSS. Y 表达式 X.CROSS. Y.CROSS. Z 优先顺序是从左到右的表达式 Y.EQV. Z 等价运算表达式也是表达式 X.NEQV. Y 等价运算表达式也是表达式 X.NEQV. Y.EQV. Z 等价运算表达式也是表达式 X.OR. Y 或运算表达式也是表达式 X.AND. Y 与运算表达式也是表达式.NOT. X 非运算表达式也是表达式 X.NE. Y 关系表达式也是表达式 X <=Y 表达式 X//Y 表达式 X+Y 加法表达式也是表达式 X / Y / Z 表达式 X**Y 幂运算表达式也是表达式.ABEL.G 自定义一元表达式也是表达式 G 单独的基元也可以构成表达式 13. 表达式形式的层次上面我们已经完备地给出了表达式的语法形式, 可以明显地看到从最简单的表达式到更为复杂的表达式, 具有一种层次结构, 这种依据优先级顺序给出的层次结构是我们构造复杂表达式所必须遵循的规则, 也是计算机理解表达式时所依据的规则下面我们给出总结例 8-17 下面是一个表达式里的运算优先级降低的例子 : X! 基元.INVERSE. X! 自定义一元运算 X**Y! 幂运算表达式 X*Y! 乘法运算表达式 -X! 加法运算表达式 X//Y! 连接运算表达式 X.EQ. Y! 比较运算表达式.NOT. X! 非运算表达式 X.AND. Y! 并运算表达式 X.OR. Y! 或运算表达式 X.EQV. Y! 等价运算表达式 X.CROSS. Y! 一般表达式下表 8-2 给出各种一般形式的表达式的运算优先级 :

134 表 8-2 一般形式的表达式的运算优先级优先级向下递降的运算项运算的定义优先级基元自定义一元运算表达式常量常量子对象变量数组构造器函数引用 ( 表达式 ) [ 自定义算符 ] 运算元高幂运算表达式自定义一元运算表达式 [** 幂运算表达式 ] 乘法运算表达式加法运算表达式连接运算表达式 [ 乘法运算表达式 *] 幂运算表达式乘法运算表达式 / 幂运算表达式 [ 加法运算表达式 +] 乘法运算表达式加法运算表达式 - 乘法运算表达式 + 加法运算表达式 - 加法运算表达式 [ 连接运算表达式 //] 加法运算表达式比较运算表达式 [ 比较运算表达式关系算符 ] 比较运算表达式非运算表达式 [.NOT.] 比较运算表达式并运算表达式 [ 并运算表达式.AND.] 非运算表达式或运算表达式 [ 或运算表达式.OR.] 并运算表达式等价运算表达式 [ 等价运算表达式.EQV.] 或运算表达式等价运算表达式.NEQV. 或运算表达式一般表达式 [ 表达式自定义算符 ] 等价运算表达式低算符的优先级顺序下表 8-3 给出各类算符在同样的优先级的情形下的运算优先级顺序 : 表 8-3 各类算符在同样的优先级的情形下的运算优先级顺序算符类型算符同优先级下的运算顺序优先级自定义一元自定义算符无最高数值运算 ** 右到左数值运算 * 或 / 左到右数值运算一元算符 + 或 - 无数值运算二元算符 + 或 - 左到右字符运算 // 左到右关系运算.EQ.,.NE.,.LT.,.LE.,.GT.,.GE., ==,/=,<,<=,>,>= 无

135 逻辑运算.NOT. 无逻辑运算.AND. 左到右逻辑运算.OR. 左到右逻辑运算.EQV. 或.NEQV. 左到右自定义二元自定义算符左到右最低自定义一元算符在所有算符与所有同优先级算符当中, 具有最高的优先级而自定义二元算符在所有算符与所有同优先级算符当中, 具有最低的优先级表中的无表示该算符不会连续出现, 可以看到具有这个特点的是自定义一元算符, 关系算符, 和逻辑非算符, 它们的优先级顺序只能使用括号来说明固有运算固有运算的完整含义是, 除了算符是属于固有算符, 因此可以直接使用相应符号而不需要预先说明之外, 算符所作用的算元也必须属于固有数据类型不同的算符所能够作用的算元类型是不同的下表 8-4 给出了不同的算符所能够作用的算元类型 : 表 8-4 不同的算符所能够作用的算元类型固有算符算元 1 的类型算元 2 的类型计算结果的类型一元算符 +,- I,R,Z I,R,Z 二元算符 +,-,*,/,** I I,R,Z I,R, Z R I,R,Z R,R,Z Z I,R,Z Z,Z,Z 串联算符 // C C C.EQ.,.NE., I I,R,Z L,L,L ==,/= R I,R,Z L,L,L Z I,R,Z L,L,L C C L.L T.,.LE.,.GT.,.GE., I I,R L,L = =,/=,<,<=,>,>= R I,R L,L C C L.NOT. L L.AND.,.OR.,.EQV.,NEQV. L L L 表中 I 表示整型,R 表示实型,Z 表示复型,C 表示字符型,L 表示逻辑型自定义运算自定义运算的完整含义是 : 如果算符形式上是固有算符, 那么它的算元必定不属于表 8-3 里面所规定的类型 ;

136 所含有的算符为自定义算符自定义运算的一般句法形式 (R703,R723) 为 : intrinsic-unary-operator y defined-operator y x intrinsic-binary-operator y x defined-operator y 其中自定义算符 (defined-operator) 需要在一个具有通用标识符 OPERATOR 的界面块里用一个函数子程序来加以单独的解释与计算如果自定义运算使用了固有算符的符号, 意味着扩展了其中固有算符所作用的算元的类型范围, 它的通用性需要在界面块里说明如果自定义运算使用了自定义算符, 那么该自定义运算被称为扩展运算, 所使用的自定义算符称为扩展算符表达式的数据类型, 种别参数和形状作为表达式的计算结果, 可以说表达式终究是有它的数据类型, 种别参数, 以及形状这些数据对象所具有的属性, 那么表达式的这些属性终究是由它的基元的数据属性决定的由基元的数据属性最终得到表达式的数据属性, 这中间需要完成全部的运算, 每经过一次运算, 结果的数据属性都可能随着新的算元的加入而发生改变, 唯一可以确认的是运算的顺序, 是严格按照算符的优先级顺序进行的, 鉴于基元本身的可能的数据属性的多样化, 下面分小节讨论表达式的的数据属性 1. 基元的数据类型以及种别参数基元的数据属性如果已经直截了当地在声明语句当中给予了说明, 那就不是我们在这里讨论的中心例 8-18 INTEGER I(100,20) REAL (8.5,6,4.4) 它们的数据属性已经显式地给出下面我们要讨论的基元类型是 : 指针 ; 数组构造器 ; 结构构造器 ; 函数指针变量的类型, 种别参数和秩都会在指针变量的声明语句当中予以说明但是当指针为待定形数组时, 它的形状就是由它的目标来决定例 8-19 INTEGER,POINTER::X(:,:) INTEGER,TARGET::Y(100,200) 其中 X 的形状就是由 Y 决定的, 即 (100, 200)

137 如果对指针使用固有函数 NULL, 那么它会返回一个非关联指针, 而非关联指针没有形状, 但是有秩当 NULL() 不带变量时, 固有函数 NULL 返回的结果的类型, 种别和秩由与结果关联的指针决定, 跟 NULL 出现的场合有关, 详见下表 8-5: 表 8-5 固有函数 NULL 返回的结果 N ULL() 出现的场合指针赋值语句的右边声明语句当中一个对象的初始化一个成员的默认初始化结构构造器实元 DATA 语句决定结果的类型, 种别参数和秩的对象左边的对象该对象该成员相应的成员相应的哑元相应的对象例 8-20 下面是 NULL 后接变量的例子 : INTERFACE ADD SUBROUTING S1(J,PI) INTEGER J INTEGER,POINTER::PI END SUBROUTING S1 SUBROUTING S2(K,PR) INTEGER K REAL,POINTER::PR END SUBROUTING S2 END INTERFACE REAL,POINTER::REAL_KER CALL ADD(10, NULL(REAL_KER)) 数组构造器的类型, 种别和形状由构造器的形式决定它的秩为 1, 而尺度等于其中元素的个数, 它的类型和种别与其中任意一个元素的一致, 因为它的所有元素的类型和种别都必定是相同的例 8-21 给出一个构造器 : (/2.4_2, 5.9_1, 9.4_1, 6.4_1) 为实型, 种别参数为 2, 尺度为 4. 结构构造器的类型就是派生类型的类型名称, 一个结构构造器总是标量, 而结构不具有种别参数例 8-22 给出下面的结构构造器 : SAMPLE(5.0, ALPHA )

138 它的类型就是 SAMPLE. 函数的类型, 种别和形状的决定有以下几种情形 : 在引用函数的程序单位里对函数进行了隐式声明 ; 在引用函数的程序单位里对函数进行了显式声明 ; 函数具有显式界面 ( 如果界面不是显式的, 那么函数或者是外部函数, 或者是语句函数 ) 如果界面是显式的, 属性的决定有如下几种情形 : 引用函数的程序单位里的界面块里, 有对函数的类型声明以及其他说明语句 ; 对内部过程或模块过程的类型声明以及其他说明语句说明了函数 ; 被引用的特定的固有函数的描述注意, 由于固有函数和带界面块的函数可能是通用的, 因此它们的属性由特定函数引用的实元决定例 8-23 REAL FUNCTION FUN(A) DIMENSION FUN(20,50) 上面的语句是给出了内部函数 FUN 的程序单位的一部分, 那么要引用函数 FUN(8.1), 它的类型就是默认实型, 形状为 (20,50) 例 8-24 REAL(DOUBLE)A(30,50) COS(A) 函数 COS 的界面在固有函数 COS 的定义里给出, 这里引用的函数 COS(A) 为双精度实型, 形状为 (30,50) 当函数是外部函数或为语句函数时, 界面就是隐式的, 这时形状总是标量, 而其他属性则由默认隐式类型声明所规定, 或者是由语句函数的显式声明决定例 8-25 IMPLICIT REAL ( SINGLE)(A) FUN(X) 其中的 FUN(X) 就是一个单精度实型标量如果变量或函数是属于待定形或哑形数组, 会有以下几种情形 : 对于待定形数组, 它的秩已经被声明, 但是它的每个维度的尺度需要在运行 ALLOCATE 语句或指针赋值语句之后才能确定对于哑形数组, 它的秩已经被声明, 但是它的形状需要子程序运行之后给出对于指针来说, 则需要由被关联到指针的目标来确定形状因此一般说来待定形或哑形数组, 只能在运行时间才能确定形状 2. 运算结果的类型与种别参数对固有类型算元进行固有算符的运算的结果的类型, 已经在表 8-3 给出, 因此现在只需要讨论决定种别参数的规则运算分为两类 :

139 非数值运算数值运算对于非数值运算有如下情形 : 固有关系运算 : 种别参数为默认逻辑型固有逻辑运算 : 如果算元具有相同的种别参数, 则结果与之保持一致 ; 如果算元具有不同的种别参数, 则由编译器决定固有字符运算 : 算元与结果的种别参数必定保持一致, 长度参数则是两个算元的长度的和对于数值运算, 有如下情形 : 一元运算 : 保持算元的种别参数不变二元运算 : 两个算元如果是不同数据类型, 则按照表 8-3 决定 ; 两个算元如果是相同数据类型与种别参数, 则结果保持不变 ; 如果两个算元都是整型, 种别参数不同, 那么结果取幂次范围大的, 如果幂次范围一样大, 则由编译器决定 ; 如果两个算元都是实型或复型, 种别参数不同, 那么结果取精度大的, 如果精度一样大, 则由编译器决定对于二元数值运算, 基本的规则可以理解为 : 如果把从整数到最高精度的复数按照集合包含关系排列起来, 那么只要两个算元的种别参数不同, 结果总是取所属集合更大的算元的种别参数上面讨论的是针对固有类型数据的固有运算, 对于自定义运算, 结果的类型以及种别参数由被引用的运算的界面块给出, 也即在界面块里说明的作为自定义运算的函数名的类型以及种别参数例 8-26 INTERFACE OPERATOR(.PLUS.) TYPE(SET)FCN_ SET_PLUS(X, Y) TYPE(SET), INTENT(IN)::X,Y END FUNCTION FCN_SET_PLUS TYPE(ADD) FCN_SET_PLUS(X, Y) TYPE(ADD), INTENT(IN)::X,Y END FUNCTION FCN_SET_PLUS END INTERFACE 在得到上面的算符定义之后, 如果取类型 SET 的对象 A 和 B, 那么表达式 A.PLUS.B 的类型也为 SET, 无种别参数 ; 如果取类型 ADD 的对象 A 和 B, 那么表达式 A.PLUS.B 的类型也为 ADD, 无种别参数 3. 表达式的形状表达式形状的决定同样是从基元开始, 按照算符的优先级顺序, 逐步从底层到高层而决定的但是形状的决定比类型与种别参数的决定要简单, 因为二元运算的 2 个算元的形状要求具有一定的关系 : 二元固有运算的 2 个算元必须保证形状的一致性, 也就是两个算元或者是相同形状的数组, 或者至少有一个算元是标量

140 对于二元自定义运算, 则 2 个算元或者与定义的函数的相应哑元保持一致, 或者相互也保持一致其结果的形状自然也保持不变因此结果的形状的决定也就相应比较简单了一元运算不改变算元的形状如果基元是常量, 变量, 构造器, 或函数, 则结果的形状分别就是常量, 变量, 构造器, 或函数名称如果基元是对固有函数 NULL 的引用, 那么结果的形状就与基元无关而由被关联到结果的指针决定结构构造器总是标量数组构造器总是秩为 1, 尺度等于元素数目的数组二元固有运算的算元只要有一个是数组, 结果就是相应的数组, 否则就是标量对于自定义运算来说, 如果算元的形状与哑元保持一致, 结果的形状就是定义运算的函数名称, 或者如果定义的函数是基元性的, 则结果的形状就是数组算元的形状例 8-27 INTERFACE OPERATOR(//) FUNCTION FCN_CONCAT(A,B) CHARACTER (*,1) A CHARACTER (*,2) B CHARACTER (LEN(A)+LEN(B),2) FCN_CONCAT (SIZE(B)) END FUNCTION FCN_CONCAT END INTERFACE 设 X 是种别参数为 1, 长度为 30 的字符型标量,Y 是种别参数为 2, 长度为 50 的字符型数组, 其形状为 (25) 那么考虑 X//Y 的属性 : 由于算符 // 的界面里的 FCN_CONCAT 的类型声明就决定了表达式 X//Y 的结果为种别参数 2 的字符型, 结果的长度为 2 个算元的长度之和, 即 80, 结果的形状是秩为 1, 而尺度等于相应于哑元 B 的实元 Y 的尺度, 也就是形状为 (25) 4. 表达式的宽度在大多数情形下, 数组表达式的宽度并不需要特别的考虑, 因为一致性的要求只涉及到每个维度的尺度不过如果数组表达式是固有函数 LBOUND 和 UBOUND 的 ARRAY 变量的, 数组表达式的宽度就需要加以考虑了固有函数 LBOUND 和 UBOUND 含有两个关键词变量 : ARRAY, 为数组表达式可选的 DIM, 为整型表达式如果变量 DIM 给出的话, 那么函数 LBOUND 和 UBOUND 就分别返回由变量 DIM 决定的维度的下界与上界如果变量 DIM 不给出的话, 那么函数 LBOUND 和 UBOUND 就分别返回由变量 ARRAY 决定的所有维度的下界与上界组成的秩为 1 的数组

141 8.2.9 特殊表达式表达式除了用于赋值语句之外, 还可能出现在许多特殊的场合, 在那些特殊场合里的表达式是受到了各种限制的, 比如 : 出现在 PARAMETER 语句当中的表达式就被限制为常量表达式, 起到初始化的作用这类表达式称为常量表达式 ; 在许多说明语句当中, 充当数组界或者是字符长度值的也可能是一些整型表达式, 它们在程序单位运行的时候, 就会执行计算过程, 给出数组界的值或字符长度值这类表达式称为说明表达式本节我们就是分小节讨论这 2 类特殊的表达式的特殊用途 1. 常量表达式常量表达式就是扩展常量或扩展常量通过固有算符构成的表达式所谓扩展常量的含义有如下几种情形 : 字面常量, 命名常量, 常量子对象, 其中子对象的每个下标, 或片断下标, 或子串范围的始点与终点都是常量表达式一个数组构造器, 它的每个子表达式的基元都是常量表达式, 或者是数组构造器的隐式 do 变量每个成员都是常量表达式的结构构造器在汇编时被计算的固有函数引用括号里的常量表达式要求固有函数引用在汇编时被计算, 就排除了使用固有函数 PRESENT,ASSOCIATED 和 ALLOCATED, 并且要求函数引用的每个变量都是常量, 或者至少在编译时, 变量的种别参数与界已知例如在所有维度具有显式界的数组 A, 对于 A 的查询函数 SIZE(A) 在编译时是可以计算的, 那么 SIZ E(A)*3 就是一个常量表达式, 可以作为扩展常量这样一个限制就排除了属于待定形数组, 哑尺度数组, 指针数组和可分配数组这类对象的变量有了以上限制之后, 常量表达式就可以应用于任何可执行语句, 而普通表达式是不能出现在任何可执行语句当中的例 8-28 下面是常量表达式的合法例子 : 实型字面常量 45 整型字面常量 -5.0_QUAD 实型字面常量, 其中 QUAD 为命名整型常量 5_SHORT 整型字面常量, 其中 SHORT 为命名整型常量 (/(K,K=0,100),50) 数组构造器 BESSEL1(3.1, J) 结构构造器, 其中 BESSEL 为派生类型,J 为命名整型常量 UBOUND(X,1)-10 固有查询函数的引用,X 为显形数组 COS(X) 固有函数, 其中 X 为命名常量 KIND(X) 固有函数, 其中 X 为具有已知种别参数的实型变量 REAL(K-2) 固有函数, 其中 K 为命名整型常量 COUNT(X) 固有函数, 其中 X 为命名逻辑型常量 SIN(3.3) 固有函数

142 SUM(X) 3*I+J**4/2.5 固有变换函数, 其中 X 为命名整型数组常量数值表达式, 其中 I,J 为命名整型常量 2. 初始化表达式所谓初始化表达式是具有如下限制的常量表达式 : 幂函数的幂次只能是整数下标, 片断下标, 子串范围的始点与终点, 结构构造器的成员, 以及固有函数的变量都必须是初始化表达式数组构造器的元素都必须是初始化表达式, 或者是隐式 do 对象, 其中数组构造器值和隐式 do 参数是基元为初始化表达式或隐式 do 变量的表达式初始化表达式里的基本固有函数必须包含整型或字符型变量, 并且必须返回整型或字符型结果初始化表达式里的固有变换函数必须是如下几种固有变换函数之一 : NULL,REPEAT,RESHAPE, SELECTED_INT_KIND,SELECTED_REAL_KIND,TRANSFER, TRIM 其中除了 NULL 之外, 它们的变量都必须是初始化表达式这样实际上就是排除了以下的变换函数 : ALL,ANY,COUNT,CSHIFT, DOT_PRODUCT,EOSHIFT,MATMUL,MAXLOC, MAXVAL,MINLOC,MINVAL,PACK,PRODUCT,SPREAD,SUM,TRANSPOSE, UNPACK 初始化表达式不能通过 ALLOCATE 语句给出, 也不能通过指针赋值给出允许使用固有查询函数, 除非它的变量或者是初始化表达式或者变量的种别与界不能够通过查询获得括号里的任意子表达式都必须是初始化表达式在节里的常量表达式例子里面, 除了最后 5 个例子外, 其他都是初始化表达式最后 5 个例子之所以不是初始化表达式, 是因为初始化表达式不允许包含返回实型结果的函数, 不允许引用某些特定的变换函数, 也不允许幂运算的幂次是非整数例 8-29 下面是初始化表达式的其他形式的例子 : SIZE(2,X)+10 整型表达式, 其中 X 为显形数组 KIND(5.0E+01) 变量为常量的查询函数 SELECTED_REAL_KIND(33,100) 变量为常量的查询函数 SELECTED_INT_KIND(10**K) 变量为初始化表达式的查询函数, 其中 K 为预先声明过的整型常量初始化表达式使用在如下场合 : 在 PARAMETER 语句或者附加了 PARAMETER 属性的类型声明语句当中, 作为初始值跟在等号的后面在类型声明语句里, 作为某项的初始值跟在等号的后面在 DATA 语句的取值列表里作为结构构造器的表达式在类型声明语句当中, 作为种别参数值, 这时它必须取整型标量作为如下固有转换函数的 KIND 哑元的实元 : AINT,ANINT,CHAR,CMPLX,INT,LOGICAL,NINT,REAL

143 这时它也必须取整型标量在 CASE 语句当中作为情形值, 这时它必须为整型, 逻辑型或字符型标量在 EQUIVALENCE 语句当中, 作为等价对象的下标或子串范围表达式, 这时它必须取整型标量初始化表达式必须用于在编译时必须获得表达式的值的场合初始化表达式不能包含返回实型, 复型以及逻辑型的结果的固有函数, 也不能包含实型, 复型以及逻辑型的变量 3. 说明表达式首先我们给出限制表达式的定义作为一种说明, 一个限制表达式就是它的每个算符都是固有的或者是由纯粹函数定义的自定义算符, 而每个基元都是如下类型之一 : 常量或常量子对象作为哑元的变量在公用块里的变量可从模块访问的变量来自主程序的变量一个数组构造器, 它的每个表达式的基元都是限制表达式或者是数组构造器的隐式 do 变量每个成员都是限制表达式的结构构造器一个基本固有函数, 它的结果为整型或字符型, 它的变量是任意整型或字符型的限制表达式初始化表达式里的固有变换函数必须是如下几种固有变换函数之一 : NULL,REPEAT,RESHAPE, SELECTED_INT_KIND,SELECTED_REAL_KIND,TRANSFER, TRIM 其中除了 NULL 之外, 它们的变量都必须是初始化表达式这样实际上就是排除了以下的变换函数 : ALL,ANY,COUNT,CSHIFT,DOT_PRODUCT,EOSHIFT,MATMUL,MAXLOC, MAXVAL,MINLOC,MINVAL,PACK,PRODUCT,SPREAD,SUM,TRANSPOSE, UNPACK 自定义的纯粹函数除了 PRESENT,ALLOCATED,ASSOCIATED 之外的固有查询函数, 并且它的变量必须是 : 限制表达式 ; 不能查询种别参数与界的变量, 不能由 ALLOCATE 语句定义, 也不能由指针赋值语句定义这样任何下标, 片断下标, 以及子串范围的始点和终点都是限制表达式所谓说明表达式就是一个限制表达式, 同时它必须取整型标量值之所以称为说明表达式, 就是因为说明表达式用于在类型声明, 属性说明, 维度声明以及其他说明性语句当中, 表示数组的界, 或者字符型对象的长度参数值

144 4. 声明语句中的初始化表达式和说明表达式在说明性语句当中使用初始化表达式和说明表达式的规则如下 : 在这些表达式里的变量或命名常量的类型和种别参数, 都必须在同一个作用域范围内, 或者是主作用域单位里, 或者是在一个可以访问当前作用域单位的模块作用域单位里, 预先加以说明, 或者是通过隐式默认规则得到说明如果这些变量和常量在随后的显式类型声明里得到属性说明, 则必须与当前的属性保持一致如果表达式里引用了一个数组的元素, 那么该数组的界必须预先得到说明如果说明表达式同时包含了一个变量与它的值, 那么该表达式必须出现在子程序的说明部分, 而不能出现在主程序里例 8-30 考虑下面程序片断里的变量 I: INTEGER I COMMON I REAL X(I) I 的值用来决定数组 X 的尺度, 那么这个程序片断就不能出现在主程序, 而只能出现在一个子程序的说明部分所谓预先说明, 也可以是指在同一个说明语句当中, 但必须是出现在引用的左边例 8-31 下面的说明是有效的 : INTEGER,DIMENSION(4),PARAMETER::X=(/5,7,2,9/) REAL,DIMENSION(X(2)) ::Y,Z(SIZE(Y)) 由于常量数组 X 的第二个元素为 7, 因此 Y,Z 的尺度都是 7 例 8-32 类似的以下声明却是无效的 : REAL,DIMENSION(X(2))::Z(SIZE(Y)),Y! 无效声明! 因为 SIZE(Y) 在 Y 之前出现了例 8-33 这个例子使用了说明表达式来声明一个带有相同形状的哑元数组的工作数组 : SUBROUTING X(A) REAL::A(:,:) REAL::WORK(SIZE(A,DIM=1),SIZE(A,DIM=2)) END SUBROUTING X 在 FORTRAN 95 标准里面, 纯粹用户定义函数可以用于计算界, 然后这些函数还可以用于其他声明语句当中例 8-34 SUBROUTING S(A) IMPLICIT NONE REAL::A(:,:) REAL::TAMP(RN(A),CN(A)) REAL::TTAMP(CN(A),RN(A)) CONTAINS

145 PURE FUNCTION RN(X) INTEGER::RN REAL,INTENT(IN)::X(:,:) RN=SIZE(X,DIM=1) END FUNCTION RN PURE FUNCTION CN(X) INTEGER::CN REAL,INTENT(IN)::X(:,:) CN=SIZE(X,DIM=2) END FUNCTION CN END SUBROUTING S 5. 各种表达式的应用本小节, 我们总结一下前面所讨论的各种表达式上面所讨论的一般表达式, 限制表达式, 说明表达式, 常量表达式, 以及初始化表达式相互之间具有一定的包含关系, 下面的图 8-1 给出了它们的集合包含关系的示意图 : 图 8-1 各种表达式集合之间的关系图对于初始化表达式与说明表达式的异同由下表 8-6 给出 : 表 8-6 初始化表达式与说明表达式的异同性质初始化表达说明表达式式字符型结果有无 * 整型结果有有标量结果有有数组结果有无作为基元的变量 ( 限于哑元, 公用对象, 主对象, 模块对象 ) 有

146 作为基元的整型与字符型基本固有函数有有 * 作为基元的整型与字符型的基本的与纯粹自定义的函数无有 * 作为基元的实型, 复型, 逻辑型与派生类型的基本固有函数无无作为基元的实型, 复型, 逻辑型与派生类型的基本的与纯粹自定义的函数无无基元只是常量有无下标, 步长, 字符长度都是常量有无以下固有变换函数可以作基元 : REPEAT,RESHAPE, SELECTED_INT_KIND,SELECTED_REAL_KIND,TRANSFER, TRIM 查询函数可以作基元 ( 不包括 ALLOCATE,ASSOCIAT ED, PRESENT) * 字符型的表达式结果如果是某些固有函数的变量, 则是许可的下表 8-7 总结了表达式的种类和它们各自的用途 : 有有有有表 8-7 表达式的种类以及用途表达式可能的出现的场合 3 声明语句里的界限制表达式初始化表达式说明表达式类型 1 2 秩否否可 I 标量 4 声明语句里的长度否否可 I 标量 EQUIVALENCE 语句里的下标和子串范围否可否 I 标量 CASE 语句里的值否可否 I.L.C 标量声明语句里的种别参数否可否 I 标量固有函数里的类型变量否可否 I 标量 PARAMETER 语句和类型声明语句里的初始值 5 附加 PARAMETER 属性的类型声明语句里的初始值成员声明里的初始值隐式 do 数据对象的参数否可否任意任意否可否任意任意否可否任意任意 5 否限制否 I 标量赋值可可可任意任意可执行语句的下标可可可 I =1 可执行语句的步长可可可 I 标量

147 可执行语句的子串范围可可可 I 标量 SELECT CASE 里的表达式可可可 I,L,C 标量 IF-THEN 语句可可可 L 标量 ELSE-IF 语句可可可 L 标量 IF 语句可可可 L 标量算术 IF 语句可可可 I,R 标量 DO 语句可可可 I 标量 FORALL 的指标参数可可可 I 标量 FORALL 里的过滤可可可 L 标量 WHERE 语句里的过滤可可可 L 标量 WHER E 结构了的过滤可可可 L 标量输出项列表可可可任意任意除了 FMT= 说明符之外的 I/O 说明符值可可可 I,C 标量 I/OFMT= 说明符值可可可 C 任意 RETURN 语句可可可 I 标量完成计算的 GO TO 语句可可可 I 标量隐式 do 数组构造器参数可可可 I 标量隐式 doi/o 参数可可可 I 标量实元可可可任意任意语句函数定义里的表达式可可可任意标量表达式注释 1: 本栏里的任意指任意固有或派生类型注释 2: 本栏里的任意指结果可以是标量或任意秩 ( 小于 8) 的数组注释 3: 相关声明语句包括类型声明, 成员定义,DIMENSION,TARGET,COMMON 语句注释 4: 相关声明语句包括类型声明, 成员定义,IMPLICIT,FUNCTION 语句注释 5: 隐式 do 数据参数可以是一个以固有算符作用于常量或任意包含隐式 do 的 do 变量的 8.2 表达式的解释可以说, 上节只是完备地说明了一个合法的表达式应该是什么样的, 从形式的角度来看, 表达式的分类, 以及每种表达式能够担当什么样的语法作用按照所有那些语法规则写完表达式之后, 相当于当编译器读完源码的表达式之后, 判断相关源码是否出现语法错误, 例如表达式的形

148 式是否完整无误, 表达式是出现的场合, 即它在它的上下文里面是否恰当, 甚至还可以根据表达式里所涉及的一切对象所表明的属性, 来给它们安排存储空间 ; 依据其中的初始化语句对相关对象进行初始化取值等这一切妥当之后, 程序并没有开始运行因为程序的运行, 必定是从初始化取值开始, 逐步地对每个变量对象求值, 而这个求值过程依赖于计算机对于表达式的理解, 也就是对于计算机而言, 表达式的任意成员究竟应该翻译成什么指令因此我们说, 这是一个给形式语言赋予语义的过程接下来, 我们就来讨论 FORTRAN 对于表达式所规定的语义, 当然所有的语义的实现都是由编译系统完成的, 并不需要程序作者的干预, 我们只是需要知道如何使用 FORTRAN 所提供的语言要素, 来表达我们的计算任务由于表达式所具有的层次性结构, 对表达式的解释过程是与对表达式的构造过程相平行的即从基元的取值出发, 按照运算优先级规则, 基元经过一层一层的算符的作用, 而逐步得到表达式在每个层次, 每个部分的取值, 最终, 得到整个表达式的取值, 从而完成了对表达式的解释过程与表达式的构造过程类似, 对表达式的解释分为两类 : 对于固有运算的解释 ; 对于自定义运算的解释由于实质上计算机只能处理有限数值, 因此除了对于整数的除法之外,FORTRAN 的固有运算都是与通常的数学含义一致的, 只是任何具体的数值, 在计算机里的表示都必须以有限数值的形式出现至于整数除法的特殊性, 来源于 FORTRAN 运算对于算元与结果的数据属性的一致性的要求, 两个整型数值的商还必须保持为整型数值, 因此必须给出特别的约定, 才能解决两个整数不能整除的问题对于自定义运算的解释, 则是在定义该算符的函数所在的, 具有 OPERATOR 形式的通用说明符的界面块里完成的, 那里实际上涉及的是对于一个程序的解释, 而不只是对于表达式的解释从对表达式的解释过程可以看出, 对表达式的解释是独立于表达式的上下文的, 因为从底层开始进行的解释过程, 根本不需要考虑它的上下文但是这种独立性并不表明同样的算符作用于同样的算元, 最后的值处处都是一样的这种现象的根源在于计算机对于数值的表示是有限形式的, 因而计算机的计算总是某种近似计算, 也就是说总是会产生误差, 而这种误差并不是可以得到精确控制的例如实型表达式 X-Y, 它在赋值过程 Z=X-Y 里, 与它在表达式 X-Y.EQ.Z 里, 不一定会得到相同的取值固有运算的解释基于表达式的构造, 可以把对于固有运算的解释分为如下部分 : 对于固有数值运算的解释对于非数值固有运算的解释对于具有数组算元的固有运算的解释对于具有指针算元的固有运算的解释 1. 对于固有数值运算的解释除了整数幂次的幂次运算之外, 固有数值运算总是首先按照前面的算元与结果的数据属性一致性规则, 把算元的数据类型与种别都转换为与结果一致的形式, 然后再开始按照

149 通常的属性含义进行运算至于整数幂次的幂次运算, 则完全不必转换整数幂次的类型, 因为乘方实际上就是转换为乘法运算, 整数幂次的的乘方, 就是非常直接的乘法对于两个整数除法, 由于一致性的要求, 商也必须是整数, 对于无法整除的情形, 规定取离小数形式的商最近的整数值作为计算结果对于幂次运算 X**Y 如果 Y 是负数, 那么表达式就转换为 1/(X**(-Y)) 注意, 这里引入除法之后, 就在幂次运算里增加除法的特殊性例 8-35 下面表达式 5**(-2) 的结果等于 0 如果 X 为负数, 而 Y 为实型, 则表达式无意义而当 Y 为实型或复型, 则返回值是数学函数 X Y 的基本值完整的对固有运算的解释见表 8-7 表 8-8 固有运算的解释运算运算的解释 X ** Y X 的 Y 次乘方 X / Y X 被 Y 除 X * Y X 乘 Y X - Y X 减 Y - Y Y 反号 X + Y X 加 Y + Y Y 不变 X // Y X 后面连接 Y X.LT. Y 如果 X 小于 Y 则为 TRUE X < Y 如果 X 小于 Y 则为 TRUE X.LE. Y 如果 X 小于等于 Y 则为 TRUE X <= Y 如果 X 小于等于 Y 则为 TRUE X.GT. Y 如果 X 大于 Y 则为 TRUE X > Y 如果 X 大于 Y 则为 TRUE X.GE. Y 如果 X 大于等于 Y 则为 TRUE X >= Y 如果 X 大于等于 Y 则为 TRUE X.EQ. Y 如果 X 等于 Y 则为 TRUE X == Y 如果 X 等于 Y 则为 TRUE X.NE. Y 如果 X 不等于 Y 则为 TRUE X /= Y 如果 X 不等于 Y 则为 TRUE

150 .NOT. Y 如果 Y 为 FALSE 则为 TRUE X.AND. Y 如果 X 与 Y 都是 TRUE 则为 TRUE X.OR. Y 如果 X 或 Y 或都是 TURE 则为 TRUE X.EQV. Y 如果 X 与 Y 都是 TURE 或都是 FALSE 则为 TRUE X.NEQV. Y 如果 X 和 Y 一个为 TURE, 一个为 FALSE 则为 TRUE 2. 对于非数值固有运算的解释字符型数据的运算就是字符的串联, 按照从左到右的顺序把右边的算元接在左边的算元的右边即可关系运算按照算元分三类 : 算元都是数值这时就是一般的数学意义上的大小与相等的概念, 如果它们的类型或种别不同, 则先转换为它们的和的类型或种别, 再进行比较对于复数, 只能说是否相等, 不能比较大小结果都是默认逻辑型算元都是字符型算元的长度可以不同, 但是类型必须相同如果长度不同, 则在短字符串的右边添加空格符, 使得两者长度一致, 再从左边第一个字符开始作比较, 如果相同, 则比较第二个字符, 直到出现不相同的情况, 这时就可以得到是否相等的判断, 进一步根据第一个不相同的字符在编译器规则的字符顺序表里的位置前后, 来决定它们的大小因此字符型数据的大小关系是依赖于编译系统的, 而是否相等则不依赖算元都是逻辑型逻辑型运算的取值表见表 8-9 表 8-9 固有逻辑运算的值 X Y.NOT.Y X.AND.Y X.OR.Y X.EQV.Y X.NEQV.Y TURE TURE FALSE TURE TURE TURE FALSE FALSE TURE FALSE FALSE TURE FALSE TURE TURE FALSE TURE FALSE TURE FALSE TURE FALSE FALSE TURE FALSE FALSE TURE FALSE 3. 对于具有数组算元的固有运算的解释对于二元固有运算来说, 基于一致性的要求, 数组作为算元只会出现两者情况 : 两个算元都是数组, 而且形状必定相同一个算元是数组, 另一个是标量这时, 由于两个算元形状不同, 如果导致特定的运算无法进行, 则把标量扩充为一个与数组算元具有相同形状的数组, 该数组的所有元素都等于该标量数组的运算, 无论是一元还是二元运算, 基本的规则就是对所有的元素进行相同的运算

151 例如数组运算 A+B 的结果是一个与 A,B 相同形状的数组, 该数组的每个元素都等于相应位置上的 A 与 B 的元素的和而数组运算 -A 的结果是一个与 A 相同形状的数组, 该数组的每个元素都等于相应位置上的 A 的元素的反号结果注意这里的运算解释不同于数学意义上的矩阵的运算如果固有运算出现在过滤赋值语句当中, 那么运算就只针对满足过滤条件的元素实际上, 在机器内部, 所有元素的计算都执行了, 但是不满足过滤条件的元素的计算并不影响最终的结果, 因为不满足过滤条件的元素再也不会在随后的程序当中出现, 也就不会导致运行时错误数组元素的分别计算并不存在顺序, 对于处理器来说, 可以是任意顺序实际上不管是向量处理器还是标量处理器, 都有可能是所有元素的计算一次同时完成 4. 对于具有指针算元的固有运算的解释固有运算的算元也有可能是指针, 这时指针必须已经关联到一个已经定义好了的目标上, 然后把目标的取值代入指针, 再按照前面的解释进行运算如果运算的算元是一个同时也是指针的结构变量的成员, 那么它的取值就是和该结构变量关联的作为目标的结构的相应命名成员例 8-36 TYPE(ADD) I,J::INTEGER END TYPE TYPE(ADD),POINTER::PTR TYPE(ADD),TARGET::T 这里 PTR 被关联到 T, 如果 PTR%I 成为了一个算元, 那么该算元的取值就是目标 T 的成员 I, 即 T% I 自定义运算的解释对自定义运算的解释由带有 OPERATOR 界面的函数子程序提供如果同一个 OPERATOR 界面包含多个函数, 那么由所含哑元的类型, 种别, 秩等一致的函数提供解释例 8-37 设有自定义运算.ADD., 而派生类型 RATIONAL 对象 A 和 B 构成如下表达式 : A.ADD. B 其中的自定义运算.ADD. 来自如下 OPERATOR 界面块, 里面包含了 2 个函数 : INTERFACE OPERATOR(.ADD.) FUNCTION RATIONAL_ADD(L, R) USE RATIONAL_MODULE TYPE (RATIONAL),INTENT(IN)::L,R TYPE (RATIONAL) ::RATIONAL_ADD END FUNCTION RATIONAL_ADD

152 FUNCTION LOGICAL_ADD(L, R) LOGICAL, INTENT(IN)::L, R LOGICAL ::LOGICAL_ADD END FUNCTION LOGICAL_ADD END INTERFACE 显然.ADD. 由函数 RATIONAL_ADD 给出解释. 下面是自定义运算的说明 : 自定义运算由包含 1 个或 2 个哑元的函数定义函数哑元代表了运算的算元如果只有 1 个哑元, 则为一元运算 ; 如果有 2 个哑元, 则为二元运算, 其中第一个哑元为左算元, 第二个哑元为右算元必定存在一个具有通用说明符 OPERATOR 的界面块定义函数表达式里的算元的数据属性必须与函数里的哑元保持一致自定义运算的算符不能和任何固有运算的算符相雷同如果函数不是基本的, 那么算元的秩必须与函数里的哑元保持一致 ; 如果函数是基本的, 算元可以是数组, 如果包含 2 个算元, 它们必须保持一致性或者有一个哑元是派生类型, 或者都是固有类型, 但是与表 8-3 里的固有运算不保持一致如果存在两个界面都满足给一个自定义运算提供解释的条件, 例如 : 一个界面包含 1 或 2 个满足条件的哑元 ; 另一个函数界面是基本的, 同样包含 1 或 2 个满足条件的标量哑元那么引用非基本函数的那个例 8-38 设有如下界面块 : INTERFACE OPERATOR(.ADD.) ELEMENTAL FUNCTION ELEM(X,Y) REAL,INTENT(IN)::X,Y END FUNCTION ELEM FUNCTION NOELEM(X,Y) REAL,INTENT(IN),DIMENSION(20)::X,Y REAL NONELEM(20) END FUNCTION NONELEM END INTERFACE 然后在以下程序当中引用运算 A. ADD.B REAL A(20),B(20),C(20) C=A.ADD.B

153 基于以上的规则, 这里执行的函数是 NONELEM, 而不是 ELEM 注意自定义运算的算元不需要在形状上保持一致性, 因为函数可能是非基本的对于自定义运算必须注意避免产生如下的异常运算 : 由固有运算或固有函数导致的整数溢出整数除法 0/0 固有数值运算导致的浮点溢出 0**0 浮点运算导致的浮点下溢浮点舍入错误 X**Y,X 为实型,Y 为负数 8.3 表达式的计算基于表达式的语义, 一个计算过程得以开始的前提是每个算元都已经定义好, 或者说具有具有确定的定义状态 ( 参见第 17 章通讯 ) 而一旦开始计算, 机器的计算过程, 或者说计算途径并不是唯一的, 因为要唯一确定表达式的计算过程, 就必须把括号全都写出来, 实际上我们省略了很多括号, 这就使得编译系统的计算可以在许多不同的途径当中进行优化这种优化的实质, 就是给出表达式的等价表达式, 选择更加有效率的表达式进行实际的计算所谓两个表达式等价, 是指如果它们的算元取所有可能的值时都结果一样在这样的定义之下, 似乎只要两个表达式具有数学上的等价性即可, 然而由于在数值计算方面, 计算机具有本质上的局限性, 使得 FORTRAN 语言里的表达式的等价与数学意义上的表达式的等价并不完全一致, 这点主要表现在如下方面 : 因为按照 FORTRAN 语言的规定, 括号的位置是绝对不可变更的, 因此对表达式的等价变换受到了一定的限制即在对一个表达式进行等价变换时, 显式的括号位置不能改变, 不能减少, 只能增加当遵循交换律, 结合律和分配律来进行等价变换时, 必须考虑到所涉及的算元的取值精度是否会因此而发生改变因为所谓等价变换, 实际上就是改变表达式里的各种算符的计算顺序, 甚至有可能省略掉本来有的算符, 由于各种运算对于精度的影响是不同的, 有的运算总是绝对精确的, 有的运算, 或者在有的时候, 会产生一定的误差, 这样的运算在被改变运算顺序之后, 在数值上就不会是等价的了在下面的表 8-10 和表 8-11 里面我们分别给出有效的等价代换与无效的等价代换的例子 : 表 8-10 表达式计算的有效代换表达式 X+Y X*Y -X+Y X+Y+Z X-Y+Z X*Y/Z X*Y-X*Z 等价的表达式 Y+X Y*X Y-X X+(Y+Z) X-(Y-Z) X*(Y/Z) X*(Y-Z)

154 X/Y/Z X/5.0 X>Y X.OR.Y.OR.Z X.AND.X X=Y//Z X/(Y*Z) 0.2*X (X-Y)>0 X.OR.(Y.OR.Z) X X=Y!LEN(X)<=LEN(Y) 表 8-11 无效的表达式代换的例子表达式不允许的代换表达式 I/2 0.5*I X*I/J I/J/X (X+Y)+Z (X*Y)-(X*Z) X*(Y-Z) X*(I/J) I/(J*X) X+(Y+Z) X*(Y-Z) X*Y-X*Z 注意在改变运算顺序之后有可能发生的舍入误差, 导致计算结果的不一致例如 X-Y-Z 和 X-(Y+Z) 就有可能具有不同的数值结果需要注意在表达式没有进行计算的部分, 有可能包含具有在引用运行后, 能够改变程序状态的副作用第 9 章基本计算 ( 一 ) 赋值语句从计算机的实际状态来看, 给出表达式并不意味着计算的开始, 真正能够驱动计算的是可执行语句, 而最直接驱动表达式的计算过程的就是赋值语句, 完成一个赋值步骤, 就意味着机器的状态的局部或全局发生了一个根本的变化从语法的角度来看, 一个表达式还只是一个比较复杂的复合词汇, 还不能构成一个完整的语句, 而赋值语句则是一个在语法意义上的完整的语句, 表达式在赋值语句中扮演关键的语法作用从计算问题的角度来看, 赋值可以说是基本的计算步骤, 考虑一下我们人工计算的过程就可以发现, 任何一个完整的计算步骤, 都可以说就是一个赋值步骤, 特别是公式演算和数值计算, 完成一个局部运算过程的标志, 往往就是求出某个中间变量的数值或表达式 FORTRAN 语言作为一种以公式翻译为初衷的高级语言, 它的赋值语句的一般形式就是一个数学等式, 当然不是那种公式恒等变换得到的恒等式, 而是要把运算的结果赋予一个变量, 因此它的一般句法形式为 : variable = expression variable => expression

155 可以看到一个赋值语句作为一个完整的语句, 分为三个部分 : 被赋值的变量赋值符号计算 ( 表达式 ) 其中被赋值的变量, 通过赋值, 就拥有了明确的取值形式, 如果该变量含有下标, 片断下标或子串范围, 则赋值的前提是它们都已经获得具体的取值基于表达式结果的不同种类, 赋值语句分为 : 固有赋值 : 固有赋值是把任意类型的值赋予一个非指针变量, 或把一个指针变量赋予一个与之相关联的目标自定义赋值 : 自定义赋值得以构成的前提是存在一个可访问的子例行程序, 它包含一个具有 ASSIGNMENT 形式的赋值界面, 其属性与自定义赋值语句里的变量和表达式的属性保持一致指针赋值 : 指针赋值把一个指针变量关联到它的目标对象, 或者说把一个目标对象赋予到一个指针变量在形式上它使用符号 => 过滤数组赋值 : 这个赋值过程是对满足一定条件的数组元素进行赋值, 而不是对数组整体进行赋值并行指标数组赋值这种赋值形式给出了一种有效的并行机制, 能够大规模地对多重指标变量进行赋值下面我们将分节讨论这 5 类赋值形式, 首先给出一些例子如下 : 例 9-1 X=X-2 实型的固有赋值 CHAR(5:8)= M_30 逻辑型的固有赋值 SAMPLE=NOTE_2 结构的固有赋值 STRING= MYSAMPLE 可变串结构的自定义赋值 WHERE(X/=0.0) 过滤数组赋值 A=B/X END WHERE FORALL(I=0:N,J=1:N) 并行指标结构 A(I,J)= 3.0/(I-J+2) 并行指标赋值 B(I,J)%PTR=>C(I:N,J:N) 并行指标指针赋值 END FORALL PTR=>X 指针赋值 9.1 固有赋值语句所谓固有赋值的主要特征就是被赋值的变量不能是指针变量, 赋值语句本身就是对变量的定义或重定义, 变量的取值就是直接计算赋值语句右边的表达式所得不需要额外的子程序来加以说明下面说明固有赋值语句的用法 :

156 固有赋值中变量与表达式所能够具有的类型, 以及它们的一致性要求见表 9-1 变量的类型 INTEGER REAL COMPLEX CHARACTER LOGICAL 派生类型表 9-1 固有赋值中变量与表达式的类型表达式的类型 INTEGER,REAL,COMPLEX INTEGER,REAL,COMPLEX INTEGER,REAL,COMPLEX 变量为具有相同种别参数的 CHARACTER LOGICAL 变量为相同的派生类型如果变量是标量, 那么表达式也必须是标量如果变量是数组, 那么表达式或者是标量, 或者是相同形状的数组如果变量是显形数组, 那么变量的形状可以通过说明语句说明如果变量是待定形数组, 那么它的形状由 ALLOCATE 语句, 或指针赋值语句确定如果变量是哑形数组, 那么它的形状由变量里的片断下标, 或实元确定变量不能是哑尺度数组, 除非存在含有最后一个维度上的上界的片断下标, 或数组的下标向量, 或者标量下标表达式的形状由算元的形状, 表达式里的运算, 以及其中的函数引用决定如果变量是一个指针, 那么它必定已经关联到一个目标, 赋值语句把表达式的值赋予指针的目标指针所关联的目标可以是一个数组, 指针决定数组的秩, 而每个维度的宽度则由目标决定在赋值过程本身被执行之前, 赋值语句右边表达式以及表达式和变量里面包含的下标与下标片断表达式, 都必须预先求值完毕如果变量的类型以及种别参数和表达式的不一致, 那么在执行赋值语句之前, 还必须完成必要的针对表达式的类型转换, 固有转换函数见下表 9-2: 变量的类型 INTEGER REAL COMPLEX LOGICAL 表 9-2 固有转换函数被赋的值 INT(expression,KIND(variable)) REAL(expression,KIND(variable)) CMPLX(expression,KIND(variable)) LOGICAL(expression,KIND(variable)) 表达式里面可以使用赋值语句左边变量的部分值例 9-2 DATE(5:10)=DATE(2:6) 注意这是 FORTAN 现代版本所增加的功能, 在 FORTRAN77 里面是不允许的如果变量和表达式都是字符型的, 那么它们必须具有相同的种别参数值如果变量和表达式是具有不同长度属性的字符型对象, 那么赋值过程遵循以下规则 : 如果变量的长度比表达式的短, 那么把表达式的右边长出来的部分截除 ;

157 如果变量的长度比表达式的长, 那么在表达式的右边添加空格, 直到跟变量一样长如果在赋值语句左边的变量里面含有表达式, 例如下标表达式, 那么这个表达式的计算与取值完全与赋值语句右边的表达式无关, 因为左边变量的任何表达式都必须是预先完成计算的如果把一个标量赋值给一个数组, 为了保持形状的一致性, 需要把该标量扩充为一个与左边数组同样形状的数组, 该数组的每个元素都是那个标量例 9-3 INTEGER X(100) X=5.0 经过赋值后 X 的取值为含有 100 个元素的数组, 每个元素都是 5.0 数组的赋值过程是按照元素位置一一对应进行的例 9-4 设有两个相同形状的数组 X 和 Y, 有赋值语句 : X=Y 那么具体的赋值过程就是 Y 的元素赋予 X 的相同位置的元素, 至于不同位置的元素是按照什么顺序来进行赋值的, 并不需要考虑, 可以认为所有元素的赋值是同时进行的对于派生类型的对象的固有赋值, 变量与表达式必须是属于同一个派生类型, 而赋值方法类似于数组, 在相同位置的成员之间进行赋值, 如果某个成员是指针, 则该成员的赋值过程按照指针赋值的规则进行 9.2 自定义赋值语句如果需要进行赋值的变量和表达式是不符合表 9-1, 表 9-2 所规定的一致性要求的固有类型或派生类型, 那么就需要使用自定义赋值语句, 它提供赋值界面与相应子例行程序以供访问, 从而完成赋值自定义赋值是由具有赋值说明符 ASSIGNMENT(=) 的子例行程序来完成赋值操作的用户可以在子例行程序当中通过定义新的规则, 来扩充可以进行赋值的类型下面介绍自定义赋值运算的用法 : 自定义赋值运算由具有两个哑元的子例行程序声明 ( 子例行程序可以是外部或模块子例行程序里的对象 ) 子例行程序的哑元按照其出现的前后顺序, 分别表示自定义赋值的变量与表达式其中第一个哑元必须具有 INTENT 的 OUT 或 INOUT 的属性, 而第二个哑元必须具有 INTENT 的 IN 的属性具有 ASSIGNMENT(=) 形式的通用说明符的子例行程序必须带有界面块变量与表达式的类型以及种别参数必须与哑元保持一致对于一个非基本子例行程序, 变量与表达式的秩必须与哑元的秩相同对于一个基本子例行程序, 变量必须是数组, 而表达式与之保持一致 ; 或者两者都是标量如果变量和表达式同时与一个基本子例行程序和一个非基本子例行程序的界面匹配, 那么赋值运算由非基本子例行程序定义两个哑元或者有一个是派生类型, 或者都是固有类型, 但不满足固有赋值的一致性条件

158 对变量的自定义赋值的结果由所引用的子例行程序决定例 9-5 INTERFACE ASSIGNMENT(=) ELEMENTAL SUBROUTING RATIONAL_TO_REAL(L,R) USE RATIONAL_MODULE TYPE (RATIONAL), INTENT( IN) :: R REAL, INTENT(OUT) ::L END SUBROUTING RATIONAL_TO_REAL ELEMENTAL SUBROUTING REAL_TO_RATIONAL (L,R) USE RATIONAL_MODULE REAL INTENT(IN) ::R TYPE (RATIONAL), INTENT(OUT)::L END SUBROUTING REAL_TO_RATIONAL END INTERFACE 上面的界面块通过两个外部子例行程序给出了自定义赋值, 一个把派生类型 RATIONAL 的对象赋值给实型对象, 另一个把实型对象赋值给派生类型 RATIONAL 的对象有了上面的界面块, 就可以进行下面的自定义赋值 : REAL R_VALUE, R_ARRAY(20) TYPE (RATIONAL) RAT_VALUE, RAT_ARRAY(20) R_VALUE=RATIONAL(5, 8) RAT_VALUE= 指针赋值所谓指针赋值, 实际上就是把指针变量关联到一个具有 TARGET 属性的对象上, 即使得指针变量成为目标对象的一个别名如果指针所关联的目标的状态发生改变, 例如去关联, 或去定义, 那么指针的状态也发生相应的改变一旦指针赋值语句被执行之后, 指针的关联状态就不会改变了, 除非执行另外一个指针赋值语句来改变其状态, 或执行 ALLOCATE,DEALLOCATE,NULLIFY 语句对指针重定义指针赋值的一般形式 (R736) 为 : pointer-object=> target 其中指针对象 (pointer-object) 的一般形式 (R630) 为 : variable-name structure-component 而目标 (target) 的一般形式 (R737) 为 :

159 variable expression 下面说明指针赋值的用法 : 如果指针对象为变量名称或结构成员, 那么它们都必须具有 POINTER 属性如果目标是命名变量, 那么它必须具有 TARGET 或 POINTER 属性如果目标是子对象指示符, 那么它的父结构必须具有 TARGET 或 POINTER 属性, 或者它必须是一个在最右边成员具有 POINTER 属性的结构引用目标与指针对象的类型, 种别参数, 长度参数, 秩都必须一样如果 => 右边的变量具有 TARGET 属性, 那么 => 左边的指针对象就被关联到该目标如果 => 右边的变量具有 POINTER 属性, 并且处于关联状态, 那么 => 左边的指针对象在指针赋值语句执行之后, 也被关联到目标指针所关联的同一个数据对象如果 => 右边的变量具有 POINTER 属性, 并且处于去关联状态, 或者右边的表达被引用到固有函数 NULL, 那么 => 左边的指针对象也成为去关联状态如果 => 右边的变量具有 POINTER 属性, 并且处于去定义关联状态, 那么 => 左边的指针对象也成为去定义关联状态指针赋值语句终止了指针对象此前所具有的任何关联状态, 从而产生一个新的关联状态如果指针对象是待定形数组, 那么指针赋值语句就能够确立指针数组每个维度的宽度, 即其目标的相应维度的宽度, 除非目标本身是去关联指针或去定义指针例 9-6 执行以下语句 : INTEGER,TARGET::T(11:20) INTEGER,POINTER::P1(:),P2(:) P1=>T P2=>T(:) 得到 P1 的宽度是 11 和 20, 而 P2 的宽度是 1 和 10 目标不能是属于哑尺度数组的命名变量如果目标是一个哑尺度数组的数组片断, 那么它必须具有下标, 或者具有在最后一维给出了上界的下标三元组如果目标为数组片断, 那么它不能具有下标向量如果目标是一个表达式, 那么它必须给出一个指针结果, 这意味着该表达式引用了固有函数 NULL, 或者是引用了能够得到指针结果的用户自定义函数或自定义运算因为在固有函数或固有运算里, 只有 NULL 得到指针结果如果一个指针的目标没有被引用或定义, 那么该指针也不能被引用或定义如果一个结构的某些成员具有 POINTER 属性, 而该结构被固有派生类型赋值语句进行了赋值, 那么对于每个具有 POINTER 属性的成员, 是运用指针赋值语句进行赋值的自定义赋值语句可以用来在结构的成员之间进行指针赋值例 9-7 MONTH=>DAYS(1:30) PTR=>X(:,5) NUMBER=>INDEXONE%INDEXTWO FIRST_RESLUT=>NULL()

160 例 9-8 下面的目标也是指针 : REAL,POINTER::PTR,P REAL,TARGET::X REAL Y X=5.7 P=>X PTR=>P Y=PTR-8.1 例 9-9 下面的目标为表达式 : INTERFACE FUNCTION POINTER_FCN(X) REAL X REAL,POINTER::POINTER_FCN END FUNCTION REAL,POINTER::P REAL A P=>POINTER_FCN(A) 注意以下情形 : 在指针与目标之间建立关联, 除了指针赋值语句之外, 使用 ALLOCATE 语句也能做到, 而使得指针去关联则也可使用 DEALLOCATE 或 NULLIFY 语句当在表达式或过程里引用指针时, 会得到与该指针关联的目标的值, 这点与在指针赋值语句里不同当指针是作为一个与具有 POINTER 属性的哑元相应的实元出现的时候, 那么该引用是到达指针本身, 而不是它的值 9.4 过滤数组赋值对于数组的赋值, 除了全数组的一一对应的赋值方式之外, 很多时候, 还需要做到在数组里挑选符合一定条件的某些元素, 只对这些特定元素进行赋值这时已有的赋值语句都无法做到, 因此 FORTRAN 专门提供了过滤数组赋值方式, 用来完成这类任务所谓过滤数组赋值, 实际上就是建立 WHERE 块, 或 ELSEWHERE 块, 或者是 WHERE 语句, 然后在其中使用固有赋值语句, 它的变量为数组时, 就可以对其元素进行选择性赋值在 WHERE 语句或 WHERE 结构里对数组元素进行过滤, 是根据一个逻辑数组表达式的值来进行的, 该逻辑数组表达式是从数组取值而得到逻辑型值的条件表达式, 作用于 : 基本固有运算 ; 基本固有函数引用 ; 基本自定义运算 ; 基本自定义函数引用 ;

161 固有赋值 ; 基本自定义赋值注意所谓 WHERE 语句或 WHERE 结构非常类似于选择控制结构 IF 结构或 IF 语句, 但它们有一个主要的差别, 就是在 WHERE 结构里, 所有的赋值语句都是要执行的, 即使是不满足条件的元素, 它的赋值同样执行了, 只是不满足条件的元素的赋值对随后的程序不其任何作用而已但是在 IF 结构里, 不满足条件的情形是不被执行的 WHERE 语句 WH ERE 语句的句法形式 (R738) 为 : WHERE(logical-expression)array-assignment-statement 其中逻辑表达式 (logical-expression) 对所有数组元素起作用, 就相当于一个过滤网, 使得表达式结果为 TURE 的数组元素被赋值给变量, 而表达式结果为 FALSE 的数组元素不被赋值给变量例 9-10 WHERE(CURRENT>1.00)PASS=CURRENT WHERE(TEMP<0.40) USEFULL=TEMP WHERE 结构 WHERE 结构的句法形式 (R739) 为 : [where-construct-name:] WHERE(logical-expression) [where-body-construct] [ELSEWHERE(logical-expression)[where-construct-name] [where-body-construct] ] [ELSEWHERE [where-construct-name] [where-body-construct] ] END WHERE [where-construct-name] 其中 where 体结构的句法形式 (R741) 为 : assignment-statement where-construct where-statement 在初始 WHERE 语句当中出现的逻辑表达式构成了一个过滤网, 可以控制在 WHERE 体结构里给出的数组赋值语句的表达式取值和赋值如果逻辑表达式在 ELSEWHERE 语句当中也出现, 那么该语句就成为了过滤 ELSEWHERE 语句例 9-11 INTEGER::N(9)=(/1,2,3,4,5,6,7,8,9/) WHERE(MOD(N,2)==0) N=2! 现在 N=(/1,2,3,2,5,2,7,2,9/)

162 ELSEWHERE(MOD(N,3)==0) N=3! 现在 N=(/1,2,3,2,5,2,7,2,3/) ELSEWHERE(MOD(N,5)==0) N=5! 现在 N=(/1,2,3,2,5,2,7,2,3/) ELSEWHERE N=0! 现在 N=(/0,2,3,2,5,2,0,2,3/) END WHERE 下面说明 WHERE 结构的用法 : 一个结构名称不能单独出现在初始 WHERE 语句, 或 END WHERE 语句里, 必须成对出现如果一个结构名称出现在 ELSEWHERE 语句里, 或者是过滤 ELSEWHERE 语句里, 那么它也必定出现在 WHERE 结构语句里在 WHERE 结构的每个赋值语句里, 被定义的变量必须和过滤网具有相同的形状, 如果在 WHERE 结构的其他位置也出现了过滤网, 它们的形状必须都相同 WHERE 结构里的语句按照其出现的顺序执行每个过滤网的有效取值只有一次, 随后的逻辑表达式里的取值变化都对控制过滤网的值没有影响 WHERE 结构里的自定义赋值必须由基本子例行程序定义只有在控制过滤网取真值时, 赋值语句里的基本运算或函数才得到计算例 9-12 REAL X(1,100) WHERE(X>0.0) SQRTX=SQRT(X) END WHERE 如果在结构的逻辑表达式或赋值语句当中出现了数组构造器, 那么它将不经过过滤而得到完全计算结构里的表达式或变量或逻辑表达式里的非基本函数引用将得到完全计算, 尽管有可能结果数组的所有元素都用不上例 9-13 REAL A(2,3),B(3,10),C(2,10), D(2,10) IMTRINSIC MATMUL WHERE (D<0.0) C=MATMUL(A,B) END WHERE 其中矩阵乘积的所有元素都得到了, 但是只有小于 0 的元素才得到赋值在 WHERE 结构里, 只有 WHERE 语句才能成为分支目标 WHERE 结构的运行当 WHERE 结构开始运行的时候, 其中的控制过滤网和候选过滤网就都已经建立了, 而控制

163 过滤网主宰了随后的语句块的执行如果 WHERE 结构不是嵌套 WHERE 结构, 那么控制过滤 mask 取得逻辑表达式的值, 而候选过滤网的值为.NOT.mask 例 9-14 WHERE(A1)! 语句 1 CALL B1! 块 1 ELSEWHERE(A2)! 语句 2 CALL B2! 块 2 ELSEWHERE! 语句 3 CALL B3! 块 3 END WHERE 在执行语句 1 之后, 控制过滤网的值为 A1, 而候选过滤网的值为.NOT.A1; 在执行语句 2 之后, 控制过滤网的值为 (.NOT.A1).AND.A2, 而候选过滤网的值为 (.NOT.A1).AND(.NOT..A2); 在执行语句 3 之后, 控制过滤网的值为 (.NOT.A1).AND(.NOT..A2) 如果 WHERE 结构是嵌套 WH ERE 结构, 还是以上面的例子来说明运行过程 : 如果最外层主宰着块内的语句运行的初始控制过滤网是 outer-mask, 那么块 1 的控制过滤网取值为 outer-mask.and.a1, 从这个初始状态开始, 就可以得到向内嵌套过程的每个控制过滤网取值, 即总是向内取逻辑与运算到运行内部 END WHERE 语句时, 控制过滤网就回复到 outer-mask WHERE 结构与控制结构的差别 WHERE 结构与控制结构的主要差别在前面 9.4 已经讨论过, 除此之外, 还有个差别, 就是在 WHERE 结构里, 不存在从 WHERE 块或 ELSEWHERE 块里转移出来的机制, 当然除了使用函数引用之外因为在这些块里都不允许分支语句 WH ERE 结构还有一个特征, 就是在结构前面块里的语句的执行, 会影响后面块里的变量引用, 因为所有块里的语句都会顺序得到执行 9.5 并行指标数组赋值在数学计算当中, 经常会遇到如下的计算任务 : x = i j ij 2 2, 对于 i 从 1 到 n,j 从 1 到 m x ii = y i, 对于 i 从 1 到 n 其中第一个计算可以使用嵌套 DO 循环描述如下 : DO J=1,M DO I=1,N X(I,J)=I**2-J**2

164 END DO END DO 不过这种实现方法完全没有利用数组这种强大的数据结构, 而在很多系统里面, 通过利用数组, 可以更加有效地完成上面类型的计算任务对于 FORTRAN 而言, 除了运用 DO 循环之外, 运用固有函数 SPREAD, 再采用数组赋值的形式, 也可以完成上面的计算 : X=SPREAD((/(I,I=1,N)/),DIM=2,NCOPIES=M)**2-& SPREAD((/(I,I=1,M)/),DIM=1,NCOPIES=N) 而在 FORTRAN 里, 一种更加自然的计算方法是使用 FORALL 语句该语句充分发挥了数组在数据结构方面的特点, 使得这种计算更加有效率 : FORALL (I=1:N,J=1:M)X(I,J)=I**2-J**2 显然, 在这种计算方法里面,FORALL 能够直接把数组元素和片断引用到表达式里面, 不仅使得计算过程一目了然, 而且表现了并行计算的优越性对于上面的第二个数学计算任务, 它不能使用数组片断来描述, 但 FORALL 语句则能够把秩为 1 的数组 Y 的元素赋值给数组 X 的对角线 : FORALL(I:N)X(I,I)=Y(I) 如此就轻松自然地完成了计算任务在关键词 FORALL 后面的括号部分称为 FORALL 头, 它能够对后面的多个语句发挥控制作用例 9-15 FORALL (I=2:N-1,J=2:N-1) A(I,J)=(A(I+1,J)+A(I-1,J)+A(I,J+1)+A(I,J-1))/10.0 B(I,J)=10.0/A(I+1,J+1) END FORALL 在 FORALL 语句与 END FORALL 语句之间的部分, 称为 FORALL 体,FORALL 体里面可以包含如下内容 : 赋值语句 ; 指针赋值语句 ; WHERE 结构和语句 ; FORALL 结构和语句 FORALL 体可以包含 FORALL 结构和语句, 也就是说 FORALL 结构可以嵌套 FOR ALL 体的结构和语句的执行是顺序往下执行的, 所有右边的表达式对所有的指标进行求值计算时, 对于不同的指标的求值计算, 则是按照任意次序, 当这样的计算都完成之后, 随即进行的赋值也是按照任意的次序所以尽管 FORALL 语句构造了一个循环结构, 但是每当针对结构里的一个语句进行求值时, 被认为是进行并行指标运算, 每完成一个语句的所有指标的运算, 才转到下一个语句的计算, 因此具体的在计算每个语句的所有指标时, 到底系统是按照什么顺序, 是不需要规定的, 完全依靠具体的系统的自身特定来实现, 在 FORTRAN 语言层面上不加以规定, 因此使得 FORALL 结构

165 具有了与控制结构完全不同的特征, 因为所谓控制结构, 是对每一个指标的运算都加以控制的, 因此在执行控制语句时, 不得不制定不同指标的运算顺序 FORALL 的优越性正是体现在这里, 因为语言没有规定的对指标的计算, 完全可能在某些系统里面是并行进行的, 这样的话, 一下子就使得数组具有了并行计算的特征, 从而可以大大地提高程序运行的效率有时, 可能需要排除一些元素, 这时, 就需要在 FORALL 头里加入一个过滤表达式例 9-16 FORALL(I=1:N,J-=1:M,A(I)<100.AND.B(I)<100)& C(I,J)=A(I)+B(J) FORALL 结构在 FORALL 头里的说明三项列, 再加上可选的过滤网, 就可以控制 FORALL 体内的多种赋值语句, WHERE 结构与语句, 以及嵌套 FORALL 语句与结构下面我们分形式与运行两个部分来讨论 FORALL 结构 1. FORALL 结构的形式 FOR ALL 结构的句法形式 (R747) 为 : [forall-construct-name:]forall(forall-triplet-specification-list & [,scalar-logical-expression]) [forall-body-construct] END FORALL [forall-construct-name] 其中的 forall 说明三项 (forall-triplet-specification) 的句法形式 (R750) 为 : index-name = scalar-integer-expression:& scalar-integer-expression [:scalar-integer-expression] 其中的 forall 体结构的句法形式 (R751) 为 : assignment-statement pointer- assignment-statement where-construct where-statement forall-construct forall-statement FORALL 结构的一般规则如下 : 结构名称必须在 FORALL 语句与 END FORALL 语句里成对出现, 或者都不出现指标名称必须是一个标量整型变量的名称该名称的作用域与 FORALL 结构的作用域一致, 并且在该作用域内保持自己的属性不变例 9-17 SUBROUTING OPE(I,X) INTEGER,INTENT(IN)::I

166 INTEGER X(:) FORALL(I=1:SIZE(X)) X(I)=I END FORALL.. END SUBROUTING OPE 在执行了上面的 FORALL 结构之后,X 取值为 (1,2, ), 而 I 保持它在刚进入子例行程序时的取值不变 ; 在 FORALL 结构里对 I 的定义过程也不影响 I 的意向属性 IN 在说明三项里的表达式里面, 不能引用它所在的说明三项列里的指标名称例 9-18 下面的 FORALL 语句是错误的 : FORALL(I=1:J,J=1:M)A(I,J)=I*2+J*3 必须换一种写法如下, 才是有效的 : FORALL(I=1:N,J=1:M,I<=J)A(I,J)=I*2+J*3 一个标量逻辑型表达式定义了一个过滤网, 其中可以引用指标名称例 9-19 FORALL(I=1:100,J=1:100,X(I)/=0.0.AND. Y(J) >0.0) END FORALL 在定义过滤网的逻辑表达式或 FORALL 体结构里的任意位置, 要引用过程的话, 该过程必须是纯粹过程在 FORALL 体结构里指标名称不能被加以赋值 FORALL 结构里的单个语句不能进行多对一的赋值例 9-20 FORALL(J=1:30) X(INDEX(J))=Y END FORALL 上面的赋值只有在 INDEX(1:30) 不包含重复值的情形下才能进行, 不过在 FORALL 结构里, 可以通过使用多个语句做到赋值或指针赋值到同一个数据 FORALL 体结构不能是分支结构每个说明三项列里的指标名称, 是可以出现在被赋值的变量的下标或片断下标列表里面 FORALL 结构里的赋值语句可以是数组赋值语句例 9-21 REAL X(100,100) FORALL(I=1:N) X(I,:)=1.0/REAL(I)

167 上面的赋值语句把一个标量值 1.0/REAL(I) 赋值到数组 X 的第 2 维的每个坐标上 FORALL 结构里的赋值语句可以是指针赋值语句例 9-22 TYPE SCREW CHARACTER(20),POINTER::HEAD_TYPE REAL LENGTH,THREAD END TYPE SCREW TYPE(SCREW) INVENTORY(500) REAL THREAD(100) CHARACTER(20), TARGET:: HEAD_TYPES(5) FORALL (I=1:500, INVENTORY(I)%LENGTH>.05) INVENTORY(I)% HEAD_TYPE=> HEAD_TYPES & (MOD(I-1, 5)+1! HEAD_TYPES 的下标是 1,2,3,4,5,1,2,3,4,5, INVENTORY(I)%THREAD=THREADS((I-1)/5+1)! THREADS 的下标是 1,1,1,1,1,2,2,2,2,2,3,3,3,3,3, END FORALL 所谓三项说明实际上就是一个三元组, 即 : scalar-integer-expression:scalar-integer-expression:scalar-integer-expression 可以理解为一个数学上常规的三元组, 三元组它的取值的集合即对这 3 个表达式值的集合的笛卡儿乘积 2. FORALL 结构的运行 FORALL 结构的运行分如下 3 个步骤 : 确定指标名称变量的取值 ; 如果存在过滤网表达式的话, 计算该表达式 ; 执行体结构 1. 确定指标名称变量的取值首先对指标名称变量求值, 得到指标值的集合对三元组里的 3 个标量整型表达式的求值, 可以是任意次序如果有必要的话, 需要把结果值的类型转换为指标名称的类型设 3 个表达式分别为 m1,m2,m3, 那么指标值的数目由如下公式决定 : n=(m2-m1+m3)/m3 其中如果 m3 不存在的话, 取默认值 1 如果 n 小于或等于 0, 那么整个结构的执行就到此为止, 否则指标名称的值的集合就是 m1+(k-1)*m3 而指标值组合的集合由每个三项说明给出的值集合的笛卡儿乘积决定 2. 计算过滤网表达式

168 过滤网逻辑表达式的结果为 TURE 时, 就从上面步骤得到的指标值的组合的集合 ( 一个笛卡儿乘积 ) 里选择出一个子集合, 被称为指标值的激活组合 3. 执行体结构 FORALL 体结构里的可能的执行单位类型包括 : 赋值语句 ; 指针赋值语句 ; WHERE 结构或语句 ; 嵌套 FORALL 结构或语句整个体结构的执行次序, 就是按照各个执行单位出现的先后次序当每个单位得到执行时, 必须遍历所有的指标值的激活组合下面分类型予以说明 : 赋值语句赋值语句的一般形式为 variable = expression 因此赋值语句的执行包括两个部分, 即表达式对指标的求值, 和每得到一个表达式的值就进行相应的赋值因此每个部分都必须遍历所有的指标值的激活组合, 这种遍历是不规定次序的也就是被称为并行指标计算的来源如果赋值过程为自定义赋值, 那么定义该赋值的子例行程序不能包含对任何被赋值的变量, 或被关联的指针的引用指针赋值语句指针赋值语句的一般形式为 pointer-object=>target 因此与赋值语句类似, 指针赋值过程也包括两个部分, 即目标表达式对指标的求值, 和每得到一个目标的值就进行相应的关联因此每个部分都必须遍历所有的指标值的激活组合, 这种遍历同样是不规定次序的 WHERE 结构或语句 ; WHERE 结构里的语句都是按照出现的顺序执行的首先是 WHERE 语句或结构, 以及 ELSEWHERE 语句里的过滤网对所有的由外部 FORALL 结构给出的指标值的激活组合进行过滤, 如果 WHERE 结构嵌套的话, 则需要一直过滤到最里层, 然后其中的赋值语句再对所有经过过滤剩下的指标值的激活组合进行赋值操作例 9-23 INTEGER X(5,4) INT_WHERE: FORALL (I=1:5) WHERE(X(I,:)==0) X(I,:)=I END FORALL INT_WHERE 如果 X 取初始值 :

169 那么运算的结果为 : 嵌套 FORALL 结构或语句内部 FORALL 结构或语句的头里的三项列中的表达式的计算是对外部 FORALL 结构的指标值的激活组合进行的, 每个表达式由此得到的值的集合组合起来, 即得到该层 FORALL 结构的指标值组合集合然后再通过其中的过滤网得到它的指标值的激活组合的集合, 再用这个指标值集合来控制其中的赋值语句例 9-24 INTEGER X(3,3) OUTER:FORALL(I=1:N-1) INTER:FORALL(J=I+1:N) X(I,J)=X(J,I) END FORALL INTER END FORALL OUTER 如果 N 取值 3,X 取初始值为 : 那么经过上面程序的运算, 得到值 : FORALL 语句 FORALL 语句通过一个指标值集合以及可选的过滤网, 对单独一个赋值语句或指针赋值语句进行控制 FORALL 语句的一般形式 (R754) 为 : FORALL(forall-triplet-specification-list [,scalar-logical-expression])&

170 forall-assignment-statement 其中 forall 赋值语句的句法形式 (R752) 为 : assignment-statement pointer- assignment-statement FORALL 语句实际上可以把它看成是只包含一个为赋值语句或指针赋值语句的体结构的 FORALL 结构, 它的运行过程就是那个 FORALL 结构的运行过程, 其中头里面的指标的作用域就是该语句自身上面有关嵌套 FORALL 结构的例子里面的嵌套 FORALL 结构的功能可以使用一个单独的 FORALL 语句来表达 : FORALL(I=1:N-1,J=1:N,J>I)X(I,J)=X(J,I) 第 10 章基本计算 ( 二 ) 选择控制结构在上章我们可以看到, 赋值语句之所以能够驱动计算过程的运行, 除了赋值语句本身构成完整的运算求值指令之外, 计算机本身所具有的串行机制保证了, 只要把执行语句与说明语句串列下来, 然后保证数据对象流的畅通, 计算机就能够按照语句序列的次序依次执行下来, 从而完成相应的计算任务不过分析一下我们的实际计算任务, 就会发现真正完全可以只需要按照一个固有计算序列算下来, 就可以完成计算的问题只是少数简单的问题而已, 稍微复杂点的问题往往都需要在计算过程当中出现某种判别问题, 使得计算途径可以分支, 对不同的情形, 会有不同的计算途径与不同的计算结果 ; 还会出现反复进行同一种运算, 然后再在适当的条件下跳出循环的情形, 如果只是使用串行序列来描述此时的运算过程, 会使得程序的写作充满重沓的语句显然这些类型的计算任务, 或者是语句串行序列无法描述的, 或者是描述发生令人难以忍受的所以一种描述计算过程的语言, 除了可以构成串行的计算序列之外, 还必须能够控制这个序列有可能出现的选择分支与循环的情形, 这就是所谓语言的控制结构本章和下章, 我们将分别讨论 FORTRAN 所提供的两种类型的控制结构以及相应的控制语句 : 选择控制结构 ; 循环控制结构把程序序列当中的控制结构清晰地加以强调出来, 实际上既有助于程序的阅读, 也是符合人的思维的清晰性原则的, 因此控制结构的规范化正是编程语言追求结构化的一个主要着力点, 但是在早期 FORTRAN 版本里面, 并没有完全意识到结构化编程风格的重要性, 因此引入了一些常常破坏结构的转移控制语句, 而 FORTRAN 语言的现代版本还没有完全放弃它们, 但不提倡使用, 这些转移控制语句我们在下章也将简略地讨论到

171 10.1 执行顺序一个完整的 FORTRAN 程序, 或程序单位, 就给出了一个由可执行语句引导的语句执行序列, 这个序列就是语句在程序里面出现的序列, 称为正常运行序列但是某些可执行结构或可执行语句, 能够控制实际的语句运行不止是按照语句书写的序列进行, 这样的可执行结构或语句包括控制结构和分支语句控制语句执行序列有两种基本风格 : 使用可执行结构, 使得程序能够选择性地运行程序序列里某个特定位置的语句块或结构使用能够分支到程序其他任意位置的语句的可执行语句一般说来, 上面的第一种方式具有更好的可阅读性和可维护性, 因此我们将详细讨论第一种方式的实现, 而第二种方式则放在下章末尾简略说明一下 10.2 块与可执行结构所谓控制结构由一个或多个语句块和结构构成, 其中必定显式地或隐式地包含控制逻辑语句根据相应的逻辑控制条件, 就可以选择性地运行某个特定的语句块与结构一个块就是一个由 0 个或多个语句与结构构成的序列, 句法形式 (R801) 为 : [execution-part-construct] 构成块的语句与结构的序列构成一个程序单位, 是一个某种意义上的整体, 即或者整个块被执行, 或者整个块都不被执行, 不能够出现块的某个部分被执行的情形不过也可能出现在整个块被执行的情况下, 块内的某些语句没有被执行的情况, 例如在块内的比较靠前的分支语句, 常常能够制止它后面的语句得到执行, 但是从语法意义上来看, 整个块的功能得到了完整的实现, 因此这种情形也被认为是块的完全执行所谓结构就是由一个或多个语句块或者结构, 加上作用于这些块的控制语句构成结构通常在块前具有一个初始语句, 而在块后具有一个终止语句 ; 当结构包含不止一个块时, 结构必定包含了用来选择执行哪个块的条件语句, 而一个块是否被执行, 正是由结构的作为条件语句的控制逻辑语句当中的表达式决定的 ; 结构也有可能在块之间放置特定的语句, 用来决定相应的块是否被执行 ; DO 结构专门用来决定一个块可以被连续地执行的次数例 10-1 下面给出的可执行结构控制了一个块 : IF(K<=1)THEN X=K**2 Y=SIN(X) END IF!IF 结构的初始语句! 块的第一个语句! 块的第二个语句!IF 结构的终止语句 FORTRAN 提供了三种能够控制块的可执行结构 : IF 结构 CASE 结构 DO 结构块的一般规则如下 :

172 首先执行块内的第一个语句或结构, 随后的执行顺序就是语句的排列顺序, 除非中间包含控制结构或语句改变这个顺序一个块作为一个整体, 必须是完整地被包含在一个结构当中 ; 一个块也可以是空块, 即不包含任何语句与结构在块内允许出现分支结构或控制结构, 使得运行序列能够转移到该块内的特定语句或结构在块内的任意位置, 都可以强制运行的退出从块的外部通过分支到达块的内部, 哪怕是块内的第一个可执行语句, 都是禁止的块内可以引用过程结构可以具有结构名称结构名称在结构的初始语句和终止语句当中的出现, 必须是成对的, 也就是说或者同时出现在这两个位置, 或者都不出现在上章我们讨论了 WHERE 结构与 FORALL 结构, 它们似乎同样具有控制结构的功能, 但实质上它们都是属于赋值语句 WHERE 结构可以包含多个块, 但是除了块内的某些数组元素被过滤网过滤掉, 从而不参与计算之外, 每个块内的每个语句, 都必须被执行 FORALL 结构只包含一个块, FORALL 对这个块的执行控制, 不是反复地运行这个块, 而是其中的每个语句都必须对指标值集合里的所有元素执行一次, 然后才转入下一个语句在 FORALL 结构里也可以引入过滤网, 以排除掉不符合条件的计算 10.3 IF 结构和 IF 语句一个 IF 结构至多选择结构里的一个语句与结构的块来得到执行而一个 IF 语句至多控制一个语句的执行在下章后面会简略讨论到的算术 IF 语句与这里的 IF 语句没有关系, 算术 IF 语句是一种分支语句, 并且是过时的 IF 结构 IF 结构可以包含多个块与多个逻辑表达式, 还可能包含 ELSE 语句与 ELSE IF 语句逻辑表达式总是放置在相应的块之前, 因此 IF 结构的执行总是从逻辑表达式开始的, 一旦逻辑表达式取真值, 则相应的块获得执行, 整个 IF 结构内至多只有一个块能够被选择执行, 而如果没有 ELSE 语句的话, 可能没有块满足执行的条件一旦被选择执行的块运行完毕, 或者不存在满足执行条件的块, 则整个 IF 结构的运行被终止 1. IF 结构的形式 IF 结构的句法形式 (R802) 为 : [if-construct-name:] IF(scalar-logical-expression) THEN block [ELSE IF(scalar-logical-expression)THEN[if-construct-name]

173 block]. [ELSE [if- construct-name] block] END IF [if-construct-name] IF 结构的一般规则如下 : 至多只有一个结构里的块被执行, 或者没有块被执行 ELSE IF 语句不能跟随在 ELSE 语句后面不能出现分支到 ELSE IF 语句或 ELSE 语句的情形从 IF 结构里的任意块都可以分支到 END IF 语句, 即随时可以退出 IF 结构结构名称必须成对出现在 IF-THEN 语句和 END IF 语句当中 ELSE IF 语句和 ELSE 语句里的结构名称是可选的, 如果有的话, 必须和 IF-THEN 语句里的结构名称一致在同一个作用域单位内, 同一个结构名称不能用于不同的命名结构 2. IF 结构的运行结构里的逻辑表达式按照序列位置执行, 直到某个表达式为真值, 然后紧跟该表达式后面的块得到执行, 该块运行完毕之后, 整个 IF 结构即退出运行在第一个真值表达式后面如果还存在真值表达式, 则它们不影响对执行块的选择如果在该 IF 结构内 ( 而不是它的子结构内 ) 找不到真值表达式, 则 ELSE 语句后面的块被执行 ; 如果没有 ELSE 语句, 则退出 IF 结构下面的图 10-1 给出了 IF 结构的运行示意图例 10-2 IF(I<J)THEN X=Y*2.5 ELSE IF(I>8.3)THEN X=0.0 Y=100 ELSE X=100 Y=0.0 END IF 上例的执行顺序就是 : 首先执行 I<J, 如果为真, 则执行 X=Y*2.5; 如果为假, 则执行紧跟后面的 ELSE IF -THEN 语句进入 ELSE IF-THEN 语句后, 首先执行 I>8.3, 如果为真, 则执行 X=0.0,Y=100; 如果为假, 则执行紧跟后面的 ELSE 语句进入 ELSE 语句后, 执行 X=100,Y=0.0

174 然后执行 END IF 语句, 退出该 IF 结构图 10-1 IF 结构的运行流示意图 IF 语句一个 IF 语句用在只需要控制一个语句的场合 1. IF 语句的形式 IF 语句的句法形式 (R807) 为 ; IF(scalar-logical-expression)action-statement 例 10-3 IF(X=0)Y=X+1

175 2. IF 语句的运行首先执行逻辑表达式, 如果为真值, 则执行 IF 语句里的作用语句 (action-statement); 如果为假, 则退出该语句, 执行程序里跟在 IF 语句后面的其他语句注意作用语句 (action-statement) 不能是一个 IF 语句, 也不能是一个 END 语句如果逻辑表达式包含一个函数引用, 那么逻辑表达式的运行可能产生修改作用语句的副作用, 这是允许的作用语句能够改变变量, 或输入输出系统条件, 或控制语句的状态, 作用语句的例子包括赋值,WRITE, GO TO 语句等 ; 说明性语句,FORMAT 语句, 和 ENTRY 语句等不属于作用语句, 而结构也不能看成是作用语句 10.4 CASE 结构和 IF 结构类似的是,CASE 结构也可以包含多个块, 而最终能够获得执行的最多只能是一个和 IF 结构不同的是,CASE 结构的选择是基于结构开头的 SELECT CASE 语句里的标量表达式的取值, 这个取值被称为情况指标, 它可以是离散型的各种标量值, 例如整型, 字符型, 逻辑型, 而在 IF 结构里, 用来进行判别而提供选择条件的是逻辑型取值, 即只有.TURE. 和.FALSE. 两个值得到情况指标之后, 搜索所有的 CASE 语句里的情况选择符的值, 如果有与情况指标匹配的, 则执行相应的 CASE 语句里的块, 否则执行具有默认选择符的 CASE, 如果不存在具有默认选择符的 CASE, 则退出使用 CASE 结构可以很自然地表达需要分情况考虑的问题, 同时每种情况的定义必须是已知的例 10-4 设分段函数 : sin( x) x 0 y = cos( x) x< 0 可以很自然地使用 CASE 结构描述如下 : SELECT CASE(x>=0) CASE(.TRUE.) Y=SIN(X) CASE(.FALSE.) Y=COS(X) END SELECT 例 10-5 一年中十二个月的天数也可以用 CASE 结构表示如下 : MONTHDAY :SELECT CASE(MONTH) CASE(2) DAYS=28 CASE(4,6,9,11) DAYS=30 CASE(1,3,5,7,8,10,12)

176 DAYS=31 END SELECT MONTHDAY CASE 结构的形式 CA SE 结构的句法形式 (R808) 为 : [case-construct-name:]select CASE(case-expression) [CASE(case-value-range-list)[case-construct-name] block] [CASE DEFAULT[case-construct-name] block] END SELECT [case-construct-name] 其中的情况表达式 (case-expression) 为标量表达式, 该表达式经过计算得到的取值为情况指标其中的情况值范围 (case-value-range) 即连同其括号称为情况选择符, 表示它的取值所属的离散区间, 也可以就是一个单独的值, 它的句法形式 (R814) 为 : case-value case-value : :case-value case-value :case-value 即如果是区间的话, 该区间可以是半边开的其中的情况值 (case-value) 是一个标量初始化表达式, 与情况表达式的类型等属性一样所谓初始化表达式即在编译时可以取值的表达式, 本质上即常量表达式它们的取值都只能是整型, 字符型和逻辑型可以看到在 CASE 结构里, 包含了三种语句 : SELECT CASE 语句 ; CASE 语句 ; END SELECT 语句而在 CASE 语句当中, 跟在关键词 CASE 后面的 (case-value-range-list) 或 DEFAULT 就是情况选择符 CASE 结构的一般规则如下 : 如果 CASE 结构具有名称的话, 那么结构名称必须成对出现在 SELECT CASE 语句和 END SELECT 语句当中情况选择符后面如果出现结构名称的话, 必须与 SELECT CASE 语句当中的结构名称一致具有情况选择符 DEFAULT 的 CASE 语句是可选的, 如果它出现在结构当中的话, 上述 CASE 结构的句法形式并没有要求它放置在结构的最后在一个 CASE 结构里, 情况表达式与所有的情况值都必须属于同一个类型, 如果属于字符型, 它们可以具有不同的长度, 但是种别参数必须一致情况值范围里面出现冒号时, 表示一个区间, 而区间的构成隐含着相应的关系表达式

177 情况值不能是逻辑型如果是字符型的话, 则依据字符型的关系运算规则确定相应的取值范围例 10-6 CASE( ABOUT : Z ) 里面的情况值范围为按照与处理器相关的默认字符类型的关系运算, 在 ABOUT 与 Z 之间的所有字符串结构当中的表达式的取值完成后, 必须保证最多只能有一个情况选择符的值与情况指标值匹配, 也即不允许在不同的情况之间情况值出现重复的情形情况值 DEFAULT 与任何跟所有结构内的其他情况值都不匹配的情况指标值匹配例 10-7 CALCU_AREA: SELECT CASE(OBJECT) CASE(RECTANGLE) CALCU_AREA AREA=LENGTH*WIDTH CASE(SQUARE) CALCU_AREA AREA=SIDE*SIDE CASE(CIRCLE) CALCU_AREA AREA=PI*RADIUS**2 END SELECT CALCU_AREA CASE 结构的运行首先计算 SELECT CASE 语句当中的作为标量表达式的情况指标, 它的值最多与结构里的一个情况值匹配, 与之匹配的情况值后面紧跟的块得到执行, 然后退出结构程序进入紧跟该结构的 END SELECT 语句后面的可执行语句或结构如果没有与情况指标值匹配的情况值, 而结构里包含了 CASE DEFAULT 语句, 按照 DEFAULT 的定义, 情况值这时必定与之匹配, 因此执行该语句后面的块, 然后退出该结构如果结构当中不存在 CASE DEFAULT 语句, 又没有与情况指标值匹配的情况值, 那么退出该结构, 不执行结构里的任何块所谓情况指标值与结构里的一个情况值匹配, 包含如下情形 : 如果情况值为单独的一个值, 则运用等价与非等价关系运算, 看是否与指标值等价 ; 如果情况值是一个区间, 则按照下表 10-1 的定义 : 情况值范围 case-value1 :case-value2 case-value : :case-value 表 10-1 不同情况值的匹配匹配的定义 case-value1.le. case-index.le. case-value2 case-value.le. case-index case-value.ge. case-index 注意不同 CASE 语句的情况值范围不能有重叠结构的执行最多只允许其中的一个块被执行只能从结构内部分支到该结构的 END SELECT 语句

178 不允许分支到 CASE 语句, 但可以分支到 SELECT CASE 语句下面的图 10-2 给出了 CASE 结构的运行流的示意图 : 例 10-8 图 10-2 CASE 结构的运行流示意图 INDEX=2 SELECT CASE(INDEX) CASE(1) A=(1,2) CASE(2) A=(2,3) CASE DEFAULT A=(0,0) END SELECT

179 例 10-9 下面的例子描述了一个交通规则 : COLOR= GREEN SELECT CASE(COLOR) CASE( RED ) STOP CASE( YELLOW ) CALL STOP_IF_YOU_CAN_SAFELY CASE( GREEN ) CALL GO_AHEAD END SELECT 第 11 章基本计算 ( 三 ) 循环控制结构上章讨论的控制结构的特点是通过判别条件来对结构内的块进行选择, 所对应的算法结构, 最简单的例子, 就是解一元二次方程, 在输入方程所以的参数值之后, 需要首先计算一个判别式, 然后根据判别式的值, 再选择使用哪个公式, 也就是计算的途径, 才能够给出最终的解在本章所讨论的控制结构的特点则是针对结构内的块进行多次的重复运算, 每完成一次运算, 都判别一下是否需要把此次运算结果作为输入, 再进行一次运算这种控制结构所对应的算法结构, 一个最简单的例子, 就是求级数的部分和我们知道对于具有通项表达式的级数, 求它的部分和的每一项, 总是需要进行同样的运算过程, 如果使用按照序列形式排列的程序结构, 那么需要计算多少项, 就需要写下多少条语句, 把它们顺序排列下来, 才能做到程序走一遍即完成计算这样的算法设计显然是没有利用运算过程里所表现的循环结构, 如果使用一种控制结构与循环过程对应, 让程序的运行能够重复表示通项公式的表达式计算, 就能够用一个表达式代替所有项的表达式, 显然更加合理例 11-1 设有一个级数 : n x = 1/ i 如果要求级数在 N=K 时的值, 如果一定要使用序列结构的程序, 那么在程序当中肯定会出现如下 K 个表达式顺序排列的情形 : I=1 SUM=1/I**3 I=2 SUM=SUM+1/I**3 I=3 SUM=SUM+1/I**3 i= 1 3

180 I=K SUM=SUM+1/I**3 由于这 K 个表达式是一样的, 因此如果使用如下的一个控制结构, 只需要使用一个表达式赋值语句, 就可以表示整个循环运算过程 : SUM=0.0 DO I=1, K SUM= SUM+1/I**3 END DO 上面的控制结构, 就是本章所要讨论的 DO 结构实际上这是一种基本的计算过程, 为很多重要算法的实现提供了基础 FOR TRAN 语言提供用来进行循环控制的主要结构就是 DO 结构, 因此本章主要讨论的就是 DO 结构最后还会简略的讨论有关分支转移的实现问题, 尽管它们不属于循环控制, 但是由于在现代结构性编程风格的要求下, 这种分支转移是一种过时的方式, 因此简略地附加在本章后面 11.1 DO 结构 DO 结构包含 0 个或多个语句或结构, 它们在 DO 结构的其他部分的控制下进行重复运行这些被重复运算的语句或结构构成一个循环,DO 结构控制了该循环的运行次数 DO 结构的运行分为如下步骤 : 如果 DO 结构由一个 DO 变量控制, 那么决定循环次数的该表达式的值首先需要计算出来 ; 然后决定循环部分是否运行 ; 如果运行循环部分, 则完成循环后, 更新 DO 变量, 再进入第二个步骤 ; 如果不需要运行循环部分, 则退出该 DO 结构, 进入程序的后续部分其中对于 DO 结构的循环部分的控制方式有 3 种 : 利用一个循环变量从初始 DO 语句开始, 以确定的方式增长 ( 也可能是负方向增长 ), 该变量作为一个循环计数器, 它的取值变化的次数标记了循环的次数 ; 利用 WHERE 条件 ; 使用简单 DO 结构, 或者称为永远 DO 显然这种方式需要一个可执行语句来终止 DO 结构, 例如 EXIT 语句, 可以用来退出循环从 D O 结构的整体构造来看,DO 结构分为两种形式 : DO 结构块 ; DO 结构本身构成一个块结构, 总是使用一个 END DO 语句或 CONTINUE 语句来终止 DO 结构的运行非块 DO 结构非块 DO 结构本身不构成一个块状结构, 它或者使用一个作用语句或结构来终止该 DO 结构的运行, 或者与其他 DO 结构共享一个终止语句这两种形式具有相同的功能, 都可以使用 DO WHERE 与永远 DO 的循环形式, 但是非块 DO 结构属于早期 FORTRAN 版本的遗留物, 是在还不重视结构化编程的时代的产物, 因此是过时的表达方式, 现代 FORTRAN 语言不提倡使用下面是一个 DO 结构块的例子

181 例 11-2 DO I=1,N SUM=SUM+X(I) END DO 下面是执行与上例同样的计算任务的非块 DO 结构的例子例 11-3 DO 100 I=1,N 100 SUM=SUM+X(I) DO 结构块的形式 DO 结构块就是使用不与其他 DO 结构共享的 END DO 语句或 CONTINUE 语句作为终止语句的 DO 结构它的一般句法形式 (R817) 为 : [do-construct-name:] DO [label][loop-control] [execution-part-construct] [label] END DO 其中循环控制 (loop-control) 的句法形式 (R821) 为 : [,]scalar-integer-variable-name = & scalar-integer-expression,scalar-integer-expression & [,scalar-integer-expression] [,]WHILE(scalar-logical-expression) 其中 END DO 语句的句法形式 (R824) 为 : END DO [do-construct-name] CONTINUE 其中在可选的结构名称加关键词 DO 后面的语句称为 DO 语句 ; 关键词 END DO 后面的语句称为 END DO 语句 ; 关键词 CONTINUE 后面的语句称为 CONTINUE 语句 DO 结构的一般规则如下 : DO 结构里循环控制里的 DO 变量, 必须是整型的标量命名变量整个 DO 结构块如果有一个结构名称, 那么它必须同时出现在 DO 语句和 END DO 语句里面, 而不能只出现在其中之一里面如果 DO 语句里面不包含标签, 那么 END DO 语句里面也不能包含标签 ; 如果 DO 语句里面包含标签, 那么 END DO 语句必须使用同样的标签注意 DO 结构块里的终止语句绝对不能与其他 DO 结构共享, 因此 END DO 语句的标签绝对不能在别的地方被引用如果终止语句其他 DO 结构共享了, 则属于非块 DO 结构 DO 结构里面可选的标签既可以使用自由源码形式也可以使用固定源码形式下面给出一些不同形式的 DO 结构的例子例 11-4

182 SUM=0.0 DO I=1,N SUM=SUM+(-1)**N*(1/N**2) END DO 这个例子里面的 DO 变量是 I 例 11-5 FOUND=.FALSE. I=0 DO WHILE(.NOT. FOUND.AND.I<LIMIT) IF(KEY==X(I))THEN FOUND=.TRUE. ELSE I=I+1 END IF END DO 这个例子使用了 WHERE 语句例 11-6 NO_ITERS=0 DO 下面的 FU 和 FU_PRIME 都是函数 X1=X0-FU(X0)/FU_PRIME(X0) IF ( ABS (X1 - X0 ) < SPACING ( X0 ).OR. & NO_ITERS > MAX_ITERS ) EXIT X0 = X1 NO_ITERS=NO_ITERS+1 END D O 这个 DO 结构里面使用 IF 语句例 11-7 INNER_PROD= 0.0 DO 100 I=1,10 INNER_PROD=INNER_PROD+X(I)*Y(I) 100 CONTINUE 这个例子里面使用了 CONTINUE 语句例 11-8 LOOP: DO I=1, N Y(I)=A*X(I)+Y(I) END DO LOOP

183 在这个例子里面给出了 DO 结构名称非块 DO 结构的形式非块 DO 结构的终止语句总是使用标签, 并且采取如下两种情形 : 一个非块 DO 结构的终止语句是与其他的 DO 结构共享的 ; 非块 DO 结构的终止语句本身是一个结构或作用语句, 而不是 END DO 语句或 CONTINUE 语句具有这样的终止语句的 DO 结构, 就不能形成一个块结构, 这导致它是一种过时的表述方式非块 DO 结构的句法形式 (R826) 为 : action-terminated-do-construct outer-shared-do-construct 其中作用语句终止 DO 结构 (action-terminated-do-construct) 的句法形式 (R827) 为 : [do-construct-name:]do label [loop-control] [execution-part-construct] label action-statement 其中可外部共享 DO 结构 (outer-shared-do-construct) 的句法形式 (R830) 为 : [do--construct-name:]do label [loop-control] [execution-part-construct] label shared-termination-do-construct 其中可共享终止 DO 结构 (shared-termination-do-construct) 的句法形式 (R831) 为 : outer-shared-do-construct inner-shared-do-construct 其中可内部共享 DO 结构 (inner-shared-do-construct) 的句法形式 (R832) 为 : [do-construct-name:]do label [loop-control] [execution-part-construct] label action-statement 其中用来退出作用语句终止 DO 结构 (action-terminated-do-construct) 的作用语句称为终止 DO 作用语句 ; 用来退出可内部共享 DO 结构 (inner-shared-do-construct) 的作用语句称为终止 DO 共享语句 ; 所有这些用来终止非块 DO 结构的语句或结构形式, 包括终止 DO 作用语句, 终止 DO 共享语句, 终止 DO 共享结构, 都称为 DO 终止, 或 DO 结构的终止语句非块 DO 结构的一般规则如下 : 一个终止 DO 作用语句不能是任何形式的如下语句 : CONTINUE 语句 ;GO TO 语句 ;RETURN 语句 ;STOP 语句 ;EXIT 语句 ;CYCLE 语句 ; END 语句终止 DO 作用语句和相应的 DO 语句必须具有相同的标签一个终止 DO 共享语句不能是任何形式的如下语句 : GO T O 语句 ;RETURN 语句 ;STOP 语句 ;EXIT 语句 ;CYCLE 语句 ;END 语句终止 DO 共享语句和相应的所有共享它的 DO 语句必须具有相同的标签

184 D O 结构里面可选的标签既可以使用自由源码形式也可以使用固定源码形式下面给出一些不同形式的非块 DO 结构的例子 : 例 11-9 PROD=1.0 DO 20 I=1,N 20 PROD=PROD*P(I) 例 DO 20 I=1,N DO 20 J=1,N 20 HILBERT(I,J)=1.0/REAL(I+J) 这个例子里面包含 DO 语句的嵌套结构例 FOUND=.FALSE. I=0 DO 20 WHILE(.NOT.FOUND.AND.I<LIMIT) I=I+1 20 FOUND=KEY==X(I) 这个例子里面使用了 WHERE 语句例 : DO 20 I=1,N DO 20 J=I+1,N A=B(I,J) ;B(I,J)=B(J,I);B(J,I)=A 20 CONTINUE 这个例子里面使用了 CONTINUE 语句 DO 结构的范围所谓 DO 结构的范围是指从 DO 语句到该 DO 结构的终止语句的所有语句在 D O 结构的范围内部可以包含其他类型的结构, 例如 IF 结构,CASE 结构, 以及其他 DO 结构, 其中任何一个内部结构都必须是完整地包含在另一个结构之中, 而不能有各个结构相互交错的情形如果在一个 DO 结构里面包含了其他 DO 结构, 那么该 DO 结构称为嵌套 DO 结构嵌套的 DO 结构共享一个终止语句是允许的, 但是属于即将淘汰的语法形式, 因此尽量不要使用从一个 DO 结构的外部分支到它的内部某个语句是绝对禁止的 DO 结构的激活与灭活一个 DO 结构可以处于激活状态, 也可以处于灭活状态

185 当一个 DO 结构被运行时, 就是处于激活状态当一个 DO 结构处于如下几种情形时, 就是处于灭活状态 : 在检测条件时循环计数器取值为 0; 在检测条件时 WHILE 条件为假 ; 执行了 EXIT 语句, 导致从 DO 结构退出 ; 执行了 CYCLE 语句 ; 出现一个指向 DO 结构外部的控制转移 ; 执行了 RETURN 语句 ; 任何其他原因导致程序终止 DO 结构的运行由于 DO 结构具有非常不一样的三种形式, 因此 DO 结构的运行也具有三种形式 : 带循环计数器的 DO 结构的运行 ; DO WHILE 结构的运行 ; 简单 DO 结构的运行所有这些运行形式都可以包含能够导致程序不按照语句顺序执行的可执行语句, 当然也可以包含导致 DO 结构运行终止的语句下面分别予以说明 1. 带循环计数器的 DO 结构的运行在这种 DO 结构的形式里面, 循环计数器控制了循环部分执行的次数带循环计数器的 DO 结构的句法形式 (R818) 为 : DO [label] [,] do-variable=expression1,expression2[,expression3] 其中的 DO 变量与相应的表达式都必须是整型下面是这样的不同形式的 DO 语句的一个例子例 DO 100 I=0,N DO,I=-N,N DO J=N,1,-1 所谓循环计数器是用来计量 DO 结构里面的循环部分的循环运行次数的循环计算器里面包括三个表达式, 这些表达式经过计算后得到的结果必须转换为 DO 变量的类型, 假设分别为 e1,e2,e3,( 其中 e3 不能是 0, 但可以省略, 而取默认值 1 ) 它们的含义为 : e1 表示 DO 变量的初始值 ; e2 表示 DO 变量的终止值 ; e3 作为可选项表示 DO 变量的变化的步长, 默认值取 1 那么循环的次数可以由下面的公式得到 : MAX((e2-e1+e3)/e3,0) 注意在下面的情形下导致循环计算器的取值为 0, 也就导致 DO 结构灭活 : e1>e2 并且 e3>0; e1<e2 并且 e3<0

186 然后通过循环计算器的控制,DO 结构的运行步骤如下 : 1. D O 变量的初始值设置为 e1; 2. 检测循环计数器, 如果取值为 0, 则退出 DO 结构 ; 3. 如果循环计数器的取值不是 0, 则 DO 结构的范围得到执行这时循环计数器的值减 1, 而 DO 变量增长 e3 4. 重复步骤 2 和 3, 一直到循环计数器的值为 0 注意在整个 DO 结构终止后,DO 变量的取值保持为相应的循环计数器值为 0 时的值在 DO 结构的范围的整个运行过程中, DO 变量不能被重定义, 也不能被去定义在 DO 结构的运行过程当中, 决定循环参数的表达式里面的变量的变化不影响循环计数器, 每次进入 DO 结构, 循环计数器的值都是固定的下面的示意图 11-1 表示了带有循环计数器的 DO 结构的运行流 : 图 11-1 带有循环计数器的 DO 结构的运行流例下面的例子运行了 10 次 N=10 SUM=0.0 DO 10 I=1,N SUM=SUM+A(I) N=N+1 10 CONTINUE 运行之后,I=11,N=20

187 例下面的内部循环运行了 10 次 : X=20 DO 10 I=1,2 DO 9 J=1,5 X=X CONTINUE 10 CONTINUE 运行整个 DO 结构之后,I=3,J=6,X=30 如果其中的第二个 DO 语句改为 : DO 9 J=5,1 那么其中的内部 DO 结构根本就不会运行, 而 X 取值仍然是 20,J=5,I=3 2. DO WHILE 结构的运行 DO WHILE 结构的循环控制不是通过一个整型变量来给出循环的次数, 而是通过对一个取逻辑型值的表达式的运算, 来获得进行循环的条件关键词 DO WHILE 后接逻辑型表达式的语句称为 DO WHILE 语句 DO WHILE 语句的句法形式为 : DO [label ] [,]WHILE [scalar-logical-expression] DO WHILE 语句的例子 : DO 100 WHILE(X(I)/=0) DO,WHILE(.NOT.FOUND) DO WHILE(y>=0.01) DO WHILE 结构的运行非常简单 : 首先计算逻辑表达式, 如果为真, 则运行循环部分 ; 如果为假, 则退出该 DO 结构例 SUM=0.0 I=0 DO WHILE (I<5) I=I+1 SUM=SUM+I END DO 上面的循环执行 5 次, 最后得到 SUM=15.0,I=5 3. 简单 DO 结构的运行也可以在 DO 结构里面不使用任何循环控制, 而是直接使用终止语句, 即 DO 范围里面的语句总是循环执行, 除非 DO 范围里面的某条终止语句在一定条件下被执行简单 DO 结构的一般形式就是 :

188 DO [label ] 例 DO READ*, DATA IF(DATA<0) STOP CALL PROCESS(DATA) END DO 在这个例子里面, 一直到 DATA 读入一个负值, 其中的 DO 范围才停止循环, 并退出 DO 结构把上面的例子改写为带有标签的形式, 如下 : DO 15 READ*,DATA IF(DATA<0) STOP CALL PROCESS(DATA) 15 CONTINUE 在 DO 结构范围内改变运行顺序在 DO 结构范围内部, 可以使用两个专门的语句来改变正常的运行顺序, 它们是 : EXIT 语句 ; CYCLE 语句当然可以用来在 DO 范围内改变正常运行顺序的语句, 并不只是这两个语句, 还包括一些分支语句, 例如 RETURN 语句,STOP 语句等, 但是这两个语句是专门用于 DO 结构内部的而那些分支语句则没有这个限制下面分别说明这两个语句 1. EXIT 语句 EXI T 语句直截了当地导致程序退出 DO 结构,DO 结构里面的任何其他语句都不再被执行 EXI T 语句既可以在 DO 结构块里面使用, 也可以在非块 DO 结构里面使用, 但是它本身不能充当非块 DO 结构里面的终止 DO 作用语句和终止 DO 共享语句 EXIT 结构的句法形式 (R835) 为 : EXIT[do-construct-name] 注意 EXIT 语句必须是在一个 DO 结构内部如果 EXIT 语句具有一个结构名称, 那么该 EXIT 语句必须是在同名 DO 结构的内部 ; 当该 EXIT 语句被执行的时候, 该同名 DO 结构就被终止, 同时, 任何包含了该 EXIT 语句的 DO 结构以及包含在该同名 DO 结构里面的 DO 结构全都被终止如果 EXIT 语句不带结构名称, 那么只有所有包含 EXIT 语句的结构之中最接近 EXIT 语句的 DO 结构被终止例 11-18

189 LOOP10:DO IF(TEMP==INDEX)EXIT LOOP10 END DO LOOP10 上例当中的 EXIT 语句带有结构名称, 那么当 IF 语句里面的条件被满足时, 就运行 EXIT 语句, 也就退出整个 LOOP10 结构 2. CYCLE 语句上面的 EXIT 语句是完全地退出整个 DO 结构, 而 CYCLE 语句则只是中断已经完成的循环, 使用可能更新过的循环计数器以及 DO 变量, 再次启动循环部分的循环计算过程 CYCLE 语句既可以在 DO 结构块里面使用, 也可以在非块 DO 结构里面使用, 但是它本身不能充当非块 DO 结构里面的终止 DO 作用语句和终止 DO 共享语句如果 CYCLE 语句在非块 DO 结构里面使用, 那么非块 DO 结构里面的终止 DO 作用语句和终止 DO 共享语句将不会得到执行 CYCLE 语句的句法形式 (R834) 为 : CYCLE[do-construct-name] 注意 CYCLE 语句必须是在一个 DO 结构内部如果 CYCLE 语句具有一个结构名称, 那么该 CYCLE 语句必须是在同名 DO 结构的内部 ; 当该 CYCLE 语句被执行的时候, 该同名 DO 结构就被中断, 同时, 任何包含了该 CYCLE 语句的 DO 结构以及包含在该同名 DO 结构里面的 DO 结构全都被终止如果 CYCLE 语句不带结构名称, 那么只有所有包含 CYCLE 语句的结构之中最接近 CYCLE 语句的 DO 结构被中断 CYCL E 语句可以用于任意形式的 DO 语句 ; 在循环控制条件许可的情形下, 就可以启动下一个循环的开始当 DO 结构被 CYCL E 语句中断之后, 如果 DO 结构存在 DO 变量的话, 该 DO 变量就被更新, 同时循环计数器被减小 1, 然后就开始了 DO 范围的下一个循环的执行例 DO INDEX= IF (INDEX<0)EXIT IF (INDEX=0)CYCLE END DO 在上面的例子当中, 只要 INDEX 为正数, 循环就一直进行 ; 一旦 INDEX 为负值, 则整个 DO 结构被终止 ; 而如果 INDEX 为 0 时, 则循环部分在 CYCLE 后面的所有语句都被跳过去, 重新开始循环过程

190 11.2 程序的分支所谓分支就是使得程序的运行从当前的语句转移到该程序单位里的另外一个语句, 也就意味着紧接当前语句的下面的语句得不到执行了导致转移的当前语句称为分支语句, 而被转移到的得到执行的语句称为分支目标语句可以成为分支目标语句的语句包括所有的作用语句, 另外还有如下语句 : IF-THEN 语句 ; SELECT CASE 语句 ; DO 语句 ; WHERE 语句 ; FORALL 语句 ; 以及其他在一定条件下的语句, 包括 : END SELECT 语句, 接受来自 CASE 结构里面的分支 ; END DO 语句, 接受来自 DO 结构里面的分支 ; END IF 语句, 接受来自 IF 结构里面的分支 END DO 语句, 终止 DO 作用语句以及终止 DO 共享语句, 接受来自 DO 结构的分支, 这种用法是过时的用法注意在一个块的内部的任意语句都不能接受来自块的外部的任意分支在转移到分支目标语句时, 需要在分支语句当中给出目标语句的位置, 因此就需要对目标语句标上标签当然从 FORTRAN 语法的角度来讲, 任何语句都可以加上标签, 但是现在一般在不必要的时候, 都是省略掉标签的因此一定要注意, 分支语句引用了分支目标语句的标签, 就意味着相应的分支目标语句必须具有相应的标签, 绝对不能省略另外标签的形式既可以使用自由源码形式也可以使用固定源码形式 GO TO 语句 GO TO 语句是一种无条件的改变程序运行顺序的分支语句 DO TO 语句的句法形式 (R836) 为 : GO TO label 注意 GO TO 语句里的标签必须是引用在与 GO TO 语句同一个作用域单位里的分支目标语句, 包括内部过程, 派生类型的定义, 以及界面块里面的语句的标签当执行 GO TO 语句时, 接下来执行的是 GO TO 语句里面给出的标签所指定的分支目标语句, 后面的程序运行则从该目标语句开始例 GO TO 100! 表示无条件地转移到标签为 100 的语句 IF X=3,THEN A(X)=X**2! 尽管该语句紧接着上面的 GO TO 语句,! 但是由于它不具有标签 100, 因此不被执行 GO TO 20

191 GO TO 020!GO TO 语句含义一样! 由于 20 和 020 是同一个标签, 因此这两个 CONTINUE 语句 CONTINUE 语句的句法形式 (R839) 为 : [label] CONTINUE CONTINUE 语句主要用来作为 DO 终止语句, 也可以作为分支目标语句如果 CONTINUE 语句只有它自己, 没有充当任何功能, 那么它对程序的运行顺序以及运行结果都没有任何影响例 CONTINUE 20 CONTINUE STOP 语句无论何时何地执行 STOP 语句, 都能够终止程序的运行 STOP 语句的句法形式 (R840) 为 : STOP [scalar-character-constant] STOP digit [digit [digit [digit [digit ] ] ] ] 其中的标量字符常量 (scalar-character-constant) 和数字 (digit) 列是可选的, 称为停止码注意可选的字符常量必须是默认字符型可选的数码的第一个数字如果为 0, 是没有意义的这些停止码在程序终止后可以访问如果存在多个 STOP 语句, 这些停止码就可以用来标志程序终止的位置对于停止码的解释依赖于编译系统所使用的局部中断过程例 STOP STOP 100 STOP Error # 算术 IF 语句算术 IF 语句是一个基于算术表达式的三路分支语句它的句法形式 (R838) 为 : IF(scalar-numeric-expression)label,label,label 算术 IF 语句的一般规则如下 : 在同一个算术 IF 语句当中, 同一个标签可以重复出现不止一次

192 其中的标量数值表达式 (scala r-numeric-expression) 不能是复型表达式语句当中的每个标签都必须是算术 IF 语句所在作用域单位里的作为分支目标的语句的标签当然, 具有这些标签的语句首先必须存在于此作用域单位之中算术 IF 语句的执行顺序是 : 首先计算数值表达式, 如果为负值, 则分支到第一个标签 ; 如果得到 0, 则分支到第二个标签 ; 如果得到正值, 则分支到第三个标签算术 IF 语句现在已经很少用到, 属于过时的语言成分计算 GO TO 语句类似于算术 IF 语句, 计算 GO TO 语句通过计算一个整型表达式, 根据得到的数值, 从一系列的分支目标的标签当中选择下一个应该执行的分支目标语句由于运用 CASE 语句能够实现完全相同的功能, 而 CASE 语句更加具有结构化的特征, 因此计算 GO TO 语句已经完全过时计算 GO TO 语句的句法形式 (R837) 为 : GO TO(label-list)[,]scalar-integer-expression 计算 GO TO 语句的一般规则如下 : 如果在标签列表 (label-list) 当中出现了 n 个标签, 而表达式的结果是从 1 到 n 的数值 k, 那么该数值表示了被选择的标签是列表当中的第 k 个标签, 即分支到该标签所表示的语句继续程序的运行过程如果表达式的结果小于 1 或大于 n, 那么不进行任何分支转移过程, 直接执行紧接该计算 GO TO 语句的下一个可执行语句标签列表当中的每一个标签, 都必须是在与该计算 GO TO 语句同一个作用域单位里的分支目标语句的标签一个标签可以在标签列表当中出现不止一次例 GO TO(15,45),A(X) GO TO(33,47,32,1),X**2*I 例 SWITCH= GO TO(33,100,33,56)SWITH X=Y**3 X=Y+2. X=SIN(Y) 100 X=Y**( 1/2) 如果 SWITH 取值为 1 或者 3, 则分支到语句 33, 执行语句 33; 如果 SWITH 取值为 2, 则分支到语句 100; 如果 SWITH 取值为 4, 则分支到语句 56; 如果 SWITH 取值大于 4, 小于 1, 那么在 GO TO 语句后, 执行语句 X=Y **3, 然后再执行语句 33

193 第三篇计算任务的剖分与组合从前, 有两个表匠, 一个叫霍拉, 一个叫坦普斯两人都很受顾客的欢迎, 他们各自的工场中的电话总是响个不停, 因为老有新主顾上门不过, 霍拉发了大财, 坦普斯却越来越穷, 最后连店铺都给亏没了这是为什么呢? 他们做的表都是由 1000 个零件组成坦普斯做表的方式是连续地把一只表从头做到尾, 如果尚未装完一只表就不得不中途放下 ( 比如说要去接客户电话了 ), 那么装了一半的表就会立刻散掉, 又得从头装起顾客们越喜欢他的表, 他的电话就越多, 也就越难得到足够的不被打断的时间来装成一只表霍拉做的表并不比坦普斯的简单但他经过设计, 用十个零件装成一个组件十个组件又可装成更大的组件十个大组件构成的系统就是整只表因此, 当霍拉不得不放下装了一部分的表去接电话时, 他只损失了一小部分活儿, 他装表所用工时只是坦普斯所用工时的一个零头在这个寓言里面, 我的中心思想是, 具有复杂性的系统最好是采取层级结构的形式, 而层级结构有一些与系统的具体内容无关的共同性质我将论证说, 层级结构是构造复杂事物的建筑师们所使用的主要结构方式之一 ----H.Simon [1] The Sciences of the Artificial 一个计算任务可以很简单, 使用几个语句进行描述, 执行之后就可以得到结果, 但是如果说我们人类使用计算机只是进行那种简单的计算, 显然是浪费而复杂的计算任务, 则和任何复杂事物一样, 具有非常庞大的内部结构, 人类解决复杂问题的一般思路, 就是把一个大的结构分解为相对比较小的结构, 如果可能就一直分解到非常简单的结构, 分别解决了那些简单结构的问题, 按照我们分解大问题的逻辑, 也就解决了开始的复杂问题如何运用程序语言来表达这个解构的思路, 就是本篇我们要讨论的主要论题首先我们讨论一个 FORTRAN 程序所可以具有的结构, 按照这个语言对程序结构模本的规定, 我们就可以规划相应的针对计算任务的问题解构方式所谓 FORTRAN 程序的结构, 就是一个 FORTRAN 程序可以包含那些程序单位, 然后这些单位又必须如何组装在一起所以我们分类讨论了 FORTRAN 的程序单位之后, 就需要讨论数据流与指令流是如何进行不同程序单位之间的通讯的, 通过这种通讯, 一个由许多程序单位组成的 FORTRAN 程序就构成了一个有机的整体, 恢复了被支解的问题的本来结构特别的, 我们还需要讨论最为重要的程序单位, 就是过程, 它的可执行程序单位的主体其中 FORTRAN 语言以标准形式给出的固有过程, 相当于为解决常见计算问题而准备的常用工具, 熟练使用它们可以达到事半功倍的效果 [1] Herbert A. Simon, ,20 世纪所谓认知科学革命的核心人物, 人工智能的巨擘, 在计算机科学和心理学领域都作出了开创性贡献 1975 年获得图灵奖,1978 年以决策理论荣膺诺贝尔经济学奖,1993 年美国心理学协会授予他终生杰出成就奖,1994 年获选中科院外籍院士, 生

194 前多次访华第 12 章程序的单位一个 FORTRAN 程序可以由那些单位组成, 在第一篇以及第 4 章都已经简单涉及过, 在这里我们要详尽地讨论这个问题, 特别是给出每种程序单位的结构与功能 12.1 程序单位 FORTRAN 的程序单位分为两大类 : 可执行程序单位 ; 不可执行程序单位其中可执行程序单位, 用来执行一个完整的功能, 包括 : 主程序 ; 外部函数子程序 ; 外部子例行程序子程序不可执行程序单位, 用来为其他程序单位提供定义, 包括 : 模块程序单位 ; 数据块程序单位因此上面的五种类型的程序单位构成了 FORTRAN 程序的基本单位, 不过在后面我们会看到, 数据块程序单位属于早期版本的遗留物, 完全是多余的一个完整的 FORTRAN 程序至少需要一个主程序, 而且也只能有一个主程序一般说来, 要完成一个完整的计算任务, 除了一个主程序之外, 往往还需要有函数以及子例行程序作为辅助, 这时, 主程序的作用就还包括驱动与管理这些作为过程的外部子程序, 使得它们构成一个整体, 从而完整地解决相关计算问题模块程序单位主要是提供给编程者用来组织程序元素的一个模块程序单位包含了如下几个方面的内容 : 数据声明 ; 派生类型定义 ; 过程界面信息 ; 供其他程序单位使用的子程序定义因此这样一个程序单位本身不是可执行程序单位数据块程序单位用于给出命名公用块里面的变量的初始值, 因此同样不是可执行程序单位由于 FORTRAN 的现代版本引入了模块结构, 而模块能够提供全局的数据初始化, 因此数据块程序单位几乎可以说是多余的由于在第 13 章我们将专门讨论过程以及过程的应用, 因此属于过程的外部函数子程序和外部子例行程序子程序, 在本章都只是简略说明, 需要详细讨论的是主程序和模块各种程序单位里面并不是能够使用任何 FORTRAN 语句, 语句类型与程序单位之间的兼容性在下面的表中予以说明

195 语句表 12-1 语句与程序单元的兼容性主程模块说数据序明部分块 USE 语句可可可可可可可 ENTRY 语句否否否可可否否 FO RMAT 语句可否否可可可否几种声明语句 * 可可可可可可可 D ATA 语句可可可可可可否派生类型定义可可可可可可可界面块可可否可可可可语句函数 # 可否否可可可否 CONTAINS 可可否可可否否可执行语句可否否可可可否注意 :* 几种声明语句包括 :PARAMETER 语句,IMPLICIT 语句, 类型声明语句以及说明语句 # 语句函数语句属于过时语言成分一个 FORTRAN 程序总是从主程序的第一个可执行语句开始运行, 在第三章我们已经讨论过一个完整 FORTRAN 程序的结构在下面的图 12-1 中, 我们再给出一个完整 FORTRAN 程序的外部子程示意图, 它包含了一个主程序, 一个模块, 以及两个子例行程序序模块子程序内部子程序界面体图 12-1 钟表制作程序的结构在上面的例子里面, 我们假设在装配一块钟表时, 零件装配与工具配套分别由两个徒弟完成, 那么等负责工具配套的徒弟把零件都放置在适当的工具旁边的时候, 就可以让钟表匠开始总的钟表装配工作了因此模块 ACCESSORY_BOX( 附件箱 ) 里面包含了子例行程序 PARTS( 零件 ) 与 TOOL( 工具 ) 所需要的一切数据与过程信息主程序调用了子例行程序 TOOL, 而主程序本身不需要模块 ACCESSORY_BOX 里面的信息

196 12.2 主程序主程序说明了整个 FORTRAN 程序的逻辑结构, 同时整个程序的运行就是从主程序的第一个可执行语句开始的不过从形式上看, 一个主程序和外部子程序其实的非常类似的一个主程序包括如下三个基本部分 : 说明部分这个部分定义了程序的数据环境运行部分整个程序从这个部分的第一个可执行语句开始, 该部分给出了整个程序运行的逻辑结构内部子程序部分处于主程序内部的与主程序共享数据的过程下面我们分小节说明主程序的说明部分和运行部分, 由于内部子程序部分由一个或多个内部过程组成, 而内部过程的讨论见 12.3, 因此在 12.2 略过终止主程序运行的方式有如下两种 : 在程序的任意位置执行 STOP 语句, 就能即刻终止整个程序所谓任意位置, 包括组成程序的任意程序单位的任意位置程序的运行到达主程序的最后一个语句主程序的组织主程序的形式 (R1101) 如下 : [PROGRAM program-name] [specification-part] [execution-part] [internal-subprogram-part] END [PROGRAM [program-name]] 下面是一个最最简单的 FORTRAN 程序 : 例 12-1 END 下面是一个稍微有意思一点的最简单程序 : 例 12-2 PROGRAM HI PRINT*, HELLO END 主程序的一般规则如下 : PROGRAM 语句作为主程序的程序头是可选的, 但是其他的程序单位都必须具有程序头如果程序名称出现在 END 语句当中的话, 那么该名称必须和 PROGRAM 语句里面的名称一样, 并且放置在关键词的后面不能单独出现 END 语句当中

197 主程序不提供哑元主程序不能在任何位置被引用, 也就是说, 主程序不能被直接或间接地递归运行主程序不能包含 RETURN 语句和 ENTRY 语句, 不过主程序里面的内部过程可以包含 RETURN 语句主程序的说明部分主程序的说明部分主要就是用来描述程序的数据环境主程序里面所能够包含的语句类型见表 12-1, 具体列出如下表 12-2: ALLOCATABLE COMMON DATA DIMENSION EQUIVALENCE EXTERNAL FORMAT IMPLICIT INTRINSIC NAMELIST 表 12-2 主程序说明部分允许使用的语句 PARAMETER POINTER SAVE TARGET USE 派生类型定义界面块语句函数语句类型声明语句主程序的说明部分的一般规则如下 : OPTIONAL 以及 INTENT 属性或语句都不能在主程序的说明部分出现, 因为它们都只能应用于哑元可访问性说明 PUBLIC 以及 PRIVATE 都不能出现于主程序, 因为它们都只能应用于模块内部在主程序里面, 动态对象没有意义尽管在主程序里面可以使用 SAVE 属性或语句, 但它们在主程序里面并没有实际的作用主程序的运行部分主程序的运行部分由可执行语句构成, 能够出现在主程序的运行部分的语句列出如下表 12-3 所示 : ALLOCATE BACKSPACE CALL CASE 结构 CLOSE CONTINUE 表 12-3 主程序运行部分允许使用的语句 GO TO IF IF 结构 INQUIRE NULLIFY OPEN

198 CYCLE DATA DEALLOCATE DO 结构 END ENDFILE ENTRY EXIT FORAL L FORAL L 结构 FORMA T PRINT READ REWIND STOP WHERE WHERE 结构 WRITE 算术 IF 语句赋值语句计算 GO TO 语句指针赋值语句 12.3 内部过程内部过程和外部过程的主要差别就在于它们的的位置不同 : 内部过程必须封装在主程序或其他过程子程序内部, 这就导致以下后果 : 内部过程的名称是局部的而不是全局的 ; 内部过程只能被包含了它的定义的程序单位所引用 ; 内部过程能够访问它的宿主的数据对象 ; 内部过程可以递归, 不能包含 ENTRY 语句, 也不能作为实元传递构造内部过程的主要原因如下 : 内部过程提供了能够很方便地访问宿主环境的过程内部过程提供了一种具有语句函数功能的多语句形式便于模块设计以及具有更好的软件工程效能内部过程之所以能够提高安全性以及灵活性, 是因为其界面非常清晰宿主的内部过程部分的形式 (R210) 为 : CONTAINS internal-subprogram [internal-subprogram] 其中的内部子程序由一个或多个内部过程组成, 而内部过程或者是由如下形式 (R1216) 的函数组成 : function-statement [specification-part] [execution-part] END FUNCTION [function-name] 或者是由如下形式 (R1221) 的子例行程序组成 : subroutine-statement [specification-part]

199 例 12-3 [execution-part] END SUBROUTINE [subroutine-name] PROGRAM WEATHER CONTAINS FUNCTION STORM(CLOUD) END FUNCTION STORM END 其中的过程 STORM 就是主程序 WEATHER 里面的一个内部过程内部过程的一般规则如下 : 内部过程内部不能再包含内部过程, 即内部过程不能嵌套内部过程不能包含 ENTRY 语句内部过程不能包含 PUBLIC 和 PRIVATE 属性或语句内部过程不能作为实元传递内部过程的说明部分除了可以包含主程序的说明部分所许可的语句之外, 还可以包含 INTENT 语句以及 OPTIONAL 语句内部过程的运行部分除了可以包含主程序的运行部分所许可的语句之外, 还可以包含 RETURN 语句在 CONTAINS 语句之后, 至少需要有一个内部子程序内部过程可以被它的宿主的运行部分引用, 也能够被同一个宿主里面的所有内部过程引用, 包括它自身, 因此内部过程可以直接或间接地使用递归的形式内部过程名称属于局部名称, 因此满足如下规则 : 内部过程名称具有比相同名称的外部过程或固有过程更高的优先级内部过程名称必须不同于任何同一个宿主里面的其他内部过程的名称, 也必须不同于任何通过模块进入宿主或进入该内部过程的名称内部过程的名称必须不同于任何宿主或自身内部的其他局部名称, 也必须不同于通过 USE 语句可访问的名称有关宿主以及内部过程里面的其他名称所需要遵循的规则参见第 15 章有关宿主关联的内容 12.4 宿主关联内部过程当中的某些变量有可能并非源自内部过程本身, 而是从内部过程的宿主单位继承而来的, 这样的变量被称为宿主关联的, 它反映了内部程序与宿主在数据交流方面的密切关系宿主关联作为一种数据通讯方式, 同样存在于模块过程与其作用域单位之间, 因此我们将在第 15 章的更为一般的情形下讨论它

200 12.5 外部子程序同样外部子程序是由一个或多个外部过程组成, 因此下文当中, 我们将根据具体的上下文交替使用外部子程序与外部过程这两个概念外部过程与内部过程从语法上来看, 实质上是一致的, 因为毕竟它们都是属于过程, 因此外部子程序的语法形式和内部子程序一样, 即 : 外部子程序由一个或多个外部过程组成, 而外部过程或者是由如下形式 (R1216) 的函数组成 : function-statement [specification-part] [execution-part] [internal-subprogram-part] END FUNCTION [function-name] 或者是由如下形式 (R1221) 的子例行程序组成 : subroutine-statement [specification-part] [execution-part] [internal-subprogram-part] END SUBROUTINE [subroutine-name] 这是两种不同风格的过程形式同时, 外部过程与内部过程又具有如下一些很重要的差别 : 对于一个 FORTRAN 程序来说, 外部子程序是全局性的, 因为它可以在任何位置被调用或引用, 相反, 内部过程则只是对于它的宿主而言是已知的外部过程的界面在它被其他过程引用的时候, 并非已知的, 因为外部过程一般都是单独编译的 ; 相反, 对于内部过程来说, 它是由它的宿主单位编译的, 因此在它的宿主单位引用它的时候, 它的界面信息必定已经给出了具有与生俱来的显式界面是内部过程或模块过程的一个很大的优点, 它的好处将在第 13 章讨论相比之下, 外部过程就只能单独给出它的界面信息从 FORTRAN 标准语法上来看, 外部过程可以包含内部过程, 而内部过程则不能包含内部过程, 不过也有许多 FORTRAN 的实现都允许内部过程的嵌套下面是外部过程的两个不同形式的例子 : 例 12-4 FUNCTION CIRCLE(NET) INTEGER CIRCLE CIRCLE=NODE END FUNCTION 这个例子使用了函数作为外部过程例 12-5

201 SUBROUTINE TAYLOR(I,J) I= J= END SUBROUTINE 这个例子使用了子例行程序作为外部过程外部子程序的一般规则如下 : 外部子程序作为程序单位的头, 即 FUNCTION 语句或 SUBROUTINE 语句, 是不能省略的, 这点与主程序不同如果在 END 语句出现过程名称, 那么它必须与头语句里面的过程名称一样用于哑元的 INTENT 和 OPTIONAL 属性或语句可以出现在外部子程序的说明部分, 注意它们只能应用于哑元外部子程序的说明部分和运行部分都可以包含 ENTRY 语句 ; 运行部分可以包含 RETURN 语句外部子程序不能包含用来说明可访问性的 PUBLIC 或 PRIVATE 属性或语句外部过程可以采用直接或间接的递归形式, 这时, 在该过程的头语句里面必须使用关键词 RECURSIVE 一个外部子程序对于在它内部定义的内部过程而言, 就是宿主单位外部过程名称可以在过程引用的时候作为实元来使用, 相应的哑元就是引用它的过程里面的过程哑元无论是外部过程, 内部过程或模块过程, 作为过程的更加一般的讨论参见第 13 章 12.6 模块模块是到了 FORTRAN90 版标准之后才引入的一个极其强大的程序结构单位形式只要是多于一个程序单位都需要使用的任何东西, 都可以封装在一个模块里面, 供相关的程序单位使用在 F ORTRAN 的早期版本当中, 为了解决一些程序要素的重复使用问题, 使用了 INCLUDE 行, 它的功能纯粹只是把一段源码原封不动地引入某个程序 ( 参见第四章 ), 相当于 COPY+PASTE 的功能, 以避免在重复写入别处的源码段时可能出现的笔误, 也节省编写源码的工作量但是这样一种解决方式是非常有局限性的, 因为这完全只是一种形式上的重用, 根本不具有灵活性与多功能性, 因此到了制订 FORTRAN90 标准的时候, 就引入了符合现代编程风格的模块结构, 使得 INC LUDE 行逐渐退出了历史舞台模块为 FORTRAN 解决了如下的问题 : 解决了大量的与全局性数据公用块相关联的可靠性问题, 因为对于全局性数据来说, 名称关联比存储关联更为有必要提供了更为可靠的定义派生类型的方式许多的情形下都要求显式的界面, 而模块正好满足了这种需求提供了极其重要的信息隐藏功能, 模块保证了可靠性所要求的有效的封装与隐藏功能尽管模块可以包含被其他程序单位的运行部分引用的可执行过程, 但它自身并不是可执行的程序单位, 实质上它只是被动地提供信息, 在这个意义上, 模块就已经是足够强大的管理程序的组织与简化程序设计的工具

202 模块的组织模块的语法形式 (R1104) 为 : MODULE module-name [specification-part] [module-subprogram-part] END [MODULE [module-name]] 模块的名称如果出现在 END 语句, 那么必须和 MODULE 语句里面的模块名称一样模块的说明部分示 : 模块的说明部分与其他的程序单位的说明部分非常类似, 它可以包含的语句如下表 12-4 所 ALLOCATABLE COMMON DATA DIMENSION EQUIVALENCE EXTERNAL IMPLICIT INTRIN SIC NAMELIST PARAMETER 表 12-4 模块说明部分允许使用的语句 POINTER PRIVATE PUBLIC SAVE TARGET USE 派生类型定义界面块类型声明语句模块的说明部分的一般规则如下 : 不允许使用 OPTIONAL 和 INTENT 属性或语句不允许使用 ENTRY 语句不允许使用 FORMAT 语句不允许使用动态对象不允许使用语句函数语句可以使用 PUBLIC 和 PRIVATE 属性或语句注意在模块的说明部分中使用 SAVE 属性或语句是非常必要的, 因为 SAVE 能够保证模块里面的数据对象, 不会受到使用该模块的其他程序单位的影响如果没有使用 SAVE 属性或语句的话, 那么相应的数据对象常常会被使用该模块的其他程序单位去定义, 而使用 SAVE 属性或语句, 则能够保证相应的数据对象保留其定义状态例 12-6 MODULE DATA1 SAVE INTEGER::X,IX REAL::K=0.01

203 REAL::Y(10,20),Z(20,30) END MODULE DATA1 SUBROUTINE TASK1 USE DATA1 END SUBROUTINE TASK1 在上面的模块 DATA1 当中, 声明了三个标量变量 : X,IX 和 K, 其中 K 给出了初始值, 还有两个数组 :Y(10,20),Z(20,30), 这 5 个数据对象都是全局性的, 都可以在任何时候被其他的程序单元使用在后面的子例行程序 TASK1 里面就通过 USE 语句使用了这 5 个变量模块的子程序部分在语法上, 模块的子程序部分类似于主程序的内部过程部分或外部子程序模块的子程序部分由一个或多个模块过程组成, 它们通过宿主关联共享模块的数据环境, 不过模块的子程序部分与内部子程序有如下两个基本的差别 : 模块过程的组织结构, 规则与限制都与外部过程的一样, 而与内部过程的不同, 例如模块过程可以包含内部过程, 而内部过程不能包含内部过程模块过程并非严格地局限于宿主模块, 也不是全局性地面对整个程序, 只有使用了模块的程序单位才能访问没有标记为 PRIVATE 的模块过程模块子程序部分的语法形式 (R212) 为 : CONTAINS module-subprogram [module-subprogram] 其中的模块子程序或者是由如下形式 (R1216) 的函数组成 : function-statement [specification-part] [execution-part] [internal-subprogram-part] END FUNCTION [function-name] 或者是由如下形式 (R1221) 的子例行程序组成 : subroutine-statement [specification-part] [execution-part] [internal-subprogram-part] END SUBROUTINE [subroutine-name] 这是两种不同风格的过程形式模块过程的一个例子如下 : 例 12-7

204 MODULE INTERNAL. CONTAINS FUNCTION SET_INTERNAL(KEY) END FUNCTION END 注意模块过程通过宿主关联来访问它的宿主模块的数据对象, 但不能访问使用该模块的程序单位的数据对象 CONTAINS 语句后面至少需要有一个内部子程序模块的使用方法任何一个程序单位都可以通过 USE 语句来使用一个模块里面的说明与定义这样一种从模块外部的程序单位到模块内部的命名对象的访问, 导致一种关联, 称为使用关联 USE 语句必须跟在要使用模块的程序单位的头语句后面, 对于 USE 语句的数目并没有具体的限制每个模块里面的命名对象都具有 PUBLIC 属性或者 PRIVATE 属性, 这两个属性决定了该对象是否可以被使用该模块的程序单位所使用, 即 : 如果具有 PUBLIC 属性, 则可以被使用该模块的程序单位所使用, 当然这种可访问性也有可能遭到 USE 语句本身的限制如果具有 PRIVATE 属性, 则不能被使用该模块的程序单位所使用下面的图 12-2 表示了模块内对象与外部程序单位的使用关联图 12-2 模块内对象与外部程序单位的使用关联 1. 访问模块内的所有公用对象 USE 语句最简单的功能就是通过使用该语句, 外部程序单位可以访问模块内部的所有公用对象 USE 语句的语法形式 (R1107) 为 :

205 USE module-name 如果外部程序单位在引用了模块的公用命名对象后, 导致与程序单位自身的命名对象的冲突, 或违反了该程序单位的命名约定, 那么就需要在 USE 语句当中加上改名选项, 即 : USE module-name,rename-list 其中改名列表 (rename-list) 里面的每个元素都具有以下形式 (R1108): local-name=>module-entity-name 即给每个模块内需要使用的对象的名称 (module-entity-name) 重新赋予一个新的程序单位内使用的本地名称 (local-name) 例 12-8 USE FOURIER USE S_LIB, PRESSURE => X_PRES 注意改名的形式与赋值语句的相似性, 但是改名属于 USE 语句内的一个选项, 而不是一个单独的语句 2. 访问模块内的部分公用对象如果要想让外部程序单位只是访问一个模块的部分公用对象, 则使用如下形式的 USE 语句 : USE module-name, ONLY:access-list 即在 USE 语句的 ONLY 子句里面显式指出可以访问的公用对象对于这些公用对象也可以根据程序单位的本地要求进行改名可访问对象列表里面的元素的形式可以具有如下这些形式 (R1109): [local-name=>]module-entity-name OPERATOR(defined-operator) ASSIGNMENT(=) 即除了模块对象名称之外, 还可以是模块内定义的自定义运算或赋值界面例 12-9 USE TENSOR1,ONLY:X,Y,OPERATOR(.CROSS.) USE MONTHS,ONLY:JANUARY=>JAN,MAY 3. 模块内的对象的可访问性在模块内部, 如下类型的对象都可以被声明, 定义, 或说明, 并且可以具有公用属性, 然后就可以被外部程序单位通过 USE 语句而使用, 其中除了自定义运算和赋值界面之外, 还可以被改名这些对象包括 : 经过声明的变量 ; 命名常量 ; 派生类型定义 ; 过程界面 ; 模块过程和固有过程 ;

206 通用识别符 ; 名称列表集合公用块也可以放置在模块里面, 由于公用块的名称总是全局性的, 因此公用块名称总是可以被模块外部访问, 并且不需要使用额外的 USE 语句, 不过如果要对公用块里面的变量进行改名, 则可以使用加改名选项的 USE 语句在默认情况下, 模块里面的上述所有对象都是具有 PUBLIC 属性的, 如果使用一个 PRIVATE 语句加上空的对象列表, 则把模块内的所有对象的属性改为私用的了当然可以使用 PRIVATE 语句或在类型声明语句当中附加 PRIVATE 属性的方式单独地对单个对象赋予私用属性而一旦默认可访问属性被改为 PRIVATE 之后, 还可以使用 PUBLIC 语句或在类型声明语句当中附加 PUBLIC 属性的方式单独地对单个对象赋予公用属性相比之下, 模块内部的任何对象, 包括模块内部的模块过程里面的对象, 都可以通过宿主关联而被模块过程访问模块内部对象的这两种被访问方式以及它们各自的特点, 示意于下面的图 12-3 图 12-3 模块内对象的使用关联与宿主关联把 U SE-ONLY 语句和模块内的 PUBLIC 以及 PRIVATE 属性这两种方式综合起来, 就使得模块兼具了信息安全性和数据访问灵活性 4. 使用模块时的可能的名称冲突当一个外部程序单位使用某个模块时, 有可能出现以下两种名称冲突的情形 : 模块内的公用对象和外部程序单位内的本地对象具有相同的名称 ; 一个外部程序单位同时使用了两个或多个模块, 它们的公用对象具有相同的名称这样的冲突只有在产生冲突的名称永远也不会被引用的情形下才能够容忍, 否则, 就必须使用改名选项或 USE 语句的 ONLY 子句, 来限制相关对象的使用例 MODULE BLUE INTEGER A,B,C END MODULE BLUE

207 MODULE GREEN USE BLUE, ONLY: A1=>A REAL B,C END MODULE GREEN! 在下面的程序 RED 里面 :! 用 A1 或 A 访问整型 A;! 用 B 访问整型 B;! 用 B1 访问实型 B;!C 不能被访问, 因为存在名称冲突 PROGRAM RED USE BLUE! 访问了 A,B, USE GREEN B1=>B! 用 A1 访问 A, 用 B1 访问 B, 访问 C END PROGRAM 5. 使用关联当一个外部程序单位通过使用 USE 语句而访问一个模块里面它自身所不具有的对象时, 就意味着这些被访问的对象与外部程序发生了关联, 这种关联称为使用关联 ; 相比之下, 在模块的内部, 当模块里面的模块过程访问其宿主模块的对象时所发生的关联, 称为宿主关联使用关联与宿主关联具有如下两个重要的差别 : 一个模块的隐式类型规则对于使用它的外部程序单位的环境没有影响通过 USE 语句来访问的对象, 不能在它所在的本地重说明, 改名不属于重说明范畴不过这个规则存在一个例外, 即假如外部程序单位本身是一个模块, 那么它从某个模块访问得到的对象, 可以在它的内部重新说明为具有 PRIVATE 属性, 显然, 该对象在原来的模块里, 是具有 PUBLIC 属性的例设一个程序单位使用如下所示的模块 M2, 那么它就只能使用对象 X, 而不能使用对象 Y, 因为 Y 在 M2 里面被重说明为具有 PRIVATE 属性, 尽管 Y 来自模块 M1, 并且在 M1 里面是具有 PUBLIC 属性的 MODULE M2 USE M1,ONLY:X,Y PRIVATE Y END MODULE M2 对象不能被重说明意味着同一个公用块, 也不能在模块和相应的外部程序单位里面被说明这也就意味着本地的对象不能和从模块里面访问得到的对象等价一个模块可以一个或多个 COMMON 块, 这些 COMMON 块总是可以被访问的, 这意味着它们不能在使用它们的宿主模块的外部程序单位不能再次声明它们因为从一个模块里面访问得到的名称不能在本地被重新说明, 所以要从不同的模块里面访问同一个名称, 就只有在下面的两种情形下, 才有可能 :

208 从不同的模块里面访问得到的同名对象本身就是同一个对象 ; 如果从不同的模块里面访问得到的同名对象不是同一个对象, 那么只要该名称并没有被外部程序单位引用, 那么也是可能的模块的典型应用如下几种功能可以很容易地包装在一个模块里面 : 全局数据, 包括数据结构和公用块自定义运算软件库数据抽象所有模块的典型应用也就集中在这 4 种功能上, 下面分别予以讨论 1. 全局数据利用模块可以很容易地在整个程序当中进行全局性的类型定义与数据声明模块当中的数据并不存在隐式的存储关联, 也不存在任何隐式地对这些数据的的排列顺序的约定模块当中的全局数据可以是任意的类型, 或任意类型的组合例 MODULE MODELS COMPLEX ::A(33,98) REAL::X(50) REAL, ALLOCATABLE::Y(:),Z(:,:) INTEGER LVA,RVA END MODELS 使用这个模块的方式可以有如下几种 : USE MODELS 通过这种方式可以使用模块内的任意对象以及它们的属性 USE MODELS,ONLY:A,Z 通过这种方式可以使用模块内的对象 A 和 Z USE MODELS,K=>LVA 通过这种方式可以使用模块内的任意对象以及它们的属性, 只是其中的整型 LVA 需要改名为 K 2. 模块内的公用块把一个公用块封装起来的一种方法, 就是把它放置在一个模块里面例 MODULE COFF COMMON

209 COMMON COMMON COMMON /BLOCK1/ END MODULE PROGRAM EQU1 USE COFF END 上面的例子里面, 在程序 EQU1 里面使用了 USE 语句后, 就可以访问模块 COFF 里面的公用块里面的所有变量运用模块来封装公用块, 显然最大程度地减少了当公用块被多个程序单位使用时, 所产生的错误 3. 全局派生类型模块当中的派生类型定义可以通过 USE 语句而得到多个程序单位的使用例 MODULE NEW_TYPE TYPE NODE_STAT REAL X COMPLEX Z END TYPE NODE_STAT END MODULE NEW_TYPE 然后, 只要任何程序单位通过 USE 来使用该模块的话, 就可以在它的内部声明属于派生类型 NODE_STAT 的数据对象 4. 算符的扩展算符与赋值符号都可以进行如下形式的扩展 : 一个界面块可以用来声明新的算符, 或者对固有算符定义新的含义赋值符号 = 也可以定义新的含义, 或者对于派生类型的固有赋值也可以进行重定义注意, 只有对于派生类型的赋值, 才能进行固有算符或固有赋值的重定义在进行这样的扩展时, 要求界面块具有 OPERATOR 或 ASSIGNMENT 属性一般说来, 这样的界面块都放置在一个模块里面, 以便利用模块的可靠性与灵活性例 INTERFACE OPERATOR(.INVERSE.) FUNCTION INVERSE(MATRIX1) TYPE(MATRIX),INTENT(IN)::MATRIX1 TYPE(MATRIX)::INVERSE END FUNCTION INVERSE

210 END INTERFACE 在上面的例子当中, 运用具有 OPERATOR 属性的界面来定义矩阵的逆, 这就要求定义一个求逆的函数以及定义自定义运算的界面块这就是上面定义的函数 INVERSE 与算符.INVERSE., 然后就可以把这个自定义算符运用于其他表达式, 例如 : 0.5+(.INVERSE.A) 注意其中的加法 + 也必须扩展为一个实型值与一个矩阵的加法 5. 数据抽象把类型定义和运算封装到一个模块当中对于相关的程序单位尤其方便例 MODULE POLAR_COORDINATES TYPE POLAR PRIVATE REAL RHO,THETA END TYPE POLAR INTERFACE OPERATOR(*) MODULE PROCEDURE POLAR_MULT END INTERFACE CONTAINS FUNCTION POLAR_MULT(P1, P2) TYPE (POLAR), INTENT(IN) :: P1,P2 TYPE(POLAR) POLAR_MULT POLAR_MULT = POLAR(P1 % RHO * P2 %RHO, & P1 %THETA + P2 % THETA) END FUNCTION POLAR_MULT END MODULE POLAR_COORDINATES 在上面的例子当中, 利用函数 POLAR_MULT, 结构构造器 POLAR 计算得到一个数值, 表示了在极坐标里面两个变量的乘积, 这样任何访问模块 POLAR_COORDINATES 的程序单位, 都可以同时数据类型 POLAR 和对固有运算 * 的一个扩展, 即极坐标乘法这样的一个把运算与数据对象封装到一个模块的方法, 称为数据抽象 6. 过程库一个模块可以包含相应于过程的一系列界面块, 从而构成一个过程库例 MODULE ENG_LIBRARY INTERFACE

211 FUNCTION FOURIER(X,Y) END SUBROUTINE INPUT(A,B,C,L) OPTIONAL C END SUBROUTINE INPUT END INTERFACE END MODULE ENG_LIBRARY 其中的子例行程序 INPUT 可以使用如下的方式调用 : CALL INPUT (AXX, L=LXX, B=BXX) 如果多个过程都需要访问相同的类型定义和数据声明, 那么它们构成一个集合, 就可以都放置在一个模块里面例 MODULE BOOKKEEPER TYPE,PRIVATE::IDDATA INTEGER IDNUMBER CHARACTER(25) NAME,ADDRESS(3) REAL BALANCE END TYPE IDDATA REAL,PRIVATE::GROSSIN,EXPENSES,PROFIT,LOSS INTEGER,PARAMETER::NUMCUST=1000,& NUMBER=100KUIBU NUMCH=10 CONTAINS SUBROUTINE ACCTS_RECEIVABLE(CUST_ID, AMOUNT) END SUBROUTINE ACCTS_RECEIVABLE SUBROUTINE ACCTS_PAYABLE(CUST_ID, AMOUNT) END SUBROUTINE ACCTS_PAYABLE SUBROUTINE PAYROLL(EMP_ID, AMOUNT) END SUBROUTINE PAYROLL FUNCTION BOTTOM_LINE(AMOUNT) END FUNCTION BOTTOM_LINE END MODULE

212 数据块程序单位一个数据块程序单位提供了一个命名公用块里面的初始数据值, 还包含了相应的数据说明在数据块程序单位里面不存在可执行语句, 它的唯一功能就是提供初始数据实际上它的这个功能完全可以由模块来实现, 因此这种程序单位纯粹只是 FORTRAN 早期版本的残留物, 已经完全过时数据块程序单位在其他程序单位里面是通过 EXTERNAL 语句来引用的, 它的语法形式 (R1112) 为 : BLOCK DATA[block-data-name] [specification-part] END [BLOCK DATA[block-data-name]] 数据块程序单位的一般规则如下 : 可以只出现一个无名的数据块程序单位如果在 END 语句出现数据块单位名称, 那么必须和 BLOCK DATA 语句里面的名称一样在数据块程序单位的说明部分只能出现如下表 12-5 所示的语句或属性, 其他语句或属性则不能出现 : 数据块程序单位可以对多个命名公用块里面的对象进行初始化无须初始化整个公用块如果在数据块程序单位里面给出了某个公用块里面的对象的初始值, 那么该公用块必须是完全说明的一个给定的命名公用块可以只出现在一个数据块程序单位里面例 BLOCK DATA SEQ COMMON / BLOCK1 / A,B,C DATA A/1.02/,B/9.01/,C/0.04/ END BLOCK DATA SEQ COMMON DATA DIMENSION EQUIVALENCE IMPLICIT INTRINSIC PARAMETER 表 12-5 数据块程序单位的说明部分所许可的语句或属性 POINTER SAVE TARGET USE 派生类型定义类型声明语句

213 第 13 章过程及其通讯如果说一个语句可以看成是一条指令, 那么在 FORTRAN 95 语言里, 一个具有一定结构的计算任务可以对应的最小程序单位, 就是一个过程从专致于科学计算的初衷出发,FORTRAN 在语言的结构层面上, 可以认为是面向过程的一种语言, 尽管在编程语言流行面向对象的今天, 面向过程显得有点落伍, 但却有效地适用于描述计算任务, 当然随着现代技术对于计算的要求越来越复杂与庞大,FORTRAN 也不是一味地守旧, 可以预计 FORTRAN 的下一个版本, 就会具有适应大型软件工程的要求的面向对象的语言特性 FORTRAN 95 语言作为一种语言的主要特点, 可以说就体现在它的过程这个主要的程序结构上而从我们程序编写者的角度来看, 能否把一个完整的算法转写成一个完整的程序, 关键也就在于能否构造出一些恰当的过程来作为程序的基本单位特别是对于大型的 FORTRAN 95 程序, 需要把它分解为好几百个过程是很常见的, 这时如何恰当地使用过程来构建整个程序, 可以说是编写程序最主要的工作因此如何构建过程, 如何根据需求运用过程, 然后在不同的过程之间建立必要的通讯, 是值得我们非常仔细地加以讨论的本章的主要任务即在于此 13.1 过程的分类与性质由于过程具有多方面的功能与属性, 因此对于过程的分类可以有多种方式下面我们首先讨论过程的各种分类方式及其相应的分类意义, 然后我们讨论有关过程引用的要点与相应概念过程的分类过程可以有几个不同的分类方式, 每种分类方式反映了过程的某个方面的特性下面分别予以讨论从形式上根据调用的方式的不同,FORTRAN 的过程分为两类 : 函数 ; 函数返回一个可以供表达式使用的值因此函数的调用总是作为一个表达式的算元, 函数的值也就是相应表达式算元的取值函数调用时直接使用函数的名称和它的变量, 或者作为一个自定义运算, 它返回值之后, 它的功能就算完成, 不对程序产生后效, 当然,FORTRAN 标准也不绝对禁止使用产生一定后效的函数子例行程序子例行程序的调用必须使用 CALL 语句, 或者是作为一个赋值子例行程序的功能主要在于产生一定的后效, 例如改写一些变元, 以及全局变量, 或者执行某些输入输出函数与子例行程序的一般规则如下 : 函数与子例行程序在调用方式上的差别实际上来源于一个函数总是和一个相应的函数结果值相关联, 只要运行或者调用一个函数, 总会得到相应的函数结果值, 而子例行程序却没有相应的概念, 这就使得子例行程序只能依靠使用专门的 CALL 语句来调用, 而既然函数总是能够给

214 出一个函数值来, 就可以直接把它作为表达式的算元来调用函数结果可以是任意的数据类型, 例如派生类型, 或者是取数组值都可以如果在 FUNCTION 语句当中使用 RESULT 属性, 那么就可以给结果一个与函数定义里面的函数名称不同的名称, 这主要应用于直接调用自身的递归函数在除了模块以及数据块程序单位之外的程序单位的说明部分还可以使用一种由一个语句组成的函数, 称为语句函数, 不过它的功能完全可以由下面的内部过程来实现, 因此已经过时再从过程与其他程序单位的关系的角度来分类的话, 过程也可以分为如下两大类 : 外部过程 ; 顾名思义, 外部过程就是处于任何的程序单位的外部, 它作为一个孤立的过程, 可以单独构造, 单独编译, 单独使用, 而可以完全独立于任何的过程与程序单位甚至还可以是用其他的语言编写的, 例如常见的 C 语言当然, 一个外部过程还是可以通过变元列表, 模块, 公用块等来共享数据与过程之类的信息内部过程内部过程总是定义在一个程序单位内部, 该程序单位就称为它的宿主当一个过程出现在它的宿主内部的时候, 总是出现在宿主的 CONTAINS 语句和 END 语句之间一个内部过程对于其宿主而言, 总是局域的, 而且通过宿主关联继承了宿主的数据环境特别的, 如果一个内部过程的宿主是一个模块, 那么这种内部过程被单独称为模块过程模块过程模块过程同样必须出现在其宿主模块里面的 CONTAINS 语句和 END 语句之间一个模块同样可以通过宿主关联继承宿主模块的数据环境但与一般内部过程不同的是, 模块内的模块过程可以具有 PUBLIC 属性, 即从模块外部可以直接访问具有 PUBLIC 属性的过程 ; 当然模块过程也可以具有 PRIVATE 属性, 使得模块外部不能访问该过程注意在早期 FORTRAN 版本里面出现过语句函数的概念, 它是出现在程序单位的说明部分的单语句定义的函数, 不能够出现在模块或数据块程序单位当中由于它的功能可以完全由内部过程替代, 因此语句函数的概念已经过时一般由多个过程组成过程子程序对于内部过程来说, 组成过程子程序的多个过程可以通过宿主关联而获得对宿主数据环境的共享 ; 而对于外部过程来说, 当一些外部过程要组成过程子程序的时候, 由于缺乏类似的关联机制, 它们的数据共享问题是通过所谓过程登录机制来解决的所谓过程登录是通过运用 ENTRY 语句来说明一个过程与一个过程子程序的关联关系的每一个 ENTRY 语句就给出了一个过程, 所有这些过程就可以共享该过程子程序的数据环境例如两个不同的函数 SIN 和 COS 就可以通过这种方式使用同一个外部子程序, 因为 SIN 和 COS 具有如下的关系 : π cos( x) = sin( x) 2 尽管对于内部过程来说, 过程登录是不必要的, 但也可以应用于模块过程根据过程对于变元的作用效果来分类, 则可以把过程分为纯过程与非纯过程所谓纯过程就是在执行对变元的作用之后, 不会产生后效, 这对于程序按照序列进行一般是没有什么影响的, 但是对于程序的并行执行, 却往往会给程序带来不确定性, 因此就需要对一般的过程加以约束, 使得其完全没有后效, 从而得到纯过程例如过程 A 和 B, 都具有对 X 进行赋值的后效, 设 A 把 X 赋值为 1.0, 而 B 把 X 赋值为 2.0, 那么如果 A 和 B 这两个过程是并行完成的, 那么 X 的具体取值就变得不可预料, 因此需要对过程 A 和 B 进行一定的约束, 使得它们成为纯过程

215 如果从过程作用于数据对象的方式来进行分类, 那么过程可以分为逐元过程和变换过程逐元过程, 即过程的本来属于标量形式的变元可以被赋予数组, 这时过程的作用方式是对数组的每个元素进行单独的运算, 得到的所有结果再构成一个与变元数组相同形状的数组, 就称为该过程作用于数组后的结果变换过程, 即过程的变元本来就是数组, 对数组的作用方式是把数组作为一个整体进行变换, 而不是逐个地针对元素进行因此逐元过程既可以标量变元来引用, 也可以通过数组变元来引用, 只是当通过数组变元来引用的时候, 实际上就是通过标量数组元素来引用, 只不过需要引用多次引用的次数等于数组元素的个数逐元过程总是纯过程, 因为逐元过程不产生后效如果从过程的来源来看, 过程还可以分为固有过程和自定义过程两类所谓固有过程, 也称为内建过程, 即 FORTRAN 标准已经建立好了的过程, 一共包括 115 个固有过程这意味着任何的 FORTRAN 实现, 都必须能够直接提供这些固有过程固有过程的名称在程序单位的任何地方都是可以直接引用的, 唯一的例外, 就是当使用了显式的 EXTERNAL 语句或过程界面块的时候, 固有过程的通用属性就可能被扩充, 即固有过程的名称也可能用来引用非固有过程, 这时该名称所表示的固有过程反而成了一种默认值大部分的固有过程同时还是逐元的, 自定义过程也可以被定义为逐元过程, 这样就极大地增强了 FORTRAN 的数组计算能力过程的引用所谓过程的引用就是使得过程的名称出现在程序的恰当位置, 当程序运行到该位置时, 过程名称能够导致程序转入执行该过程过程的引用也可以称为调用或访问, 在本书当中, 这几个词汇是根据一般用词习惯而交替使用的过程的引用分为两种形式, 即子例行程序的引用和函数的引用子例行程序的引用是依靠一个单独的 CALL 语句, 某些时候也可以使用赋值语句的形式函数的引用是作为表达式的一部分, 即采用函数名称及其变元列表作为表达式的项出现, 某些时候, 函数引用也可以采取一元运算或二元运算的形式, 其变元作为表达式的算元过程的引用本质上就是通过变元来进行数据的传递或通讯, 在进行过程的引用过程当中, 变元根据它所行使的功能, 还可以分为三种 : 实元, 哑元, 替代返回变元实元在过程的引用当中, 所谓实元就是在程序执行的时候需要实际采用的数据对象例如实元在作为变量的时候, 可以在每次引用当中取不同的值, 因为作为实元, 是直接面向具体取值的实元的取值可以是输入值, 也可以是过程运行之后返回的值, 或者两者都是哑元所谓哑元就是一个名称, 通过该名称过程内部就能够访问到相应实元因此哑元在过程被定义的时候就已经给出, 在过程进行计算时, 它就充当变元名称一旦在程序运行时引用该过程, 那么引用的实元就通过变元关联而与相应哑元建立关联关系如果过程界面是显式的, 那么在引用过程时, 就可以直接使用哑元名称作为实元关键词过程定义里面的哑元名称还可以用来指称一个过程, 这实际上就是一个过程引用因为与该哑元具有变元关联关系的实元名称就是一个过程的名称, 不过这个被关联的过程不能是内部过

216 程, 语句函数, 已经具有类属性的过程替代返回变元所谓替代返回是只在子例行程序里面出现的一种变元的功能, 通过替代返回, 就可以中断程序的顺序执行次序, 控制程序的执行分支到其他某个位置, 替代返回里面的实元就是分支目标语句的标签, 这种分支方式经常用于从子例行程序里面出错退出的情形, 不过在现代的 FORTRAN 控制结构里面, 具有更合理的控制方式, 因此这种分支方式已经过时过程通过变元进行通讯的途径就是关联, 过程关联的形式有 4 种 : 变元关联, 宿主关联, 使用关联, 以及共享存储关联变元关联变元关联是过程之间进行数据通讯的主要方式在 13.7 节会详细地加以讨论宿主关联宿主关联是建立在一个过程与其所属的程序单位之间的数据关联关系一个宿主程序单位可以是一个主程序, 模块程序单位, 外部过程, 模块过程这些宿主程序单位里面所有被允许访问的数据对象都可以通过宿主关联而被其包含的过程访问到对于宿主关联的详细讨论见第 15 章使用关联一个过程可以通过一个 USE 语句和该 USE 语句所在的程序单位建立使用关联通过使用管关联, 过程可以和模块共享数据对象, 也可以按照程序编写者的意愿, 通过 ONLY 子句来隐藏某些数据对象对于使用关联的详细讨论见第 12 章共享存储关联有关存储关联的详细讨论见第 7 章和第 15 章在组织程序时, 除了在不同过程之间进行通讯之外, 过程自身还可以构成递归的结构即一个局部变量得到初始化之后, 尽管它出现在递归的每一层里面, 但是其初始化值只能够在该递归结构开始运行时有效地使用一次, 因此实际上等价于对于变量使用了 SAVE 属性, 使得每一层的递归都保留了它的变量值, 可以说是一种数据的隐式保留属性一个过程无论是进行直接的递归还是进行间接的递归, 都必须在过程定义里面的 FUNCTION 语句或 SUBROUTINE 语句里面加上关键词 RECURSIVE, 这个关键词的功能就是能够实现编译器对于过程调用的优化过程的引用并不涉及过程的具体功能, 也就是对于过程的内部计算过程, 在引用时是不需要考虑的, 这样就可以把所有涉及到过程引用的信息集中在一起, 包括过程及其变元的名称与属性, 这就构成了所谓过程的界面顾名思义, 也就是一个过程与外部进行通讯的层面如果一个过程的这些信息对于一个引用它的程序单位来说, 不是显式的, 那么该过程就被称为具有隐式界面这时, 引用它的程序单位就只能依据过程名称以及过程引用里面的实元的属性来确定过程的有关信息, 同时有关的哑元与实元的数据匹配都需要程序编写者预先规划好如果过程界面是显式, 那么相关的数据匹配工作就可以完全由编译系统来完成检查在很多的引用情形下, 都一定要求被引用的过程具有显式界面, 例如 : 作为数组片断的实元 ; 指针变元 ; 可选变元 ; 关键词调用 ; 自定义运算 ;

217 自定义赋值 ; 自定义过程的逐元调用 ; 自定义类过程各种类型的过程的界面形式的显式或隐式的情况如下 : 固有函数, 内部过程, 模块过程都是显式的界面, 自定义过程也可以具有显式界面所有固有函数的显式界面信息都包含在任何一个 FORTRAN 编译器内部, 在对固有函数进行任何引用时, 系统都可以根据实元的类型来检查与匹配相应的固有函数, 从而得到一个正确的引用因此对固有函数的引用可以直接使用函数的类名称以及关键词内部过程和模块过程在它的定义里面就要求具有显式界面, 因此对这两种过程的引用同样是安全可靠的外部过程和语句函数都是隐式的界面不过在引用外部过程时, 可以在引用程序单位里面为所引用的外部过程提供一个界面块, 这样就等价于该外部过程具有了一个显式的界面有关界面的详细讨论见 13.8 节正是由于引用只与过程的界面有关, 因此被引用的过程可以是使用其他语句编写的, 例如 C, C++ 等, 不过使用非 FORTRAN 的过程可能移植性不太好, 因为在不同的系统之间, 其他的语言可能具有不同的过程通讯机制 13.2 子例行程序的运用一个子例行程序就是一个完备的能够执行一定的计算任务的程序单位它由以下五个部分构成 : 初始的 SUBROUTINE 语句 ; 说明部分 ; 计算执行部分 ; 某些内部过程 ; END 语句当一个子例行程序被调用时, 从它的第一个可执行结构开始运行, 它通过变元关联, 使用关联, 宿主关联以及存储关联与外部进行数据通讯下面分别讨论子例行程序的定义与引用子例行程序的定义一个子例行程序, 无论是内部的, 外部的, 还是模块的, 都具有以下语法形式 (R1221): [subroutine-prefix] SUBROUTINE subroutine-name & [([dummy-argument-list])] [specification-part] [execution-part] [internal-subprogram-part] END [ SUBROUTINE [subroutine-name]] 其中所谓子例行程序的前缀 (subroutine-prefix) 是如下的几个可选项 :

218 RECURSIVE PURE ELEMENTAL 不过其中表示递归属性和逐元属性的 RECURSIVE 与 ELEMENTAL 不能同时作为同一个子例行程序的前缀其中哑元列表 (dummy-argument-list) 里面的哑元既可以是哑元名称, 也可以是星号 (*) 星号表示替代返回变元当子例行程序被执行的时候, 这些哑元就获得了同引用子例行程序时给出的实元的关联子例行程序的一般规则如下 : 如果在 END 语句里面使用了子例行程序的名称, 那么这个名称就必须和 SUBROUTINE 语句里面的名称一致一个内部子例行程序不能再包含一个内部子程序部分内部子例行程序不能包含 ENTRY 语句内部子例行程序与模块子例行程序的 END 语句必须是如下的形式 : END SUBROUTINE [subroutine-name] 即必须在 END 语句里面使用关键词 SUBROUTINE 如果子例行程序要实现递归结构, 那么在 SUBROUTINE 语句里面必须加上前缀 RECURSIVE 在一个 SUBROUTINE 语句里面, 不能重复使用某个前缀一个子例行程序不能同时是递归的和逐元的参见 13.4 节与 13.5 节每个哑元都是其所在是子例行程序的局部变元哑元可以在子例行程序里面获得显式说明, 也可以在某些特定情况下获得隐式声明子例行程序里面的哑元都可以具有 INTENT 属性或 OPTIONAL 属性, 但是哑指针和哑过程都不能具有 INTENT 属性在子例行程序里面不能使用 PUBLIC 属性和 PRIVATE 属性用于表示替代返回变元的星号 * 是一种过时的语言特征例 13-1 下面是 SUBROUTINE 语句的几种形式的例子 : ELEMENTAL SUBROUTINE BESSELL1 SUBROUTINE IMBEDDING(X) SUBROUTINE TASK() SUBROUTINE PARTICAL(CURRENT,*) SUBROUTINE COMPUT2 RECURSIVE SUBROUTINE WALLIS(X,Y) 例 13-2 下面是一个子例行程序的例子 : SUBROUTINE WAVELET(A,B) REAL A INTEGER B. END SUBROUTINE WAVELET

219 子例行程序的引用当程序的某个位置需要调用一个子例行程序时, 就在该位置使用 CALL 语句或者是一个自定义赋值语句实际上对子例行程序的调用, 就是给出子例行程序的名称和实元下面首先讨论使用 CALL 语句的引用方式 CALL 语句的语法形式 (R1211) 为 : CALL subroutine-name [([subroutine-actual-argument-list])] 其中的子例行程序的实元的语法形式 (R1212) 为 : [keyword=] subroutine-actual-argument 其中的的关键词是子例行程序的界面里面的某个哑元名称, 而子例行程序的实元则具有以下几种形式 (R1214) 之一 : 包含一个变量的表达式 ; 过程名称 ; 作为替代返回的 * 标签以上子例行程序的引用实际上就是建立一个哑元与实元的关联即或者是通过直接使用哑元名称作为关键词, 给出相应的实元, 或者是省略了关键词, 但是实元在实元列表里面的顺序对应着相应的子例行程序界面里面的哑元列表的顺序, 从而为每个子例行程序的哑元指定了相应的实元作为实元的表达式的一个特殊情况就是只有一个变量自身, 这时该变量作为实元可以与具有任意 INTENT(IN,OUT,INOUT) 属性的哑元相关联, 但一个表达式就只能和具有 INTENT(IN) 属性的哑元相关联 CALL 语句的引用的一般规则如下 : 根据变元列表位置来进行实元与哑元的关联的变元, 必须放置在实元列表的前面部分, 而一旦在该列表当中出现了关键词, 那么该关键词后面的变元就必须全部是关键词在实元列表与哑元列表的对应当中, 一个实元和与之对应的非可选哑元相关联, 而对于可选哑元, 相应的实元可省略关键词就是子例行程序的显式界面里面的哑元名称, 如果在引用里面使用关键词, 那么实元就与具有该名称的哑元相关联如果在一个实元列表当中, 与某个实元相关联的关键词被省略了, 那么在这个列里面该实元前面的所有关键词都必须省略 ; 一个没有关键词出现的实元列表里面的所有实元, 都是依据列表位置来确定它们相应的哑元的如果一个实元列表使用了多个关键词, 那么关键词的顺序是无关紧要的, 如果一个实元列表里面全是关键词, 那么它们的顺序可以是任意, 不需要与哑元列表里面的顺序有对应关系作为替代返回说明符的星号后面的标签, 必须是与 CALL 语句同一个作用域单位的分支目标语句的标签实元不能是内部过程或语句函数的名称与一个哑过程相关联的实元必须是一个种过程的名称, 如果一个过程的类名称与种过程相同, 那么实际引用的是种过程对于某些固有函数来说, 它们的种固有函数名称不能用来作为实元过程引用的另外一种形式就是使用自定义赋值语句可以通过自定义赋值形式得到引用的子

220 例行程序必须具有一个 ASSIGNMENT 界面, 在这个界面里面必须给出两个变元 arg1 和 arg2, 其中 arg1 具有 INTENT(OUT) 或 INTENT(INOUT) 属性, 而 arg2 则具有 INTENT(IN) 属性自定义赋值引用的形式为 : arg1 = arg2 对于这种引用形式的详细讨论见节例 13-3 下面是一个通过 CALL 语句引用子例行程序的例子 CALL SUB1( X,*25)! 引用 SUBROUTINE SUB1 25! 替代返回的目标语句 CALL SUB2(X=5.02,N=75)! 引用 SUBROUTINE SUB2(X,N) 例 13-4 下面是一个通过自定义赋值形式引用子例行程序的例子 MODULE POLAR_COORDINATES TYPE POLAR REAL ::RHO THETA END TYPE INTERFACE ASSIGNMENT(=) MODULE PROCEDURE ASSIGN_POLAR_TO_COMPLEX END INTERFACE SUBROUTINE ASSIGN_POLAR_TO_COMPLEX (Z, P) COMPLEX INTENT ( OUT ) :: Z TYPE (POLAR) INTENT (IN) :: P Z= CMPLX (P%RHO * COS (P%THETA), & P%RHO * SIN (P%THETA)) END SUBROUTINE ASSIGN_POLAR_TO_COMPLEX USE POLAR_COORDINATES COMPLEX ::CARTESIAN CARTESIAN = POLAR(R,PI/6) 在上面最后语句里面, 使用了一个赋值语句, 实际上就等价于下面的 CALL 语句 : CALL ASSIGN_POLAR_TO_COMPLEX(CARTESIAN,POLAR(R,PI/6)) 13.3 函数函数与子例行程序的最大区别就是函数可以用来作为表达式的项, 而函数的定义的语法结

221 构则与子例行程序类似函数的变元用来引入初始值, 然后经过函数的计算, 得到函数结果, 作为表达式相应的项的输入值函数同样可以通过 4 种关联形式从函数外部获得数据函数的定义一个函数子程序, 不管它是外部子程序, 内部子程序还是模块子程序, 都具有如下的语法形式 : [function-prefix] simplest-function-statement [RESULT (result-name) ] [specification-part] [execution-part] [internal-subprogram-part] END [FUNCTION [function-name]] 其中的函数前缀 (function-prefix) 包括如下几种形式 : type-specification RECURSIVE PURE ELEMENTAL 其中 RECURSIVE 和 ELEMENTAL 不能同时用于一个函数其中的最简单 FUNCTION 语句 (simplest-function-statement) 的语法形式为 : FUNCTION function-name ([dummy-argument-name-list]) 其中的哑元在函数运行时获得引用实元的变量关联因此函数语句可以有几种不同的形式, 下面是一些例子例 13-5 FUNCTION LAGRANGE1 (X,Y) COMPLEX FUNCTION SHORDINGER2(X,T) FUNCTION LATTICE(X,Y) RESULT(CROSS) RECURSIVE REAL FUNCTION SUM1(N,K)RESULT(SUM2) 函数遵循如下规则 : 函数的类型既可以在函数语句当中予以说明, 也可以使用单独的类型声明语句当中予以说明, 但是不能同时采用这两种说明方式如果这两种说明方式都没有出现, 那么系统会认为是默认类型如果函数值是数组或指针, 那么函数声明必须给出其函数结果名称的相应属性函数结果名称可以是显形数组或哑形数组如果为显形数组, 那么它的非常数界可以是表达式形式哑元的属性既可以在函数体当中显式说明, 也可以隐式说明哑元总是相应函数的局部变量, 因此哑元名称在函数内部必须是唯一的如果在 END 语句当中出现了函数名称, 那么该名称必须和 FUNCTION 语句当中的函数名称一样一个内部函数不能再包含一个内部子程序

222 一个内部函数不能包含 ENTRY 语句在一个函数语句当中, 函数前缀不能重复出现一个函数不能同时具有前缀 ELEMENTAL 和 RECURSIVE 参见 13.4 和 13.5 节内部函数和模块函数的 END 语句必须是如下形式 : END FUNCTION [function-name] 即在 END 语句当中必须包含关键词 FUNCTION 如果函数语句当中不出现结果子句, 那么函数名称就用作结果变量的名称, 则对函数名称的引用实质上就是对函数结果变量的引用如果函数语句当中出现结果子句, 那么函数名称就不能用作结果变量的名称, 则对函数名称的引用就是函数引用, 属于递归调用如果函数语句当中出现结果子句, 那么函数名称就不能出现在任何说明语句当中如果函数的结果值不是一个指针, 那么在函数执行完毕之前, 它的结果值就必须完全给定定义 : 如果结果值是数组, 那么数组的所有元素都必须给出定义 ; 如果结果值是结构, 那么结构的所有成员都必须给出定义如果函数结果值是一个数组或指向数组的指针, 那么在函数执行完毕之前, 它的结果值的形状必须给定如果函数结果是一个指针, 那么在函数执行完毕之前, 指针的分配状态必须给定, 即或者是给出其所关联的目标, 或者是显式说明它的去关联状态函数的哑元的 INTENT 属性和 OPTIONAL 属性必须予以说明不过对于哑指针和哑过程, 则不具备 INTENT 属性在函数里面不能使用 PUBLIC 属性和 PRIVATE 属性当函数采取直接递归形式的时候, 必须同时给出 RECURSIVE 关键词和 RESULT 选项, 这是唯一的必须给出 RESULT 选项的情形 RESULT 选项 RESULT 子句的功能在于给出一个不同于函数名称的名称, 用来赋予函数结果值如果不通过 RESULT 子句来给定单独的函数结果的名称, 那么结果值总是赋予函数名称, 这样做在函数是非递归的时候, 不会带来什么不良后果, 但是当函数为递归形式的时候, 就会导致歧义, 因为在递归引用时, 对函数的引用必须和对函数结果值的引用加以区分例如一个函数的唯一变量是实型的标量, 而它的结果值是一个数组, 那么在对它进行递归引用时, 如果不对它的结果另外规定名称, 就会和对数组结果的引用混淆起来, 在这种情况下, 就必须使用 RESULT 子句对结果变量进行单独的命名因此当一个函数是直接或间接递归的时候, 都必须使用 RESULT 子句由于函数的结果值在递归过程当中一直在发生变化, 因此函数的结果值为最后一个赋予结果名称的值下面是一个给出了 RESULT 子句的递归函数的例子例 13-6 PROGRAM REVERSE_PHRASE PRINT *,REVERSE( The following inequalities hold for any lattice ) CONTAINS RECURSIVE FUNCTION REVERSE (PHRASE)RESULT(LATTICE)

223 CHARACTER(*) PHRASE CHARACTER(LEN(PHRASE)) LATTICE L=LEN_TRIM(PHRASE) K=INDEX(PHRASE(1:L),,BACK=.TRUE.) IF(K==0)THEN;LATTICE=PHRASE ELSE;LATTICE=PHRASE(K+1;L)// // REVERSE(PHRASE(1:K-1)) END IF END FUNCTION REVERSE END PROGRAM REVERSE_PHRASE 在上面的例子里面, 函数结果的长度是动态的, 因此其函数界面是显式的函数引用函数的引用有两种形式 : 直接在表达式里面使用函数的名称 ; 通过自定义运算的形式第一种函数的引用是非常直接的, 就是把函数名称以及它的实元用作表达式的项而一旦函数通过这种方式得到引用, 那么引用该函数的表达式的计算, 就意味着函数里面的实元已经得到计算, 相应的变量关联已经建立, 而该函数的定义里面的所有语句都已经得到执行, 因此函数对于引用它的表达式来说, 就是函数结果变量函数引用的一般语法形式 (R1210) 为 : function-name([function-actual-argument-list]) 其中函数实元 (function-actual-argument) 的一般语法形式 (R1212) 为 : [keyword = ] function-argument 其中的函数变元 (function-argument) 具有一下几种形式 (R1214) 之一 : 包含一个变量的表达式过程名称而其中的关键词 (keyword) 是函数界面里面的一个哑元名称函数引用里面的实元与函数界面里面的哑元的对应规则与子例行程序一样, 或者是根据哑元列表里面的顺序与实元相应顺序的对应, 或者是利用关键词来指定对于引用函数的表达式来说, 一个变量也是一种表达式的形式, 如果只是一个变量, 那么它所关联的哑元可以具有任意的 INTENT(IN,OUT,INOUT) 属性, 而对于其他形式的表达式, 则其中的实元只能关联于具有 INTENT(IN) 属性的哑元注意表达式 (X) 总是一个表达式, 尽管括号里面的 X 只是一个变量, 因此 X 作为实元, 只能关联于一个具有 INTENT(IN) 属性的哑元这种形式的函数引用与子例行程序引用的唯一差别, 就是函数引用里面的变元列表里面不能包含替代返回, 其他的规则完全与节里面有关子例行程序引用的规则一样下面是在表达式里面直接引用函数的例子例 13-7 X=Y+5*LEBESGUE1(3.5)! 引用了函数 LEBESGUE1(R)

224 PRINT*,ANALOG1(5.0,6.7)! 引用了函数 ANALOG1(I,U) 函数引用的第二种形式就是通过自定义运算的形式除了固有运算之外, 我们总会需要定义不能由任何固有运算表示的运算, 这时就可以使用函数来定义自定义运算以及给出运算符的界面块, 具体是说明参见节利用自定义运算来引用函数的规则如下一元运算只能使用包含一个变元的函数来定义而二元运算则使用包含 2 个变元的函数定义函数的变元不能是可选的, 并且必须具有 INTENT(IN) 属性自定义算符只能采取在两个句点中间为字符串的形式, 其中的字符串不能多于 31 个字符, 而且不能包含下划线, 也不能与逻辑型字面常量雷同如果自定义运算的算符与固有运算的算符发生雷同的现象, 那么自定义运算肯定是对相应的固有运算进行了某些扩充, 例如对于算符所适用的算元的取值范围进行了扩充下面是一个通过自定义运算来引用函数的例子例 13-8 INTERFACE OPERATOR(.FOURIER.) FUNCTION FOURIER_OPERATOR(X,Y)! 这些界面部分给出函数 FOURIER_OPERATOR 以及! 它的变元 X,Y 的属性, 并且需要说明 X 和 Y 具有!INTENT(IN) 属性 END FUNCTION FOURIER_OPERATOR END INTERFACE PRINT*,X1.FOURIER. Y1 在上面的例子里面,PRINT 语句里面通过使用自定义运算.FOURIER. 而引用了函数 FOU RIER_OPERATOR, 而实元 X1 和 Y1 则分别对应着函数界面里面的哑元 X 和 Y 语句函数所谓语句函数语句, 就是只包含一条 FORTRAN 语句的函数定义, 它的一般语法形式 (R1228) 为 : function-name([dummy-argument-name-list])= scalar-expression 实际上语句函数的功能完全可以用内部函数来实现, 而通过内部函数形式来表示同样的功能, 可以使得程序更加具有结构性, 因此语句函数已经过时与上面的语句函数等价的内部函数采用如下的形式 : FUNCTION function-name([dummy-argument-name-list]) function-name = scalar-expression END FUNCTION 可以看到, 上面采用内部函数的形式更加具有结构性语句函数的一般规则如下通过语句函数给出的函数以及哑元都必须是标量

225 语句函数里面的表达式只能包含固有运算, 并且都只能取标量值表达式可以引用具有数组变元但是取值为标量的固有函数例如固有函数 SUM(A+B) 就是这样的固有函数, 因为它的变元都是数组, 而函数结果值则是一个标量语句函数作为一种函数的定义形式, 只能出现在一个程序单位, 或内部过程或模块过程的说明部分在表达式里面引用的语句函数都必须在相应的程序单位的说明部分已经经过定义, 因此语句函数不能采取递归的形式, 无论是直接的还是间接的递归形式都不行语句函数里面的表达式里面的命名常量和变量都必须在说明部分已经经过定义, 或者能够通过宿主关联或使用关联而获得数据如果在表达式里面使用了某个数组的元素, 那么该数组也必须预先在说明部分经过声明语句函数的表达式里面的任何数据对象或者是已经预先声明过, 或者就是采用默认的隐式类型声明, 而在该语句函数之后, 如果存在对于这些数据对象的任何显式类型声, 那么都必须与语句函数里面采取的隐式类型声明相兼容语句函数里面的哑元的作用域与该语句函数语句的作用域一样语句函数的哑元被预定为具有 INTENT(IN) 的属性, 即表达式里面的任何函数引用都不能改变任何哑元的值语句函数本身不能作为实元语句函数的引用形式与其他形式的函数的引用一致, 变元关联的规则也一致只是语句函数的界面总是隐式的, 因此它的实元就不能采取关键词形式由于语句函数的变元只能是标量, 而显式界面只能适用于那些具有数组值结果, 哑形哑元, 指针变元以及关键词变元的过程, 因此语句函数不能具有显式界面下面是语句函数的几个不同形式的例子例 13-9 CHARACTER (10) WORD_10 CHARACTER (20) WORD_20 WORD_10 (WORD_20) = WORD_20 (11 : 20) REAL WAVE,X WAVE(X)= COS(X)+SIN(X) REAL LENS COMPLE C LENS(C)= REAL(C)**2 + AIMAG(C)** 纯过程纯过程这个概念完全是 FORTRAN 95 为了适应并行化计算而进行的改进由于并行化计算本质上要求进行并行计算的不同运算过程具有相对的独立性, 也就是处于并行位置的不同计算单位的计算值, 相互不会产生影响而传统的来源于串行计算的 FORTRAN 的过程, 在语言设计上, 一般允许过程在执行时具有后效例如当一个函数的引用的目的不是需要使用函数的结果值, 而是利用函数来进行值的传递, 那么该函数的执行的后果, 就是改变了在公用块里面的变元或变量的值

226 具有后效的过程也具有类似作用, 即改变公用块里面的数据对象的值实际上除了这种作用于作用域外部的后效之外, 输入输出本质上就是一种能够带来后效的操作显然后效对于并行计算会产生不可预计的后果例如能够执行并行运算的 FORALL 结构或语句, 它内部的语句执行顺序是不加以规定的, 如果其中包含可能产生后效的过程, 就会导致最终计算结果的不确定性因此要想顺利地进行并行计算, 就必须在进行并行计算的程序单位里面完全排除具有后效的过程而所谓纯过程正是这种完全不会导致后效的纯过程纯过程包括两类 : 所有的固有函数和固有子例行程序 MVBITS 都是纯过程 ; 在 FUNCTION 语句或 SUBROUTINE 语句里面具有前缀 PURE 的自定义过程都是纯过程必须使用纯过程的上下文有以下 4 种情形 : 在 FORALL 语句或结构里面引用的函数 ; 在说明语句里面引用的函数 ; 作为实元被调用到一个纯过程的过程 ; 被纯过程体引用的过程, 包括被自定义运算或自定义赋值引用的过程如果一个过程被上面的上下文要求是纯过程, 那么它的界面就必须是显式的, 并且包含关键词 PURE 纯过程的一般规则如下 : 纯函数的哑元必须具有 INTENT(IN) 属性纯子例行程序的哑元必须给出其 INTENT 属性, 除非该哑元是过程, 或指针, 或替代返回变量纯过程的局部变量不能具有 SAVE 属性也就是说纯过程里面的局部变量不能在过程定义的说明部分获得初始化, 因为获得初始化意味着该变量自动具有了 SAVE 属性在纯过程里面的所有内部过程都必须是纯过程纯过程不能包含如下几种语句 : STOP 语句 ; PRINT 语句 ; OPEN 语句 ; CLOSE 语句 ; BACKSPACE 语句 ; ENDFILE 语句 ; REWIND 语句 ; INQUIRE 语句 ; 说明外部文件的 READ 语句 ; 说明外部文件的 WRITE 语句纯过程里面的任意一个变量, 只要它是公用的, 或者是具有宿主关联, 或者是具有使用关联, 或者是具有 INTENT(IN) 属性, 或者是与这样的变量具有存储关联, 那么它就不能用于以下的上下文情形 : 赋值语句的左边 ; 指针赋值语句 ; DO 变量或隐式 DO 变量 ;

227 READ 语句来自内部文件的输入项 ; WRITE 语句的内部文件 ; I/O 语句的来自内部文件的 IOSTAT 变量或 SIZE 变量 ; ALLOCATE 语句或 DEALLOCATE 语句的 STAT 变量或分配对象 ; NULLIFY 语句里面的指针对象 ; 赋值语句的右边, 而该赋值语句的左边在某个层次包含了指针成员下面是纯过程的一个例子例 PURE FUNCTION ACROSS(X,C) REAL ACROSS REA L,INTENT(IN) :: X COMPLEX C INTENT(IN)::C END FUNCTION ACROSS 13.5 逐元过程如果说纯过程的概念是为了给程序运行的并行化排除障碍, 那么逐元过程的概念则是 FORTRAN 95 实现程序运行的并行化的强有力工具逐元过程的哑元都是标量, 逐元函数的结果值也是标量, 而它实现并行化计算的功能就体现在任意调用它的实元可以是任意秩的数组一般说来任意形式的实元数组都是与逐元过程的标量哑元相匹配的, 不过还是有如下两种例外情形 : 如果一个固有函数带有变元关键词 KIND, 那么相应的实元就不能是数组, 而只能是一个标量整型初始化表达式如果一个自定义函数的哑元用于一个说明表达式, 那么与该哑元相关联的实元就只能是标量那么一个以标量为哑元的逐元过程是如何作用于数组实元的呢? 实际上该过程的作用对象仍然是标量, 即逐元过程作用于数组实元的每一个标量元素, 然后对于每一个元素得到相应的值, 所有这些值构成一个集合, 就是该逐元过程作用于数组实元所得到的数组值至于该过程对数组实元的元素的作用顺序, 则是不加以规定的, 因为正是不规定顺序, 才能实现不同元素相互独立的计算处理进程的并行化, 否则, 如果强制性地规定对于元素的处理顺序, 那就回到了串行序列处理的方式, 无法发挥具有并行处理功能的系统的并行处理能力当然具体的针对数组元素的运行方式, 是由系统决定的, 如果系统不支持并行计算, 那么系统会采取默认的顺序安装串行方式来运行 ; 如果系统支持并行运算, 那么就会根据系统的并行能力, 做到某些元素是同时加以计算处理的实际上,FORTRAN 95 把逐元过程的概念从固有过程扩展到自定义过程是 FORTRAN 语言的一个显著进步, 类似于在 FORTRAN90 实现的把过程类属的概念从固有过程扩展到自定义过程对于逐元的自定义过程来说, 在 FUNCTION 语句或 SUBROUTINE 语句里面必须加上前缀说明 ELEMENTAL, 以说明该自定义过程为逐元过程由于逐元过程本来就是用来进行并行计算的, 因此任何逐元过程首先必须是纯过程这样在

228 出现了 ELEMENTAL 前缀之后, 也可以再加上前缀 PURE, 但完全是多余的由于逐元过程同时也是纯过程, 使得纯过程的所有规则 ( 参见 13.4 节 ) 也都适用于逐元过程, 另外逐元过程还遵循下面列举的规则逐元过程不能是递归的逐元过程的哑元不能是指针逐元函数的结果不能是指针逐元子例行程序的哑元不能是替代返回变量逐元过程的哑元不能是一个过程逐元过程在任何引用它的程序单位里面都必须具有显式的界面例 ELEMENTAL FUNCTION QUADRIC(Z,X) REAL QUADRIC REAL,INTENT(IN)::X COMPLEX,INTENT(IN)::Z END FUNCTION QUADRIC QUADRIC((3.0,5.4),6.8)! 此处调用具有标量变元的函数 QUADRIC QUADRIC(C1,X1)! 此处的 C1 和 X1 分别为适当的复型数组和实型数组, 因此此处! 调用的实元为数组变量, 而该调用的结果为分别与这两个实元相! 匹配的数组 13.6 与过程相关的语句有五个语句是专门为在程序当中运用过程服务的, 它们都是通用的语句, 也就是能够用于任何形式, 任何种类的过程这些语句列举如下 : RETURN 语句 ; CONTAINS 语句 ; ENTRY 语句 ; EXTERNAL 语句 ; INTRINSIC 语句下面分别说明它们的功能 RETURN 语句 RETURN 语句的功能就是终止过程的执行, 使得程序的运行返回到引用该过程的程序单位由于过程的结构当中本身含有 END 语句, 因此 RETURN 语句的功能在大多数情况下, 都可以直接由过程自身的 END 语句来完成不过 RETURN 语句还具有一个功能却是 END 语句无法

229 替代的, 即 RETURN 语句能够放置在一个过程内部的执行部分的任意位置, 使得过程能够在执行的任意时刻中断, 返回到引用该过程的程序单位 RE TURN 语句的语法形式 (R1226) 为 : RETURN [scalar-integer-expression] 其中的选项标量整型表达式 (scalar-integer-expression) 只能用于子例行程序, 并且是用于替代返回的情形其中的表达式只能是整型的, 取值范围为 1 到 n,n 表示变元列表当中替代返回变元的位置, 即列表从左到右的顺序位置表达式的取值就表示所选择的从过程返回的位置这个替代返回的作用可以用 GO TO 语句的形式表示, 例如 : CALL SUBROUTINE22(,SELE) GO TO (label-list),sele 这样在程序从子例行程序 SUBROUTINE22 返回之前, 与 SELE 相应的哑元就被赋予为整型表达式替代返回值, 实际上这样的替代返回的功能完全可以通过使用 CASE 结构来完成, 并且 CASE 结构能够使得程序更加结构化, 因此相对而言, 使用 RETURN 语句是一种过时的风格 CONTAINS 语句 CONTAINS 语句只是起一种隔离标志的作用, 即把内部过程从它的宿主单位的说明部分或执行部分里面隔离标记出来, 或者是把模块过程从它所在模块说明部分隔离标记出来 CONTAINS 语句的语法形式 (R1227) 为 : CONTAINS 即在需要予以标记的过程前面一行使用 CONTAINS 一个词即可 CO NTAINS 语句不是可执行的, 它只是起一个标记的作用, 把过程从其所在的程序单位隔离开, 这样当程序运行到 CONTAINS 语句时, 它后面的语句就不会接着执行, 而是直接转移到该程序单位的 END 语句 ENTRY 语句 ENTRY 语句的功能是为过程与过程子程序之间提供数据共享即在一个过程子程序的说明部分或执行部分给出一条 ENTRY 语句, 就定义了相应的过程登录, 该被登录的过程也就可以访问其所在子程序的数据环境 ENTRY 语句的语法形式 (R1225) 为 : ENTRY entry-name [([dummy-argument-list])] [RESULT(result-name)] 如果该登录出现在一个函数内部, 那么它的哑元 (dummy-argument) 与结果 (result-name) 的属性都必须在子程序的说明部分预先予以说明 ENTRY 语句的功能实质上可以看作是在一个函数子程序或一个子例行程序子程序里面, 引入一条 FUNCTION 语句, 或 SUBROUTINE 语句的非常灵活的一种方法当然登录进来的名称不能与子程序里面已有的任何名称以及子程序本身的名称相冲突

230 为了更加清晰地说明 ENTRY 语句的功能, 下面给出一个例子例 SUBROUTINE COUNT1(dummy-argument-list1) RETURN ENTRY OP1(dummy-argument-list2) ENTRY OP2(dummy-argument-list3) RETURN END SUBROUTINE COUNT1 在上面的子例行程序 COUNT1 里面, 至少登录了两个过程 OP1 和 OP2,ENTRY 语句之间是一系列的可执行语句, 它们构成了被登录过程一旦某个登录过程被其所在子程序单位所调用, 那么整个子程序单位的运行就转到该 ENTRY 语句, 按照通常的方式执行该过程, 然后忽略后续的任何 ENTRY 语句, 一直到遇到 RETURN 语句, 或者是到达了子程序单位的 END 语句在很多的实际情况下, 一个子程序里面登录的过程都是非常类似的计算过程, 可能具有相同的数据对象以及代码, 那么就不需要在多个 ENTRY 语句体里面进行重复, 完全可以只在最后一个 ENTRY 语句里面出现, 然后运用适当的分支来访问该 ENTRY 体如果不希望使用分支方式的话, 也可以把这个公共的数据与代码封装为一个内部过程, 随时供整个子程序单位访问这样一个函数子程序里面的所有 ENTRY 语句就定义了相应的函数子过程, 而一个子例行程序子程序里面的所有 ENTRY 语句也定义了相应的子例行程序子过程对于函数子程序里面的 ENTRY 语句来说, 它的 RESULT 选项与 FUNCTION 语句里面的 RESULT 选项的涵义与形式都是一样的 ENTRY 语句的一般规则如下 : 如果 ENTRY 语句是出现在一个函数子程序里面, 那么 ENTRY 语句里面用来隔离可选哑元列表的括号必须出现只有外部子程序与模块子程序可以使用 ENTRY 语句, 内部子程序不能使用 ENTRY 语句在外部子程序与模块子程序里面可以使用任意有限数目的 ENTRY 语句在可执行结构, 例如 IF,DO,CASE,FORALL,WHERE 这些结构里面, 或者是非块 DO 循环里面, 都不能使用 ENTRY 语句登录名称不能与其所在子程序的任何哑元名称相冲突登录名称不能出现在子程序的 EXTERNAL 语句,INTRINSIC 语句, 以及过程界面块里面 ENTRY 语句里面的 RESULT 选项只能用于函数登录, 因此只能出现在函数子程序里面如果在一个函数登录里面指定了一个 RESULT 名称, 那么该名称不能与子程序里面的其他 RESULT 名称, 以及登录名称和函数名称相冲突 ; 而且相应的登录函数名称不能出现在子程序的任何说明语句当中, 函数名称的属性与其结果名称的属性保持一致 ENTRY 语句当中不能使用关键词 RECURSIVE 实际上在子程序里面的初始 SUBROUTINE 语句或 FUNCTION 语句里面使用或不使用 RECURSIVE 关键词, 就表示了该子程序里面的所有 ENTRY 过程都具有或不具有 RECURSIVE 属性

231 如果在一个函数子程序里面的所有 ENTRY 函数的结果, 都具有相同的类型, 种别参数, 以及形状, 那么它们可以看成是同一个结果变量而对于该结果变量的性质没有任何限制如果一个函数子程序里面的所有 ENTRY 函数以及它们的函数结果, 并不具有完全相同的数据属性, 即不具有完全相同的类型, 种别参数, 以及形状, 那么它们都必须是标量, 并且不能具有指针属性, 必须属于默认整型, 或默认实型, 或默认复型, 或双精度实型, 或者默认逻辑型因为一个子程序里面的所有 ENTRY 结果与函数结果都是相互之间具有存储关联关系的 ENTRY 语句所给出的哑元不能出现在该 ENTRY 语句之前的可执行语句里面, 也不能出现在该 ENTRY 语句之前的语句函数的标量表达式里面, 除非该哑元同时也是其所在语句函数的哑元如果一个可执行语句或语句函数依赖于某个登录过程的哑元, 或者通过一个局部数据对象而间接依赖于某个登录过程的哑元, 例如尺度依赖某个登录过程的哑元的局部动态数组, 那么只有在该哑元出现在引用过程的 ENTRY 语句的可选哑元列表里面的情形下, 该可执行语句或语句函数才能够得到执行而在该哑元可选的情况下, 其所关联的实元也必须存在在 ENTRY 语句里面的哑元的名称, 顺序, 数目, 类型, 种别参数都可以不同于其所在子程序的 FUNCTION 语句, 或 SUBROUTINE 语句, 以及任何其他 ENTRY 语句里面的哑元对于外部子程序来说, 由 ENTRY 语句定义的过程的界面可以在另外的作用域单位里面, 通过在过程界面块里面给出界面体, 而显式地表示出来, 这时 ENTRY 语句必须作为界面体的第一条语句, 而且关键词 ENTRY 必须用关键词 FUNCTION 或 SUBROUTINE 替代如果子程序是递归的话, 那么界面体当中必须包括关键词 RECURSIVE, 并且必须给出哑元的属性 ; 如果过程为函数的话, 则还需给出函数结果的属性对于模块过程里面的 ENTRY 过程来说, 其界面已经在引用该模块的程序单位里面显式地给出下面是不同形式的 ENTRY 语句的例子例 ENTRY SUB_WAVELET (X)! 登录子例行程序 ENTRY FUN_FACTOR(A,B) RESULT(CO_FACTOR)! 登录函数, 必须具有 RESULT 选项 EXTERNAL 语句 EXTERNAL 语句用于说明某个程序单位里面没有加以说明的名称为过程名称其具体用法参见节考虑如下的程序单位的片断 : X=SIN(A)* COS(B) CALL SUB1(A,B) CALL SUB2(X,SUB1,C)

232 单纯从上面的片断里面, 就可以判断里面的 X,A 和 B 为变量名称, 而 SUB1,SUB2 为过程名称, 但是无法判断 C 属于变量名称还是过程名称, 因此在程序单位的其他位置必须说明 C 的性质, 如果没有说明, 则系统默认该变元为变量而如果希望指定该变元为过程, 就需要使用 EXTERNAL 语句 EXTERNAL 语句的一般规则如下 : 通过 EXTERNAL 语句给出的过程名称必须是其所在程序单位的实元, 相应的过程则必须是外部过程或哑过程, 而不能是内部过程, 语句函数或类属过程, 因为这几种过程的名称不能作为实元 EXTERNAL 给出的名称不能作为过程名称出现在其所在的作用域单位的界面块里面由于在一个程序单位里面给出外部过程的界面块也能够实现 EXTERNAL 语句的类似功能, 因此从结构化编程的角度出发,EXTERNAL 语句属于过时的语言成分不过 EXTERNAL 还具有关联数据块程序单位的功能, 因此还不能说 EXTERNAL 语句完全可以废弃 INTRINSIC 语句 INTRINSIC 语句的功能与 EXTERNAL 语句的功能类似, 只是 INTRINSIC 语句用来指示固有过程, 而 EXTERNAL 语句用来指示外部过程 INTRINSIC 语句的具体用法参见节考虑下面的例 CALL SUB1(X,Y,LOG) 如果在上面的子例行程序的引用里面出现的名称 LOG 没有被其所在的程序单位额外指定为某个特定的过程名称, 那么 LOG 就表示 FORTRAN 的固有过程, 这时就需要使用 INTRINSIC 语句来说明这点由于固有过程已经被系统内在地加以定义, 所以不需要具有界面块, 因此界面块无法替代 INTRINSIC 语句的功能, 这点与 EXTERNAL 语句是不同的过程通讯的途径 -- 变量关联本章后面的变量关联与过程界面这两节围绕着一个主题, 即过程之间的通讯一个过程是一个完整的 FORTRAN 计算结构, 而一个实际的计算任务常常需要多个不同的过程组合起来, 这样就存在一个程序如何一个过程通讯的问题, 即如何与过程传递数据的问题归根结底, 如果把数据看成内容物的话, 那么装载数据的容器就是变元而数据通讯就可以归结为如何在不同的变元之间交换它们的内容物, 也就是数据把一个过程纳入一个程序的运行顺序, 在 FORTRN 里面称为引用, 即如果一个程序单位引用了一个过程, 那么该程序单位的数据流就从属于该程序单位的变元传递到属于被引用过程的变元, 使得数据流在被引用过程里面得到过程对其进行的计算处理, 然后该过程再把数据结果输出到程序单位里面的用来装载过程数据结果的变元, 这样就完成了对过程的引用, 也完成了与过程的数据通讯可以看到在上面的程序单位对过程的通讯之中, 涉及到两种类型的变元 : 一类是属于程序单位的变元, 用于装载程序单位对过程的输入数据与输出数据 ;

233 一类是属于过程的变元, 作为过程的处理对象, 用于表示相应数据在过程执行当中的涵义这两种变元的定义是完全独立的, 属于程序单位的变元在其所在的程序单位里面得到定义, 而完全不用考虑它将需要把数据传递到什么过程里面去 ; 同样属于过程的变元完全在过程里面得到定义, 而完全不需要考虑它将接受来自什么样的程序单位的数据输入正是基于这种相对性, 属于引用过程的程序单位的变元称为实元, 而属于被引用的过程的变元称为哑元, 所谓与过程的通讯, 正是实元与哑元之间的数据交换,FORTRAN 称之为实元与哑元的关联, 更一般地则称为变元关联那么如何指定需要相互进行数据交换的实元与哑元呢?FORTRAN 的表述方式非常自然, 我们回顾一下在定义过程的时候, 例如在定义子例行程序的 SUBROUTINE 语句, 和定义函数的 FUNCTION 语句里面, 都在过程名称后面给出了一个哑元列表, 即该过程所使用的所有哑元的一个序列, 而我们在引用过程时, 使用了 CALL 语句, 在引用函数时, 则直接引用函数名称, 这两种方式都在过程名称后面给出了实元列表, 即在程序单位里面需要经过引用过程的处理的所有变元的一个序列那么在实元与哑元之间建立一一对应的关联的自然方法, 就是利用这两个列表的变元顺序, 约定两个变元列表按照从左到右的顺序是一一对应, 即处于两个列表的相同的位置变元, 意味着它们是相互关联的下面以 SUBROUTINE 语句和对子例行程序的 CALL 引用语句为例, 对这种序列的按照位置的对应约定进行了图示 SUBROUTINE name(dummy-argument1,dummy-argument2,dummy-argument3, ) 第一对实哑对应第二对实哑对应第三对实哑对应... CALL name(actual-argument1,actual -argument2,actual -argument3, ) 图 13-1 实元与哑元之间的按照顺序约定的关联因此在这种基本的实元与哑元的关联表示当中, 两个变元列表的变元位置是基本的表达方式本节我们将更加仔细地分小节说明建立这种关联关系的各种规则与变化形式变元关联时数据属性的匹配变元关联的本质就是变元之间交换数据值, 而变元本身在各自的程序单位, 或过程内部肯定是经过定义的, 或者是显式地定义, 或者是存在默认定义, 这就对变元之间的数据交换构成了前提, 即一个变元通过交换数据而获得的数据的属性不能与变元本身被定义的属性相冲突, 这就是变元关联时的数据属性匹配问题对于所谓实元, 具有明确的数据内容, 并且属于所在程序单位的实际执行对象, 因此它的数据属性必然是明确的对于所谓哑元, 它并不具有实际的数据内容, 也不是程序单位实际执行过程中需要处理的对象, 表面上实元和哑元交换了数据内容, 但是哑元本身在任何时候都没有参与程序的执行, 在哑元与实元建立关联后, 哑元所在过程的运行, 实际上仍然是实元携带其数据内容在参与程序的运行, 尽管这时的实元在该过程里面扮演的正是相关哑元的角色但是, 哑元作为其所在过程里面的变元, 却是具有明确的数据属性的, 这个属性是由过程本身决定的, 实元要扮演哑元在过程里面的角色, 就不能与哑元的数据属性有冲突, 否则该过程本身是否还有意义, 都会很成问题

234 例如只对实型数据有意义的一个函数, 如果它被引用之后, 与其中哑元对应的实元可以取复型数据, 那么肯定会发生该函数无法计算的后果因此数据属性的匹配问题, 是实元与哑元双方面的问题, 不能只对其中一方面进行检查那么变元之间的数据属性匹配要达到什么程度呢? 首先我们必须在对数据对象进行分类的基础上来讨论这个问题, 因为可以作为过程变元的数据对象除了可以是固有数据类型, 派生数据类型, 表达式, 数组, 指针等常见数据对象之外, 还可以是过程以及替代返回变元, 对于数组, 指针, 替代返回, 以及过程, 后面都将分小节专门进行讨论, 因此在本节只讨论标量直观地看, 变元之间的数据属性匹配所需要达到的一个基本目的就是能够使得过程得到合理的运行结果, 在这个前提下, 所谓数据属性的匹配包含如下三个方面的要素 : 数据类型 ; 种别参数 ; 秩一个数据对象的这三个方面的属性组合起来, 简称为 TKR 模式变元关联的基本原则, 或者说实元与哑元获得关联的基本前提, 就是它们的 TKR 模式相同如果我们目前只考虑标量的话, 在秩都是 1 的前提下, 这个基本原则包含如下内容 : 要求与一个标量实元相关联的哑元, 同样必须是标量, 并且必须与该实元标量具有相同的数据类型与相同的种别参数值数组的元素, 结构的标量成员, 字符子串都可以作为有效的标量实元由于字符型标量的变元还包括字符长度这个数据属性, 而只有在保证所有字符型变元的长度都得到显式地说明前提下, 才能做到有效检测匹配条件, 但这样就会限制过程的使用范围, 为了解决这个问题,FORTRAN 给出哑长度哑元的概念, 使得在不给出显式长度说明的情况下, 也能够做到变元匹配, 从而适当地放松了字符型变元匹配的条件 : 字符型哑元如果不能做到显式地说明长度, 那么就必须具有哑长度属性哑长度属性只适用于哑元, 其表示方式为 (*), 即用星号代替长度值该哑元的长度只有在获得实元的关联之后, 才能被确定, 也就是实元在把自己的值传递给哑元的同时, 也把自己的长度属性值传递给了哑元如果不使用哑长度哑元的形式, 而是给出变元长度的显式说明, 那么对于非默认字符型变元, 哑元与实元的长度必须是一样的 ; 而对于默认字符型变元, 则从语法上可以允许不一样, 并且针对如下的不同情形进行不同的处理 : 如果实元的长度大于哑元的长度, 那么被调用过程在使用该实元值时, 只取该字符型标量实元值的左端的字符子串, 该子串的长度与哑元的长度一致因此在实元的右端所有超过了哑元长度值的字符都被该过程忽略掉了如果实元的长度小于哑元的长度, 则是不允许的为了安全与简便起见, 在涉及到字符型变元的匹配时, 还是把哑元设置为哑长度哑元为宜注意除非哑元属性是在宿主单位里面定义的, 语句函数引用是满足这个基本条件的由于外部过程与引用它的程序单位一般都是分别进行编译的, 因此系统在编译时, 无法对它们进行变元匹配性质的检查, 这常常导致 FORTRAN 程序产生匹配错误, 因此 FORTRAN 提供了显式过程界面的机制, 来解决这种匹配问题

235 数组的匹配由于数组具有形状属性, 所以和标量的匹配相比, 数组的匹配还需要考虑形状的因素数组变元的匹配的基本原则就是实元与哑元必须具有相同的形状, 这意味着实元与哑元必须具有相同的维数, 每个相应的维度都必须具有相同的元素数目, 它们的尺度必须相同当然上述原则的前提是数组哑元与数组实元都经过了显式的形状说明, 才能完成匹配检查, 这个前提实际上限制了过程应用的灵活性, 因此与字符型变元类似, 对于数组 FORTRAN 也提供了哑形数组的概念, 使得具有哑形数组属性的哑元的过程, 能够更加具有通用性一旦对哑元赋予哑形数组的属性, 就简化了匹配条件, 即只需要实元与哑元的秩相同, 就保证了实元与哑元的匹配, 因为对于哑形哑元来说, 它的形状只有在获得实元的关联之后, 才能完全确定下来, 这样在秩相同的前提下, 就不再存在匹配方面的冲突哑形哑元与实元的匹配在通过秩相同的检查之后, 就按照两个数组变元的元素与元素之间的匹配条件进行检查, 即按照标量的要求来进行匹配检查这可以说是一个完整的 TKR 模式匹配的检查过程因此尽管数组比标量在结构上要复杂, 但是通过引入哑形数组的概念, 就大大简化了数组变元的匹配问题, 我们在实际编程当中, 也应该尽量运用哑形哑元来进行变元关联哑形数组是 FORTRAN 新近引入的概念, 在 FORTRAN 的老版本里面, 数组变元的匹配问题就显得要复杂得多一方面由于存在丰富的老版本 FORTRAN 源码值得我们加以利用, 另一方面由于数组变元的老式的通过数组元素序列建立的关联具有特别的功能, 所以下面我们分别详细说明这种数组变元关联方式, 以及数组元素序列关联在存储层面的有关内容另外由于结构与数组的相似形, 最后也将说明结构对象的关联方式 1. 数组元素序列关联如果按照元素序列关联的观点来建立数组变元之间的关联, 那么在哑元为显形数组或哑形数组的情形下, 就不需要要求哑元的秩和与之相关联的实元的秩一样了所谓建立数组元素序列 (AES) 关联, 就是把数组看成是一个由数组元素构成的序列, 这个序列的元素是按照数组元素序进行排列的, 而所谓数组元素序在第 6 章已经给出定义, 扼要地说, 就是在该序列里面, 从左往右看, 第一个下标变化最快, 而第二个下标次之, 顺次类推, 最后一个下标的变化最慢这样就把数组元素排成了一个 1 维的线性序列把哑元和实元都变换成序列之后, 它们之间的所谓序列关联的机制与非默认字符型数据的字符串的关联方式 (13.7.1) 类似, 即从两个变元的左边第一个元素开始, 按照序列的顺序进行元素与元素之间的关联匹配与字符串匹配类似的是, 实元的序列长度不能小于哑元的序列长度, 而可以大于哑元的长度在这种情况下, 需要采取截断方式, 来保证元素的一一对应的关联, 截断的规则是从最左端开始对齐, 按照元素序进行序列关联, 一直到哑元序列结束的地方, 实元所有不能与哑元元素对应的元素都被截除数组元素序列关联的一般规则如下 : 如果哑元为哑形数组, 那么哑元的元素组成的序列的长度会是未定的, 一直到该哑元被某个实元建立关联, 那么该哑元的元素序列长度就取为实元的元素序列长度如果哑元的元素为字符, 那么元素逐一地进行关联的时候, 还存在一个字符串长度匹配的问题, 这时出现如下两种情形 : 对于非默认字符型元素, 实元数组元素的字符长度必须和哑元数组元素的字符长度, 这样实元与哑元之间的元素之间的一一对应的关联就可以按照上面的规则建立起来

236 对于默认字符型元素, 任何实元数组元素的字符长度都可以和哑元数组的字符长度不同, 不过这时不需要在按照元素序的元素之间进行长度的对比, 而是把数组的所有元素都按照元素序串接起来, 这样整个数组构成一个大的字符串, 而每个字符元素都是该字符串的一个子串, 然后把实元与哑元的两个大的字符串从最左端开始对齐, 按照字符对字符的方式, 在字符之间建立一一对应的关联, 而不是以元素为单位建立关联, 因为显然按照这种方式建立起来的关联有可能把元素之间的对应关系打乱, 从而出现一个元素的字符与多个元素的字符具有关联关系的情形这时, 实元与哑元之间的长度匹配规则是整个实元数组元素组成的字符串的字符数目, 不能少于整个哑元数组元素组成的字符串的字符数目而实元比哑元在右端多出来的字符全部被截断按照上面的数组元素序列关联规则, 实元数组与哑元数组的秩是可以不同的, 但是由于实元和哑元在进行序列关联时, 总是要求实元数组元素序列大于或等于哑元数组元素序列, 因此有如下两个特殊情况需要注意 : 如果哑元是标量, 即秩为 0 的数组, 那么实元可以具有任意的非 0 秩, 这时相当于把逐元过程应用于数组对象如果哑元是数组, 那么只有在哑元为显形或哑形数组, 并且实元只有在是一个单独的数组元素或元素的子串的情况下, 才能建立元素序列关联构成序列关联的数组元素必须都是实元哑形数组或指针数组的元素不能与哑元元素建立关联对于默认字符型变元, 实元甚至可以是数组元素的子串, 而该子串不能是来自哑形数组或指针数组的元素至此, 我们可以看到数组变元的关联匹配, 在不同的情形下可以在三个层次上进行, 即 : 数组层次 ; 数组元素层次 ; 元素字符串的字符层次在数组层次上建立关联, 必须要求变元数组的形状一样, 在形状相同的基础上, 就可以进行元素与元素之间的一一对应的关联在数组元素层次上建立关联, 则是把数组看成一个线性序列, 在序列的基础上进行元素与元素之间的一一对应的关联这时要求实元序列的元素不能少于哑元序列的元素在元素字符串的字符层次上建立关联, 只是针对默认字符型数组元素而言, 因为字符型标量的关联可以建立在字符的层次上, 所以由字符型元素组成的数组可以以字符为单位构成序列, 对这种序列建立关联, 就同样是以字符为单位, 在字符与字符之间建立一一对应的关联这时要求实元序列的字符数目不能小于哑元序列的字符数目显然序列关联方式远比 TKR 关联方式要繁复, 而且容易隐藏错误, 所以最好的选择, 还是赋予数组哑元以哑形以及哑长度的属性, 然后以 TKR 关联方式建立数组变元的关联尽管通过序列关联能够在哑元与实元的秩不一样的情形下建立关联, 而这个功能是 TKR 方式所不具有的, 但是实际上我们可以通过调用数组片断来达到同样的效果 2. 数组片断的调用在引用过程时, 能够调用数组的片断是数组的一个非常强有力的功能为了实现这个功能, 运用数组元素序列关联显然是不够的, 因为在大多数情况下, 数组片断在数组元素序里面都不是连续的, 这样要引用数组片断就会很麻烦相反如果使用哑形哑元的概念, 则可以很自然地做到调用数组片断数组片断调用的一般规则如下 :

237 数组片断的引用可以通过以下三种方式来构造 : 运用下标三元组的数组引用 ; 运用向量下标的数组引用 ; 非最右端部分为数组值的结构成员引用这样就可以很自然地应用 TKR 模式匹配来得到正确地引用了数组片断还可以调用为显形哑元和哑尺度哑元, 这时如果过程的数组变元为隐式界面的话, 为了与 FORTRAN 早期版本兼容, 则必须认为其与哑元的关联为序列关联, 因此这时数组片断的引用就必须使用数组元素序列关联的形式在使用数组片断作为实元的时候, 运用向量下标构造的数组片断不能是可定义的, 也就是说该变元不能在过程运行时赋予新值同时相应的哑元不能具有 INTENT(OUT) 或 INTENT(INOUT) 属性因为在使用向量下标时, 同一个实元数组元素可能是多个数组片断的一部分, 这样就使得该实元数组元素同时与多个哑元元素相关联因此如果数组片断是可定义的话, 同一个实元数组元素就可能被赋予相冲突的不同的值与上面的规则类似, 通过多个变元引入同一个过程的同一个数据对象不能是有定义的例如假设两个数组片断 X(1:10) 和 X(5: 15) 都是同一个过程的实元, 那么相同的元素 X(5: 10) 就通过两个实元被引入了该过程, 这时在该过程里面, 这些元素都不能获得定义这个限制对于任意数据对象都是成立的, 再例如 X 是一个标量, 那么 X 可以多次出现在实元列表当中, 但这样一来 X 就不能作为引用的结果而得到定义如果哑元是哑形的, 那么相应的实元就不能是哑尺度数组因为哑形哑元自身不具有一个完整的数组结构方面的信息, 它必须从与实元的关联当中来获得形状信息, 而如果实元本身也是哑尺度的话, 那么就得不到完整的形状信息不过, 一个哑尺度数组的片断则是有可能作为一个实元的, 因为该片断的形状信息可以是完整的如果在一个过程里面通过变元关联来引入数据对象, 那么该数据对象在本过程里面只能作为哑元被定义与被引用例如下例里面的变元 X 在子例行程序里面获得赋值就是非法的例 CALL SUBROUTINE1(X) CONTAINS SUBROUTINE SUBROUTINE1(A) A = 1000 如果哑元是一个具有指针属性的数组, 那么实元也必须具有指针属性对于一个类过程, 或自定义运算, 或自定义赋值的引用,TKR 模式匹配规则必须应用到它的所有变元与算元, 除非该引用为逐元引用因此在任何情形下, 一个数组元素都不能被传递给一个数组哑元例如, 如果函数 SQUIRT 被作为一个类过程名称引用, 那么 SQUIRT(X(10)) 的实元为标量, 而相应的哑元也必须是标量, 而如果一个类过程既允许使用标量哑元, 也允许使用数组哑元, 那么就选择使用标量哑元的相应种过程如果一个固有过程的实元是一个数组元素, 那么数组就不能被传递到该固有过程, 而只有数组元素才能够传递到该固有过程

238 3. 结构的序列关联由于结构与数组类似, 因此结构变元之间也可以建立按照成员顺序排列的序列关联的关系如果一个结构是一个外部过程的哑元, 那么该结构的派生类型必须予以说明, 使得它具有与相应实元的完全相同的派生类型要实现这个结构的匹配要求, 最好的方式是把派生类型的定义放在一个模块里面, 使得外部过程和引用该派生类型结构的程序单位都可以通过使用关联来访问该模块, 从而获得该结构的类型定义此外, 一个比较容易出错的实现方式是建立结构之间的序列关联, 这种方式使得编译器很难查错, 因此应该尽量避免使用具有序列关联关系的实元结构与哑元结构的派生类型不需要是完全相同的, 但必须是等价的, 所谓两个派生类型数据对象的等价, 是指它们具有相同的类型名称, 相同的序列类型, 按照顺序排列的成员的名称与属性都相同, 并且都不能包含私有成员如果通过序列关联来引用结构, 那么该关联的存储模式由编译器来设置由于结构的序列关联要求成员的名称, 数目, 顺序和属性都相同, 因此引用程序单位和被引用程序单位都可以为相关联的结构设置兼容的存储模式, 从而在过程与引用程序单位之间进行正确的通讯指针的匹配所谓指针本质上就是变元之间建立关联的一种形式任何一个数据对象都可以或者具有 POINTER 属性, 或者具有 TARGET 属性, 或者这两种属性都不具有, 但不能同时具有这两种属性这样作为哑元的数据对象和作为实元的数据对象就分别具有三种情形, 它们的组合则一共有九种情形, 下面的表 13-1 列出了全部的可能性表 13-1 指针关联的组合情形实元哑元 POINTER 属性 TARGET 属性都不具有的情形 POINTER 属性 A TKR 不允许出现的情形不允许出现的情形 TARGET 属性都不具有的情形 F, 与 B 相同 B C TKR 或 AES TKR 或 AES TKR 或 AES G, 与 D 相同 D E TKR 或 AES TKR 或 AES TKR 或 AES 其中包含两个不允许出现的情形, 即哑元具有 POINTER 属性, 而相应的实元或者具有 TARGET 属性, 或这两种属性都不具有还包括两个重复的情形, 因此还剩下 5 种情形需要讨论对于情形 E, 实元与哑元都不具有 POINTER 属性与 TARGET 属性, 因此属于前面讨论的一般变元关联的情形对于情形 B,C,D, 它们的实元和哑元都至少有一个具有 TARGET 属性, 或者是都具有 TARGET 属性, 而没有 POINTER 属性, 这时与情形 E 是非常类似的, 它们都可以通过 TKR 模式匹配或序列关联模式来进行关联匹配, 因此也就遵循相应的匹配规则在情形 B,C,D 里面至少有一个变元具有 TARGET 属性, 这意味着可以存在指针是以它们为目标的, 这里存在如下两种类型 : 在情形 B 和 D 里面, 实元都具有 TARGET 属性, 因此在引用程序单位里面就可以存在指针以该实元为目标

239 在情形 B 和 C 里面, 哑元都具有 TARGET 属性, 因此在过程的执行的时候, 过程里面局部的指针或可访问指针, 或具有指针属性的其他哑元, 都可以以该哑元为目标一旦建立了变元关联关系, 任何与具有 TARGET 属性的实元相关联的指针就一直保持与该数据对象相关联的 PO INTER 属性如果相应哑元是哑形数组或标量, 则成为与该哑元相关联的指针 ; 如果相应哑元是显形数组或哑尺度数组, 则是否与指针建立关联由编译系统决定在引用之前与实元建立了关联的指针将保持指针关联关系, 一直到过程运行完毕, 并且实元与哑元的关联关系被解除为止对于情形 B 和 C, 在哑元目标与引用程序单位可访问指针之间建立的指针关联关系一直到被引用程序运行完毕才被解除如果一个引用程序调用了具有相同 TKR 模式的一个指针和一个目标来作为两个不同的实元, 那么被引用程序单位可以在引用程序作用域范围内, 建立或解除此两者的指针关联关系情形 A 表明实元与哑元都可以具有 POINTER 属性当哑元为指针的时候, 那么在引用程序里面过程界面必须是显式的, 而相应的实元也必须是具有 POINTER 属性情形 A 所遵循的规则如下 : 适用于 TKR 模式的匹配规则建立变元关联之后, 哑元必须和实元具有相同的指针关联状态, 而如果实元与一个目标建立了指针关联, 那么哑元也必须与同一个目标建立指针关联关系在过程执行的时候, 哑元的指针关联状态可以发生变化, 而任何的这种变化都导致实元的指针关联状态的相应变化情形 F 和 G 的实元都是指针, 而哑元都不是指针在这两种情形下, 实元都必须与一个目标相关联, 而正是这个目标与哑元具有变元关联关系, 因此这两种情形分别与情形 B 和 D 等价从效果上来讲, 当实元具有 POINTER 属性, 而哑元不具有 POINTER 属性的时候, 实际上可以看成是一个指针引用, 也就是引用到一个目标数据对象至于表中不允许出现的情形都是非法的, 因为实元与哑元的指针运算有冲突在情形 D, 过程界面在引用程序单位里面可以是, 也可以不是显式的, 而在情形 A,B 和 C 则过程界面必须是显式的因此引用程序单位可以把具有目标关联的指针传递给具有隐式界面的外部过程运用变元关键词建立关联在实元与哑元之间建立关联的基本方式就是变元列表的依据位置的配对不过在某些情形下, 为了更加灵活地建立变元关联, 还需要有不依赖于位置的配对方式, 因此 FORTRAN 引入了通过关键词来指定关联的方式所谓关键词就是在实元列表当中引用的哑元的名称, 该哑元被直接地显式说明与其关联的实元这种说明变元关联的形式为 : dummy-argument-name = actual-argument 即直接使用等号来表示哑元名称与实元的关联例 CALL SUBBATA(X,Y,Z,CORE=30,SHELL=PI**2) CALL UNIT(A,B,MINI=0.23)

240 运用变元关键词建立关联的一般规则如下 : 这种直接的表示方法可以应用于任意的实元, 而且由于这种方式已经不需要依赖变元的列表位置, 所以在实元列表当中使用这种方式的实元可以用任意的顺序这种方式还可以与依赖位置的配对方式混合使用, 这时为了便于分辨通过位置配对的实元, 约定使用关键词表示方法的实元必须集中在实元列表的右端, 使用位置配对方式的实元则必须集中在实元列表的左端, 因此只要在实元列表里面出现了一个关键词, 那么该关键词后面的所有实元都必须使用关键词在两种方式混用时, 必须注意在一次引用当中, 同一个哑元不能使用不同的方式进行关联, 因为要保证每个哑元至多只能与一个实元关联使用关键词方式的最大好处就是不需要记忆哑元列表的顺序, 因此不容易出错如果出现在变元列表当中某个非列表最右端的可选变元被省略了的情形, 则只有使用关键词方式才能恰当表示变元关联如果在过程的实元列表当中使用了关键词, 那么在包含该引用的程序单位的作用域当中, 过程的界面必须是显式的由于固有过程, 内部过程, 和模块过程的界面都是显式的, 因此在这些过程里面都可以使用关键词引用方式而对于外部过程来说, 要使用关键词方式, 则需要在引用程序当中给出界面块, 这时关键词可以与过程定义里面的哑元名称不一样, 这是自动具有显式界面的固有过程, 内部过程, 和模块过程所不具有的功能, 因此也是外部过程引用的一个特点哑元的 OPTIONAL 属性一个具有 OPTIONAL 属性的哑元意味着该哑元在某个特定的过程引用当中, 不需要获得实元的关联任何过程的任何哑元原则上都可以被赋予 OPTIONAL 的属性, 也就是说没有哪个哑元是注定了要在一切引用当中都需要获得实元关联的赋予一个哑元以 OPTIONAL 属性的方式有两种, 即在过程定义当中使用 OPTIONAL 语句, 或在面向对象的声明语句当中使用 OPTIONAL 属性说明具体说明参见第 7 章在一个使用了位置方式表示变元关联的变元列表当中, 如果可选变元是处于列表的最右端, 那么在引用时就可以直接省略, 因为其被省略并不影响其他非可选变元的位置变化而如果该可选变元不是处于列表的最右端, 那么要省略它, 在引用时就必须使用关键词方式, 除非该可选变元的右边的所有变元都可以被省略, 因此一个具有可选变元的过程要求该过程具有显式的过程界面下面是一个例子例 CALL UNIT(0.85,X=FUN1(I)) SUBROUTINE UNIT(A,B,X,Y) OPTIONAL B,X,Y END SUBROUTINE UNIT 对于过程的可选变元来说, 由于它在不同的引用环境里面, 常常可能是被省略了, 或获得了实元的关联, 因此在一个特定的引用当中, 需要在运行过程的时候, 检查该过程引用的可选哑元是否获得实元的关联, 即与该哑元相关联的实元是否实际存在, 实现这个检查功能的固有函数即

241 PRESENT 该固有函数包含一个变元, 即需要检查的过程的可选变元的名称通过运行这个固有函数, 返回一个默认逻辑值, 从而可以确定被检查的可选哑元是否究竟在该过程引用当中获得了实元的关联下面是使用该固有函数的一个例子例 IF(PRESENT(A)) THEN! 运行条件就是哑元 A 具有关联实元 FUN1=FUN2(A)**2 ELSE! 运行条件就是哑元 A 不具有关联实元 FUN1=FUN2(B)**2 END IF 在这个例子里面,PRESENT 被用来作为条件控制的条件表达式当一个可选哑元不出现的时候, 有以下规则, 这里的不出现的实际含义就是说该可选哑元不具有关联实元需要注意如下几点 : 没有出现的哑元不能获得引用没有出现的哑过程不能获得调用没有出现的哑元不能又作为一个与非可选哑元关联的实元出现, 除非是被固有函数 PRESENT 引用没有出现的哑元可以作为一个与可选哑元关联的实元出现, 这时后面的可选哑元不能出现一个不出现的指针哑元可以被调用为一个实元, 但是该实元必须与一个同样是指针的哑元相关联, 除非该指针哑元是被固有函数 PRESENT 引用哑元的 INTENT 属性除了哑过程, 哑指针之外的任意哑元, 都可以赋予 INTENT 属性而且只有哑元可以赋予 INTENT 属性具有一定的 INTENT 属性的哑元表示该哑元在过程里面的特定的使用方式, 那么编译器就可以依据该属性来检查是否出现违背这种特定使用方式的情形出现 INTENT 属性用来说明 3 种不同的变元使用方式, 它们的不同形式与具体含义如下 : INTENT(IN) 这个属性用来表示该哑元只能用来给过程输入数据, 而不能用来给引用程序返回过程的结果, 并且在过程的运行过程当中, 该属性不能改变, 如果试图改变哑元的这个属性, 将被视为出错 INTENT(OUT) 与 INTENT(IN) 的含义相反, 这个属性用来表示该哑元只能用来给引用程序返回过程的结果, 而不能用来给过程输入数据具有 INTENT(OUT) 属性的哑元在过程里面获得定义之前, 不能被引用与具有 INTENT(OUT) 属性的哑元关联的实元必须是一个可定义的数据对象, 即一个变量 INTENT(INOUT) 具有 INTENT(INOUT) 属性表示变元在进入过程时定义了值, 并且在过程运行过程当中随时可以改变取值这样如果要求一个变元在过程里面能够随时被过程更新取值, 就必须赋予其 INTENT(INOUT) 的属性与具有 INTENT(INOUT) 属性的哑元相关联的实元必须是一个可定义的

242 数据对象, 即一个变量注意取值为向量值下标的数组片断的实元, 不能与具有 INTENT(OUT) 或 INTENT(INOUT) 属性的哑元相关联, 因为它的取值是不可变的赋予哑元 INTENT 属性并不要求过程具有显式界面, 因为这个属性只是规定变元在过程内部的用法不过如果在过程的界面里面显式地给出哑元的 INTENT(OUT) 或 INTENT (INOUT) 属性, 那么就可以防止该哑元被不可定义的数据对象关联逐元过程引用当中的变元关联 FORTRAN 引入逐元过程这个概念的基本目的, 就是要使得以标量为变元的过程能够具有并行计算的能力, 也就是能够作用于数组这时, 由于引用过程存在一个变元关联的匹配问题, 即过程的标量哑元如何能够与数组实元匹配呢? 解决的方式就是引入逐元过程的概念, 来扩展变元匹配的要求即凡是逐元过程, 都可以以标量哑元和数组实元建立关联关系而以标量作为变元的逐元过程的结果必定也是标量, 那么当逐元过程的变元与数组实元建立关联之后, 该逐元过程的结果如何决定呢? 基本的约定就是把该逐元过程分别作用于实元数组的每个标量元素, 从而得到相应的结果标量, 并返回给引用该过程的程序单位, 然后所有这些结果标量构成一个集合, 显然这个集合是一个具有与实元数组相同形状的数组, 那么就可以把该数组看成是逐元过程作用于数组实元的结果因此逐元过程名称的由来就是对数组实元的元素的逐个的作用, 至于对于实元数组的元素的作用顺序则不予规定, 而这点正好在语言层次上赋予了系统进行并行计算的能力逐元过程可以具有 2 个以及 2 个以上的变元, 因为标量可以与任意形状的数组匹配, 所以一个逐元引用当中的实元列表可以是任意的数组变元与标量变元的组合实际上很多的固有逐元函数都包含了作为标量的 KIND 哑元, 它的作用在于规定相应实元的种别参数值一个标量在一个逐元引用当中用作实元的效果, 等价于该标量被扩充为具有相同元素的与数组变元具有相同形状的数组所有的逐元固有过程的详细说明参见附录 B 类过程引用当中的变元关联所谓类过程, 就是同一个过程名称表示了 2 个或多于 2 个的不同过程, 当然这些具有相同名称的过程属于同一个计算过程, 只是它们的变元具有类型参数方面的差异由于引用的实质是依赖过程名称而进行的, 那么在引用类过程名称的时候, 如何具体选择某个种过程呢? 显然只有依靠能够对它们进行区分的信息, 而它们的区别只是在于变元的 TKR 模式里面的各种参数值, 因此实元的 TKR 模式序列就可以提供足够的用来选择种过程的信息这样在引用这种类过程的时候, 除了名称之外, 还需要给出实元的 TKR 模式序列, 就能够选择出唯一的与具有给定实元的 TKR 模式序列相匹配的哑元列表的种过程例如下的 3 种形式的固有函数 SIN 的引用就分别代表了 SIN 的 3 个种过程形式 : SIN(9.9) SIN((0.1,6.4)) SIN(9D+10) 为了使得能够通过利用实元的 TKR 模式序列来唯一地选择类过程集合里面的某个种过程, 在一个类过程集合里面的任何两个种过程的哑元列表必须符合一定的要求这个要求就是这两个

243 任意的哑元列表必须在其中的一个列表当中包含一个非可选哑元, 该非可选哑元满足以下两个条件之一 : 如果把两个哑元列表进行位置对应, 那么该哑元不存在与之对应的哑元 ; 或者存在与之对应的哑元, 但两个哑元的 TKR 模式不同该哑元的名称与另外的哑元列表里面的所有哑元名称都不相同 ; 或者存在相同名称的哑元, 但它们的 TKR 模式不同前一个条件是针对按照位置匹配变元的方式而言, 后一个条件则是针对关键词匹配变元的的方式而言一个逐元过程也可能具有一个类过程名称, 而共享该类过程名称的其他某个种过程可能不是逐元的, 那么在引用这样一个逐元过程的时候, 就可能与对那个非逐元种过程的引用无法区分开, 这时的约定是引用那个非逐元种过程, 而如果该类过程集合里面不存在这样的非逐元过程, 那么就引用该逐元种过程例 INTERFACE SUB1 ELEMENTAL SUBROUTINE SUB2(X) REAL X END SUBROUTINE SUBROUTINE SUB3(Z) REAL Z(:) END SUBROUTINE END INTERFACE REAL A(99), B(25,50) CALL SUB1(A)! 引用了 SUB2 CALL SUB1(B)! 引用了 SUB3 由于在引用类过程时, 涉及到实元列表与哑元列表的匹配, 所以在引用所处的作用域单位里面, 类过程集合里面的过程的界面都必须是显式的, 有关过程界面的描述参见下面的 13.8 节两种非数据对象的过程变元的关联 : 替代返回变元与哑过程过程的变元除了是数据对象之外, 还可以是两种非数据对象之一, 即替代返回变元与哑过程下面分别说明它们的关联表达形式所谓替代返回是子例行程序当中的一种非正常的返回 ( 或者说退出 ), 它只能在子例行程序里面使用, 由于它的功能完全可以通过 RETURN 语句的方式获得, 因此它属于过时的语言成分, 不提倡使用它, 但还是需要了解, 以便于阅读过去的 FORTRAN 代码在一个子例行程序的变元列表当中可以使用多个替代返回, 而且它们在列表当中的位置也可以是任意的在哑元列表当中, 直接使用星号表示替代返回变元, 作为替代返回的哑元不能是可选的, 而相关联的实元也不能具有关键词与替代返回哑元相关联的实元必须使用一个星号后接一个语句标签来表示, 该语句标签即在引用程序单位所属的作用域单位里面的返回分支目标语句的标签例下面例子给出了一个包含替代返回的子例行程序以及对它的引用 SUBROUTINE SUB1(X,Y,*,Z,*)

244 . END SUBROUTINE SUB1 CALLSUB1(A,B,*99,C,*999) 运用 RETURN 语句完全可以获得同样的功能, 这里 RETURN 语句的形式为 : RETURN scalar-integer-expression 其中的整型标量表达式 (scalar-integer-expression) 的取值为从 1 到哑元列表当中的星号的个数 n, 表示子例行程序运行到该 RETURN 语句时, 应该返回到该数字 k 所指示的实元列表当中第 k 个星号后接标签所表示的语句继续使用上面的例子, 就是 : RETURN 1 RETURN (2) RETURN! 返回到引用程序的标签为 99 的语句! 返回到引用程序的标签为 99* 的语句! 从该引用里面正常返回所谓哑过程就是一个过程名称, 它可以出现在界面块里面, 可以出现在 EXTERNAL 语句里面, 或者作为一个过程的名称被引用在一个函数或子例行程序引用里面与作为哑元的哑过程相关联的实元必须是一个外部过程, 或模块过程, 或固有过程, 或哑过程的名称哑过程的一般规则如下 : 实元不能是内部过程或语句函数的名称实元不能是类过程的名称, 除非该类过程名称同时也是一个种过程的名称如果哑过程的界面是显式的, 那么其相关联的实元过程必须与该界面相匹配如果哑过程被明确引用为一个函数, 那么相应的实元过程也必须是一个函数如果哑过程被明确引用为一个子例行程序, 或具有一个显式的子例行程序的界面, 那么相应的实元过程也必须是一个子例行程序哑过程可以是可选的, 但不能具有 INTENT 属性哑过程可以出现在函数子程序或子例行程序子程序里面实元过程可以使用关键词说明 13.8 过程界面所谓一个过程的界面, 顾名思义就是过程与过程外部进行数据交流所必须提供的信息集合它包括过程及其哑元的名称, 过程的属性, 哑元列表的顺序及其属性如果上面所列举的信息对于引用该过程的程序单位来说是已知的, 或者说是可访问的, 那么该过程的界面就称为在引用程序的作用域单位里面为显式的, 否则称为隐式的固有过程, 内部过程, 和模块过程的界面总是显式的 ; 而外部过程和语句函数的界面为隐式的要使得外部过程的界面成为显式的, 可以在引用程序的作用域单位的说明部分使用界面块

245 界面块的功能包括 : 给出过程的类属性质定义新的自定义算符, 并且扩展固有算符的类属性质重定义派生类型的固有赋值, 或对新的数据组合形式扩展赋值运算说明一个过程为外部过程鉴于显式界面在 FORTRAN 里面的重要性, 下面我们分节说明有关显式界面的各种问题显式界面显式界面是 FROTRAN 的最为重要的一个语言特性之一, 因为它能够有效地根除 FROTRAN 编程最大的错误来源, 即过程引用当中出现的数据匹配错误在出现以下变元数据对象与过程对象的情形下必须给出显式界面 : 1. 可选变元 ; 2. 数组值函数 ; 3. 长度动态决定的字符值函数 ; 4. 指针值函数 ; 5. 用于数组片断调用的哑形哑元 ; 6. 具有 POINTER 属性与 TARGET 属性的哑元 ; 7. 关键词实元 ; 8. 类过程 ; 9. 自定义算符, 实际上是调用某些函数的替代形式 ; 10. 自定义赋值, 实际上是调用某些子例行程序的替代形式 ; 11. 逐元过程 ; 12. 要求纯过程的上下文里面的过程引用下面分别说明这些不同情形之所以需要使用显式界面的原因在情形 1 和情形 7 的时候需要使用显式界面的原因, 可以从下面的例子里面看到例 SUBROUTINE SUB1(A,B,C,D,E);OPTIONAL A,B,C END SUBROUTINE CALL S UB1(F,G,H,I,J)! 基本的引用 CALL SUB1(F,H,I,J)! 省略了第二个变元 CALL SUB1(A=F,B=G,C=H,D=I,E=J)! 与第一个引用等价 CALL SUB1(A=F, C=H,D=I,E=J)! 与第二个引用等价 CALL SUB1(D=I,E=J)! 省略了全部可选变元 CALL SUB1(E=J,D=I)! 与上面的引用等价 CALL SUB1(C=H,B=G, D=I,E=J)! 省略了一个可选变元 CALL SUB1( D=I,A=F,B=G, E=J)! 省略了一个可选变元上面例子里面的引用都是有效的引用, 从上面例子的最后 4 个引用可以看到, 当存在可选变元与关键词的时候, 都必须使用显式界面, 使得引用程序能够建立正确的变元关联, 否则由于在哑元列表里面的任意哑元都可以被设置为可选变元, 而可选变元又原则上可以被省略 ; 关键词方

246 式又完全不依赖于列表位置, 因此要建立不会产生歧义的变元关联, 就必须使用显式界面在情形 2 和情形 3 里面的数据对象都具有尺度概念, 即数组的尺度和字符串的长度, 这些参数值都是由过程的运行来决定的, 因此在引用过程当中会发生变化, 这时就需要显式界面来提供明确的信息在情形 4 里面, 引用过程需要为指针对关联的实元数据对象建立缓存, 因此也需要显式界面情形 5 实际上是实现了 FORTRAN 的一个重要功能, 即能够非常灵活地引用数组的任意片断, 哪怕是按照数组元素序为不连续的片断而要做到引用任意的数组片断, 就需要给引用程序提供除了一般数组引用之外的额外信息, 例如数组片断的具体组成等为了能够说明数组的任意片断, 在很多时候就需要非常复杂的描述片断的组成, 这都要求通过显式界面来完成这个描述任务在原则上, 任何数组都可以传递给任何形式的哑元, 对于具有隐式界面的数组来说, 默认情况下是传递给显形数组和哑尺度数组, 而哑形哑元则需要具有显式界面的数组对于任意形式的数组片断来说, 尽管也可是传递给显形数组和哑尺度数组, 但这样一来系统就需要把可能非常零散的数组片断包装成一个完整的数组, 再输入过程, 然后从过程返回的结果又需要拆散为原来的片断形状, 这显然是一个多余而繁重的任务所以自然的解决之道就是运用哑元哑元来引用数组片断, 同时给出显式界面在情形 6 时, 由于实元本身有可能就是一个指针, 那么在引用该实元时, 就会发生究竟是引用该指针还是引用该指针的目标的歧义, 这时就需要知道哑元是否具有 POINTER 属性, 而显式界面即可提供这个信息在隐式界面的情形下, 默认的选择是引用目标数据对象在情形 7 里面的关键词本身为哑元的名称或这些名称的别名, 这些都需要通过显式界面来给出在情形 8 里面的类过程的名称本身意味着多个不同的种过程, 因此在引用时如果使用了类过程名称, 就需要给出额外的信息来决定究竟引用的是那个种过程, 这同样需要通过显式界面来提供信息, 即在显式界面里面给出哑元的属性模式, 例如 TKR 模式, 通过哑元的属性模式的匹配机制来选择恰当的种过程具体的说明参见节对于传统的二元运算的函数符号, 可以使用自定义算符的形式代替, 因此引用这种函数时, 就可以采用引用自定义算符的形式而这种自定义算符常常按照习惯采用一些存在既有定义的算符符号, 以便于阅读, 这样就发生了和类过程类似的情况, 即同一个算符符号可能代表了不同的运算, 这时同样地需要显式界面来给予明确的说明有关自定义算符的具体说明参见节情形 10 实际上仍然还是要解决在引用类名称时如何选择种对象的问题, 只是这里涉及的是不同数据类型之间的区分与转换, 即在把一个数值赋值给某个数据对象之前, 可能需要对该数据值进行类型或种别的转换, 使得自定义赋值能够合法进行有关的说明参见节在情形 11 里面, 逐元过程的引用实际上就是一种类过程引用的形式, 这时需要靠秩的信息来选择恰当匹配的种过程, 因此同样需要通过显式界面来提供这个信息在情形 12 里面, 之所以要求显式界面, 是因为在有可能涉及到并行运算的情况下, 例如 FORALL 结构或语句, 或在一个说明表达式里面, 都要求纯过程, 因此只有通过显式界面来说明所引用的过程为纯过程, 才能保证该引用是有效的

247 界面块所谓界面块是一个在语法上特别标示出来的程序单位, 特别强调了其作为界面的功能, 即当一个程序需要引用过程时, 界面块能够提供所有有关该过程的信息, 从而能够保障引用的正常工作由于界面块的基本功能是面向需要引用过程的程序, 因此它必须放置在该程序的说明部分, 或由该程序使用的模块里面应用界面块的场合基本上是如下 4 类 : 1. 为外部过程和哑过程提供显式界面 ; 2. 为类过程提供完备的信息, 即 : 类过程名称, 共享该名称的所有种过程, 其中所有外部过程的显式界面 ; 3. 定义新的运算符, 或者是对已有的固有运算符或已知算符进行扩展, 然后说明它们所对应的函数, 并且为其中的所有外部函数提供显式界面 ; 4. 定义新的强制转换赋值, 对固有的派生类型赋值进行扩展, 给出相关的子例行程序, 并且为其中的所有外部子例行程序提供显式界面因此界面块除了它的最为基本的为外部过程提供显式界面的功能之外, 其他的三种功能实际上都是要解决在引用一个集合的名称的前提下, 如何通过界面块所给出的信息来决定唯一的集合的某个元素的名称后面的 3 种情形将分别在 ,13.8.4, 节讨论, 下面我们主要说明界面块的一般形式和上面的第一种情形界面块的的语法形式 (R1201) 为 : INTERFACE [generic-specification] [interface-body] [MODULE PROCEDURE procedure-name-list] END INTERFACE 其中类说明 (generic-specification) 的一般形式 (R1207) 为 : generic-name OPERATOR ASSIGNMENT(=) 其中界面体 (interface-body) 给出函数或子例行程序的界面, 语法形式 (R1205) 为 : function-statement [specification-part] END [FUNCTION [function-name]] subroutine-statement [specification-part] END [SUBROUTINE [subroutine-name]] 界面块的一般规则如下 : 如果类说明选项省略, 则 MODULE PROCEDURE 选项也必须省略, 省略类说明的界面块形式只适用于外部过程和哑过程情形

248 在情形 2 是在类说明里面给出类过程名称 ; 在情形 3 是给出 OPERATOR; 在情形 4 是给出 ASSIGNMENT 在所有的情形里面, 界面体都是用于外部过程和哑过程的界面体的说明部分只能包含对于哑元以及函数结果的说明, 不能包含 ENTRY 语句, DATA 语句,FORMAT 语句, 或语句函数语句在界面体的说明部分里面必须给出哑元以及函数结果的属性的完备说明, 即所有在相应的过程定义里面给出的属性说明不过哑元的名称可以改变, 但属性绝对不能改变由于界面体是用来提供定义在外部作用域的过程的信息, 而不是来自界面体自身所在宿主作用域的信息, 因此界面体是一个相对独立的作用域单位, 它不从其宿主通过宿主关联继承任何数据及其属性与规则, 例如命名常量, 隐式类型规则等但是界面体可以包含 USE 语句, 因此可以通过使用关联访问相应的数据对象, 例如派生类型定义等在 MODULE PROCEDURE 语句里面的过程名称是一个模块过程的名称, 该模块过程或者是属于界面块的宿主模块, 或者是可以通过使用关联访问到该模块过程在与该界面块相同的作用域单位里面, 或某个可访问的作用域单位里面, 该名称不能同时以同样的类说明符出现在另外的界面里面界面块不能包含 ENTRY 语句, 但是在界面体里面可以使用作为函数名称或子例行程序名称的登录名称来说明登录界面在一个作用域单位里面, 一个过程只能具有一个显式界面界面块不能出现在数据块程序单位里面在界面体的 END 语句里面, 关键词 FUNCTION 和 SUBROUTINE 都是可选的, 这意味着一个外部程序的说明与 END 语句可以用来构成有效的界面体具有相同的类说明符的两个或多个类界面, 可以在同一个作用域单位里面同时被直接地访问, 或通过宿主关联, 或通过使用关联被访问这时, 它们可以被看成是一个界面块如果过程定义里面出现了 PURE,ELEMENTAL,RECURSIVE 这样的关键词, 那么相应的界面块里面必须给出同样的关键词, 绝对不能省略界面块最基本的应用就是给出外部过程与哑过程的显式界面这时界面块的形式更加简单 : INTERFACE [interface-body] END INTERFACE 在上面的一般规则里面, 需要特别注意如下几点 : 界面块的宿主里面的 IMPLICIT 语句, 类型声明语句, 以及派生类型定义都不影响界面块内部在一个宿主程序单位里面, 一个外部过程的界面体只能出现一次界面体不能用来说明固有过程, 内部过程, 以及模块过程, 因为这些种类的过程本来就具有显式界面类过程的界面之所以提出类过程的概念是因为, 当一个过程的变元采用多种不同的数据类型值时, 变元取一种数据类型值, 就对应着一种种过程, 其变元有可能取多少种类的数据类型模式, 就存在多少个不同的种过程, 而这些种过程尽管表明上是不同的, 但是过程的运算实质是相同的, 并且通过变元的模式匹配, 就足够区分不同的种过程, 因此这些种过程可以拥有相同的作为一个过程种类

249 的名称, 即类过程名称, 而对它们的引用也可以使用同一个类过程名称例如固有过程 LOG, 根据它的变元的不同数据类型, 实际上它包含 3 个种过程 :ALOG, CLOG,DLOG, 它们的变元分别是默认实型, 默认复型和双精度实型要引用该过程, 完全可以只使用它们的类名称 LOG, 在进行数据通讯时, 可以通过变元之间的数据类型匹配而自动选择相应的种过程在引用类过程时, 常常需要定义额外的类过程性质, 这时就需要构造类过程的界面块, 具有这种功能的界面块的形式为 : INTERFACE generic-name [interface-body] [MODULE PROCEDURE procedure-name-list] END INTERFACE 其中的类名称 (generic-name) 就是在该界面块的宿主单位里面引用的类过程的名称这个界面块里面给出了所有共享该类名称的种过程, 其中可能包括外部过程与模块过程这两种类型的过程具有如下的差别 : 对于外部过程来说, 除了给出相应种过程名称之外, 还给出其显式界面 ; 而对于模块过程来说, 只需要给出名称即可, 因为其界面本来就是显式的在一个给定的宿主单位里面, 一个外部过程只能出现在一个类过程集合里面 ; 而由于 MODULE PROCEDURE 语句里面不需要给出显式界面, 所有模块过程可以同时出现在一个宿主单位里面的多个类过程集合里面固然类过程都必须借助界面块而得到引用, 而同时内部过程, 固有过程以及语句函数都不能出现在界面块里面, 那么当类过程名称同时也是某个内部过程, 固有过程或语句函数的名称的时候, 就必须把该名称看成类名称, 或者还可以对过程类进行扩展例 INTERFACE SQRT MODULE PROCEDURE NORMAL_SQRT END INTERFACE 在这个例子里面, 作为类名称的 SQRT 被增加了一个自定义的过程 NORMAL_SQRT 实际上类过程名称是没有任何限制的, 它可以取类过程自身所包含的种过程的名称, 也可以取其他某个类过程的名称, 或完全自定义的命名, 对于类过程引用来说, 正确的引用不在于它的名称本身, 而是必须做到能够通过界面块确切地选择唯一的种过程因此只要能够保证一个过程引用总是能够明确地说明是对某个种过程的引用, 那么在一个作用域单位里面可以同时存在多个类名称, 例如通过 USE 语句来引入多个类过程名称从类过程名称而确定唯一的种过程的基本方法, 就是在变元位置关联或关键词关联方式之下, 运用 TKR 模式进行匹配也只有通过这种方法, 才能做到任何的过程引用都肯定是对唯一的种过程的引用例给定一个 2 变元的子例行程序 SUB(A,B), 设 SUB 是一个类过程名称, 并且它的两个哑元 A,B 都不是可选哑元, 那么实元 X,Y 对 SUB 的引用有如下几种形式 : CALL SUB(X,Y)! 合法的引用 CALL SUB(X,B=Y)! 合法的引用 CALL SUB(B=Y,X)! 不合法的引用

250 CALL SUB(A=X,B=Y)! 合法的引用 CALL SUB(B=Y,A=X)! 合法的引用如果类过程 SUB 包含了一个种过程 ESUB, 那么上面的各种不同引用方式对不同情形下的种过程 ESUB 的影响是不同的 : 第一种引用方式一定排除了对 ESUB 的引用, 如果 ESUB 的两个变元分别与 SUB 的 A 和 B 都具有完全相同的 TKR 模式 ; 第四种和第五种引用方式一定排除了对 ESUB(B,A) 的引用, 如果 ESUB 的第一个变元名称为 B, 并且该变元与 SUB 的变元 B 具有相同的 TKR 模式 ; 同时 ESUB 的第二个变元名称为 A, 并且该变元与 SUB 的变元 A 具有相同的 TKR 模式 ESUB 的其他情形都包含在对 SUB 的引用当中有关引用的 TKR 模式匹配问题的详细说明参见第 15 章自定义算符的界面通过运用界面块可以提供一种直观的引用函数的方式, 其基本的原则与借助界面块来引用类过程一样, 即扩展运算符的含义, 使得算符能够用来表示函数, 这时算符就相当于一个类过程, 可以同时表示多个含义, 再通过界面块所提供的信息, 就可以选择出算符的唯一义项作为实际引用的对象之所以要采用算符的形式来引用函数, 主要的意图是希望 FORTRAN 源码能够具有更加自然的数学形式, 因为按照数学的习惯表示方式, 对 1 个或 2 个算元的计算一般直接采用算符的形式, 而 FORTRAN 的函数也大多是执行计算任务, 因此对于包含 1 个或 2 个变元的函数, 一般倾向于除了直接使用函数的定义名称作为引用名称, 还采用一个算符作为函数的别名加以引用当然这个算符既可以是对固有算符的扩展, 也可以是自定义的算符, 无论何种情形, 都有可能导致同一个算符实际代表了几种函数或运算的含义, 这时就需要使用界面块来获得引用的唯一性无论是扩展既有算符的含义, 还是给出自定义算符, 界面块的形式都是 : INTERFACE OPERATOR(defined-operator) [interface-body] [MODULE PROCEDURE procedure-name-list] END INTERFACE 应用于自定义算符的规则与类过程的规则是一致的不过需要特别注意以下几点 : 每个界面体都是用于一个具有 1 个或 2 个变元的函数, 而在 MODULE PROCEDURE 语句里面的过程名称都是一个具有 1 个或 2 个变元的函数的名称所有的变元都不是可选变元, 并且都具有 INTENT(IN) 属性在 INTERFACE 语句里面给出的算符, 表示了在界面块里面给出的函数的运算引用形式对于 1 个变元的函数就是采用前缀算符的形式 ; 对于 2 个变元的函数就是采用中缀算符的形式函数除了采用算符的形式加以引用之外, 当然还可以采用直接引用函数名称的方式经过定义的算符具有以下 2 种形式之一 : intrinsic-operator. letter [letter].

251 其中在字符串左右两端加句点的形式不能取逻辑值形式, 而如果采用固有算符, 那么就必须遵循该固有算符对于其所作用的算元的数目的约定, 即算符的计算含义可以扩展, 但是作用的算元数目不能变更一个自定义算符界面实际上可以看成是定义了一个类过程, 该算符可以看成是类过程的名称因此一个自定义算符实际上意味着代表了多个函数, 如果把固有算符也理解为某种函数的话显然, 引用一个自定义算符同样面临着如何通过界面块来确定唯一的选择的问题, 解决的方案与类过程相同, 也是利用 TKR 模式的匹配, 甚至更加简单, 因为算符的那种语法形式不允许使用关键词形式来表达变元关联, 而只能使用变元的位置匹配形式通过 TKR 模式来自动地获得算符含义的唯一性基本约定是 : 针对一个算符的扩展只是扩展它的算元的类型与属性范畴, 因此一个算符的具体含义完全通过它所作用的算元的类型属性模式来决定 ; 如果要针对相同的算元对象构造与既有算符具有完全不同的计算含义的算符, 就不能通过对既有算符的扩展来得到, 而需要采用完全新的算符符号, 这时就不存在如何与固有算符区分的问题了例如对于固有算符 +, 可以把它扩展为不同种别参数的整型与实型的加法, 而如果要针对这个不同种别参数的整型与实型定义一个与该既有加法不同的运算, 就不能采用 + 这个算符了下面的两个例子分别表示了这两种情形, 即一种是属于对固有算符进行扩展的自定义运算, 另一种是属于停工一个函数来全新地定义一种新的运算, 具有自身的独特的算符例在这个例子里面对固有算符 + 进行了扩展, 使得 + 能够作用于一个整型数值和一个属于派生类型的区间值, 这种算元模式显然扩展了固有算符 + INTERFACE OPERATOR(+) FUNCTION INTEGER_PLUS_INTERVAL (A, B) USE INTERVAL_ARITHMETIC TYPE (INTERVAL) :: INTEGER_PLUS_INTERVAL INTEGER, INTENT (IN) :: A TYPE (INTERVAL), INTENT (IN) :: B END FUNCTION INTEGER_PLUS_INTERVAL MODULE PROCEDURE RATIONAL_ADD END INTERFACE 例在这个例子里面通过模块过程 VERTEX_VALENCE 定义了一个全新的符.VALENCE., 它不属于任何固有算符的扩展 INTERFACE OPERATOR(.VALENCE.) MODULE PROCEDURE VERTEX_VALENCE END INTERFACE 自定义赋值的界面所谓赋值子例行程序本质上还是一种类过程, 而这里的赋值只是一种采用了赋值语法形式的具有数据类型转换功能的子例行程序, 即它的主要功能就是把数据值从一种 TKR 模式强制转换为另外一种 TKR 模式本来这种功能是需要通过子例行程序来完成的, 但纯粹为了使得 FORTRAN 源码具有更加自然的形式, 就把这种特别的转换子例行程序表述为一种赋值的形式,

252 即等号两边各有一个变元的形式同时, 也可以把这种特定功能的自定义赋值过程看成是一个作用于两个变元的子例行程序, 该子例行程序类似于上节说明的函数, 具有一个唯一形式的算符 =, 即把 = 理解为一种运算, 而形式上它的两边分别出现一个变元因此类似于自定义算符的扩展, 自定义赋值过同样存在一个扩展的问题, 这就使得自定义赋值具有了类过程的属性, 而对自定义赋值的引用同样是通过界面块来给出唯一性信息的用来定义新的赋值运算的界面块采用如下的语法形式 : INTERFACE ASSIGNMENT(=) [interface-body] [MODULE PROCEDURE procedure-name-list] END INTERFACE 这种界面块形式当然满足界面块的一般规则, 此外还必须注意如下的一些特定规则 : 每一个界面体都必须给出一个具有两个变元的外部子例行程序在 MODULE PROCEDURE 语句里面的所有过程都必须是具有两个变元的可访问的模块子例行程序界面块里面的变元都不能是可选的第一个变元必须具有 INTENT(OUT) 属性或 INTENT(INOUT) 属性, 它将出现在赋值语句的等号的左边, 用来表示经过转换而得到的数据值 ; 第二个变元必须具有 INTENT(IN) 属性, 它将出现在赋值语句的等号的右边, 用来表示需要转换的数据值构造了赋值界面之后, 就可以使用赋值语句的形式来表示对界面块里面给出的子例行程序的引用该赋值的形式为 : variable=expression 其中等号左边的变量 (variable) 就是子例行程序引用里面的第一个实元, 而等号右边的表达式 (express ion) 则是子例行程序引用当中的第二个实元, 因此这个赋值语句形式实际上表示了一个子例行程序引用, 当然这种引用方式需要配合该自定义赋值的界面块既然是采用了赋值语句的形式, 那么其中作为实元的变量必须满足赋值语句里面对于等号左边变元的语法要求赋值符号可以理解为一个类子例行程序集合的类名称, 而自定义赋值界面块的功能正是给该类子例行程序集合添加自定义的外部子例行程序或模块子例行程序如果把 = 理解为算符, 那么与自定义算符一样, 自定义赋值的界面块还必须提供保证种子例行程序引用唯一性的信息, 其唯一性的获得同样是依靠 TKR 模式的匹配规则如果在等号两边的变元具有不同的数据类型模式, 那么该赋值等价一定于某个固有转换子例行程序, 因此这种类型的赋值 ( 或者说子例行程序 ) 不能通过使用界面块的形式来给出, 因为会导致无法唯一确定种子例行程序的情况显然 TKR 模式匹配规则保证了这种情况不会出现, 相应的编译系统依据这个规则就能够检查出可能的错误不过在涉及到派生类似数据的转换赋值时, 可以根据具体计算的需要改变固有赋值的常规含义例如对于以分数表示的有理数, 常常在赋值之前需要进行化简, 即约去分子分母的公共因子, 这种添加了化简步骤的赋值就改变了固有赋值的含义例在下面的赋值界面块的里面实际上给出了两个自定义子例行程序 INTERFACE ASSIGNMENT(=)

253 SUBROUTINE ASSIGN_STRING_TO_CHARACTER (CH, ST) USE STRING_DATA CHARACTER (*), INTENT (OUT) :: CH TYPE (STRING), INTENT (IN) :: ST END SUBROUTINE ASSIGN_STRING_TO_CHARACTER MODULE PROCEDURE REAL _TO_ COMPLE END INTERFACE 然后基于这个界面块, 就可以采用赋值形式来引用其中的自定义转换子例行程序 ASSIGN_STRING_TO_ CHARACTER 和 ASSIGN_REAL_TO_COMPLEX, 即 : CH = ST CO = RE 这两个被引用的自定义子例行程序分别表示把字符串变元 ST 转换为字符变元 CH, 把实型变元 RE 转换为复型变元 CO 13.9 过程的性质如果把过程分为外部过程, 内部过程, 固有过程, 模块过程以及语句函数这五种的话, 那么它们的各方面的性质并不是完全一致的下面的表 13-1 为此进行了归纳表 13-2 五种过程的不同性质过程的性质外部过程内部过程固有过程模块过程语句函数哑元是可选的是是是是否可以通过关键词引用是是是是否可以递归引用是是 N/A 是否定义里面可以包含 CONTAINS 语句是否是是否可以传递是否是是否可以出现在界面体是否否否否界面自动为显式的否是是是否可以逐元引用是是是是否可以用于定义运算是否否是否可以作为种过程是否是是否可以包含 ENTRY 语句是否 N/A 是 N/A 注 :N/A 表示该项内容不存在

254 第 14 章固有过程固然, 我们已经能够做到运用 FORTRAN 95 来描述任何的计算任务, 因为 FORTRAN 95 所提供的数据类型, 固有运算, 派生类型, 自定义运算, 以及构造函数与子例行程序的方法, 都足以使得我们应付任何的计算问题不过 FORTRAN 95 标准还提供了大量的科学计算的常规计算与函数, 都可以作为固有过程直接使用, 而不需要我们自己来编写源码这就好像对于一个汽车装配师, 除了给他提供螺栓, 轴承之类的标准零件, 还给他提供更高层次的标准配件, 例如各种型号的发动机, 电机之类因此熟练掌握固有过程, 将给我们带来如虎添翼的感觉 FORTRAN 95 把固有过程作为标准来提出, 就意味着任何的 FORTRAN 95 的编译器实现版本, 都必须能够提供它们 :115 个固有过程, 其中包括 109 个固有函数和 6 个固有子例行程序当然不排除很多的编译器还提供额外的固有过程正是由于固有过程是属于 FORTRAN 95 的标准内容, 因此和固有运算, 例如 +, 一样, 总是随叫随到, 无论在哪个程序单位内部, 只要使用某个固有过程的名称, 就等于调用了该固有过程不过, 如果它的名称被用户定义的函数或子例行程序所侵占, 那么在下面的情况下, 被调用的将是用户自定义的函数或子例行程序而不是固有过程 : 该自定义函数或子例行程序的界面是显式的 ; 该自定义函数或子例行程序出现在 EXTERNAL 语句当中 ; 该自定义函数属于语句函数当然上述的名称被侵权的有效范围只是该自定义函数或子例行程序的作用域相应的, 固有过程也就只能在下面的情形下夺回被侵占的名称 : 不存在使用该名称的语句函数 ; 它的名称出现在 INTRINSIC 语句当中 ; 相应的用户定义的过程的界面是隐式的例如在一个模块或一个内部过程里面, 由于它的界面是显式的, 那么固有过程的名称就能够被侵占, 除非固有过程的名称出现在一个有效的 INTRINSIC 语句当中下面我们主要讨论固有过程的按照功能的分类, 以及每个种类的固有过程所能够完成的计算任务 FORTRAN 95 的固有过程主要分为如下 5 类 : 查询与数字操作函数 ; 转换, 置空以及传递函数 ; 计算函数 ; 数组函数 ; 固有子例行程序在分别讨论上面 5 种固有过程之前, 我们首先讨论 13 章所没有仔细讨论的固有过程的一些特点 14.1 固有过程的分类与性质固有过程可以从形式和功能两个方面来进行分类

255 从形式的角度来看, 固有过程分为如下两类 : 类过程 ; 种过程所谓类过程是一个集合名称, 类过程与种过程是一个集合与其元素的关系一个类过程由两个或多个种过程组成在固有过程中间之所以会出现这种关系, 是因为过程所具体针对的变元的作为数据对象的类型与种别, 是具有不同分类的, 这样就导致同一个函数, 当它的变元取不同类型或种别的数据值时, 就需要对固有过程按照情形进行分类, 甚至采用不同的过程名称, 来应对相应的变元情况例如同样是求一个变量的绝对值, 当该变量分别取实型和复型数值时, 就对应了完全不同的计算过程, 因此有必要给予不同的函数名称, 尽管在数学的意义上, 都是成为取绝对值在所有的 115 个固有过程当中, 除了如下 4 个固有函数外, 其他都是类过程 : LGE; LGT; LLE; LLT 对于每个类过程属下的种过程, 显然都必定具有相应的类型, 种别, 甚至秩的属性许多的种过程具有专门的过程名称, 在下面的表 14-1 当中列出了它们的全部名称以及相应的变元属性这些种过程的名称也可以直接用作过程引用, 但并不提倡这些名称的主要用途是作为实元来传递, 这时就必须使用种过程名称注意, 在表中注明了少数种过程不能作为实元如果从功能的角度来对固有过程分类, 那么除了上面的比较具体的 5 类之外, 还可以从固有过程对数组的作用方式的角度, 把固有过程分为两大类 : 逐元过程和变换过程逐元过程从数学的观点来看, 这种过程的计算对象并不是数组, 但是可以运用一种自然的方式使得这种过程能够作用于数组对象, 并且得到相同形状的数组结果也就是使得该过程分别作用于数组的每个元素, 把所有的过程结果再集合起来作为结果数组固有过程当中的大部分都属于逐元过程, 包括 : 转换函数 ; 计算函数 ( 除了 REPEAT, TRIM,DOT_PRODUCT,MATMUL 之外 ); 子例行程序 MVBITS 其他的所有固有过程就都不是逐元过程了变换过程固有过程里面逐元过程之外的所有过程都称为变换过程, 因为从它们的定义的实质上看, 就是作用于一个数组数据对象, 得到一个标量或者数组结果, 也就是一个变换的过程, 而不是单独地作用于每个元素因此除了函数 NULL 之外, 所有的变换过程或者是具有一个取数组值的哑元, 或者是具有一个取数组值的实元, 它们对数组的作用都是某种整体变换作用例如对于向量的乘积, 就不能逐个元素地进行固有过程的引用正如一般过程的引用一样, 可以使用关键词变元由于某些固有过程的变元是可选项, 因此使用关键词能够省略相应的实元关键词变元也就是固有过程的哑元名称, 在少数情况下, 同一个名称会出现在不同的固有过程, 不过这些名称基本上表示了相似的功能, 因此不会带来什么实质问题这几个名称列举如下 DIM; DIM 主要用于数组简化函数以及其他一些数组函数, 表示在函数的作用对象不是整个数组的

256 情况下, 数组的哪个维度被过程作用 DIM 取值为标量整型值, 并且常常是可选变元 MASK; MASK 总是表示一种过滤器的作用, 即把数组里面与过程作用无关的元素过滤掉, 以免耗费资源 MASK 的是通过一个与被过滤数组相同形状的逻辑型数组来行使过滤功能的一般 MASK 为可选变元 KIND; KI ND 一般用于转换函数, 说明转换结果的种别参数 KIND 实元必须是一个标量整型初始化表达式, 一般是可选的 BACK BACK 作为一个可选的逻辑型变元用来表示逆序过程, 即它所出现的固有过程的对于数据对象的反方向操作例如如果在固有过程 INDEX 当中出现了 BACK=.TRUE., 那么 INDEX 的搜索操作就必须与正常方向相反, 即从字符串的右端开始注意固有函数的非指针哑元都具有 INTENT(IN) 的属性, 而指针哑元则不能改变其关联的实元或目标表 14-1 种过程的过程名称以及相应的变元属性类过程名称种过程名称及其变元种过程变元类型 ABS ABS(A) 默认实型 CABS(A) 默认复型 DABS(A) 双精度实型 IABS(A) 默认整型 ACOS ACOS(X) 默认实型 DACOS(X) 双精度实型 AIMAG AIMAG(Z) 默认复型 AINT AINT(A) 默认实型 DINT(A) 双精度实型 ANINT ANINT(A) 默认实型 DNINT(A) 双精度实型 ASIN ASIN(X) 默认实型 DSIN(X) 双精度实型 ATAN ATAN(A) 默认实型 DTAN(A) 双精度实型 ATAN2 ATAN2(A) 默认实型 DTAN2(A) 双精度实型 CHAR *CHAR(I) 默认整型 COS COS(X) 默认实型 CCOS(X) 默认复型 DCOS(X) 双精度实型 CONJG CONJG(X) 默认复型 COSH COSH(X) 默认实型

257 DCOSH(X) 双精度实型 DIM DIM(X,Y) 默认实型 IDIM(X,Y) 默认整型 DPROD DPROD(X,Y) 默认实型 EXP EXP(X) CEXP(X) DEXP(X) 默认实型默认复型双精度实型 ICHAR *ICHAR(C) 默认字符型 INDEX INDEX(STRING,SUBSTRING) 默认字符型 INT *INT(A) *IFIX(A) *IDINT(A) 默认实型默认实型双精度实型 LEN LEN(STRING) 默认字符型 LGE *LGE(STRING_A,STRING_B) 默认字符型 LGT *LGT(STRING_A,STRING_B) 默认字符型 LLE *LLE(STRING_A,STRING_B) 默认字符型 LLT *LLT(STRING_A,STRING_B) 默认字符型 LOG LOG10 MAX 注 1 ALOG(X) CLOG(X) DLOG(X) ALOG10(X) DLOG10(X) *MAX0(A1,A2,A3, ) *AMAX1(A1,A2,A3, ) *DMAX1(A1,A2,A3, ) *MAX1(A1,A2,A3, ) 注 2 *AMAX0(A1,A2,A3, ) 默认实型默认复型双精度实型默认实型双精度实型默认整型默认实型双精度实型默认实型默认整型 MIN *MIN0(A1,A2,A3, ) 默认整型 *AMIN1(A1,A2,A3, ) 默认实型注 1 *DMIN1(A1,A2,A3, ) *MIN1(A1,A2,A3, ) 双精度实型默认实型注 2 *AMIN0(A1,A2,A3, ) 默认整型 MOD NINT REAL MOD(A,P) AMOD(A,P) DMOD(A,P) NINT(A) IDNINT(A) *REAL(A) *FLOAT(A) *SNGL(A) 默认整型默认实型双精度实型默认实型双精度实型默认整型默认整型双精度实型 SIGN SIGN(A,B) 默认实型

258 DSIGN(A,B) ISIGN(A,B) 双精度实型默认整型 SIN SIN(X) 默认实型 CSIN(X) 默认复型 DSIN(X) 双精度实型 SINH SINH(X) 默认实型 DSINH(X) 双精度实型 SQRT SQRT(X) 默认实型 CSQRT(X) SDQRT(X) 默认复型双精度实型 TAN TAN(X) DTAN(X) 默认实型双精度实型 TANH TANH(X) 默认实型 DTANH(X) 双精度实型注 1: 该函数没有相应的类过程名称, 它的结果为默认整型注 2: 该函数没有相应的类过程名称, 它的结果为默认实型注 3: 标注星号 * 的函数不能用作实元注 4 : 某些种过程名称与其类过程名称一样 14.2 数据的表示模式一些固有函数的计算结果是与数据的表示模式有关的, 因此在这里我们首先给出数据的 3 种表示模式一个数据值的表示模式, 决定了它的存储空间以及表示精度, 包括如下 3 种模式 : 位模式 ; 整数模式 ; 实数模式有关数值的表示模式的信息对于很多的计算都是非常重要的, 因为计算机的数据表示的离散性本质, 使得我们不能期望很多的数学计算能够在计算机上面具有通常的行为, 例如级数的收敛问题涉及到几乎所有的微积分数值计算, 由于实数在计算机里面并不是可以无限位地表示, 所以必须知道某个具体的系统所能够达到的精度, 才能够判断相应的计算能够做到什么程度所谓位模式就是把一个整型标量非负的数据对象 B 表示为一个 2 进制的数字序列 : bbb... b n 1, 其中的每个数字取 0 或 1 把这样一个数字序列转换为 10 进制数值, 采用如下的公式 : n 1 B= b k 2 所谓整数模式的数值表示形式是一个任意进制的数字序列, 但可以具有正负号, 不能带有小数点, 转换为 19 进制的公式为 : k k= 0

259 n 1 I = s b r k= 0 k k 其中 : s 为 +1 或 -1; r 为大于 1 的整数 ; bk 0 b 为整数并且 k < r 所谓实数模式采用如下的公式 : n e k R= sr bk r k= 1 其中 : s 为 +1 或 -1; r 为大于 1 的整数 ; n 为尾数部分数字的数目, 是一个大于 1 的整数 ;, bk 0 b 为整数并且 k < r ; e 是某个最大值与最小值之间的整数, 表示某种实现所能够表示的数值范围实数的一般实现方式是按照 IEEE 2 进制浮点标准, 在单精度模式时, 取 : r=2 n= e 128 这样一个实数的尾数部分包括符号一起就占据了 24 位, 而它的指数部分包括符号一起占据了 8 位, 因此一个单精度实数表示要占据 32 位注意 e 不能取 -126,-127,-128 这些数值, 因为还需要额外地表示溢出,0, 以及 NaNs, 即非法值 14.3 查询函数和数字操作函数本节所讨论的函数并不是一般概念下对变元进行某种计算的函数, 它的返回值是用来反映有关变元的状态与性质的各种信息所谓查询函数返回的是有关变元的数据类型的信息, 因此返回值与变元的具体取值无关, 而引用这种函数的实元也不需要预先定义所谓数字操作函数返回的是与实元取值相关的数值环境信息, 因此引用这种函数的实元就需要给出定义根据所查询信息的不同种类, 查询函数还可以分为 7 类, 分别说明如下字符查询函数这类函数只包含一个固有函数 LEN 它返回作为字符串的变元的字符长度值该长度值是在变元数据类型声明里面给出的, 因此变元不需要给出具体的取值, 就能够使用该查询函数

260 对于哑长度的哑元,LEN 返回的是其实元的长度值位查询函数这类函数只包含一个固有函数 BIT_SIZE 如果一个整型标量数据对象采用了位模式的表示模式, 那么使用该函数, 就能够返回其变元的位模式表示公式里面的 n 的值其变元只需要是一个整数即可, 不需要给出定义种别查询函数这类函数包含 3 个固有函数 KIND,SELECTED_INT_KIND, 和 SELECTED_REAL_KIND 这 3 个固有函数都返回变元的种别参数, 而变元的具体取值都不需要预先给出但它们的变元的取值范围是不同的 KIND 的变元可以是任意的固有数据类型 ; SELECTED_INT_KIND 的变元是整型变量, 它返回的是表示 10 进制幂次范围的种别参数 ; SELECTED_REAL_KIND 的变元是实型变量, 它返回的是表示 10 进制精度与 10 进制幂次范围的种别参数数组查询函数这类函数包含 5 个固有函数, 它们返回的都是变元数组的各种属性参数它们的名称以及返回值列举在下表 14-2 表 14-2 数组查询函数的名称以及返回值函数名称 ALLOCATED LBOUND SHAPE SIZE UBOUND 返回值变元数组的分配状态一个数组或数组的一个维度的下界数组在每个维度上的元素的数目数组的尺度, 即其全部元素的数目一个数组或数组的一个维度的上界这 5 个函数的变元的取值都不需要给出, 但如果在 SIZE,LBOUND,UBOUND 这些函数里面使用可选变元 DIM, 则 DIM 的值需要预先定义指针关联状态查询函数这类函数只包含一个固有函数 ASSOCIATED, 该函数的返回值为逻辑型值, 根据该函数所带有的可选变元的不同情况, 其返回值也分为以下 3 种情况 : 如果不出现可选变元, 那么当变元具有指针属性, 并且关联到一个目标时, 返回值为真如果出现非指针的可选变元, 那么当变元具有指针属性, 并且关联到该可选变元时, 返回值为真如果出现可选变元, 并且该可选变元也是指针, 那么当变元具有指针属性, 并且与可选变元都关联到同一个目标时, 返回值为真变元存在查询函数这类函数只包含一个固有函数 PRESENT 它的变元必须是一个可选哑元的名称函数的返回值为逻辑型值当作为变元的哑元具有相应的实元时, 函数返回值为真, 否则为假数值模式查询函数这类函数包含 9 个固有函数, 它们返回的都是变元在整数模式和实数模式表示下的各种参数它们的名称以及返回值列举在下表 14-3 表 14-3 数值模式查询函数的名称以及返回值函数名称返回值

261 DIGITS EPSILON HUGE 整数模式和实数模式公式里面的 n 值实变元的 1 n r 的值按照整数模式和实数模式所能够表示的最大数值 MINEXPONENT MAXEXPONENT 实变元所能够取得的最小的 e 值实变元所能够取得的最大的 e 值 PRECISION 实数或复数的 10 进制精度 RADIX 整数模式和实数模式公式里面的基数值 RANGE 整数, 实数或复数的 10 进制幂次范围 TINY 注意 : 这些函数的变元都不需要预先定义实变元所能够取得的最小的正数值它们都是类过程, 因为它们都能够用于任意类型的实变元除了 EPSILON,MINEXPONE NT,MAXEXPONENT 这 3 个函数之外, 它们都能够用于任意类型的整型变元与数值模式查询函数类似, 数字操作函数同样是基于数值的表示模式得到返回值的, 但是它们最大的差别在于, 数值模式查询函数所作用的变元代表了整个数值类型, 返回的是有关整个数值类型的表示模式参数, 而数字操作函数所作用的变元只是在某种特定表示模式下的单个的具体的数值, 因此它的变元需要在函数引用之前予以定义数字操作函数包括 7 种, 它们的名称以及返回值列举在下表 14-4 函数名称 EXPONENT FRACTION NEAREST RRSPACING SCAL E SET_EXPONENT SPACING 表 14-4 数字操作函数的名称以及返回值返回值实数值的实数模式表示公式里面的 e 值实数值的小数部分系统所能够表示的在给定方向上最接近第一个变元的数值变元附近的最小间距的倒数用给定的值替换 e 值把 e 值设置为给定的值变元附近的最小绝对间距这 7 个函数只能应用于实数环境, 变元可以是任意类型的实数值, 而且都是逐元函数 14.4 转换函数, 置空函数 NULL 以及传递函数 1. 转换函数所谓转换函数就是能够把某种数据对象的类型与种别的某种组合转换为另外一种类型与种别的组合所有这些函数都是类函数, 因为它们需要处理可能的各种类型与种别的组合, 同时, 它们也都是逐元的

262 转换函数包括 15 个固有函数, 它们的名称以及返回值列举在下表 14-5 表 14-5 转换函数的名称以及返回值函数名称返回值 ACHAR AIMAG AINT A NINT C HAR C MPLX C ONJG D BLE IACHAR IBI TS ICHAR INT LOGICAL NINT REAL 在 ASCII 字符集的指定位置的字符复数的虚部把一个实数截断为实型整数把一个实数截断为最接近的实型整数在系统字符集的指定位置的字符与变元相应的复数值复数变元的共轭复数与变元相应的双精度值指定字符在 ASCII 字符集里面的位置以位表示的整型变元的指定子串指定字符在系统字符集里面的位置变元被截断得到的整型值与变元相应的逻辑型值把一个实数截断为最接近的整型值与变元相应的实型值 2. 置空函数 NULL 固有函数 NULL 返回一个能够赋值给指针变量的去关联的指针尽管它的功能与 NULLIFY 语句的功能一样, 但是它们的应用场合不同 : NULL 函数应用于说明语句当中, 以便对指针变量进行初始化, 还可以在派生类型定义当中定义其指针成员的默认初始化 ; NULLIF Y 语句作为可执行语句应用于程序当中固有函数 NULL 为变换函数而不是逐元函数 3. 传递函数 TRANSFER 固有函数 TRANSFER 能够在数据的不同类型与种别组合模式之间进行纯粹二进制数据传递, 而不需要进行烦琐的类型与种别组合模式的转换当一个固有函数 TRANSFER 作用于一个源数据时, 它的二进制表示形式, 也就是它的物理存储模式被传递为函数结果, 而函数结果的类型与种别组合模式则由函数的 MOLD 变元决定这样在传递过程当中就根本不需要进行类型与种别组合模式的转换 TRANSFER 为变换函数, 而不是逐元函数, 它的值常常是不具有可移植性的 14.5 计算函数所谓计算函数都是针对变元的计算, 包括 47 个固有函数, 分为如下三类 : 数值计算函数 ; 除了计算机所特有的数据类型以及精度限制之外, 数值计算函数可以理解为就是相应的数学计算函数, 数值计算函数表示了几乎所有最常用的基本数学函数

263 字符计算函数 ; 字符计算函数的主要功能就是对字符串进行编辑位计算函数位计算函数基于数据的位模式表示进行操作与计算这 3 类固有函数的名称以及返回值分别列举在下面的表 14-6, 表 14-7, 和表 14-8 里面 ABS ACOS ASIN ATAN ATAN2 CEILING COS COSH 函数名称表 14-6 数值计算函数的名称以及返回值变元的绝对值变元的反余弦值变元的反正弦值变元的反正切值返回值复数变元 (X,Y) 的幅角弧度值大于或等于变元值的最小整数值变元的余弦值变元的双曲余弦值 DIM 如果 2 个变元的差为正数, 则返回差值, 否则返回 0 DOT_PRODUCT DPROD EXP FLOOR LOG LOG10 MATMUL MAX MIN MOD MODULO SIGN SIN SINH SQRT TAN TANH 2 个秩为 1 的数组的点积 2 个单精度数值的双精度乘积自然指数函数小于或等于变元值的最大整数值自然对数函数以 10 为底的对数函数矩阵乘积一个值集合里面的最大值一个值集合里面的最小值求余函数, 其符号与第一个变元的符号一致求余函数, 其符号与第二个变元的符号一致赋予给定值给定的符号变元的正弦值变元的双曲正弦值变元的平方根变元的正切值变元的双曲正切值表 14-7 字符计算函数的名称以及返回值函数名称 A DJUSTL ADJUSTR INDEX 返回值把字符串左边的空格移到它的右边把字符串右边的空格移到它的左边一个子串在给定字符串里面的位置

264 LEN_TRIM 删除尾部空格后的字符串长度 LGE 基于 ASCII 序列的大于或等于的比较 LGT 基于 ASCII 序列的大于的比较 LLE LLT REPEAT SCAN TRIM VERIFY 基于 ASCII 序列的小于或等于的比较基于 ASCII 序列的小于的比较重复连接字符串扫描一个字符串以获得给定字符串在其中的位置删除尾部空格后得到的字符串给出不属于指定字符集里面的字符在字符串里面出现的位置表 14-8 位计算函数的名称以及返回值函数名称返回值 BTEST 整型变元在指定的位上面的值 IAND 2 个整型变元的逻辑 AND 运算的结果 IBCLR 把一个整型变元的指定的位上的值清 0 IBSET 把一个整型变元的指定的位上的值设置为 1 IEOR 2 个整型变元的逻辑排除 OR 运算的结果 IOR 2 个整型变元的逻辑包含 OR 运算的结果 ISHFT 对变元进行逻辑移位 ISHFTC 对变元进行逻辑循环移位 NOT 变元的逻辑补注意 : 计算函数当中除了 LGE,LGT,LLE,LLT 之外都是类过程计算函数当中除了 DOT_PRODUCT,MATMUL,REPEAT 之外都是逐元过程位计算函数的结果不可移植 14.6 数组函数数组函数包括 17 个固有函数, 根据它们的功能可以分为 5 类如下 : 数组简化函数 ; 数组构造函数 ; 数组重组函数 ; 数组操作函数 ; 数组定位函数这 5 类函数的名称以及它们的返回值分别列举如下 1. 数组简化函数所谓数组简化函数, 从形式上都是把一个数组经过计算之后得到一个标量, 或者是得到一个秩为 1 的数组, 它们的的名称以及返回值见表 14-9

265 表 14-9 数组简化函数的名称以及返回值函数名称 ALL ANY COUNT MAXVAL MINVAL PRODUCT SUM 返回值如果变元数组的所有元素都是真则取真值如果变元数组的元素当中存在一个真值则取真值变元数组的元素当中取真值的元素的数目变元数组的元素当中的最大值变元数组的元素当中的最小值变元数组的元素的乘积变元数组的元素的和 2. 数组构造函数所谓数组构造函数都是从变元数组的元素出发得到一个新的数组, 它们的的名称以及返回值见表表数组构造函数的名称以及返回值函数名称 MERGE PACK SPREAD UNPACK 返回值在过滤器的控制下组合 2 个合适的数组把一个过滤了的数组封装为一个向量通过复制某个维度而得到增加维度的数组从一个向量还原为一个过滤了的数组 3. 数组重组函数数组重组函数只包含一个固有函数 RESHAPE, 它的功能是把一个秩为 1 的数组的元素重组为一个给定形状的数组 4. 数组操作函数数组操作函数对变元数组的元素进行重新排列, 它们的的名称以及返回值见表表数组操作函数的名称以及返回值函数名称 CSHIFT EOSHIFT TRANSPOSE 数组元素的循环移位数组元素的移位变元数组的矩阵转置返回值 5. 数组定位函数数组定位函数给出数组元素里面的最大值或最小值在数组当中, 或在数组的某个维度当中的位置, 它们的的名称以及返回值见表表数组定位函数的名称以及返回值 MAXLOC 函数名称包含最大元素的秩为 1 的数组返回值

266 MINLOC 包含最小元素的秩为 1 的数组 14.7 固有子例行程序固有子例行程序都只能通过 CALL 语句来引用, 而不能作为实元传递, 因为它们都没有特定名称固有子例行程序一共有 6 个, 分别说明如下 : CPU_TIME 该固有子例行程序返回以秒为单位的处理器时间, 它不包含具有 INTENT(OUT) 属性的变元 DATE_AND_TIME 该固有子例行程序返回日期与时间信息作为一些具有 INTENT(OUT) 属性的变元的值 MVBITS 该固有子例行程序把一个二进制码序列从一个整型数据对象复制到另一个整型数据对象该固有子例行程序是唯一的逐元固有子例行程序 RANDOM_NUMBER 该固有子例行程序返回一个伪随机数值或伪随机数组作为变元的取值表面看来它应该可以作为一个函数, 但是实际上它具有后效, 即它每产生一个伪随机数结果, 都会影响它底下的伪随机数生成器的变量的取值, 因此它不是纯过程, 而固有函数必须是纯过程 RANDOM_SEED 该固有子例行程序同样返回一个伪随机数值或伪随机数组作为变元的取值但它还允许对它底下的伪随机数生成器的变量进行特定的初始化或恢复原来的取值 SYSTEM_CLOCK 该固有子例行程序以整数形式返回处理器时钟信息, 可以有几种格式, 并且可以作为具有 INTENT(OUT) 属性的变元的值第 15 章通讯计算的过程除了指令的序列之外, 还有一个极端重要的部分, 就是通讯试想一下人工的计算过程, 几乎每做一个计算步骤, 都有可能需要引用很多东西, 例如其他计算的结果, 问题的初始值, 其他的现成公式, 或已经推导出来的公式, 或者引用别人的计算成果等等, 这种引用在本质上就是通讯, 即一个相对独立的计算步骤, 或计算过程, 都不可能是真正独立的, 它总是需要得到来自外部的信息, 无论是外部的数据, 还是外部的计算, 只要是叫得出名字的东西, 都有可能被用到而该计算步骤或计算过程本身, 不也是有可能被别的计算所使用吗! 当然这一切都是通过草稿纸, 通过我们的记忆, 通过论文来进行的这就是计算当中的通讯, 通过所有这些通讯才能使得计算成为一个整体, 才能使得计算真正是面向了本来是一个整体的真实世界的问题相应的, 当我们使用 FORT RAN 语言来描述计算任务的时候, 它同样需要描述其中的通讯过

267 程, 而且还得是严格地把一切通讯过程都毫无遗漏地描述出来同样地, 一个 FORTRAN 程序正是通过这些通讯而把所有程序单位, 乃至所有的语句或指令单位, 都连接起来, 才能构成一个能够解决问题的计算过程那么这种通讯利用 FORTRAN 语言是如何进行的呢? 还是让我们回到人工计算的过程, 因为本质上, 一个 FORTRAN 计算程序描述的就是一个人工计算过程首先我们需要对想使用的对象命名, 才能称呼它们, 然后才谈得上进行引用然而我们不能够指望给世界上的每一个具体对象都给予一个唯一的名称, 那么做既不现实, 也忽略了事物之间所具有的紧密联系因此在同一个名称可以称呼不同的对象的情况下, 我们需要一个约定, 就是一个名称必定跟随有关该名称的有效范围的说明在给所有的对象起了合适的名称之后, 就需要考虑建立在不同的场合里面出现的对象之间的联系, 例如在波函数里面出现的正弦函数与在交流电电流公式里面出现的正弦函数, 因为它们的名称一样, 就可以认为是同一个函数而波函数里面的振幅和交流电电流公式里面的振幅, 尽管名称一样, 却不能够应用于同样的公式, 例如波函数里面的振幅可以引用到几率幅公式里面, 而几率幅公式对于交流电却没有任何意义所以建立合适的, 明确的关联是第 3 个重要的任务最后, 我们可能还得检验某个对象是否具备进行通讯的资格, 例如在有关交流电的计算任务当中, 如果不小心引用了几率幅的概念, 显然它没有任何用处, 只会捣乱, 因此检验一个对象是否具备良好的定义, 是我们在进行计算通讯的同时不可遗忘的任务好了, 上面分析出来的 4 个概念 : 命名, 名称的有效范围, 关联, 良好的定义, 构成了 FORTRAN 语言描述通讯时最核心的概念运用 FORTRAN 语言来表达相应的意思就是 : 名称 ; 作用域 ; 关联 ; 定义状态即任何的 FORTRAN 程序里面的对象都需要给予一个名称, 而所有的名称都能够按照变量与值的关系, 建立相对的层级结构作用域就是一个 FORTRAN 程序对象能够被识别, 被访问的程序单位的范围关联就是在相同名称或不同名称下, 进行相应的值的交换定义状态就是必须能够随时确定一个变量是否具有良好的定义, 从而能够判别基于该变量的通讯是否有效可以形象地说, 这 4 个概念完备地描述了程序的数据流的一言一行, 一动一止下面我们就分别说明通讯的这 4 个核心概念 15.1 通讯与名称给对象命名是进行有关对象的通讯的前提 ( 试想一下我们要告诉别人起火了, 如果我们不知道描述火的词汇, 那该如何说清楚意思呢?) 为了保证通讯时不发生歧义, 最极端的做法就是给世界上的每一个对象给予一个唯一的名称然而这是不可能实现的, 因为世界是无限大的不过即使在有限的范围内, 也是非常不明智的例如在 FORTRAN 语言里面已经预先定义了名称 SUM 的涵义, 即用名称 SUM 来命名一个

268 固有函数, 表示一种作用于数组的运算然而如果在一个程序里面, 并没有涉及到任何与数组有关的计算, 那么我们完全可以安全地使用名称 SUM 来形象地命名一个自定义的运算, 例如两个属于派生类型的对象的组合运用容易记忆的英语词汇或缩写来表示具有相应涵义的对象, 这是一种良好的编程习惯, 不能为了避免名称的重复而被迫记忆大量的名称又例如一个大型的 FORTRAN 程序, 事实上是无法由一个人编写完成的, 那么如果由多个人分块编写的话, 又如何能够保证他们使用的名称是绝对一致的呢? 即相同的对象具有相同的名称, 不同的对象具有不同的名称这对于每个小程序单位都有成千上万个语句的大型程序, 是绝对不现实的要求, 也是完全不必要的要求因为不同对象的重名问题, 可以很轻易地通过约定名称的有效范围而获得解决, 这就是下节讨论的作用域的概念 15.2 作用域任何具有名称的对象都具有相应的作用域, 也就是存在一个明确的约定, 该名称在 FORTRAN 程序的哪个范围内, 是被识别为该对象, 而且引用该名称就意味着访问该对象在一个 FORTRAN 程序里面明显具有名称的对象包括变量, 常量, 过程, 数据块子程序, 模块, 名称列表集合等它们都具有相应的作用域还有其他的对象, 例如算符, 赋值符号, 标签, 输入输出单位编目等, 它们都已经不再需要额外的名称, 因为这些对象在被定义出来时, 就已经具有天然的名称, 因此它们也具有相应的作用域对象的作用域可以大到包括整个程序, 也可以小到只有一个语句的某个部分当一个对象的作用域为整个程序时, 该对象就称为全局对象例如一个程序里面的外部过程, 在程序的任意位置, 都可以随时引用它的名称, 而不会发生无法访问该外部过程的情形当一个对象的作用域还没有达到整个程序时, 该对象就称为局部对象例如语句标签, 一般只在该语句所处的程序单位里面有效当一个对象的作用域只是该对象所处的语句, 甚至只是语句的一个部分时, 该对象就称为语句对象例如语句函数的哑元就是典型的语句对象一般说来, 如果一个对象的作用域恰好构成一个程序单位, 那么相应的作用域也称为作用域单位, 这样一来, 许多更小型的作用域, 例如语句函数,FORALL 结构, 隐式 DO 语句等, 就不能称为作用域单位了作用域单位一般有如下三种情形 : 派生类型定义是一个作用域单位 ; 一个过程界面体, 在排除其中可能的派生类型定义, 以及包含在派生类型定义里面的过程界面体之后, 构成一个作用域单位 ; 一个程序单位, 或者子程序, 在排除其中可能的派生类型定义, 过程界面体以及包含在其中的子程序之后, 构成一个作用域单位在一个作用域单位里面还可以包含其他的作用域单位, 不过这种包含关系不完全与结构之间的嵌套关系相同因为具有包含与被包含关系的两个作用域单位可以出现如下两种情形 : 被包含的作用域单位, 可以继承包含它的作用域单位的数据环境 ; 例如派生类型定义, 模块过程, 内部过程等都继承包含自身的作用域单位的隐式类型规则被包含的作用域单位不继承包含它的作用域单位的数据环境

269 例如界面块不继承包含自身的作用域单位的隐式类型规则因此在某些情形下, 一个作用域需要排除包含其中的作用域单位之后才构成一个作用域单位作用域与作用域单位的相互关系参见示意图 15-1 里面的表示图 15-1 作用域与作用域单位的相互关系在上面的示意图 15-1 当中, 最大的方框表示一个 FORTRAN 程序, 它表示了一个整体, 显然它不构成一个作用域单位然后是其中的 4 个方框, 分别表示 1 个主程序,2 个外部过程 A 和 D,1 个模块 E 它们都是作用域单位, 但是得排除它们内部出现的方框, 即内部过程 B 和 C, 界面块, 派生类型定义, 以及模块过程 F 和 G 因为它们同样是作用域单位由于在上面的 FORTRAN 程序例子当中, 内部过程 B 和 C, 界面块, 派生类型定义, 以及模块过程 F 和 G 的内部不再出现内部过程, 界面块, 派生类型定义, 以及模块过程, 所以它们都不再需要排除什么, 就构成一个作用域单位不过一般在它们内部还包含其他的作用域单位是非常常见的名称的作用域一个名称的作用域存在如下 4 种情形 : 整个程序, 即该名称为全局性的 ; 一个作用域单位, 即该名称为局部性的 ; 一个结构, 即一个 FORTRAN 结构的作用域 ; 一个语句, 即一个 FORTRAN 语句或语句的某个部分作为作用域

270 下面按照范围从大到小的顺序分别予以说明 1. 全局情形能够具有全局性名称的对象包括 : 主程序 ; 外部过程 ; 模块 ; 数据块程序单位 ; 公用块正是因为这些对象的名称具有全局性, 因此它们在一个 FORTRAN 程序内部不能使用相同的名称 2. 局部情形能够具有局部性名称的对象包括如下 3 个类别 : 变量, 常量, 控制结构, 语句函数, 内部过程, 模块过程, 哑过程, 固有过程, 自定义类过程, 派生类型和名称列表集合派生类型的成员之所以把派生类型的名称与它的成员的名称分为不同的类别, 是因为不同名称的派生类型, 完全可以具有相同名称的成员变元关键词之所以把具有显式界面的过程的名称与其变元关键词的名称分为不同的类别, 是因为不同名称的过程, 完全可以具有相同名称的变元关键词局部性名称的作用域的一般规则如下 : 在一个作用域单位里面可以访问的全局性对象的名称, 不能用来作为一个该作用域内部的局部性对象的名称, 除非该局部性对象和一个公用块同名一个非类型的局部性对象的名称, 在它的作用域单位里面, 以及它的同一个名称类别里面, 必须是唯一的, 只有在不同的作用域单位, 或者不同的名称类别里面, 才可以把该名称用于另外一个不同的对象在其他作用域单位里面的对象, 不管其使用的名称是否与此作用域单位里面的对象所使用的名称相同, 都有可能通过关联, 而导致实际上是同一个对象一个类型的局部性名称, 可以用于同一个作用域单位里面的不同过程在一个作用域单位里面的同一个名称可以用来表示不同名称类别里面的对象例如一个变元关键词可以和一个逻辑型变量具有相同的名称派生类型的成员的作用域就是该类型定义, 当该成员被用于结构引用时, 它的作用域就是该结构引用变元关键词属于一个单独的名称类别, 因此一个变元关键词的名称可以在同一个作用域单位里面, 用作其他类别对象的名称, 例如其他过程的变元关键词, 过程, 或变量的名称如果在程序当中出现了一个公用块与一个局部性对象的名称的雷同, 那么该名称只有在表示公用块时, 才是全局性的在引用该名称时, 它所指称的对象的唯一性由该名称的上下文保证一个固有过程的名称可以在不出现该固有过程的作用域单位里面用作局部性名称也就是说一旦某个固有过程的名称在某个作用域单位里面被用来作为一个局部性名称, 比方说一个变量的名称, 那么在整个该作用域单位里面, 该固有过程本身都不能出现了对于每个函数以及不具有结果变量的函数对象, 在它的子程序作用域单位里面, 都默认

271 存在一个与该函数或函数对象同名的一个局部变量, 该局部变量用来在本作用域单位里面定义该函数或函数对象的结果值对于每个内部过程或模块过程, 它的名称对于它的宿主作用域单位而言都是局部的类似地, 对于模块过程内部的任意对象名称, 对于它的宿主作用域单位而言, 也都是局部的 3. 结构的情形在 FORTRAN 里面, 可以用作作用域的结构只有 FORALL 结构在 FORALL 语句或结构里面的指标变量的名称具有的作用域为该 FORALL 语句或结构的赋值语句的作用域该指标变量的名称在其他地方都是用作标量变量名称, 而在作用域单位的任何位置它都是整型变量 FORALL 语句或结构里面的指标变量是具有一个大于一个语句同时又小于一个作用域单位的作用域的唯一的例子 4. 语句的情形一个名称的作用域只限于一个语句或语句的一个部分的情形有以下两种 : 一个语句函数的哑元的名称 ; 在一个 DATA 语句里面的隐式 D O 列表或一个数组构造器里面的 DO 变量名称这些名称都可以在该语句的作用域单位的其他地方用作标量变量名称或公用块名称, 而不至于出现任何的名称冲突语句里面的名称的一般规则如下 : 一个语句函数的哑元的名称的作用域就是该语句, 它的类型与种别参数都在该语句所在的作用域单位里面得到声明在一个 DATA 语句里面的隐式 DO 循环或一个数组构造器里面的 DO 变量名称的作用域就是该 DO 变量所在的语句部分该 DO 变量的类型必须是整型, 而它的种别参数则由它所在的作用域单位声明在隐式 DO 列表里面的 DO 变量的作用域只是它所在语句的一部分, 而在一个 DO 结构里面的 DO 变量的作用域则是该结构所在的作用域单位这两种是完全不同的在输入输出项列表当中的隐式 DO 里面的 DO 变量的作用域, 为该输入输出语句所在的程序单位标签的作用域标签总是局部性的也就是说在一个作用域单位里面一个标签总是指称同一个语句, 而在不同的作用域单位里面, 可以同时使用同一个标签来指称不同的语句输入输出单位的作用域外部输入输出单位的编目总是全局性的也就是说, 在一个 FORTRAN 程序里面, 无论一个输入输出单位的编目出现在什么位置, 它都指称同一个输入输出单位

272 算符的作用域算符分为固有算符和自定义算符两种固有算符是全局性的 ; 而自定义算符是局部性的一个固有算符的符号也可以用作自定义算符的符号 ; 而且算符还可以具有类的属性, 即同一个算符可以用来指称几个运算符号, 它们具有不同的涵义而程序是通过相应算元的类型, 种别参数以及秩来获得对它们的辨别的赋值的作用域赋值分为固有赋值和自定义赋值两种固有赋值是全局性的 ; 而自定义赋值是局部性的赋值符号 (=) 总是全局性的, 同时也可以具有局部性的定义 ; 而且赋值还可以具有类的属性, 即不同的赋值运算可以使用同一个赋值运算符号来指称, 它们具有不同的涵义而程序是通过赋值符号 = 左右两边的对象的类型, 种别参数以及秩来获得对它们具体涵义的辨别的非歧义过程引用的作用域所谓非歧义的过程引用, 是指引用的过程名称在相应的作用域单位里面, 是一个种过程名称, 它与该作用域单位里面的任何类过程名称都不相同非歧义的过程引用包括如下的情形 : 引用内部过程 ; 引用哑过程 ; 引用语句函数 ; 引用属于固有过程的与类过程不重名的种过程名称 ; 引用模块过程或外部过程, 它不能够出现在具有所在作用域单位的类声明的界面块里面, 或者是可以通过使用关联或宿主关联来访问的只有属于外部过程的种过程名称是全局性的, 所有其他的种过程名称都是局部性的在满足以下条件的情形下, 涉及到类过程名称的过程引用也可以是非歧义的即如果任意两个过程具有同一个类过程名称, 那么在它们的哑元列表当中, 至少得有一个非可选的哑元同时满足下面两个条件 : 或者是在另外的哑元列表里面与该哑元所处列表位置相同的位置不存在相应哑元, 或者是与相应哑元具有不同的类型, 种别以及秩的不同组合模式或者是该哑元具有与另外那个哑元列表里面的所有哑元都不同的名称, 或者是即使存在同名的哑元, 也与同名哑元具有不同的类型, 种别以及秩的组合模式一个非逐元的种过程有可能引用一个类过程作为它的哑元, 同时一个与类过程重名的逐元过程也引用类过程作为它的变元, 在这种情况下, 该非逐元种过程就用于解决类过程引用所带来的名称歧义问题不管类名称是固有的, 还是由具有类说明的界面块所定义的, 上面的规则都是适用的而且它们还适用于算符类的名称以及赋值符号类对于固有函数来说, 固有函数的类名称是全局性的, 而自定义的类名称为局部性的

273 歧义过程引用的名称处理方法在 FORTRAN 程序里面, 一个过程引用发生在如下几种情形里面 : 情形 1. 运行一个 CALL 语句时 ; 情形 2. 运行一个经过定义的赋值语句时 ; 情形 3. 运行一个经过定义的运算时 ; 情形 4. 运行一个包含函数引用的表达式时在情形 2 里面, 涉及到了作为类名称的赋值符号 (=), 这时在相应作用域单位里面必定存在一个具有 ASSIGNMENT 类说明的界面块, 或者是通过使用关联或宿主关联可以访问定义了该赋值的外部子例行程序或模块子例行程序, 在这种情况下, 就必须运用节, 节以及节的相应规则来决定究竟引用哪个种子例行程序在情形 3 里面, 涉及到了作为类名称的运算符号, 这时在相应作用域单位里面必定存在一个具有 OPERATOR 类说明的界面块, 或者是通过使用关联或宿主关联可以访问定义了该运算的函数或模块函数, 在这种情况下, 就必须运用节, 节以及节的相应规则来决定究竟引用哪个种函数在情形 4 里面, 如果表达式的某个项的形式是由一个名称后接用括号括起来的表达式与过程名称的列表, 其中的过程名称在本作用域单位里面没有被声明为数组名称, 那么该表达式就包含了一个函数引用在情形 1 与情形 4 里面, 对于有可能出现的过程名称引用歧义问题, 必须按照以下的规则序列, 逐步地来决定应该被引用的种过程如果引用的过程名称是所在作用域单位里面的一个哑元, 那么该哑元就是一个哑过程, 并且实际应该引用相关联的作为实元的过程如果引用的过程名称是出现在所在作用域单位里面的一个 EXTERNAL 语句当中, 那么就引用该名称所指称的外部过程如果引用的过程名称是指向一个可访问的内部过程或语句函数, 那么就引用该内部过程或语句函数如果引用的过程名称是类过程名称, 而该类过程名称是在一个所在作用域单位里面的界面里出现, 或者是在一个通过使用关联或宿主关联可以访问界面块里面出现, 同时该引用还包含一个有关该类过程名称的种性质的类型, 种别以及秩的组合模式的说明, 那么就引用具有该类型, 种别以及秩的组合模式的相应种过程, 运用 13.7 节的规则就决定了该种过程, 而节以及节的规则则保证了这样的种过程至多只存在一个如果过程引用是由一个引用逐元过程的逐元引用组成, 而同时又不存在非逐元的过程能够匹配相应的类型, 种别以及秩的组合模式, 那么就引用该逐元过程如果引用过程名称出现在所在作用域单位里面的一个 INTRINSIC 语句当中, 那么就引用该名称所指称的相应固有种过程如果引用的过程名称, 是可以通过使用关联获得访问的, 那么就引用相应的种过程另外, 由于可能出现改名现象, 引用的过程名称可能会与模块里面的过程名称不一致如果引用所在的作用域单位还具有一个宿主作用域单位, 而如果引用歧义问题已经在其宿主作用域单位里面通过上面的规则加以解决, 那么在本作用域单位里面也就不存在歧义问题了如果引用的过程名称同时是类过程和种过程的名称, 而实元与其中特定的某个固有过程的特征相匹配, 那么就引用相应的固有种过程如果引用过程名称不是一个类过程名称, 那么就引用具有该名称的外部过程

274 如果以上规则都不能解决问题, 那么该引用就是非标准的, 或非法的引用 15.3 关联在明确了每一个名称或对象的作用域之后, 进行通讯的主要手段, 就是在不同的作用域之间建立对象之间的关联所谓建立关联, 同样是以对象的名称为基础的, 因为按照直观的理解, 无论是什么形式的通讯, 都是以能够进行名称的传递为前提的只不过在不同形式的通讯里面, 名称一般也具有不同的形式而已一个 FORTRAN 程序的运行过程就是通过名称对相应对象的操作过程, 名称的作用在于为程序辨认相应对象的属性提供依据, 或者还可以为程序指出对象的存储位置因此在程序当中进行的通讯无非就是一些交换名称的过程, 即在不同的作用域单位之间给出指称同一个对象的名称, 或者在同一个作用域单位里面给出指称同一个对象的不同名称, 就是所谓通讯过程的实质, 而关联的含义就是用来完成这两种任务关联具有以下 4 种形式 : 名称关联即直接使用名称进行关联, 这种关联必定是在不同的作用域单位之间进行名称关联包括变元关联, 使用关联, 宿主关联 3 种类型指针关联所谓指针关联的功能就是能够在一个作用域单位里面实现名称的动态关联存储关联存储关联通过存储序列实现数据对象之间的关联在相同的作用域单位里面是通过 EQUIVALENCE 来实现存储关联的, 而在不同的作用域单位之间则是通过 COMMON 来实现关联的序列关联所谓序列关联其实就是名称关联与存储关联的组合, 也是属于名称关联的变元关联的一种特殊形式序列关联在不同作用域单位的名称之间实现关联在下面的示意图 15-2, 和图 15-3 里面, 给出了两个实现各种关联的可执行程序的例子分别是在两个非模块作用域单位之间的关联和一个模块作用域单位与另一个非模块作用域单位之间的关联

275 图 15-2 两个非模块作用域单位之间的关联

276 图 15-3 一个模块作用域单位与另一个非模块作用域单位之间的关联名称关联尽管从实质看来, 关联总是要通过名称来进行的, 不过我们单独把在不同作用域单位之间相同或不同名称实现的关联称为名称关联名称关联包括如下 3 种形式 : 变元关联 ; 使用关联 ; 宿主关联下面分别予以说明

277 1. 变元关联所谓变元关联就是在一个包含了过程引用的作用域单位里面的实元和另一个包含了对被引用过程的定义的作用域单位里面的虚元之间所建立的关联, 即把可能相同也可能不同的处于不同作用域单位的名称, 指称同一个实体对象通过变元关联而实现了实哑通讯的实元, 是一个变量, 或过程, 或表达式的名称, 而相应的哑元则是出现在过程定义当中的用来引用实元的名称或表达式这种关联在程序的执行离开该过程之后, 就被撤消了, 即在被引用过程运行当中具有关联的实元名称与哑元名称在程序退出该过程之后, 就不具有关联关系了 2. 使用关联使用关联在一个模块作用域单位和一个通过 USE 语句引用了该模块的作用域单位的相同名称或不同名称之间建立关联通过这种关联就实现了使用 USE 语句的作用域单位对被引用模块内部的对象的访问按照默认的约定, 模块内部所有的具有公用属性的对象都能够接受访问在 USE 语句里面可以选择性地对需要访问的对象进行重命名, 还可以运用 ONLY 选项来挑选需要访问的对象使用关联的一般规则如下 : 如果在 USE 语句当中使用了重命名, 那么相应局部名称的一切属性都向模块里面的被关联属性看齐而且对于 USE 语句所属作用域单位里面的能够访问被引用模块的对象, 除了可以改变它的访问能力之外, 都不具有重说明属性的能力在 USE 语句里面对一个对象进行了改名, 那么模块里面的原始名称就可以在该 USE 语句所属作用域单位里面作为局部名称使用, 而不会导致名称冲突模块内部的对象的 PUBLIC 与 PRIVATE 属性都只能够由模块自身来规定, 引用模块的作用域单位不能够改变模块内部对象的可访问性 3. 宿主关联宿主关联是在一个内部过程, 或模块过程, 或派生类型定义里面的对象名称与它的宿主作用域单位里面的对象名称之间建立关联直观而言, 宿主关联就是为了使得一个宿主作用域单位里面的名称都能够被其内部的过程或派生类型定义所访问, 当然前提是这些过程和派生类型定义都是能够被其宿主作用域单位所访问的尽管宿主关联不具有使用关联那样的改名机制, 以防止出现名称冲突, 但是宿主关联可以很容易地通过在内部过程, 或模块过程, 或派生类型定义里面, 对某个名称进行局部声明, 而防止它所在的作用域单位访问其宿主作用域单位里面的同名对象从而也可以实行名称冲突管理之所以通过局部声明来防止与宿主对象名称的冲突, 是因为 FORTRAN 有一个基本的约定, 就是任何的作用域单位内部的局部声明总是优先于其所属的宿主作用域单位里面同名的声明特别是如果同时在内部作用域单位与其宿主作用域单位里面使用 IMPLICIT NONE 语句的话, 就能够强迫在它们内部的所有对象都必须具有相应的显式局部声明, 这时, 内部作用域单位的显式局部声明总是优先于其所属宿主作用域单位里面的相应显式局部声明如果只是在宿主作用域单位里面使用了 IMPLICIT NONE 语句, 那么它内部的所有作用域单位在默认情况下也是受到 IMPLICIT N ONE 的作用的, 不过在内部作用域单位里面还可以使用 IMPLICIT 语句进行单独的约定, 这时, 就会改变部分默认隐式规则例 15-1 如果在一个宿主作用域单位里面使用了 IMPLICIT NONE 语句, 然后在它的某个

278 内部作用域单位里面使用了如下的 IM PLICIT 语句 : IMPLICIT COMPLEX(O,Z) IMPLICIT LOGICAL(A-C) 这样就使得该内部作用域单位里面所有以 O 和 Z 开头的名称都是隐式复型, 而以 A,B,C 开头的名称都是隐式逻辑型, 至于以其他字母开头的名称则需要依靠显式声明才能确定其类型一旦在程序当中使用隐式声明的时候, 那么某个对象名称可能在其所属的作用域单位的说明部分就不会出现对于该名称的显式声明, 这就会给名称的引用管理带来一定的复杂性考虑所有的宿主与其内部作用域单位的同一个对象名称的显式与隐式声明的组合, 一共有如下 4 种情况 : 1. 在宿主与其内部作用域单位内都是显式 ; 2. 在宿主内没有出现隐式声明和显式声明, 在其任何内部作用域单位内都是隐式 ; 3. 在宿主的说明部分出现显式声明, 而在其内部作用域单位内是隐式 ; 4. 在宿主作用域单位内是隐式, 而在其内部作用域单位内的说明部分出现显式声明对于情况 1, 它们都是局部的, 都只是在各自的作用域单位里面有效, 不发生宿主关联关系对于情况 2, 只要该对象名称在宿主的出现不是以被引用的方式, 那么它们都是局部的, 都只是在各自的作用域单位里面有效, 不发生宿主关联关系对于情况 3, 则该对象名称是宿主对象, 其内部作用域单位内的同名对象需要通过宿主关联来访问它如果该对象名称在宿主作用域单位内部只是以被引用的方式出现, 那么同样看成是一个显式声明对于情况 4, 则在其内部作用域单位内是该作用域单位的局部名称, 不需要访问其宿主作用域单位隐式声明不管是在宿主作用域单位还是在内部作用域单位, 它都是依据隐式类型规则与 IMPLIC IT 语句约定的, 约定内容如下 : 一个名称如果在内部作用域单位里面得到显式声明, 那么它就是一个局部名称, 与其宿主作用域单位无关内部作用域单位里面的哑元本身被认为就是一个显式局部声明, 尽管该哑元的名称可能是根据其所在作用域单位的隐式类型规则进行隐式规定的如果一个内部作用域单位里面的对象名称没有得到显式声明, 那么只有在该名称在其宿主作用域单位里面根本不出现的情况下, 该名称才依据其所在作用域单位的隐式声明成为局部对象名称如果一个内部作用域单位里面的对象名称依据上面的两个规则仍然不是局部的, 那么它就是需要获得宿主关联的非局部名称内部作用域单位里面如果不出现 IMPLICIT 语句的话, 它的默认隐式类型规则就继承其宿主作用域单位的隐式规则, 即其宿主作用域单位的默认隐式规则加上可能的 IMPLICIT 语句的修改如果内部作用域单位里面出现 IMPLICIT 语句, 那么它对内部作用域单位从其宿主作用域单位继承来的默认隐式规则进行修改, 并且同样作用于其中的哑元一个内部函数或模块函数的函数名称或对象名称的类型, 或者由显示声明决定, 或者由该函数的隐式类型规则决定例 15-2 PROGRAM HOST USE GLOBAL_DATA IMPLICIT LOGICAL (E-J)! 隐式类型规则为 :A-D 为默认实型 ;

279 ! E-J 为默认逻辑型 ;! K-N 为默认整型 ;! O-Z 为默认实型 REAL A,B READ *, P! 该引用继续 P 在宿主里面的隐式规则 CALL CALC (Z )! 该引用继续 Z 在宿主里面的隐式规则 CONTAINS SUBROUTINE CALC (X) IMPLICIT REAL (G-I)! 隐式类型规则为 :A-D 为默认实型 ;! E-F 为默认逻辑型 ;! G-I 为默认实型 ;! J 为默认逻辑型 ;! K-N 为默认整型 ;! O-Z 为默认实型 REAL B X=A+B+P+Q+Y! 在 SUBROUTINE CALC 里面它们都是实型!X 为局部哑元 ;!A 获得宿主关联 ;!B 为得到显式声明的局部名称 ;!P 获得宿主关联 ;!Q 为得到隐式声明的局部名称 ;!Y 从模块获得使用关联. END SUBROUTINE END PROGRAM HOST 在上面的例子当中, 表达式 X=A+B+P+Q+Y 里面的各个算元依据不同的类型规则指针关联前面讨论的所有的关联机制都使得被关联的名称在其所在的作用域单位运行时总是具有一个确定的关联对象, 但是指针关联却是一种动态关联机制, 具有指针属性的名称在其所在的作用域单位运行时, 可以具有三种状态, 即 :

280 去定义状态 ; 去关联状态 ; 关联状态因此指针关联在本质上就是一种动态关联机制, 在其所在的作用域单位的运行期间, 随时可以根据运行的需要而变换其状态指针关联的一般规则如下 : 没有经过初始化的指针总是处于去定义状态, 在经过初始化之后, 才具有去关联状态指针获得关联可以通过如下 2 种方式 : 通过指针赋值, 使得指针变量和其他指针, 或者和具有 TARGET 属性的标量或数组数据对象建立关联通过执行 ALLOCATE 语句, 使得指针变量和此前无名的空间建立关联处于关联状态的指针变量可以通过如下 3 种方式去关联 : 在 NULLIFY 语句的作用下 ; 在 DEALLOCATE 语句的作用下 ; 被赋值为一个去关联的指针存储关联存储关联和名称关联以及指针关联的目的一样, 都是使得不同的名称能够共享同一个数据实体, 如果说名称关联和指针关联的关联途径都是通过访问名称来实现的, 那么存储关联则是通过直接访问数据对象的存储空间来实现的所谓数据对象的存储空间表面看来是属于计算机的内存的物理层面的一个概念, 但是在 FORTRAN 语言里面所谓的存储空间并不完全就是一个物理层面的概念, 而是对物理空间的一种模式描述这种描述的基本概念如下 : 存储单位一个存储单位就是指存储了单个 FORTRAN 数据值的内存空间根据存储单位所存储的 FORTRAN 数据值的不同类型, 存储单位分为数值存储单位, 字符存储单位和不定存储单位存储序列任意多个连续的数据单位就构成了一个存储序列, 存储序列的大小就是序列所包含的存储单位的数目要描述 FORTRAN 数据的存储, 就必须说明每种类型的数据对象所占据的存储单位的数目, 因此下面我们给出所有类型的 FORTRAN 数据对象所对应的存储单位分配模式一个默认整型, 默认实型, 默认逻辑型的标量数据对象占据一个数值存储单位 ; 一个默认复型, 双精度实型数据占据 2 个连续的数值存储单位, 其中复型数据的实部所占据的存储单位位于虚部所占据的存储单位一个默认字符占据一个字符存储单位所有的其他类型的数据值, 包括指针和非默认类型的数据值都占据不定存储单位如果是数据对象由多个或多种数据单位组成, 那么该数据对象的存储模式由其具体数据形式决定, 一般有以下几种形式 : 长度为 len 的默认标量字符对象占据连续的 len 个字符存储单位, 构成一个存储序列

281 一个数组对象占据一个存储序列, 该数组的每个元素占据一个适当类型的存储单位, 存储序列里面存储单位的顺序就是该数组里面元素的顺序一个具有序列机构的派生类型对象占据一个存储序列, 该派生类型对象的每个成员占据一个适当类型的存储单位, 存储序列里面存储单位的顺序就是该派生类型对象定义里面成员的顺序一个公用块占据一个存储序列, 参见 7.11 节函数子程序里面的 ENTRY 语句给出的结果占据一个存储序列, 参见 13.6 节 EQUIVALENCE 语句里面的等价列表的所有对象占据一个存储序列两个数据对象如果共享了同一个存储序列, 那么它们就称为具有存储关联的关系如果它们只是共享了同一个存储序列的部分存储单位, 那么它们称为具有部分存储关联的关系能够建立部分存储关联的数据对象只能是字符型数据以及在 COMMON,EQUIVALENCE, 或 ENT RY 语句里面给出的复合数据对象因为只有这样的复合序列形式的数据对象的子对象作为子串才是有意义的数据对象例 15-3 考虑下面给出的几个数据值 : REAL ::X( 0:3) COMPLEX ::Z EQUIVALENCE(Z,X(2)) 那么 X 所占据的存储序列就是由 4 个存储单位组成, 每个存储单位为一个数值存储单位 : X(0) X(1) X(2) X(3) 而 Z 所占据的存储序列由 2 个存 o 储单位组成, 分别作为实部与虚部的存储单位 : Zr Zi EQUIV ALENCE 语句指定了 Z 的存储序列从 X 的下标为 2 的元素所占据的存储单位开始共享存储空间, 也就是下面的形式 : X(0) X(1) X(2) Zr X(3) Zi 而如果上面的 EQUIVALENCE 语句是如下的形式 : EQUIVALENCE(Z,X(3)) 那么 Z 和 X 就构成了如下的部分存储关联形式 : X(0) X(1) X(2) X(3) Zr Zi 序列关联序列关联就是一种特殊形式的变元关联, 用于对具有序列结构的数据对象, 例如字符串, 数组等建立关联, 具体的讨论参见节

282 15.4 定义状态固然通过关联, 就可以说已经完成了通讯的过程, 但是通讯的实现过程当中还有一个重要的问题还没有讨论, 就是如何保障使用名称所指称的值时的安全性, 也就是如何保障名称的取值是定义明确并且具有可预知的行为之所以还会出现这样的问题, 是因为在程序运行过程当中, 会有很多的事件能够导致变量的病态定义, 或者是取值的不可预知性例如, 如果一个整型变量与一个实型变量具有存储关联关联, 那么对于整型变量的赋值常常导致相应实型变量的取值的不可预知性 ; 更常见的是一个输入输出的错误, 很容易就导致变量的取值的中断因此为了保证通讯的顺利实现, 我们还必须监视变量在程序运行过程中的取值行为, 也就是变量的定义状态对于一个在程序运行过程当中的变量来说, 它的定义状态就是如下两种 : 良定义的 ; 去定义的所谓良定义的就是指一个变量能够在程序的运行过程中, 通过一些语句的执行而获得明确的取值 ; 所谓去定义就是指一个变量失去了值一个变量在通过 DATA 语句, 或类型声明语句, 或默认初始化语句进行初始化取值之前, 总是默认为去定义的, 然后在进入程序的运行进程之后, 总会出现某些事件能够定义变量的取值, 或者再对变量进行去定义显然处于去定义状态的变量就不能够引用到需要使用它的值的环境当中去对于在程序运行当中有可能出现的异常的变量去定义状态, 编译器常常并不能够检查出来, 因为要求编译器总是去检查任何变量的定义状态, 是一件花销特别庞大的工作, 因此主要的避免出现变量的异常定义状态的任务, 必须由程序编写者来承担, 做到在程序的编写过程中尽量避免能够导致变量状态定义异常的事件的出现子对象的定义状态对于由一些子对象组成的数据对象, 它们的定义状态是由它们的所有子对象的定义状态决定, 即只有每个子对象都是良定义的, 整个数据对象才是良定义的 ; 只要它的一个子对象是去定义的, 那么整个数据对象就是去定义的这样一些数据对象以及子对象的例子包括 : 复型数据及其实部和虚部数组及其元素或数组片断 ; 字符型变量及其字符子串 ; 结构及其成员如果一个能够具有子对象的数据对象的子对象数目是 0, 那么约定它是良定义的, 例如 0 尺度的数组和 0 长度的字符串影响变量定义状态的事件一个程序的执行过程, 实际上就是一个不断地对其中的变量进行赋值, 引用, 再赋值的过程, 因此几乎每一个可执行语句完成后, 都会导致某些变量取值的变化, 这种取值的变化也就影响了

283 变量的定义状态, 即或者是保持变量的定义状态不变, 或者是改变了变量的定义状态下面我们分 2 节分别讨论在程序运行过程当中, 能够导致变量良定义的事件, 与能够导致变量去定义的事件导致变量良定义的事件在程序运行过程当中的如下的事件能够导致变量获得良定义 : 在固有赋值语句当中, 除了过滤数组赋值与指标并行数组赋值之外, 都能够在执行后使得等号前面的变量获得良定义过滤数组赋值与指标并行数组赋值的执行, 都能够使得赋值语句当中的数组的部分元素或全部元素获得良定义在执行输入语句的过程当中, 从输入文件获得赋值的每个变量都在数据传递到该变量时获得良定义执行一个单位说明符指向一个内部文件的 WRITE 语句时后, 被写入的每个纪录都获得良定义执行一个 DO 语句之后, 其中可能有的任何 DO 变量都获得良定义在 FORALL 结构或语句当中, 当指标名称值集经过计算之后, 其指标名称就获得良定义执行一个输入输出语句内部由一个隐式 DO 列表给出的指令之后, 隐式 DO 变量就获得良定义如果与一个过程的哑元相关联的实元获得非语句标签的良定义, 那么引用该过程后, 该哑元数据对象就获得了良定义如果与该哑元相应的实元只是部分子对象获得非语句标签的良定义, 那么那么引用该过程后, 也只有该哑元数据对象相应的部分子对象获得良定义执行一个具有输入输出说明符 IOSTAT= 的输入输出语句使得被指定的整型变量获得良定义执行一个包含输入输出说明符 SIZE= 的 READ 语句使得被指定的整型变量获得良定义在没有错误条件存在的情况下, 执行一个 INQUIRE 语句, 使得在执行语句过程中被赋值的任何变量都获得良定义当一个字符存储单位获得良定义之后, 所有通过该存储单位而建立存储关联的字符数据对象都获得良定义当一个数值存储单位获得良定义之后, 所有通过该存储单位而建立存储关联的相同类型的数值数据对象都获得良定义当一个存储双精度实型数据的存储序列获得良定义之后, 所有通过该存储序列而建立存储关联的双精度实型数据对象都获得良定义当一个不定存储单位获得良定义之后, 所有通过该不定存储单位而建立存储关联的数据对象都获得良定义当一个存储默认复型数据的存储序列获得良定义之后, 所有通过该存储序列而建立部分存储关联的默认实型数据对象都获得良定义如果一个默认复型数据的存储序列的各个部分都与其他的获得良定义的默认实型数据或默认复型数据建立了部分关联, 那么该默认复型数据对象就获得了良定义如果一个数值序列结构或字符序列结构的所有成员都与其他的获得良定义的数据对象建立了部分关联, 那么序列结构也就获得了良定义执行一个包含说明符 STAT= 的 ALLOCATE 语句或 DEALLOCATE 语句, 使得被说明符 STAT= 指定的变量获得良定义执行在一个指针与良定义的目标之间建立关联的指针语句, 就使得该指针获得良定义零尺度数组经过分配就使得该数组获得良定义

284 如果一个派生类型对象的所有非指针直接成员 ( 参见第 6 章 ) 都具有默认初始化, 那么该派生类型对象的分配导致其成员获得良定义调用一个过程使得其中所有零尺度的动态对象都获得良定义如果一个过程包含了一个非保留局部对象, 该对象不是一个哑元, 不能通过使用关联或宿主关联得到访问, 也不具有 ALLOCATABLE 以及 POINTER 属性, 并且属于派生类型, 其中所有直接成员都指定为默认初始化, 那么调用该过程, 将导致该对象的成员获得良定义如果一个过程具包含一个具有 INTENT(OUT) 属性的哑元, 并且该哑元作为一个派生类型对象, 它的所有非指针直接成员都具有默认初始化, 那么该哑元的成员都获得良定义如果一个非指针函数是一个派生类型对象, 它的所有非指针直接成员都具有默认初始化, 那么调用该函数将导致函数结果的成员获得良定义导致变量去定义的事件在程序运行过程当中的如下的事件能够导致变量的定义状态为去定义状态 : 如果一个具有给定类型的变量获得了良定义, 那么就导致与该变量相关联的具有不同类型的变量去定义不过还有如下 2 种特殊的例外情况 : 如果一个默认实型变量与一个默认复型变量部分关联, 当实型变量获得良定义, 同时实型变量在复型变量获得良定义时并不会去定义, 那么该复型变量也不会去定义如果一个默认复型变量与另外一个复型变量部分关联, 那么其中一个复型变量得到良定义不会导致另一个复型变量去定义如果一个函数经过计算, 导致函数的实元或者是模块或公用块里面的变量获得了良定义, 同时如果该函数还被一个表达式引用, 而该函数的值在该表达式里面并不参与决定表达式的值, 那么在该表达式完成计算之后, 就导致那个实元或变量去定义执行了一个子程序里面的 RETURN 语句或 END 语句之后, 就导致该子程序的所有作用域单位里面的局部变量, 或属于递归调用的当前作用域单位里面的局部变量都为去定义状态不过以下情况为例外 : 具有 SAVE 属性的变量例外 ; 具有空公用属性的变量例外 ; 从宿主作用域单位访问得到的变量例外 ; 同时出现在一个子程序以及另外一个直接或间接引用了该子程序的作用域单位里的命名公用块里面的变量例外 ; 从一个模块访问得到的变量例外, 同时要求该模块至少被另一个直接或间接引用该模块的作用域单位所引用在一个已经获得初始定义然而还没有得到进一步定义或重定义的命名公用块里面的变量例外如果在一个输入语句的执行过程中, 出现了错误条件或者文件终止条件, 那么由该语句的输入列表或名称列表集合所给出的所有变量都去定义如果在一个输入输出语句的执行过程中, 出现了错误条件或者文件终止条件, 那么部分或全部的隐式 DO 变量去定义执行一个自定义赋值语句可能导致其等号之前的部分或全部变量去定义执行一个说明了还未写入的纪录的直接访问输入语句, 将导致由语句的输入列表所给出的所有变量去定义执行 INQUIRE 语句使得 NAME=,RECL=,NEXTREC= 变量去定义当一个字符存储单位去定义, 那么所有与其相关联的字符数据对象单位去定义

285 如果一个数值存储单位去定义, 那么所有与其相关联的数值数据对象单位去定义唯一的例外是导致数值存储单位的去定义的是由于给该单位定义了一个具有不同类型的数值数据对象如果一个双精度实型对象去定义, 那么所有与其完全关联的双精度实型对象都去定义如果一个不定存储单位去定义, 那么所有与其相关联的数据对象都去定义如果一个可分配数组去分配, 那么它也就去定义针对一个还没有指定默认初始化的非零尺度对象执行 ALLOCATE 语句, 如果执行成功, 那么将产生一个去定义的对象如果在执行一个 INQUIRE 语句时出现错误条件, 那么所有查询说明符变量去定义, 在说明符 IOSTAT= 里面的变量例外调用一个过程会导致如下几种去定义情形 : 没有关联任何实元的可选哑元去定义 ; 具有 INTENT(OUT) 属性的哑元去定义, 除非是那些指定了默认初始化的变元的成员与一个具有 INTENT(OUT) 属性的哑元相关联的实元去定义如果一个哑元的子对象所关联的实元子对象去定义, 那么它自身也去定义函数的结果变量去定义, 例外是指定了默认初始化的结果的成员当一个指针的关联状态去定义或去关联, 那么该指针即去定义当 FORALL 语句或结构执行完毕之后, 指标名称去定义而如果在相应的程序单位里面存在与之同名的变量, 则该变量不受 FORALL 语句或结构的影响第 16 章数据文件的管理固然, 我们编制一个科学计算程序的目的是执行给定的计算, 是描述一个通过算法而实现的对输入数据的计算的过程, 而不只是简单的对数据的处理, 但是这并不妨碍我们从信息处理的角度来看待这个过程因为任何的计算, 再简单也必定包含数据的输入与输出过程, 更复杂的计算程序则还包含数据的缓存管理, 不同程序单位之间的数据传递, 特别是在程序的计算涉及到庞大的数据量时, 例如在工程计算中常见的大数组等, 更加不能依靠单纯的变量来管理庞大的数据量实际上分析一下我们自己进行计算的情形, 就知道在计算过程当中进行数据管理同样是一件非常重要的事务, 而按照计算机的从冯纽曼时代就已经给予奠基的基本模型来看, 一台计算机的有效工作, 依赖于指令流与数据流的有机合作, 因此 FORTRAN 语言除了要描述计算, 还要能够描述对于数据流的管理在前面我们已经讨论了 FORTRAN 程序的内部通讯问题, 那种通讯完全是依赖变量机制来进行的, 因为那种通讯都是紧密关联于计算的通讯, 直接在变量之间进行数据值的交换能够保证计算的效率和速度但是一旦计算所涉及的数据量非常庞大, 而计算过程对于数据的输入与输出要求更加复杂时, 变量机制就不足以承担数据处理的功能, 因此 FORTRAN 提供了单独的输入输出语句以及文件的概念, 来实现对数据流的输入输出的管理除了作为面向程序自身的数据输入输出管理的功能之外, 一个 FORTRAN 程序的完整运行还必须包括程序与人的交互, 而一旦涉及到机器与人的交互, 自然要求任何数据都必须以适宜于人的辨识与处理的格式出现于一定的物理媒质上, 这就是输入与输出的编辑问题, 将是下章所要讨论的内容, 本章则只说明 FORTRAN 所提供的输入输出处理语句

286 FO RTRAN 用于处理与管理输入输出数据的语句分为如下四大类 : 文件联结语句包括 OPEN 语句和 CLOSE 语句数据传输语句这一类语句又可以分为 2 个小类别 : 据传输输入语句, 包括 READ 语句据传输输出语句, 包括 WRITE 语句和 PRINT 语句文件定位语句包括 BACKSPACE 语句,ENDFILE 语句以及 REWIND 语句文件查询语句包括 INQUIRE 语句这些语句所要实现的首要的功能, 就是控制数据的输入与输出, 即数据从外部媒质到内存, 或从内部文件到内存的输入, 以及数据从内存到外部媒质, 或从内存到内部文件的输出然后就是辅助性的用来操纵外部媒质, 以及描述或查询文件与外部媒质的联结属性的功能下面在给出 FORTRAN 管理数据输入输出的一般概念之后, 再分别详细讨论这些语句 16.1 输入输出管理的数据单位 FORTRAN 对于输入输出数据进行管理的基本单位概念是纪录以及纪录组成的文件, 因此下面我们分别讨论纪录与文件概念纪录 FORTRAN 的变量一次只能存储一个数据值, 显然不足以用来进行有效的数据管理, 因此 FORTRAN 建立了专门的用来有组织地存储任意数量的数据的概念, 即文件文件由一个纪录的序列组成, 而纪录是一种逻辑形式上的单位, 可以是终端或打印输出上显示的一行, 也可以是外部存储器上的一个逻辑纪录, 尽管纪录总是与各种物理形式的数据单位保持一定的对应, 但实际上是与具体的物理表现形式无关的, 因为纪录本质上是一个语法上的概念实际上在 FORTRAN 里面并不存在物理纪录的概念组成一个文件的纪录从语法地位上分为如下两种 : 数据纪录 ; 文件终止纪录所谓数据纪录就是作为文件的数据内容的纪录, 而文件终止纪录则纯粹是一个语法意义上的纪录, 它不包含任何数据内容, 只是用来标志一个文件的终止因此文件终止纪录只能用作文件的最后一个纪录, 并且没有长度的属性由于计算机本质上的串行工作模式, 纪录同样是一个串行序列的结构, 该序列的单位就是数据值, 即一个数据值的序列组成一个纪录对于数据纪录来说, 其中的数据值可以有如下两种表示形式 : 无格式数据 ; 格式化数据所谓数据的是否具有格式, 完全是针对人而言的, 即具有格式的数据就是把数据转化为便于

287 人的阅读的字符型数据表示形式, 也就是文字与数字, 或者说 ASCII 编码形式 ; 而所谓无格式数据就是 FORTRAN 程序自身所实际处理的数据的在物理层面上的表示形式, 一般都是二进制表示的数字形式对于计算机来说, 世界上的任何形式的信息, 终归都要表示为这种形式的数据一个 FORTRAN 程序所涉及到的任何数据, 在该程序运行时, 无论是作为运行的结果还是作为运行的初始值, 它写入到内存当中, 或从内存当中读出, 或者是从内存到硬盘的输入输出, 数据流里面的数据都是无格式数据而一旦数据需要人的阅读, 就必须把二进制数据形式转换为能够被人阅读的字符形式, 实际上我们编写的源码就是这种形式的数据一个数据纪录或者完全由无格式的数据组成, 称为无格式纪录 ; 或者完全由格式化数据组成, 称为格式化纪录无格式纪录完全只是在机器内部存在, 它的具体的数据形式是由系统决定的, 最常见的就是二进制形式这种纪录完全不需要人的监视与阅读, 而格式化纪录则完全是人用来给机器输入数据, 或机器向人展示数据结果的数据纪录形式, 因此当人向机器输入格式化纪录后, 机器必须再把它翻译为无格式的纪录, 才能被程序所使用, 反之亦然格式化纪录的好处就是便于人的阅读, 它只能通过格式化输入输出语句来读或写 ; 而无格式的纪录的特点就是能够直接得到机器的处理, 相应的它也只能通过无格式的输入输出语句来读或写对于纪录可以定义长度的概念格式化纪录的长度就是其所包含的字符的数目 ; 而无格式纪录的长度同样用来计量其中数据量的大小, 它的具体度量方法的定义则依赖于具体的处理器系统对于数据量单位的定义格式化纪录和无格式纪录的长度都可以为 0 除了包含数据值的纪录之外, 还有文件终止纪录由于它只是起文件终止的语法标志作用, 因此它不包含任何数据, 所以它的长度也就是 0 一个文件至多只能包含一个文件终止纪录, 并且只能是文件的最后一个纪录文件终止纪录可以有如下几种生成方式 : 可以通过文件的序列访问, 最后用一个 ENDFILE 语句显式地写下来 ; 也可以通过文件定位语句, 如 REWIND 语句或 BACKSPACE 语句, 而隐式地写下来 ; 运用 CLOSE 语句关闭文件或部件, 或者是正常地终止程序, 或者是对同一个部件使用了另外一个 OPEN 语句, 从而隐式地写下来从上面的文件终止纪录的实现方式可以看出, 这种纪录并不需要任何实际的物理实现文件一个纪录的序列构成一个文件在程序运行的任何时候, 对于一个给定的文件, 它的访问方法, 形式, 操作以及纪录的长度, 都明确地存在相应的依赖于系统的合法性规定, 同时文件也可以具有字符串类型的名称, 即所谓命名文件, 不过对于该名称所使用的字符形式或长度, 都是由具体的系统来规定, 以便与相应操作系统对于文件的命名约定保持一致按照文件与程序的功能关系以及存储性质, 文件可以分为如下两种 : 内部文件 ; 外部文件所谓内部文件存储在程序可以访问的内存空间里面, 而外部文件则存储在系统的外部存储部件上, 例如硬盘这种存储位置的不同实际上也反映了它们对于程序的不同功能, 因为这两种存

288 储空间的物理性能差异决定了它们对于 CPU 是具有不同意义的外部文件与内部文件的这种不同功能意义体现在如下几个不同的方面 : 文件的存在性对于外部文件来说, 程序需要访问的一个外部文件可能是存在的, 也可能是不存在的, 都是合法的程序运行现象例如 INQUIRE 语句,OPEN 语句,CLOSE 语句,WRITE 语句,PRINT 语句,REWIND 语句, 以及 ENDFILE 语句都可以引用一个并不存在的文件 ; 而如果使用 WRITE 语句,PRINT 语句, 或 ENDFILE 语句来引用一个预联结的并不存在的语句, 就自然地能够生成该文件一个外部文件的不存在也可能是来源于系统对于硬盘空间的权限限制, 例如对于一个 FORTRAN 应用程序来说, 系统文件以及 FORTRAN 编译器程序文件都不应该被访问而对于程序来说, 它所涉及的内部文件则都必须存在于相应的内存空间里面程序对外部文件的访问需要通过与逻辑部件建立联结, 因此就需要相应的能够对外部文件进行联结, 定位与查询的语句, 而对于内部文件则不需要这些语句功能同时这种联结就使得外部文件具有定位的属性对于外部文件来说, 它的访问方式, 合法形式, 合法操作, 以及合法纪录长度等都不是由 FORTRAN 语言标准来规定, 而是由操作系统对于文件的约定以及用户的特定选择来决定的 ; 而内部文件的内容都是作为默认字符型变量的数据值的形式而储存的, 这些字符型数据值都是程序的通常的赋值过程所产生的, 或者是输出语句针对变量而给出的如果内部文件所表示的变量是一个标量, 那么该文件就只有一个纪录 ; 如果该变量是一个数组, 那么该数组的每一个元素组成该文件的一个纪录, 文件里面纪录的顺序就是数组的相应的元素顺序, 每个纪录的长度就是相应元素的长度文件的访问由于文件的纪录是一种串行的序列结构, 要实现对文件的纪录的访问, 可以有如下两种方式 : 序列访问 ; 直接访问所谓序列访问, 就是顺着文件的纪录序列来访问特定的纪录, 即如果要访问文件的第 n 个纪录, 则需要顺次经过文件的第 1,, 一直到第 n-1 个纪录, 才访问到第 n 个纪录 ; 而直接访问则不需要经过前面的 n-1 个纪录, 通过指定纪录号即可直接访问第 n 个纪录, 因此直接访问无论是读还是写, 都可以按照任意的顺序进行这两种不同的访问方法很大程度上是由存储文件的媒质以及系统的约定等外部因素决定的, 例如存储在磁带上面的可能就只允许采用序列访问的方式进行访问不过当一个文件被联结到了一个特定的部件之后, 或者是预联结的文件被生成之后, 它的访问方式就已经被决定了这两种不同的访问方式是由对文件的联结方式决定的, 而不是属于文件自身的属性一个文件可以只能通过序列访问方式来访问, 也可以只能通过直接访问方式来访问, 也可以分别通过这两种方式来访问, 但不能同时用这两种方式来访问, 也就是说当文件通过某个联结而被程序按照序列方式来访问, 那么需要使用 CLOSE 语句来关闭该联结之后, 再使用 OPEN 语句重新建立新的联结, 才能换为按照直接访问的方式来访问能够直接访问读的纪录只限于已经写下来的纪录能够直接访问写的文件限于建立了直接访问联结的文件

289 1. 序列访问一个外部文件建立了序列访问的联结之后, 它就具有如下的属性 : 如果针对该文件的直接访问是非法的, 那么组成该文件的纪录的顺序就是写入该文件的纪录顺序 ; 如果同时针对该文件的直接访问也是合法的, 那么该文件的纪录的顺序由直接访问来决定, 即序列访问该文件的第一个纪录就是直接访问该文件所指定的纪录号为 1 的纪录, 后面顺次类推文件的纪录或者全部是格式化纪录, 或者全部是无格式纪录, 当然有可能出现在文件最后的文件终止纪录除外只要该文件的前一个引用不是数据传输输出语句或文件定位语句, 那么文件的最后一个纪录就一定是文件终止纪录文件的纪录不允许直接访问输入输出语句的读与写 2. 直接访问如果一个外部文件所建立的联结是直接访问, 那么该文件具有如下属性 : 文件的所有纪录都具有一个唯一的纪录号, 该纪录号为一个正整数, 是在写纪录时给定的, 而这个纪录号一旦给定, 就再也不能改变该纪录号决定了文件的纪录的顺序文件的任何纪录不允许被删除, 但允许被改写文件的纪录或者全部是格式化纪录, 或者全部是无格式纪录如果对于该文件序列访问方式也是合法的, 那么当该文件被联结到直接访问时, 它有可能包含的文件终止纪录则不被认为是属于该文件的一部分如果对于该文件不允许序列访问, 那么该文件就不能包含文件终止纪录只有通过直接访问输入输出语句才能实现对纪录的读和写文件所有的纪录的长度相同对于一个文件的纪录的读写顺序不一定要求按照纪录号的顺序一旦文件与部件建立了联结, 那么对于该文件的纪录的读写可以是任意顺序的文件的纪录不能使用表控格式, 名称列表格式, 或通过非预输入输出语句来读写文件的定位由于文件是一个数据的集合, 因此程序在运行过程当中, 对于文件的读写操作总是意味着程序当前所使用的数据是在发生变化的, 为了描述程序当前所使用的数据或纪录,FORTRAN 定义了文件的位置的概念, 并且还给出了专门用来对文件位置进行操作的语句, 以便实现对文件所包含的数据的精确访问与操作针对文件所包含的纪录的串行序列结构, 以及纪录本身所包含的数据值的串行序列结构, FORTRA N 定义了如下几个特征性的文件的定位情形 : 初始点即文件第一个纪录前面紧接该纪录的位置如果文件定位在这个位置, 那么程序对于该文件的操作将从文件的第一个纪录开始终止点即文件最后一个纪录后面紧接该纪录的位置如果文件定位在这个位置, 那么程序接下来的操作将不进入该文件如果文件为空文件, 即不包含任何数据, 那么它的初始点和终止点相同

290 对于文件的定位可以处于两个紧接的纪录中间, 这时位于该位置的前面的那个纪录称为前纪录, 而位于该位置的后面的那个纪录称为后纪录当然对于初始点不存在前纪录, 而对于终止点则不存在后纪录对于文件的定位也可以是在输入输出语句运行时的当前纪录上面, 这时该当前纪录的紧接的前面的那个纪录称为其前纪录, 而该当前纪录的紧接的后面的那个纪录称为其后纪录当然, 如果文件定位不是在一个纪录里面, 那么当前纪录就不存在当文件定位处于当前文件时, 还可以更加详细地描述为定位于当前纪录的数据值序列的初始点或终止点, 或纪录的任意两个数据值之间即该纪录的紧接在数据值序列的第一个数据值前面的位置, 或紧接在数据值序列的最后一个数据值后面的位置, 或在数据值序列里面的任意两个数据值之间的位置内部文件总是在数据传输之前定位在纪录的开始位置预输入输出操作总是以纪录为单位的, 因此完成这样一个操作之后, 文件总是定位于一个纪录的终止位置或纪录之间的位置 ; 而非预输入输出操作是以字符为单位的, 因此完成一个非预输入输出操作之后, 文件有可能定位于当前纪录的字符序列之间输入输出语句的运行总能影响外部文件的定位, 根据作用效果的不同, 输入输出语句可以分为如下两种 : 预输入输出语句一个预输入输出语句总是在文件的最后一个纪录完成读写之后对文件定位, 除非中途发生错误非预输入输出语句一个非预输入输出语句可以定位于当前纪录里面的字符位置, 或者是随后的纪录上面运用非预输入输出语句就可以通过一个输入输出语句序列读写文件的纪录, 其中每个语句访问纪录的一部分这种语句也可以用来读可变长度的纪录在数据传输之前的文件的定位在直接访问文件与序列访问文件时有不同的约定 : 序列输入时, 如果存在当前纪录, 那么文件定位不变 ; 否则文件定位于下一个纪录的头部, 自然该纪录就成为了当前纪录如果这个纪录不存在, 或者在存在当前纪录, 而最近访问文件的数据传输语句执行的是输出, 那么该输入就不执行如果文件包含文件终止纪录, 那么在数据传输之前文件不能定位于文件终止纪录后面可以运用 REWIND 语句和 BACKSPACE 语句来对文件重定位序列输出时, 如果存在当前纪录, 那么文件定位不会变化, 当前纪录成为文件的最后纪录 ; 如果不存在当前纪录, 那么就生成下一个纪录作为文件的当前纪录, 文件定位于该当前纪录的头部如果是直接访问, 文件的定位情形非常简单, 即定位于纪录说明符所指定的纪录的头部该纪录就是文件的当前纪录在数据传输过程结束之后, 文件的定位有如下几种情形 : 如果数据传输过程了发生错误, 那么文件定位就是不可预知的如果数据传输过程没有发生错误, 但是读入了文件终止纪录而导致文件终止, 那么文件定位于文件终止纪录之后对于非预输入如果没有出现错误, 也没有出现文件终止条件, 但是出现了纪录终止条件, 那么文件定位于刚读入的纪录之后 ; 如果纪录终止条件也没有出现, 那么文件定位不变对于非预输出如果没有出现错误, 则文件定位不变在所有的其他情况下, 文件定位于刚读写过的纪录之后, 该纪录就成为了前纪录

291 内部文件内部文件的概念是 FORTRAN 语言的一个很大的特点, 它实现了数据从内存到内存的传输与转换的功能内部文件的属性与约定如下 : 内部文件为默认字符型变量, 不能是带向量下标的数组片断内部文件的纪录为标量字符变量如果文件本身就是一个标量字符变量, 那么该文件就只包含一个纪录, 其长度就是标量字符变量的长度如果内部文件是一个字符数组, 那么它就被看成是一个字符数组元素的序列, 其中的每个元素都是该文件的一个纪录, 该文件纪录的顺序就是该数组或数组片断的数组元素序, 该文件的每个纪录的长度都相同, 即数组元素的长度写入内部文件纪录的同时就定义了该纪录如果写入字符数目少于纪录长度, 那么纪录多余的空间就被填上空字符写入的字符数目不能超过纪录长度只有在内部文件的纪录被定义之后, 才能读入该纪录内部文件的纪录除了通过输入语句之外, 还可以使用其他方法得到定义或去定义, 例如字符赋值语句也能够定义作为纪录的字符变量在数据传输之前, 内部文件总是定位于第一个纪录的头部, 而该纪录就是当前纪录在输入内部文件时, 对空格的处理与使用具有值 NULL 的说明符 BLANK= 来打开外部文件一样, 在必要的时候纪录可以添加空格在表控输出时, 字符常量不能定界内部文件纪录的读与写只能通过不说明名称列表格式的序列访问格式化输入输出语句来完成内部文件不能出现在文件联结语句, 文件定位语句以及文件查询语句当中 16.2 文件的部件联结与访问程序要和文件进行通讯, 都需要程序通过一定的部件联结到文件, 即通过部件输出数据到文件, 通过部件从文件输入数据到程序这里的所谓部件是一个纯粹的逻辑概念, 而不是一个物理概念, 之所以要引入这么一个逻辑概念, 主要的原因就是为了在语言里获得对输入输出的通用描述因为我们知道文件概念实际上是与操作系统与硬件存储形式密切相关的, 不同的操作系统与硬件存储形式里面, 对于文件往往有不同的形式约定, 因此为了使得对输入输出能够有不依赖于具体系统的描述,FORTRAN 引入了部件这个逻辑概念作为数据从程序到文件之间的桥梁部件使用如下的语法表示方法 (R901): io-unit 其中的输入输出部件 (io-unit) 可以具有如下三种形式之一 : external-file-unit * internal-file-unit 其中外部文件部件的表示形式为标量整型表达式或者是一个星号, 而内部文件部件的表示形

292 式为默认字符型变量部件的一般规则如下 : 表示内部文件部件的默认字符型变量不能是带有向量下标的数组片断一个部件可以作为外部部件也可以作为内部部件外部部件用来联结外部文件 ; 而内部部件用来联结内部文件如果表示内部文件部件的字符型变量是指针, 那么该指针必须是获得了关联的如果表示内部文件部件的字符型变量是一个可分配数组, 或者这样一个数组的子对象, 那么该数组必须是当前可分配的表示外部文件部件的标量整型表达式必须是 0 或正整数出现在文件联结语句, 文件定位语句, 以及文件查询语句当中的输入输出部件只能表示外部文件部件在一个程序的所有程序单位里面, 一个表示外部文件部件的标量整型表达式的值, 表示同一个外部部件星号表示预先联结用来进行格式化序列访问的特定的与系统相关的外部部件对于一个给定程序, 在任意的时间总是存在一个与系统相关的外部部件集合所有的输入输出语句都可以使用存在的部件, 而 INQUIRE 语句和 CLOSE 语句还可以使用不存在的部件例 16-1 SUBROUTINE A READ (6) X... SUBROUTINE B N = 6 REWIND N 在这个程序例子里面, 两个不同的程序单位里面出现的外部部件名称 6 表示同一个外部部件文件到部件的联结与预联结一个外部部件可以被联结, 也可以不被联结, 这两种状态都是合法的外部部件通过预联结或通过使用 OPEN 语句而获得与一个外部文件的联结, 正是这种联结使得外部文件能够被程序访问这种访问也就是输入输出语句的功能所在, 或者准确地说是除了 OPEN 语句,CLOSE 语句, 以及 INQUIRE 语句之外的所有输入输出语句因此而能够通过外部部件而访问相应的外部文件或对相应的外部文件进行操作文件到部件的联结与预联结的一般规则如下 : 一个文件可以与部件建立联结但本身却还不存在, 例如一个已经建立了预联结的文件, 但可能还没有被写入一个部件在同一个时间不能联结多于一个文件 ; 而一个文件也不能在同一个时间与多于一个的部件相联结执行 CLOSE 语句之后, 相关的外部部件就失去了联结, 然后在同一个程序单位里面, 该部件仍然可以根据程序的需要再次与同一个文件或不同的文件建立联结类似的, 执行 CLOSE 语句之后, 相关的外部文件也失去了联结, 然后在同一个程序单位里面, 该文件仍然可以根据程序的需要而再次与同一个部件或不同的设备建立联结一旦一个文件失去了联结, 那么再次引用该文件的唯一方法就是在 OPEN 语句或

293 INQUIRE 语句里面引用该文件的名称, 而如果失去联结的文件没有名称, 那么就无法使得它再次获得联结对于内部部件来说, 总联结到由标志该部件的默认字符型变量所给出的内部文件一旦部件与文件建立了联结, 那么也就意味着建立了访问的方法, 或者是序列访问, 或者是直接访问一旦与一个已经存在的文件, 或者是通过联结而生成的新文件建立联结, 那么就会建立相应的格式化或非格式的数据格式如果联结是通过执行 OPEN 语句而建立的, 那么在没有指定数据格式的情形下给出默认数据格式 ; 如果联结为预联结到一个已经存在的文件, 那么数据格式由预联结建立 ; 如果预联结到一个不存在的文件, 那么数据格式可以建立, 也可以推迟到文件生成之后再建立, 例如运行格式化或非格式的 WRITE 语句之后 OPEN 语句 OP EN 语句的功能就是建立初始的外部文件与指定部件之间的联结, 或者是修改该联结具体地说, 一个 OPEN 语句可以产生如下几种作用 : 联结一个已经存在的文件到部件 ; 产生一个已经预联结的文件 ; 产生一个新的文件然后把它联结到指定部件 ; 改变一个文件与部件之间联结的特定说明符 OPEN 语句的语法形式 (R904) 为 : OPEN ( connect-spec-list ) 其中的联结说明 (connect-spec) 的语法形式 (R905) 有以下几种 : [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label FILE = file-name-expr STATUS = scalar-default-char-expr ACCESS = scalar-default-char-expr FORM = scalar-default-char-expr RECL = scalar-int-expr BLANK = scalar-default-char-expr POSITION = scalar-default-char-expr ACTION = scalar-default-char-expr DELIM = scalar-default-char-expr PAD = scalar-default-char-expr 其中的文件名称表达式 (file-name-expr) 为标量默认字符型表达式 (R906) OPEN 语句的一般规则为 : 如果在部件说明符里面省略可选字符 UNIT=, 那么联结说明列表 (connect-spec-list) 的第一项必须是部件说明符

294 在一个给定 OPEN 语句里面, 任何说明符都至多只能出现一次 ; 其中必须给出外部文件部件 (external-file-unit) 在说明符 ERR= 里面给出的语句标签必须是与该 OPEN 语句同一个作用域单位里面的分支目标语句的标签如果说明符 STATUS= 的值为 NEW 或 REPLACE, 那么说明符 FILE= 必须同时给出如果说明符 STATUS= 的值为 SCRATCH, 那么说明符 FILE= 不能同时出现如果说明符 STATUS= 的值为 OLD, 那么说明符 FILE= 必须出现, 除非部件当前联结到一个文件, 并且该文件存在说明符当中出现的标量默认字符表达式为字符的有限列表, 尾部的空格被忽略如果系统同时支持大小写, 那么字符取值不区分大小写在一个程序的任意程序单位里面, 一旦一个外部部件通过 OPEN 语句获得联结, 那么在该程序的任意程序单位里面都可以引用该部件如果一个部件已经联结到一个存在的文件, 仍然可以对该部件执行 OPEN 语句如果在该 OPEN 语句当中不包含 FILE= 说明符, 那么与该部件联结的文件就是已经与该部件联结的文件如果与部件联结的文件并不存在, 但是和已经与部件预联结的文件相同, 那么由 OPEN 语句给出的属性成为联结的一部分如果通过 OPEN 语句联结到部件的文件与已经与部件联结的文件不同, 那么这个 OPEN 语句的执行效果相当于 : 在执行 OPEN 语句之前, 马上执行一个不带有 STATUS= 说明符的 CLOSE 语句如果通过 OPEN 语句联结到部件的文件与已经与部件联结的文件相同, 只是当前起作用的 B LANK=,DELIM=,PAD=,ERR=, 以及 IOSTAT= 这些说明符的值不同, 那么会产生如下后果 : 如果 OPEN 语句当中包含 POSITION= 说明符, 那么它的值可能与文件的当前定位不符如果 OPEN 语句当中包含 STATUS= 说明符, 那么它的值为 OLD BLANK=,DELIM=,PAD= 这些说明符的值发生作用, 而其他没有出现的说明符不会发生变化, 文件的定位也不会发生变化此前执行的任何 OPEN 语句的 ERR=, 以及 IOSTAT= 这些说明符对当前执行的 OPEN 语句没有影响如果通过 OPEN 语句联结到部件的文件与已经与部件联结的文件相同, 那么具有值 OLD 的说明符 STATUS= 总是合法的, 这时如果文件在执行 OPEN 语句之前的状态为 SCRATCH, 那么在部件关闭后, 文件被删除, 并且认为具有 SCRATCH 状态如果一个文件已经与一个部件建立联结, 那么对该文件运用 OPEN 语句使其与另外一个不同的部件建立联结是非法的例 16-2 OPEN (10, FILE = 'employee.names', ACTION = 'READ', PAD = 'YES') 下面更加详细地说明 OPEN 语句当中所使用的各种说明符的含义 1 FILE= 说明符 FILE= 的值就是与给定部件联结的文件的名称它尾部的所有空格都被忽略而文件名称表达式必须是系统的合法名称如果在 OPEN 语句当中省略该说明符, 并且部件也没有与文件建立联结, 那么说明符 STATUS= 给出值 SCRATCH, 这时部件联结一个依赖具体系统的文件 2 STATUS= 其中的标量默认字符表达式取值为 OLD,NEW,SCRATCH,REPLACE, 以及 UNKNOWN

295 当说明符取值为 OLD 时, 文件存在, 而取值为 NEW 时, 则文件不存在当具有值 NEW 的 OPEN 语句成功运行之后, 生成相应的文件, 然后状态自然转变为 OLD 当取值为 REPLACE 时, 如果文件不存在, 那么 OPEN 语句生成一个新文件, 然后状态取为 OLD; 而如果文件已经存在, 则该文件被删除,OPEN 语句生成一个新文件, 具有与被删除文件相同的文件名称, 然后状态取为 OLD 如果取值为 SCRATCH, 则生成文件并联结到指定的部件, 以供程序使用, 然后在执行引用同一个部件的 CLOSE 语句之后, 或者是程序终止之后, 该文件被删除 SCRATCH 不能用于命名文件如果取值为 UNKNOWN, 则具体的状态依赖于系统的约定如果说明符被省略了, 则默认值就是 UNKNOWN 3 ACCESS= 其中标量默认字符表达式的取值为 SEQUENTIAL 或 DIRECT 分别表示文件联结的访问方法为序列访问或直接访问如果该说明符被省略, 则默认取值为 SEQUENTIAL 如果联结文件已经存在, 那么该说明符指定的访问方法必须对于该文件是合法的如果文件不存在而需要生成新文件, 那么说明符指定的访问方法必须对于该新文件是合法的 4 FORM= 其中标量默认字符表达式取值为 FORMATTED 或 UNFORMATTED 分别表示文件联结为格式化输入输出或无格式输入输出如果该说明符被省略了, 那么在文件联结为直接访问时, 默认值为 UNFORMATTED; 而如果文件联结为序列访问时, 默认值为 FORMATTED 如果联结文件已经存在, 那么该说明符指定的格式必须对于该文件是合法格式如果文件不存在而需要生成新文件, 那么说明符指定的格式必须对于该新文件是合法格式 5 RECL= 该说明符的取值必须为正整数在文件联结为直接访问的情况下, 该取值表示文件的每个纪录的长度 ; 在文件联结为序列访问的情况下, 该数值表示文件的所有纪录当中最大的长度在文件联结为直接访问时, 该说明符必须给出在文件联结为序列访问时, 该说明符可以省略, 默认值依赖于系统的约定如果文件联结为格式化输入输出, 那么取值为只包含默认字符型字符的纪录的字符数目如果纪录里面包含了非默认字符型, 那么该说明符的取值依赖于系统的约定如果文件联结为无格式输入输出, 那么纪录长度由系统约定的度量单位来决定具体数值如果联结文件已经存在, 那么该说明符指定的长度必须对于该文件是合法长度如果文件不存在而需要生成新文件, 那么说明符指定的长度必须对于该新文件是合法长度 6 BLANK= 其中标量默认字符表达式的取值为 NULL 或 ZERO BLANK= 说明符只能用于格式化输入输出的文件联结如果取值为 NULL, 那么在给定部件的数值格式化输入域里面的所有空格字符都被忽略, 除非全部为空格的域具有零值如果取值为 ZERO, 那么除了头部的空格之外, 所有其他空格都被视为 0 如果该说明符省略了, 那么默认值为 NULL

296 7. POSITION= 联结其中标量默认字符表达式的取值为 ASIS,REWIND, 或 APPEND 该说明符只能用于序列访问的一个新生成的文件总是定位于初始点 REWIND 使得一个已经存在的文件定位于它的初始点 APPEND 使得一个已经存在的文件定位于文件终止纪录的前纪录, 而如果该文件不包含文件终止纪录, 则定位于该文件的终止点如果文件存在并且已经联结, 那么 ASIS 使得它的定位不变, 而如果文件存在但没有联结, 那么 ASIS 表示它的定位未知如果该说明符被省略, 那么默认值为 ASIS 其中标量默认字符表达式可以取值为 READ, WRITE, READWRITE 取值 READ 表示 WRITE, PRINT, 以及 ENDFILE 语句都不能引用该联结取值 WRITE 表示 READ 语句不能引用该联结取值 READWRITE 表示任何输入输出语句都可以引用该联结如果该说明符省略了, 则默认值依赖于系统的约定如果文件的合法操作里面包含了 READWRITE, 那么也应该包含 READ 和 WRITE 如果联结文件已经存在, 那么该说明符指定的操作必须对于该文件是合法操作如果文件不存在而需要生成新文件, 那么说明符指定的操作必须对于该新文件是合法操作该说明符只能用于具有格式化输入输出联结的文件在输入格式化纪录时该说明符被忽略其中标量默认字符表达式可以取值为 APOSTROPHE,QUOTE,NONE 如果取值为 APOSTROPHE, 则表控或名称列表格式写入的字符值的分隔必须使用撇号 ; 而内部撇号则必须使用双撇号如果取值为 QUOTE, 那么表控或名称列表格式写入的字符值的分隔必须使用引号 ; 而内部引号则必须使用双引号如果取值为 NONE, 那么写入字符不能使用撇号或引号作为分隔标志, 内部撇号或引号也不能是双的如果该说明符被省略了, 那么默认取值为 NONE 10. PAD= 该说明符只能用于具有格式化输入输出联结的文件在格式化纪录输出时, 该说明符被忽略 8. ACTION= 9. DELIM= 其中的标量默认字符表达式可以取值为 YES,NO 如果取值为 YES, 那么在给出了输入列表, 并且格式说明要求纪录包含比它本来具有的数据更多的数据时, 该格式化输入纪录可以在尾部添加足够的空格如果取值为 NO, 那么输入列表以及格式说明都不能要求纪录具有比它本来具有的数据更多的数据如果该说明符被省略, 那么默认取值为 YES 对于非默认字符型数据, 对于附加的空格字符由系统约定 CLOSE 语句 CLOSE 语句的功能为终止一个给定部件到一个外部文件的联结 CLOSE 语句的一般语法形式 (R907) 为 :

297 CLOSE ( close-spec-list ) 其中的关闭说明 (close-spec) 可以是如下几种形式 (R908) 之一 : [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label STATUS = scalar-default-char-expr CLOSE 语句的一般规则为 : 如果在部件说明当中省略了字符 UNIT=, 那么部件说明符必须是关闭说明列表的第一项. 在一个给定关闭说明里面, 任何说明符都只能出现一次, 其中必须给出外部文件部件出现在说明符 ERR= 当中的语句标签, 必须是在和 CLOSE 语句同一个作用域单位里面的分支目标语句的标签其中的标量默认字符表达式取值为字符型数据, 其尾部的空格都被忽略如果系统同时支持大小写, 那么不区分字符的大小写在程序的任何程序单位里面都可以对某个部件执行 CLOSE 语句, 但是不能在同一个作用域单位里面和 OPEN 语句作用于同一个部件针对一个不存在的部件, 或者是一个没有与文件联结的部件执行 CLOSE 语句是合法的, 但是不影响任何文件在一个作用域单位里面, 如果一个部件被 CLOSE 语句关闭联结之后, 仍然可以再次和原来的文件, 或者是另外的文件建立联结在一个作用域单位里面, 如果一个命名文件被 CLOSE 语句关闭联结, 那么它仍然可以在该程序单位里面和同一个部件, 或者另外的部件建立联结, 只要该文件一直存在程序的执行正常终止之后, 所有的部件联结都被关闭如果在终止之前文件状态为 SCRATCH, 那么关闭之后部件状态为 DELETE; 其他情形下关闭之后的部件状态为 KEEP 例 16-3 CLOSE (10, STATUS = 'KEEP') CLOSE 语句的 STATUS= 说明符遵循如下规则 : 其中的标量默认字符表达式可以取值为 KEEP,DELETE, 分别表示是否保留与给定部件联结的文件 KEEP 不能用于在执行 CLOSE 语句之前状态为 SCRATCH 的文件如果 KEEP 用于一个存在的文件, 那么在执行 CLOSE 语句之后, 该文件继续存在如果 KEEP 用于一个不存在的文件, 那么在执行 CLOSE 语句之后, 该文件仍然不存在如果取值为 DELETE, 那么在执行 CLOSE 语句之后, 文件不再存在如果该说明符被省略, 那么默认值为 KEEP, 除非文件在执行 CLOSE 语句之前状态为 SCRATCH, 如果出现那种情况, 则默认值为 DELETE 16.3 文件的传输文件传输语句包括如下三种 : READ 语句, 为数据输入语句 ;

298 WRITE 语句和 PRINT 语句, 为数据输出语句 READ 语句的一般语法形式 (R909) 为以下两种形式之一 : READ ( io-control-spec-list ) [ input-item-list ] READ format [, input-item-list ] WRITE 语句的一般语法形式 (R910) 为 : WRITE ( io-control-spec-list ) [ output-item-list ] PRI NT 语句的一般语法形式 (R911) 为 : PRINT format [, output-item-list ] 对于其中的输入输出控制说明列表 (io-control-spec-list) 和数据输入输出项列表 (input/ou tput-item-list) 在下面分节予以说明例 16-4 READ (6, *) SIZE READ 10, A, B WRITE (6, 10) A, S, J PRINT 10, A, S, J 10 FORMAT (2E16.3, I5) 控制信息列表所谓输入输出控制说明列表就是控制信息列表, 用来控制数据的传输, 包括如下的成分 : 数据传输的源或目标 ; 可选的编辑过程的说明 ; 可选的确定纪录的说明 ; 可选的对于需要排除的操作的说明 ; 可选的状态返回 ; 可选的纪录预说明 ; 可选的读入字符数目返回输入输出控制说明的一般语法形式 (R912) 有如下几种 : [ UNIT = ] io-unit [ FMT = ] format [ NML = ] namelist-group-name REC = scalar-int-expr IOSTAT = scalar-default-int-variable ERR = label END = label ADVANCE = scalar-default-char-expr SIZE = scalar-default-int-variable EOR = label 按照控制信息列表所包含的内容的不同, 数据传输语句可以分为两种 :

299 如果数据传输语句包含了格式说明或名称列表集合名称, 那么该语句就属于格式化输入输出语句否则就属于无格式输入输出语句控制信息列表的一般规则为 : 在上面列举的输入输出控制说明当中必须包含一个, 也至多包含一个输入输出部件, 而其他的说明选项至多出现一次在 WRITE 语句当中不能出现 END=,EOR=, 以及 SIZE= 说明符出现在说明符 ERR=,EOR=, 以及 END= 里面的语句标签必须该数据传输语句所在的作用域单位里面的分支目标语句的标签如果在数据传输语句当中出现了输入输出项列表, 那么就不能同时出现名称列表集合名称一个输入输出控制说明列表里面不能同时包含一个格式说明和一个名称列表集合名称如果部件说明符里面省略了字符 UNIT=, 那么控制信息列表的第一项必须是部件说明符如果在格式说明符里面省略了字符 FMT=, 那么控制信息列表的第二项必须是格式说明符, 而控制信息列表的第一项必须是不带可选字符 UNIT= 的部件说明符如果在名称列表说明符里面省略了字符 NML=, 那么控制信息列表的第二项必须是名称列表说明符, 而控制信息列表的第一项必须是不带可选字符 UNIT= 的部件说明符如果部件说明符给出的是一个内部文件, 那么输入输出控制说明列表不能包含说明符 REC=, 也不能包含名称列表集合名称如果语句当中给出了说明符 REC=, 那么其中就不能出现说明符 END= 和名称列表集合名称, 如果出现格式说明, 则不能是星号表示的表控输入输出说明符 ADVANCE= 只能出现在具有显式格式说明的格式化序列输入输出语句里面, 其控制信息列表不包含内部文件的部件说明符如果出现了 EOR= 说明符, 那么说明符 ADVANCE= 也必须同时出现如果出现了 SIZE= 说明符, 那么说明符 ADVANCE= 也必须同时出现说明符 SIZE= 只能出现在包含取值为 NO 的说明符 ADVANCE= 的输入语句当中说明符 EOR= 只能出现在包含取值为 NO 的说明符 ADVANCE= 的输入语句当中如果数据传输语句的 IOSTAT= 或 SIZE= 说明符里面给出了变量, 那么该变量不能关联于数据传输输入输出列表里面的任何数据对象, 也不能关联于名称列表集合对象列表里面的任何数据对象, 也不能关联于数据传输输入输出列表里面的隐式输入输出 do 结构里的 do 变量在数据传输语句里面, 如果由说明符 IOSTAT= 或者说明符 SIZE= 给出的变量为数组元素引用, 那么数据传输, 隐式输入输出 do 过程, 或者在输入输出控制说明列表里面的其他说明符定义或赋值, 都不影响其下标值例 16-5 下面给出一个 READ 语句的例子 READ (IOSTAT = IOS, UNIT = 6, FMT = '(10F8.2)') A, B 下面我们分节说明控制信息列表的各种说明符以及相关内容 1. 格式说明符 FMT= 说明符 FMT= 的功能为在格式化输入输出语句当中提供格式说明, 或提供表控格式它的一般语法形式 (R913) 为 default-char-expr label

300 其中的标签 (label) 必须是出现在同一个作用域单位里面的包含了格式说明符的作为 FORMAT 语句的标签其中的默认字符表达式 (default-char-expr) 表示一个有效的格式说明该表达式也可以是一个特殊的字符常量, 注意参考第 7 章里面对于表达式的说明如果该表达式是一个数组的形式, 那么可以把该数组看成是所有的数组元素按照数组元素序串联起来如果格式表示是其中的星号 *, 那么该语句就是所谓的表控输入输出语句例 16-6 READ (6, FMT = "(" // CHAR_FMT // ")" ) X, Y, Z 在这个例子里面格式为字符表达式, 其中 CHAR_FMT 为一个默认字符变量 2. 名称列表说明符 NML= 说明符 NML= 给出名称列表集合名称该名称表示了一个需要进行数据传输操作的数据对象的集合如果语句当中给出了这个名称列表集合名称, 那么该语句就是所谓名称列表输入输出语句 3. 纪录数说明符 REC= 纪录数说明符 The REC= 给出需要读写的纪录的数目该说明符只能用于针对直接访问联结部件的输入输出语句, 因此这个说明符可以说是一个标志性的东西, 即只要控制信息列表里面包含了 REC= 说明符, 那么该语句就是所谓直接访问输入输出语句, 否则就是所谓序列访问输入输出语句 4. 输入输出状态说明符 IOSTAT= 执行一个包含了 IOSTAT= 说明符的输入输出语句实际上也就是定义了在 IOSTAT= 说明符里面给出的变量该变量的取值情况有如下几种 : 如果语句执行过程当中没有出现错误条件, 也没有出现文件终止条件和纪录终止条件, 那么变量取值为 0 如果出现错误条件, 那么取值为系统约定的正整数值如果出现文件终止条件, 而没有出现错误条件, 那么取值为系统约定的负整数值如果出现纪录终止条件, 而没有出现错误条件与文件终止条件, 那么取值为系统约定的不同于文件终止条件下的取值的负整数值只有在执行序列输入语句时才会出现文件终止条件, 而只有在执行非预输入语句时才会出现纪录终止条件, 参见下面的例子例 16-7 READ (FMT = "(E8.3)", UNIT = 3, IOSTAT = IOSS) X IF (IOSS < 0) THEN! 对联结到部件 3 的文件进行文件终止操作. CALL END_PROCESSING ELSE IF (IOSS > 0) THEN! 进行出错处理 CALL ERROR_PROCESSING END IF

301 5. 出错分支处理如果在执行一个包含了说明符 ERR= 的输入输出语句时出现了错误条件, 就会导致如下的分支后果 : 输入输出语句执行中断 ; 输入输出语句给出的文件定位不可确定 ; 如果该输入输出语句还包含了 IOSTAT= 说明符, 那么其中给出的变量取值为系统约定的正整数值如果执行的语句是 READ 语句, 并且包含了 SIZE= 说明符, 那么变量取值整数值 ; 继续执行由 ERR= 说明符给出的语句 6. 文件终止时的分支处理如果在执行包含了 END= 说明符的输入语句时出现了文件终止条件, 但没有出现错误条件, 那么会导致如下分支后果 : 输入语句的执行中断 ; 如果输入语句中指定的文件是外部文件, 那么它定位在文件终止纪录的后面如果输入语句包含了说明符 IOSTAT=, 那么其中给出的变量取值为系统约定的负整数值继续执行由 END= 说明符给出的语句 7. 纪录终止时的分支处理如果在执行包含了 EOR= 说明符的输入输出语句时出现了纪录终止条件, 但没有出现错误条件, 那么会导致如下分支后果 : 如果语句当中包含的说明符 PAD= 的取值为 YES, 那么纪录被添加上空格, 以便满足输入列表项及其数据编辑描述符对于纪录字符数目的要求输入语句的执行中断输入语句给出的文件定位于当前纪录后面如果输入语句包含了说明符 IOSTAT=, 那么其中给出的变量取值为系统约定的负整数值如果输入语句包含了说明符 SIZE=, 那么其中给出的变量取值为整数值继续执行由 EOR= 说明符给出的语句 8. ADVANCE= 说明符其中的标量默认字符表达式 (scalar-default-char-expr) 可以取值为 YES 或 NO 该说明符用来说明是否在输入输出语句当中出现非预输入输出如果取值为 NO, 则出现非预输入输出 ; 如果取值为 YES, 那么出现预格式化序列输入输出如果该说明符省略了, 那么默认取值为 YES 9. 字符数目说明符 SIZE= 当非预输入语句中断之后, 在说明符 SIZE= 当中给出的变量, 取值为在当前输入语句执行过程当中由数据编辑描述符传输的字符数目其中填充的空格不计入该字符数目值数据传输的输入输出列表一个所谓输入输出列表给出通过数据传输输入输出语句传输了数据值的数据项其中输入项 (input-item) 的一般语法形式 (R914) 为 :

302 variable io-implied-do 其中输出项 (output-item) 的一般语法形式 (R915) 为 : expr io-implied-do 其中隐式输入输出 do 结构 (io-implied-do) 的一般语法形式 (R916) 为 : ( io-implied-do-object-list, io-implied-do-control ) 而里面的隐式 do 对象 (io-implied-do-object) 的语法形式 (R917) 为 : input-item output-item 里面的隐式输入输出 do 控制 (io-implied-do-control) 的语法形式 (R918) 为 : do-variable = scalar-int-expr, & & scalar-int-expr [, scalar-int-expr ] 输入输出列表的一般规则为 : 作为输入项的变量不能是完全哑尺度数组 do 变量必须是整型的命名标量变量在输入项列表 (input-item-list) 里面, 隐式输入输出 do 对象 (io-implied-do-object) 必须是一个输入项在输出项列表 (output-item-list) 里面, 隐式输入输出 do 对象 (io-implied-do-object) 必须是一个输出项如果某个输入项为指针, 那么它必须当前关联于一个可定义的目标数据对象, 并且数据从文件传输到关联目标如果某个输出项为指针, 那么它必须当前关联于一个可定义的目标数据对象, 并且数据从关联目标传输到文件一个输入项不能是一个包含输入项的隐式输入输出 do 结构的 do 变量, 也不能关联于这样的 do 变量一个派生数据类型的对象, 如果它的成员里面包含了指针, 则不能作为输入输出列表里面的数据项因为指针成员的值只是对于内存地址的一个描述符, 因此不具有独立于系统的表示方法如果输入项或输出项为可分配数组, 那么它的当前状态应该是已分配包含在一个隐式输入输出 do 结构里面的隐式输入输出 do 结构的 do 变量, 不能是其宿主结构的 do 变量, 也不能关联于这样的 do 变量如果是输入输出列表里面出现了数组作为列表项, 那么其中的元素按照数组元素序的顺序加以说明数组的元素都不影响输入项里面任何表达式的值, 任何元素都不能在输入项里面重复出现输入输出列表当中的隐式 do 结构的循环初始化和执行过程与 DO 结构的一样如果输入输出语句说明的是内部文件, 那么输入输出列表不能包含非默认字符类型的数据对象常量, 包含算符或函数引用的表达式, 以及括号当中的表达式都可以出现在输出列表里面, 但不能出现在输入列表里面

303 例 16-8 下面的例子里面既有合法的形式也有不合法的形式 INTEGER A (100), J (100)... READ *, A (A)! 非法 READ *, A (LBOUND (A, 1) : UBOUND (A, 1))! 合法 READ *, A (J)! 如果 J 的元素都不重复则是合法的 READ *, A (A (1) : A (10))! 非法例 16-9 WRITE (LP, FMT = '(10F8.2)') (LOG (A (I)), I = 1, N + 9, K), G 这个例子的输出列表里面包含了一个隐式 do 结构数据传输输入输出语句的执行执行一个数据传输输入输出语句的完整过程如下 : (1) 决定数据传输的方向 ; (2) 确定相应的部件 ; (3) 如果要求格式则建立相应的格式 ; (4) 在文件传输之前对文件定位 ; (5) 在文件与输入输出列表或名称列表里面给出的数据项之间进行数据传输 ; (6) 随时判别是否出现错误条件, 文件终止条件, 以及纪录终止条件 ; (7) 在数据传输完成之后, 再次对文件进行定位 ; (8) 对说明符 IOSTAT= 和 SIZE= 里面的变量定义恰当的值格式化纪录的打印把格式化之后的纪录传输给系统设置的外部设备就称为打印在打印一个格式化纪录的时候, 纪录的第一个字符是格式说明, 不被打印出来, 而纪录的其他字符都打印在一行上纪录的第一个字符必须是默认字符型数据, 它的功能在于决定竖直方向的行距, 列举如下表 16-1: 表 16-1 纪录字符所表示的行距纪录的第一个字符行距约定空格 1 行 0 2 行 1 下页的第一行 + 没有前面行如果纪录不包含任何字符, 那么行距为 1 行, 并且除了空格之外, 在该行上不打印任何字符

304 PRINT 语句并不意味着打印开始,WRITE 语句也不意味着打印开始, 它们都只是起到类似记账的作用数据传输语句的终止当出现如下的情况时, 数据传输输入输出语句的执行都被中断 : 格式处理遇到一个数据编辑描述符, 而同时在输入输出项列表里面不再包含任何元素无格式的数据或表控数据的传输完成整个输入项列表或输出项列表的所有项目名称列表输出完成整个名称列表集合对象列表 (namelist-group-object-list) 里面的所有项目出现错误条件出现文件终止条件 An end-of-file condition occurs. 在表控输入或名称列表输入时, 读入纪录遇到了作为值分隔符的斜线 (/) 在执行非预输入语句时, 出现了纪录终止条件 16.4 文件的定位文件的定位语句包括 BACKSPACE 语句,ENDFILE 语句和 REWIND 语句, 它们的语法形式如下 BACKSPACE 语句的语法形式 (R919) 为 : BACKSPACE external-file-unit BACKSPACE ( position-spec-list ) ENDFILE 语句的语法形式 (R920) 为 ENDFILE external-file-unit ENDFILE ( position-spec-list ) REWIND 语句的语法形式 (R921) 为 : REWIND external-file-unit REWIND ( position-spec-list ) 其中的定位说明 (position-spec) 的语法形式 (R922) 为 : [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label 文件的定位的一般规则如下 : ERR= 说明符里面的标签必须是处于与文件定位语句同一个作用域单位的分支目标语句的标签如果在部件说明符里面省略了可选的字符 UNIT=, 那么定位说明列表的第一项必须是部件说明符

305 定位说明列表里面必须包含且只能包含一个外部文件部件, 并且每个说明符只能至多出现一次没有联结为序列访问的文件不能用于这三个定位语句, 而具有 ACTION= 说明符, 并且取值为 READ 的联结的文件不能用于 ENDFILE 语句 BACKSPACE 语句执行一个 BACKSPACE 语句, 那么文件联结到给定部件, 文件定位则有如下三种情形 : 如果文件存在当前纪录, 定位于当前部件前如果不存在当前纪录, 则定位于前纪录前面如果不存在当前纪录, 也不存在前纪录, 那么文件定位不变如果前纪录为文件终止纪录, 那么文件定位于文件终止纪录前面如果 BACKSPACE 语句导致隐式写入文件终止纪录, 那么文件定位于文件终止纪录之前的那个纪录例下面是 BACKSPACE 语句的一个例子 BACKSPACE (10, ERR = 20) ENDFILE 语句 ENDFILE 语句的功能是写入一个文件终止纪录作为文件下一个纪录, 然后文件定位于该文件终止纪录后面, 而该文件终止纪录就成为了该文件的最后一个纪录如果该文件也能够被联结为直接访问, 那么只有在该文件终止纪录之前的纪录是真实写入了的, 因此也就只有这些纪录能够被随后的直接联结读到在执行 ENDFILE 语句之后, 还可以在执行任何的数据传输输入输出语句之前应用 BACKSPACE 语句或 REWIND 语句来改变文件的定位针对一个联结了但是并不存在的文件执行 ENDFILE 语句, 将在写入文件终止纪录之前产生该文件例 ENDFILE K 这是一个简单的 ENDFILE 语句的例子 REWIND 语句执行 REWIND 语句的效果就是使得给定的文件被定位于它的初始点如果文件本来就已经定位于它的初始点, 那么再执行 REWIND 语句将不会对它的定位产生任何影响针对一个联结了但并不存在的文件执行 REWIND 语句是合法的, 但是并不能产生任何的影响例 REWIND 10

306 这是一个 REWIND 语句的简单例子 16.5 文件的查询 INQUIRE 语句的功能为查询特定命名文件或与特定部件的联结的属性 INQUIRE 语句具有三种形式 : 文件查询形式这种查询形式使用说明符 FILE= 部件查询形式这种查询形式使用说明符 UNIT= 输出列表查询这种查询形式使用说明符 IOLENGTH= 所有这些说明符的赋值规则都遵循一般的赋值语句的规则 INQUIRE 语句可以在文件的任何联结状态之下执行,INQUIRE 语句返回的值反映当前被执行的语句的文件状态 INQUIRE 语句的一般语法形式 (R923) 为 INQUIRE ( inquire-spec-list ) INQUIRE ( IOLENGTH = scalar-default-int-variable ) & &output-item-list 例 INQUIRE (IOLENGTH = IOL) A (1:N) INQUIRE (UNIT = JOAN, OPENED = LOG_01, NAMED = LOG_02, & FORM = CHAR_VAR, IOSTAT = IOS) 第 17 章数据文件的编辑对于真实世界的任何数据, 我们总是要赋予一定的表示形式, 以适应人的阅读理解习惯, 也就是对于任何数据文件的都存在一个约定的格式, 因此当我们使用计算机来输出数据文件时, 当然希望直接输出的就是我们所习惯阅读的带有相应格式的数据文件 ; 同样, 在我们向计算机输入数据文件时, 也希望仍然按照我们习惯的格式约定直接输入到计算机, 因此 FORTRAN 必须提供能够描述数据文件格式的适当的词汇与语句, 从而方便人机对话实际上只要不是特别小的 FORTRAN 程序, 无论是为了便于程序作者, 还是便于其他用户的使用, 都必须包含大量的数据输入输出的格式编辑方面的内容, 因此掌握好语言的输入输出编辑功能, 是编写一个好的 FORTRAN 程序的非常重要的方面对输入输出进行格式控制的基本任务, 就是要在数据的机器内部表示与数据的格式化纪录或文件当中的表示之间, 进行适当的转化当然从编程语言的角度来看, 我们并不需要直接地参与

307 这种具体的转化过程, 因为数据的机器内部表示是非常依赖于具体的系统的, 作为一种通用编程语言,F ORTRAN 并不需要具有描述具体系统的能力,FORTRAN 所需要做的, 只需要能够提供描述格式本身的语言就行了, 系统如何根据这种描述而进行数据转换, 则不需要程序编写者关心 FORTRAN 95 对于格式的描述主要就是依靠格式说明符来完成的, 此外还可以运用名称列表集合名称来说明名称列表格式下面我们分别予以详细讨论 17.1 显式格式说明显式的格式说明可以使用如下两种方式 : 运用 FORMAT 语句 ; 运用字符表达式下面分节讨论这两种显式格式说明方式 FORMAT 语句 FORMAT 语句的一般语法形式 (R1001) 为 : FORMAT format-specification 其中格式说明 (format-specification) 的一般语法形式 (R1002) 为 : ( [ format-item-list ] ) 其中的格式项列表 (format-item-list) 在 17.2 节专门加以讨论 FORMAT 语句的一般规则如下 : FORMAT 语句必须具有标签在格式项列表当中用于分隔不同格式项的逗号可以在如下几种情形下省略 : P 编辑描述符与后面紧接的 F, E, EN, ES, D, 或 G 编辑描述符之间 ; 没有给出可选的重复说明时, 在斜线编辑描述符之前 ; 斜线编辑描述符之后 ; 冒号编辑描述符的前后空格字符可以放置在格式说明的初始的左括号之前除了在字符串编辑描述符内部之外, 空格可以添加在格式说明的任何位置, 不影响对于格式说明的解释例 FORMAT (1PE12.4, I10) 这是 FORMAT 语句的两个简单例子字符表达式作为格式说明 9 FORMAT (I12, /, ' Dates: ', 2 (2I3, I5)) 显式的格式说明除了使用 FORMAT 语句之外, 还可以使用字符表达式, 即在格式化输入输

308 出语句里面, 字符表达式的字符串取值, 作为格式说明符能够有效地说明格式注意整个格式说明必须是包含在一对括号当中的当格式说明所在的输入输出语句开始执行的时候, 格式说明的括号里面的全部字符都必须是已经获得了定义的, 而在该语句的整个执行过程当中, 其定义都不能被重定义或去定义而最右边括号后面的字符则没有任何说明格式的意义如果格式说明符引用了一个字符数组, 那么该数组的元素按照元素序列联结起来作为一个整体看待注意 : 如果在输入输出语句里面使用了字符常量来作为格式说明符, 那么必须保证该字符常量是有效的格式说明参见下面的例子例 17-2 考虑下面的文字 : 2 ISN'T 3 这段文字在输出语句与格式说明当中可以使用如下多种形式 : WRITE (6, 100) 2, FORMAT (1X, I1, 1X, 'ISN''T', 1X, I1) WRITE (6, '(1X, I1, 1X, ''ISN''''T'', 1X, I1)') 2, 3 注意其中多重的引号与撇号 WRITE (6, '(A)') ' 2 ISN''T 3' 17.2 格式项列表的形式所谓格式项 (format-item) 的一般语法形式 (R1003) 是 : [ r ] data-edit-desc control-edit-desc char-string-edit-desc [ r ] ( format-item-list ) 其中的 r(r1004) 为整型字面常量, 表示说明重复数它必须是正的, 并且不能带有种别参数其中所谓编辑描述符分为如下三种 : 数据编辑描述符 ; 控制编辑描述符 ; 字符串编辑描述符下面分别给出它们的语法形式 1. 数据编辑描述符的语法形式 (R1005) 为以下几种形式之一 :

309 I w [. m ] B w [. m ] O w [. m ] Z w [. m ] F w. d E w. d [ E e ] EN w. d [ E e ] ES w. d [ E e ] G w. d [ E e ] L w A [ w ] D w. d 其中的 w(r1006),m(r1007),d(r1008),e(r1009) 都是整型字面常量而其中的 I, B, O, Z, F, E, EN, ES, G, L, A, 和 D 则表示不同的编辑方式详细说明参见 17.5 节数据编辑描述符的一般规则如下 : e必须是正的 w在 I, B, O, Z, 以及 F 这些编辑描述符里面必须是 0 或正数在其他编辑描述符里面则必须是正的 w, m, d, 以及 e 不能带有种别参数 2. 控制编辑描述符的一般语法形式 (R1010) 为以下几种 : position-edit-desc [ r ] / : sign-edit-desc k P blank-interp-edit-desc 其中的 k(r1011) 表示带符号的整型字面常量它不能具有种别参数而其中的位置编辑描述符 (position-edit-desc) 的一般语法形式 (R1012) 为 : T n TL n

310 TR n n X 其中的 n(r1013) 为整型字面常量, 它必须是正数, 并且不能具有种别参数符号编辑描述符 (sign-edit-desc) 的一般语法形式 (R1014) 为 : S SP SS 空格解释编辑描述符的语法形式 (R1015) 为 : BN BZ 至于 kp 里面的 k 称为比例因子控制编辑描述符里面的这些大写字符以及标点符号 T, TL, TR, X, 斜线, 冒号, S, SP, SS, P, BN, 以及 BZ 都表示编辑方式, 具体含义参见 17-6 节 3. 字符串编辑描述符 (R1016) 实际上就是一个字符字面常量, 而作为字符串编辑描述符的字符字面常量不能带有种别参数组成字符串编辑描述符的字符必须属于系统所认可的字符, 在字符字面常量中间所出现的分隔符号, 即撇号与引号, 都必须连续成对出现, 不能间隔空格, 这样的一对符号应该看成是一个单独的分隔字符如果系统同时支持大小写, 那么编辑描述符除了对于字符常量之外, 不区分大小写注意字符串编辑描述符只用于常量数据的输出, 而对输入无效与数据编辑描述符和字符串编辑描述符相关的一个概念是纪录的域 : 当格式控制遇到数据编辑描述符或字符串编辑描述符, 读入或写出的部分纪录就称为该纪录的一个域, 而域宽即该域的字符数目 17.3 输入输出的列表与格式的匹配通过格式说明来进行格式化数据传输的第一步是格式控制, 而格式控制的任何操作都依赖于下面的两个方面的信息 : 格式说明当中的下一个编辑描述符 ; 输入输出列表当中的下一个有效项这两个方面的信息都是格式控制所必不可少的, 它们之间存在一定的匹配性的要求如下 : 如果在一个输入输出说明列表当中, 至少说明了一个有效的列表项, 那么在格式说明里面就至少应该有一个相应的数据编辑描述符, 这是输入输出列表与格式说明相匹配的基本条件只有在输入输出列表里面不存在任何有效列表项的情况下, 才可以使用形式为 () 的空的格式说明

311 0 长度的字符项是一个有效的列表项, 但 0 尺度的数组和具有重复度为 0 的隐式 DO 列表不是有效列表项除了前置有重复说明因子 r 的格式项之外, 格式说明总是解释为从左到右前置有重复说明因子 r 的格式项被解释为一个项的列表, 数目等于 r, 每个项都等于原格式项, 用逗号分隔如果重复说明因子 r 省略了, 那么它的默认值为 1 对于格式说明里面的每一个数据编辑描述符, 都在输入输出列表里面存在一个相应的有效项, 当然如果输入输出列表里面的项为复型数据对象, 则需要两个 F, E, EN, ES, D, 或 G 编辑描述符对于每个控制编辑描述符或字符编辑描述符, 则不存在相应的输入输出列表项格式控制直接与纪录进行通讯只要格式说明里面格式控制遇到数据编辑描述符, 那么它就决定了在输入输出列表里面是否存在相应的有效项 : 如果存在这样的有效项, 那么在该项与纪录之间就传输相应的经过恰当编辑的信息, 然后执行相应的格式控制 ; 如果不存在这样的有效项, 那么格式控制就终止如果在格式说明里面, 格式控制遇到冒号编辑描述符, 而另一个输入输出列表的有效项又没有给出, 那么格式控制终止如果在格式说明里面格式控制遇到一个完整的格式说明的最右边的括号, 而另外的输入输出列表的有效项也没有给出, 则格式控制终止如果给出了另外的有效项, 则文件定位的方式和处理斜线编辑描述符一样格式控制回复到被前置右括号终止的格式项的开头位置 ; 如果不存在这样的前置右括号, 那么格式回复到格式说明的第一个左括号处一旦出现上述的回复操作, 那么格式说明里面重复使用的部分必须至少包含一个数据编辑描述符如果格式控制回复到一个前置有重复说明的括号时, 其前置重复说明必须同样加以重复使用格式控制的回复对于比例因子 (17.6.5), 符号控制编辑描述符 (17.6.4) 以及空格解释编辑描述符 (17.6.6) 都不产生任何影响例 17-3 格式说明的一个简单例子为 : 10 FORMAT (1X, 2(F10.3, I5)) 它的输出列表为 : WRITE (10,10) 10.1, 3, 4.7, 1, 12.4, 5, 5.2, 6 下面的格式说明能够得到同样的输出 : 10 FORMAT (1X, F10.3, I5, F10.3, I5/F10.3, I5, F10.3, I5) 17.4 格式控制的文件定位格式控制的文件定位有如下几种情况 : 在执行任何的数据编辑描述符或字符串编辑描述符之后, 文件都定位于当前纪录的最后一个被读或写的字符之后在执行 T,TL,TR, 或 X 编辑描述符之后, 文件的定位约定参见节在执行斜线编辑描述符之后, 文件的定位约定参见节

312 如果格式控制出现了上节所述的回复, 则文件定位的方式与执行斜线编辑描述符时的方式一样在进行读的操作时, 遇到任何当前纪录的不可处理的字符都被忽略, 一直到读入下一个纪录 17.5 数据编辑描述符数据的机器内部表示显然是不能直接拿来阅读的, 那么数据的输入输出肯定就包含着对于以内部表示存在的数据进行转换的过程这就是数据编辑描述符所需要实现的功能一个纪录当中的数据对象如果属于数值, 逻辑型或者默认字符型, 那么把它用字符形式表示出来的时候, 就必须是采取默认字符 ; 如果数据对象本来就是非默认字符型, 那么也必须采用相应的非默认字符型在执行字符串编辑描述符的时候, 传输到纪录的字符必须是默认字符型在执行输入语句的时候, 给出的变量同时也就获得了定义, 除非中途出现错误条件, 或文件终止条件, 或纪录终止条件在执行输出语句的时候, 给出的表达式同时也就被赋予了值下面我们分小节讨论下面这三种数据对象的编辑描述符以及一般的编辑描述符 : 数值编辑描述符 ; 逻辑型编辑描述符 ; 字符型编辑描述符数值编辑用于说明整型, 实型, 以及复型数据的输入输出格式的编辑描述符包括 :I,B,O,Z,F,E, EN, ES,D, 和 G 数值编辑的一般规则如下 : 对于整型, 实型和复型这些数值数据, 在输入的时候开头的空格都是没有意义的除了开头的空格之外, 对于其他位置的空格的解释依赖于以下项目的组合 : 说明符 BLANK=; 预联结文件或内部文件的默认解释 ; 对当前部件有效的 BN 或 BZ 空格控制数值数据之前的加号可以省略如果数值数据纪录的每个域只包含空格, 则其域宽为 0 在输入语句里面使用 F,E,EN,ES,D, 和 G 这些编辑符, 可以在输入域里面使用比系统所支持的更多的位数在输出语句里面使用 I,F,E,EN,ES,D,G 这些编辑符, 对于正数或 0, 和受到编辑描述符 S, SP,SS 的控制一样, 都可以前置加号 ; 而负数则必须前置减号在输出时, 数值表示在域里面是向右看齐的, 如果编辑产生的字符数目少于域宽, 那么字符串前面用空格填充在输出时, 如果边界产生的字符串的字符数目多于域宽, 或者如果指数的长度超过了编辑描述符 Ew.dEe,ENw.dEe,ESw.dEe,Gw.dEe 所给出的长度, 那么系统用星号填充整个宽度为 w 的域如果出现了 SP 编辑描述符, 那么加号就不是可选的了

313 在输出时, 如果使用了编辑符 I,B,O,Z,F, 那么域宽 w 的值可以是 0 这时系统自动选择保证不会使得整个域填充星号的最小的正数域宽在输入时, 域宽 w 不能为 0 1. 整数编辑应用于整数的编辑描述符包括 :Iw,Iw.m,Bw,Bw.m,Ow,Ow.m,Zw, 以及 Zw.m 其中的各个字符含义如下 : 其中的 I 编辑描述符在输入域里面, 除了作用于空格之外, 表示带符号的数字串 (signed-digit-string)(r401); 相应的 B,O,Z 则分别表示二进制, 八进制与十六进制数字串 (R408, R409, R410) 如果系统同时支持大小写, 那么在十六进制里面的字母的大小写也不予区分其中的小写字母 w 表示需要编辑的纪录的域宽, 而如果 w 为 0, 则由系统约定域宽在输入时, 域宽 w 不能为 0 所给出的输入输出列表项必须是整型数据编辑描述符 G 也可以用来编辑整型数据, 参见 m 对输入无效 Iw 编辑描述符给出的输出域由 0 或可能的空格后接整型数字字符串组成, 整型数字字符串可以是负数, 则必须前置减号, 也可以是正数, 则前置可选的加号当然都不能前置 0 一个数字字符串至少由一个数字组成编辑描述符 Bw,Ow,Zw 给出的输出域由 0 或可能的空格后接二进制, 八进制, 或十六进制形式的常数数值, 同样不能前置 0 二进制, 八进制, 或十六进制形式的常量至少由一个数字组成除了至少由 m 个数字组成的数字串之外, 编辑描述符 Iw.m,Bw.m,Ow.m,Zw.m 给出的输出域分别和编辑描述符 Iw,Bw,Ow,Zw 所给出的一致当数字数目不够的情况下, 则需要前置足够的 0 m 的值不能超过 w 的值, 除非 w 为 0 如果 m 为 0, 而内部数据值也为 0, 则输出域完全由空格组成, 同时符号控制失去作用当 m 和 w 同时为 0, 而内部数据值也为 0 时, 则产生一个空格符 2. 实数和复数的编辑用于编辑实数和复数的编辑描述符包括 :F,E,EN,ES 以及 D 因此凡是和 F,E,EN, ES, 以及 D 相应的输入输出列表项都必须是实数或复数另外编辑描述符 G 也可以用于实数和复数数据参见下面分小节说明这些编辑描述符的用法 1. 编辑符 F 编辑描述符 Fw.d 表示该域占据 w 个位置, 而它的小数部分由 d 个数字组成如果 w 的值为 0, 则由系统约定域宽不过在输入的时候, 不允许 w 为 0 使用编辑描述符 F 的规则如下 : 输入域包括可选的符号, 后接一个或多个可选的数字组成的字符串, 其中还包括小数点, 以及可以解释为 0 的空格如果输入域包含一个小数点, 那么 d 对输入无作用如果输入域当中没有出现小数点, 那么数字串的最右边的 d 个数字将被认为是所表示的数值的小数部分数字串所包含的数字字符数目可以超过系统所允许的常量表示的数字的数目, 不过这时需要采用如下的三种形式的指数形式 : 符号后接一个数字串 ;

314 E 后接 0 和多个空格, 然后再后接一个具有符号的数字串 ; D 后接 0 和多个空格, 然后再后接一个具有符号的数字串包含 D 的指数等同于包含 E 的指数如果输入域不包含一个指数, 则等价于在基本形式后接一个指数值 -k, 这里的 k 为给定的比例因子输出域包含空格, 依据数值正负而定的必须的减号, 和可选的加号, 然后就是带有小数点的数字串, 表示了内部值的大小当输出域里面的值的小于 1 时, 除了紧接小数点左边的可选的 0 之外, 不允许前置 0 当除了这个 0 自身之外, 输出域里面不再含有其他数字, 那么这个可选的 0 就必须出现 2. 编辑符 E 和 D 编辑描述符 Ew.d, Dw.d, 以及 Ew.dEe 表示外部域占据 w 个位置, 而它的小数部分由 d 个数字组成 ( 除非出现一个大于 1 的比例因子 ), 指数部分由 e 个数字组成其中 e 的取值对于输入没有作用如果输入域包含小数点, 则 d 也对输入没有作用输入域的形式和说明和 F 编辑符一致比例因子为 0 的输出域形式为 : ] [0].x [ 1 x 2 x dexp 其中为加号或减号注意如果 exp > 999, 则编辑描述符 Ew.d 和 Dw.d 都不能使用 3. 编辑符 EN 编辑描述符 EN 表示输出域的形式为实数的在工程技术领域常常使用的一种表示形式, 即如下形式的实数 : ] yyy.x [ 1 x 2 x dexp 显然这种形式的实数除非输出值为 0, 它的整数部分的绝对值都是大于等于 1 而小于 1000 的具体的编辑描述符包括 ENw.d 和 ENw.dEe, 表示外部域占据了 w 个位置, 分数部分由 d 个数字组成, 而指数部分由 e 个数字组成这时输入域的形式和解释和编辑符 F 的一致如果 exp > 999, 那么编辑符 ENw.d 就不能使用了例 17-4 内部值使用了编辑符 SS, EN12.3 的输出域 E E E E 编辑符 ES 编辑描述符 ES 产生的输出域的形式为实数的科学表示法这种形式的实数的整数部分在不

315 等于 0 的情况下, 大于等于 1 而小于 10 比例因子对输出无作用这种表示形式为 : ] y.x [ 1 x 2 x dexp 具体的编辑描述符包括 ESw.d 和 ESw.dEe, 表示外部域占据 w 个位置, 小数部分由 d 个数字组成, 而指数部分由 e 个数字组成输入域的形式和解释同编辑符 F 的一致如果 exp > 999, 那么不能使用编辑符 ESw.d 例 17-5 内部值使用了编辑符 SS, ES12.3 的输出域 E E E E 复数编辑由于在 FORTRAN 里面复数本质上被看成是两个实数组成的数组, 因此复数的编辑实际上就是分别对组成复数的两个实数的编辑, 即第一个编辑描述符用于复数的实部, 而第二个编辑描述符用于复数的虚部, 这两个编辑描述符可以不同而在这两个编辑描述符之间, 还可以使用控制编辑符和字符串编辑符逻辑型编辑逻辑型编辑描述符 Lw 表示域宽为 w, 而相应的输入输出列表项当然必须为逻辑型数据编辑描述符 G 也可以用来编辑逻辑型数据参见输入域可以包括可选的空格, 可选的小数点, 然后是 T 或 F, 分别表示真和假在 T 或 F 后面还可以附加任意的字符, 但是系统都一律予以忽略如果系统同时支持大小写, 那么在逻辑型输出域里面大小写是等价的逻辑常量.TRUE. 和.FALSE 都是合法的输入形式输出域由 w-1 个空格, 后接 T 或 F 组成, 分别表示真或假字符型编辑顾名思义, 字符型编辑描述符 A[w] 只能应用于字符型的输入输出列表项, 而同时编辑符 G 也可以用于字符型数据在编辑符 A 或 G 的控制下, 字符型数据在传输和转换时所涉及到的种别参数的匹配问题, 是由相应的列表项的种别参数来决定的如果编辑符 A 给出了域宽 w, 那么该域就由 w 个字符组成 ; 如果编辑符 A 没有给出域宽 w, 那么域里面的字符的数目就是相应列表项的字符长度, 而不用考虑种别参数值设一个输入输出列表项的长度为 LEN, 如果相应输入域宽已经由编辑符 A 给出为 w, 那么

316 当 w 大于或等于 LEN 时, 那么取右边的 LEN 个字符作为输入 ; 如果 w 小于 LEN, 那么这 w 个字符靠左边对齐, 而尾部填充 LEN-w 个空格作为输入如果编辑符 A 给出的输出域宽 w 大于 LEN, 那么输出域由 w-len 个空格后接 LEN 个字符组成 ; 如果 w 小于或等于 LEN, 那么输出域由靠左边的 w 个字符组成通用编辑编辑描述符 Gw.d 和 Gw.dE e 用于任意固有类型的输入输出列表项, 因此称为通用编辑符一般的应用这种编辑符时, 总是表示域宽为 w, 小数部分至多为 d 个数字, 而指数部分为 e 个数字当然当该编辑符应用于整型, 逻辑型以及字符型数据时,d 和 e 这两个参数都失去意义 1. 通用数值编辑当应用编辑描述符 Gw.d 和 Gw.dEe 来说明整型实型以及复型数据时, 遵循数值编辑的一般的规则参见其中的编辑符 Gw.dEe 的应用规则和编辑描述符 Ew.dEe 的规则一致通用整数编辑当针对整型数据的输入输出应用编辑描述符 Gw.d 和 Gw.dEe 时, 规则和应用编辑描述符 Iw 一致, 只是这时 w 不能为 0 通用实数和复数编辑这时输入域的形式与解释和编辑符 F 的一致而输出域的表示形式依赖于需要进行编辑的数值的大小比例因子同样是无效的, 除非数值超出了 F 编辑所允许的有效范围 2. 通用逻辑型编辑当应用 Gw.d 和 Gw.dEe 来编辑逻辑型数据的输入输出时, 遵循编辑描述符 Lw 的规则 3. 通用字符型编辑当应用 Gw.d 和 Gw.dEe 来编辑逻辑型数据的输入输出时, 遵循编辑描述符 Aw 的规则控制编辑描述符控制编辑描述符并不决定数据的传输以及数据的内部表示和外部表示之间的转换, 但是这种编辑符能够对后续的数据编辑描述符所执行的转换产生特定的影响下面分节说明 FORTRAN 的这些控制编辑描述符定位编辑所谓定位编辑描述符 T,T L,TR, 以及 X 的功能就是给出开始从纪录进行传输, 或者传输到纪录的第一个字符的位置由编辑描述符 T 给出的定位可以是当前位置的任意方向, 这样在输入时, 纪录的某个部分就有可能被多次进行不同的编辑处理由编辑描述符 X 给出的定位是从当前位置向前运行编辑描述符 nx 和编辑描述符 TRn 的效果一样

317 在输出时, 编辑描述符 T, TL,TR, 以及 X 本身不能导致字符的传输, 因此它们不能影响纪录的长度如果字符传输到或者落后于 T,TL,TR, 以及 X 所给出的定位, 那么被忽略的位置需要填充空格最后结果就是整个纪录都初始化为空格在输出时, 纪录当中的字符可以被替换, 但是编辑描述符 T,TL,TR, 以及 X 本身不能直接对字符进行替换, 而只能通过定位, 使得后续的编辑符能够完成替换的工作斜线编辑斜线编辑描述符表示数据传输的结束当从能够序列访问的文件输入数据时, 传输结束后当前纪录的剩余部分被忽略, 而文件定位于后接纪录的开头, 该后接纪录就成为当前纪录在输出到一个能够序列访问的文件时, 就在当前纪录后面产生一个新的空纪录, 该新纪录就成为文件的下一个当前纪录, 而文件也定位于该新纪录的开头对于序列访问的文件来说, 纪录数总是逐一增加的, 而文件定位也就随着该纪录数而变化一个不包含任何字符的纪录也可以作为输出, 这时如果该文件是内部文件, 或者是直接访问的文件, 该纪录就由空格字符组成在斜线编辑描述符里面, 重复说明是可选的, 如果不出现, 则默认值为冒号编辑如果在输入输出列表里面再也不存在有效的项了, 那么冒号编辑描述符就能够终止格式控制, 而如果在输入输出列表里面还存在有效项, 则冒号编辑描述符没有任何作用控制编辑符 S, SP, 以及 SS 控制编辑描述符 S,SS, 以及 SP 都是用于控制数值输出域的可选的加号, 或者说正号是否给出如果在格式说明里面使用了 SP, 那么系统将在任何后续的位置添加一个加号 ; 如果在格式说明里面使用了 SS, 那么系统将不会在任何后续的位置添加加号 ; 如果在格式说明里面使用了 S, 那么是否添加加号由系统做具体的约定编辑描述符 S,SS, 以及 S P 在执行输出语句时, 只影响编辑符 I,F,E,EN,ES, D, 和 G; 而在执行输入语句时, 这些编辑符没有任何作用控制编辑描述符 P 编辑描述符 kp 能够把比例因子重定义为 k, 而比例因子能够影响数值量的编辑在开始执行每一个输入输出语句时, 比例因子的值总是 0, 对于后续的编辑符 F,E,EN, ES,D, 以及 G, 比例因子都不受影响, 而只有在出现编辑描述符 P 的情况下, 才产生新的比例因子而格式控制的复原也不会影响已有的比例因子比例因子 k 对于编辑的影响体现在以下几个方面 : 如果使用 F,E,EN, ES,D,G 作为输入编辑, 同时输入域里面不存在指数 ; 或者使用 F 作为输出编辑, 那么比例因子的意思就是外部表示数值等于内部表示数值乘 10 k

318 如果使用 F,E,EN, ES,D,G 作为输入编辑, 而输入域里面存在指数, 那么比例因子没有作用如果使用 E,D 作为输出编辑, 那么产生的数值的带号部分需要乘 10 k, 而指数除以 k 使用 G 作为输出编辑时, 比例因子的将没有作用, 除非被编辑的数据值超过了 F 编辑所许可的范围如果要求使用编辑符 E, 那么比例因子的作用和在 E 输出编辑一样如果使用 EN,ES 作为输出编辑, 则比例因子没有作用 17.7 字符串编辑描述符字符串编辑描述符用来把需要写入的字符隔离标记出来对于字符串编辑描述符来说, 域宽就是被隔离出来的字符串的长度, 包括其中的空格也需要计入而其中成对的隔离字符被认为是一个单独的字符字符串编辑描述符的定界符或者是撇号, 或者是引号附录 C FORTRAN95 语法在本附录我们给出 FORTRAN95 的语法规则 (ISO/IEC :1997(E)) 所谓语法规则, 就是描述一切 FORTRAN9 5 的词汇, 语句, 结构等语言成分的形式规则, 凡是遵循了这个描述的, 就是合法的 FORTRAN95 语言 ; 否则, 就是不合法的因此语法规则本身必须是精确的, 绝对不能产生歧义在这种要求下,FORTRAN95 的语法采用了形式语言的方式给出语法规则, 即属于所谓 Backus-Naur 形式 ( BNF) 的一种变体由于这种描述形式本身采用了语言的形式, 因此有几点说明如下 : 在描述语法时, 对于属于 FORTRAN 字符集的字符按照字面形式来理解, 除非有特别的说明对于每一个语法成分的描述, 都有一个唯一的编号, 这个编号的采用了如下的一般形式 : Rxyy 其中的 R 表示规则, 而 x 表示 FORTRAN 标准的节号,yy 表示对于该语法成分的描述在该节的唯一编号, 因此对于每一个语法成分的描述, 这个 Rxyy 可以看成是它的唯一编号, 全书的正文当中, 每当第一次引入一个语法成分, 我们总是给出了它的这个编号在下面的规则表里面, 这个编号简写为纯数字, 省略了字母 R 下面的描述当中, 为了简洁起见, 采用了如下的缩写 : argument arg attribute..attr declaration..decl definition def descriptor desc expression..expr

319 integer int operator..op specifier.spec statement stmt 同样为了简洁的缘故, 这里给出的形式描述不可能是绝对完备和精确的, 在能够理解的前提下, 本附录采用了一定的简化形式, 并且在 FORTRAN 标准的基础上作了一定的节略除了文字之外, 还使用了来自 FORTRAN 字符集的如下特殊符号 ; 另外还使用了表示或者的意思 + 加号 % 百分号 - 减号 & and * 星号 ; 分号 / 除号或斜线省略符号 < 小于引号 > 大于. 小数点或句号 ( 左括号 = 等号 ) 右括号! 叹号或者 FORTRAN95 的语法规则 (ISO/IEC :1997(E)) 语法成分形式描述编号 access-id use-name generic-spec 523 access-spec PUBLIC 511 PRIVATE access-stmt access-spec [ [ :: ] access-id-list ] 522 ac-do-variable scalar-int-variable 436 ac-implied-do ( ac-value-list, ac-implied-do-control ) 434 ac-implied-do-control ac-do-variable = scalar-int-expr, scalar-int-expr [, 435 scalar-int-expr ] action-stmt allocate-stmt assignment-stmt backspace-stmt call-stmt close-stmt continue-stmt cycle-stmt deallocate-stmt endfile-stmt end-function-stmt end-program-stmt end-subroutine-stmt exit-stmt forall-stmt 216

320 goto-stmt if-stmt inquire-stmt nullify-stmt open-stmt pointer-assignment-stmt print-stmt read-stmt return-stmt rewind-stmt stop-stmt where-stmt write-stmt actual-arg Expr 1214 variable procedure-name actual-arg-spec [ keyword = ] actual-arg 1212 ac-value Expr ac-implied-do add-op add-operand [ add-operand mult-op ] mult-operand 706 allocatable-stmt ALLOCATABLE [ :: ] array-name [ ( deferred-shape-spec-list ) ] {, array-name [ ( deferred-shape-spec-list ) ] } allocate-lower-bound scalar-int-expr 627 allocate-object variable-name structure-component allocate-shape-spec [ allocate-lower-bound : ] allocate-upper-bound 626 allocate-stmt ALLOCATE ( allocation-list [, STAT = stat-variable ] ) 622 allocate-upper-bound scalar-int-expr 628 allocation allocate-object [ ( allocate-shape-spec-list ) ] 624 alphanumeric-character Letter 302 digit underscore and-op.and. 720 and-operand [ not-op ] level-4-expr 715 array-constructor ( / ac-value-list / ) 432 array-element data-ref 615 array-section dataref [ ( substringrange ) ] 616 array-spec explicit-shape-spec-list assumed-shape-spec-list deferred-shape-spec-list

321 assumed-size-spec assignment-stmt variable = expr 735 assumed-shape-spec [ lower-bound ] : 517 assumed-shape-spec-list assumed-shape-spec { assumed-shape-spec } 0 assumed-size-spec [ explicit-shape-spec-list, ] [ lower-bound : ] * 519 attr-spec backspace-stmt PARAMETER access-spec ALLOCATABLE DIMENSION (array-spec ) EXTERNAL INTENT ( intent-spec ) INTRINSIC OPTIONAL POINTER SAVE TARGET BACKSPACE external-file-unit BACKSPACE ( position-spec-list ) binary-constant B ' digit { digit } ' 408 blank-interp-edit-desc B "digit { digit } " BN BZ block { execution-part-construct } 801 block-data block-data-stmt [specification-part] end-block-data-stmt 1112 block-data-stmt BLOCK DATA [block-data-name] 1113 block-do-construct do-stmt do-block end-do 817 boz-literal-constant binary-constant octal-constant hex-constant call-stmt CALL subroutine-name [ ( [ actual-arg-spec-list ] ) ] 1211 case-construct select-case-stmt { case-stmt block } end-select-stmt 808 case-expr scalar-int-expr scalar-char-expr scalar-logical-expr case-selector ( case-value-range-list ) DEFAULT case-stmt CASE case-selector [ case-construct-name ] 810 case-value case-value-range scalar-int-initialization-expr scalar-char-initialization-expr scalar-logical-initialization-expr case-value case-value : : case-value case-value : case-value

322 case-value-range-list case-value-range { case-value-range } 0 char-constant constant 309 char-expr expr 726 char-initialization-exr char-expr 731 char-length ( char-len-param-value ) char-len-param-value char-literal-constant char-selector scalar-int-literal-constant specification-expr * : [ _kind-param ] ' { rep-char } ' [ _kind-param ] " { rep-char } " length-selector (LEN = char-len-param-value, KIND = scalar-int-initialization-expr ) ( char-len-param-value, [ KIND = ] scalar-int-initialization-expr ) (KIND = scalar-int-initialization-expr [, LEN = char-len-param-value ] ) char-string-edit-desc char-literal-constant 1016 char-variable variable 605 close-spec [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label STATUS = scalar-default-char-expr close-stmt CLOSE ( close-spec-list ) 907 common-block-object variable-name [ ( explicit-shape-spec-list ) ] 530 common-stmt COMMON [ / [ common-block-name ] / ] common-block-object-list { [,] / [ common-block-name ] / common-block object-list } complex-literal-constant ( real-part, imag-part ) 417 component-array-spec component-attr-spec explicit-shape-spec-list deferred-shape-spec-list POINTER DIMENSION ( component-array-spec ) component-attr-spec-list component-attr-spec { component-attr-spec } 0 component-decl component-name [ ( component-array-spec ) ] [ * char-length ] [ component-initialization ] component-decl-list component-decl { component-decl } 0 component-def-stmt type-spec [ [, component-attr-spec-list ] :: ] component-initialization component-decl-list = initialization-expr => NULL ()

323 concat-op // 712 connect-spec constant [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label FILE = file-name-expr STATUS = scalar-default-char-expr ACCESS = scalar-default-char-expr FORM = scalar-default-char-expr RECL = scalar-int-expr BLANK = scalar-default-char-expr POSITION = scalar-default-char-expr ACTION = scalar-default-char-expr DELIM = scalar-default-char-expr PAD = scalar-default-char-expr literal-constant named-constant constant-subobject subobject 702 contains-stmt CONTAINS 1227 continue-stmt CONTINUE 839 control-edit-desc position-edit-desc 1010 [ r ] / : sign-edit-desc k P blank-interp-edit-desc cycle-stmt CYCLE [ do-construct-name ] 834 d int-literal-constant 1008 data-edit-desc I w [. m ] 1005 B w [. m ] O w [. m ] Z w [. m ] F w. d E w. d [ E e ] EN w. d [ E e ] ES w. d [ E e ] G w. d [ E e ] L w A [ w ] D w. d Data-i-do-object Array-element 536 scalarstructurecomponent dataimplieddo Data-i-do-variable Scalar-int-variable 537 Data-implied-do ( data-i-do-object-list, data-i-do-variable = scalar-int-expr

324 scalar-int-expr [, scalar-int-expr] ) data-ref part-ref { % part-ref } 612 data-stmt DATA data-stmt-set { [, ] data-stmt-set } 532 data-stmt-constant Data-stmt-object scalar-constant scalar-constant-subobject signed-int-literal-constant signed-real-literal-constant NULL ( ) structure-constructor entry-stmt variable data-implied-do data-stmt-object-list data-stmt-object { data-stmt-object } 0 datastmtrepeat Scalar-int-constant scalar-int-constant-subobject data-stmt-set data-stmt-object-list / data-stmt-value-list / 533 Data-stmt-value [ data-stmt-repeat* ] data-stmt-constant 538 data-stmt-value-list data-stmt-value { data-stmt-value } 0 deallocate-stmt DEALLOCATE ( allocate-object-list [, STAT = 631 stat-variable ] ) declaration-construct derived-type-def 207 interface-block type-declaration-stmt specification-stmt parameter-stmt format-stmt entry-stmt stmt-function-stmt default-char-expr expr 727 Default-char-variable variable 606 default-int-variable variable 608 default-logical-variable variable 604 deferred-shape-spec : 518 defined-binary-op. letter { letter }. 724 defined-operator defined-binary-op 311 defined-unary-op extended-intrinsic-op defined-unary-op. letter { letter }. 704 derived-type-def derived-type-stmt { private-sequence-stmt } component-def-stmt { component-def-stmt } end-type-stmt derived-type-stmt TYPE [ [, access-spec ] ] type-name 423 digit-string digit { digit } 402 dimension-stmt DIMENSION [ :: ] array-name ( array-spec ) {,

325 array-name ( array-spec ) } do-block block 823 do-construct block-do-construct 816 do-construct-name name 0 do-stmt label-do-stmt nonlabel-do-stmt do-variable scalar-int-variable 822 dummy-arg dummy-arg-name * e int-literal-constant 1009 else-if-stmt ELSE IF ( scalar-logical-expr ) THEN [ if-construct-name ] 804 else-stmt ELSE [ if-construct-name ] 805 elsewhere-stmt ELSEWHERE [ where-construct-name ] 745 end-block-data-stmt END [BLOCK DATA [block-data-name]] 1114 end-do end-do-stmt continue-stmt end-do-stmt END DO [ do-construct-name ] 825 endfile-stmt ENDFILE external-file-unit 920 end-forall-stmt END FORALL [ forall-construct-name ] 753 end-function-stmt END [ FUNCTION [ function-name ]] 1220 end-if-stmt END IF [ if-construct-name ] 806 end-interface-stmt END INTERFACE [ generic-spec ] 1204 end-module-stmt END [MODULE [ module-name]] 1106 end-program-stmt END [PROGRAM [ program-name]] 1103 end-select-stmt END SELECT [ select-case-construct-name ] 811 end-subroutine-stmt END [ SUBROUTINE [ subroutine-name ]] 1224 end-type-stmt END TYPE [ type-name ] 430 end-where-stmt END WHERE [ where-construct-name ] 746 entity-decl object-name [ ( array-spec ) ] [ * char-length ] [ initialization ] function-name [ * char-length ] entry-stmt ENTRY entry-name [ ( [ dummy-arg-list ] ) [ RESULT 1225 ( result-name ) ] ] enum-def equivalence-object type-alias-name ( enumerator-list ) 0 variable-name array-element substring 548 equivalence-set ( equivalence-object, equivalence-object-list ) 547 equivalence-set-list equivalence-set { equivalence-set } 0 equivalence-stmt EQUIVALENCE equivalence-set-list 546 equiv-op.eq. 722.NEQ. equiv-operand [ equiv-operand or-op ] or-operand

326 executable-construct action-stmt case-construct do-construct forall-construct if-construct where-construct execution-part executable-construct {execution-part-construct} 208 execution-part-construct executable-construct format-stmt entry-stmt data stmt (check still present) exit-stmt EXIT [ do-construct-name ] 835 explicit-shape-spec [ lower-bound : ] upper-bound 514 exponent signed-digit-string 406 exponent-letter E D expr [ expr defined-binary-op ] level-5-expr 723 extended-intrinsic-op intrinsic-operator 312 external-file -unit scalar-int-expr 902 external-name-list external-name { external-name } 0 external-stmt EXTERNAL [ :: ] external-name-list 1208 external-subprogram function-subprogram subroutine-subprogram file-name-expr scalar-default-char-expr 906 forall-assignment-stmt forall-body-construct assignment-stmt pointer-assignment-stmt forall-assignment-stmt where-stmt where-construct forall-construct forall-stmt forall-construct forall-construct-stmt { forall-body-construct } 747 end-forall-stmt forall-construct-name name 0 forall-construct-stmt [ forall-construct-name : ] FORALL forall-header 748 forall-header ( forall-triplet-spec-list [, scalar-mask-expr ] ) 749 forall-stmt FORALL forall-header forall-assignment-stmt 754 forall-triplet-spec index-name = subscript : subscript [ : stride ] 750 format default-char-expr 913 format-item label * [ r ] data-edit-desc control-edit-desc 1003

327 char-string-edit-desc [ r ] ( format-item-list ) format-item-list format-item { format-item } 0 format-specification ( [ format-item-list ) ] ) 1002 format-stmt FORMAT format-specification 1001 function-name name 0 function-reference function-name ( [ actual-arg-spec-list ] ) 1210 function-stmt function-subprogram generic-spec [ prefix ] FUNCTION function-name ( [ dummy-arg-name-list ] ) [ RESULT ( result-name ) ] function-stmt [specification-part] [execution-part] [internal-subprogram-part] end-function-stmt generic-name OPERATOR ( defined-operator ) ASSIGNMENT ( = ) goto-stmt GO TO label 836 hex-constant Z ' hex-digit { hex-digit } ' 410 Z " hex-digit { hex-digit } " hex-digit digit 411 A B C D E F if-construct if-then-stmt block { else-if-stmt block } [ else-stmt block ] 802 end-if-stmt if-construct-name name 0 if-stmt IF ( scalar-logical-expr ) action-stmt 807 if-then-stmt [ if-construct-name : ] IF ( scalar-logical-expr ) 803 THEN imag-part signed-int-literal-constant 419 signed-real-literal-constant implicit-part { implicit-part-stmt } implicit-stmt 205 implicit-part-stmt implicit-stmt 206 parameter-stmt format-stmt entry-stmt implicit-spec type-spec ( letter-spec-list ) 542 implicit-stmt IMPLICIT implicit-spec-list 541 IMPLICIT NONE initialization initialization-expr 505 => NULL()

328 initialization-expr expr 730 input-item variable io-implied-do input-item-list input-item { input-item } 0 inquire-spec [ UNIT = ] external-file-unit FILE = file-name-expr IOSTAT = scalar-default-int-variable ERR = label EXIST = scalar-default-logical-variable OPENED = scalar-default-logical-variable NUMBER = scalar-default-int-variable NAMED = scalar-default-logical-variable NAME = scalar-default-char-variable ACCESS = scalar-default-char-variable SEQUENTIAL = scalar-default-char-variable DIRECT = scalar-default-char-variable FORM = scalar-default-char-variable FORMATTED = scalar-default-char-variable UNFORMATTED = scalar-default-char-variable RECL = scalar-default-int-variable NEXTREC = scalar-default-int-variable BLANK = scalar-default-char-variable POSITION = scalar-default-char-variable ACTION = scalar-default-char-variable READ = scalar-default-char-variable WRITE = scalar-default-char-variable READWRITE = scalar-default-char-variable DELIM = scalar-default-char-variable PAD = scalar-default-char-variable inquire-spec-list inquire-spec { inquire-spec } 0 inquire-stmt INQUIRE ( inquire-spec-list ) INQUIRE ( IOLENGTH = scalar-default-int-variable ) output-item-list int-constant constant 308 intent-spec IN 512 OUT INOUT intent-stmt INTENT ( intent-spec ) [ :: ] dummy-arg-name-list 520 interface-block interface-stmt { interface-specification } end-interface-stmt 1201 interface-body function-stmt [ specification-part ] end-function-stmt 1205 subroutine-stmt [ specification-part ] end-subroutine-stmt interface-specification interface-body 1202 module-procedure-stmt interface-stmt INTERFACE [generic-spec]

329 internal-file-unit default-char-variable 903 internal-subprogram function-subprogram subroutine-subprogram internal-subprogram-part contains-stmt internal-subprogram {internal-subprogram} 210 int-expr expr 728 int-initialization-expr int-expr 732 int-literal-constant digit-string [ _ kind-param ] 404 intrinsic-operator power-op mult-op add-op concat-op rel-op not-op and-op or-op equiv-op intrinsic-procedure-name-list intrinsic-procedure-name { intrinsic-procedure-name } 0 intrinsic-stmt INTRINSIC [ :: ] intrinsic-procedure-name-list 1209 int-variable variable 607 io-control-spec [ UNIT = ] io-unit [ FMT = ] format [ NML = ] namelist-group-name REC = scalar-int-expr IOSTAT = scalar-default-int-variable ERR = label END = label ADVANCE = scalar-default-char-expr SIZE = scalar-default-int-variable EOR = label io-implied-do ( io-implied-do-object-list, io-implied-do-control ) 916 io-implied-do-control do-variable = scalar-int-expr, scalar-int-expr 918 io-implied-do-object input-item output-item [, scalar-int-expr ] io-unit external-file-unit 901 * internal-file-unit k signed-int-literal-constant 1011 keyword dummy-arg-name 1213 kind-param digit-string 405 scalar-int-constant-name kind-selector ( [ KIND = ] scalar-int-initialization-expr ) 506 label digit [ digit [ digit [ digit [ digit ]]]]] 313 label-do-stmt [ do-construct-name : ] DO label [ loop-control ]

330 Length-selector ( [ LEN = ] charlenparamvalue) * char-length [, ] Letter-spec letter [ - letter ] 543 level-1-expr [ defined-unary-op ] primary 703 level-2-expr [ [ level-2-expr ] add-op ] add-operand 707 level-3-expr [ level-3-expr concat-op ] level-2-expr 711 level-4-expr [ level-3-expr rel-op ] level-3-expr 713 level-5-expr [ level-5-expr equiv-op ] equiv-operand 718 literal-constant int-literal-constant real-literal-constant complex-literal-constant logical-literal-constant char-literal-constant boz-literal-constant local-name name 0 logical-expr expr 725 logical-initialization-expr logical-expr 733 logical-literal-constant.true. [ _kind-param ]. FALSE. [ _kind-param ] logical-variable variable 603 loop-control [, ] do-variable = scalar-int-expr, scalar-int-expr [, scalar-int-expr ] [, ] WHILE scalar-logical-expr lower-bound specification-expr 515 m int-literal-constant 1007 main-program [program-stmt] [specification-part] [execution-part] [internal-subprogram-part] end-program-stmt masked-elsewhere-stmt ELSEWHERE ( mask-expr ) [ where-construct-name ] 744 mask-expr logical-expr 743 module module-stmt [specification-part] [module-subprogram-part] 1104 end-module-stmt module-procedure-stmt MODULE PROCEDURE procedure-name-list 1206 module-stmt MODULE module-name 1105 module-subprogram module-subprogram-part mult-op * function-subprogram subroutine-subprogram 213 contains-stmt module-subprogram {module-subprogram} 212 / mult-operand level-1-expr [ power-op mult-operand ] 705 n int-literal-constant 1013 name letter (alphanumeric-character } 304 named-constant name 307 named-constant-def named-constant = initialization

331 namelist-group-name name 0 namelist-group-object variable-name 545 namelist-group-object-list namelist-group-object {namelist-group-object } 0 namelist-stmt NAMELIST / namelist-group-name / namelist-group-object-list { [, ] / namelist-group-name / namelist-group-object-list } nonlabel-do-stmt [ do-construct-name : ] DO [ loop-control ] 820 not-op.not. 719 nullify-stmt NULLIFY ( pointer-object-list ) 629 numeric-e xpr expr 729 object-name name 0 object-name-list object-name { object-name } 0 octal-constant only O ' digit { digit } ' O " digit { digit } " generic-spec only-use-name only-rename only-rename local-name => use-name 1111 only-use-name only-name 1110 open-stmt OPEN ( connect-spec-list ) 904 optional-stmt OPTIONAL [ :: ] dummy-arg-name-list 521 or-op.or. 721 or-operand [ or-operand and-op ] and-operand 716 output-item expr 915 io-implied-do output-item-list output-item { output-item } 0 parameter-stmt PARAMETER ( named-constant-def-list ) 550 parent-string scalar-variable-name 610 array-element scalar-structure-component scalar-constant part-ref part-name [ ( section-subscript-list ) ] 613 pointer-assignment-stmt pointer-object => target 736 pointer-object variable-name 630 structure-component pointer-object-list pointer-object { pointer-object } 0 pointer-stmt POINTER [ :: ] object-name [ ( deferred-shape-spec-list ) ] 528 {, object-name [ ( deferred-shape-spec-list ) ] } position-edit-desc T n 1012 TL n TR n n X

332 position-spec [ UNIT = ] external-file-unit IOSTAT = scalar-default-int-variable ERR = label 922 position-spec-list position-spec { position-spec } 0 power-op ** 708 prefix prefix-spec { prefix-spec } 1218 prefix-spec type-spec 1219 RECURSIVE PURE ELEMENTAL primary constant constant-sub-object variable array-constructor structure-constructor function-reference ( expr ) 701 print-stmt PRINT format [, output-item-list ] 911 private-sequence-stmt PRIVATE 424 SEQUENCE program program-unit {program-unit} 201 program-name name 0 program-stmt PROGRAM program-name 1102 program-unit main-program 202 external-subprogram module block-data r int-literal-constant 1004 read-stmt READ ( io-control-spec-list ) [ input-item-list ] 909 READ format [, input-item-list ] real-literal-constant significand [ exponent-letter exponent ] [ _kind-param ] 413 digit-string exponent-letter exponent [ _kind-param ] real-part signed-int-literal-constant 418 signed-real-literal-constant rel-op.eq..ne..lt..le..gt..ge. == /= 714

333 < <= > >= rename local-name => use-name 1108 result-name name 0 return-stmt RETURN [ scalar-int-expr ] 1226 rewind-stmt REWIND external-file-unit 921 REWIND ( position-spec-list ) saved-entity object-name 525 / common-block-name / saved-entity-list saved-entity { saved-entity } 0 save-stmt SAVE [ [ :: ] saved-entity-list ] 524 scalar-default-int-variable scalar-int-variable 0 scalar-int-expr expr 0 scalar-int-initialization-expr expr 0 scalar-logical-expr expr 0 sectionsubscript subscript 618 subscripttriplet vectorsubscript select-case-construct-name name 0 select-case-stmt [ case-construct-name : ] SELECT CASE ( case-expr ) 809 select-construct-name name 0 sign signed-digit-string [ sign ] digit-string 401 signed-int-literal-constant [ sign ] int-literal-constant 403 sign-edit-desc S 1014 SP SS signed-real-literal-constant [ sign ] real-literal-constant 412 significand digit-string. [ digit-string ]. digit-string specification-expr scalar-int-expr 734 specification-part { use-stmt } [ implicit-part ] { declaration-construct } 204 specification-stmt access-stmt allocatable-stmt common-stmt data-stmt dimension-stmt equivalence-stmt external-stmt intent-stmt 214

334 intrinsic-stmt namelist-stmt optional-stmt pointer-stmt save-stmt target-stmt stat-variable scalar-int-variable 623 stmt-function-stmt function-name ( [ dummy-arg-name-list ] ) = scalar-expr 1228 stop-code scalar-char-constant 841 digit [ digit [ digit [ digit [ digit ]]]] stop-stmt STOP [ stop-code ] 840 stride scalar-int-expr 620 structure-component data-ref 614 structure-constructor type-name ( expr-list ) 431 subobject array-element 602 array-section structure-component substring subroutine-stmt [ prefix ] SUBROUTINE subroutine-name 1222 [ ( [ dummy-arg-list ] ) ] subroutine-subprogram subroutine-stmt [specification-part] [execution-part] 1221 [internal-subprogram-part] end-subroutine-stmt subscript scalar-int-expr 617 Subscript-triplet [ subscript] : [subscript ] [ :stride ] 619 substring parent-string ( substring-range ) 609 substring-range [ scalar-int-expr ] : [scalar-int-expr ] 611 target variable 737 expr target-stmt TARGET [ :: ] object-name [ ( array-spec ) ] {, 529 object-name [ ( array-spec ) ] } type-declaration-stmt type-spec [ {, attr-spec } :: ] entity-decl-list 501 type-name name 0 type-spec INTEGER [ kind-selector ] 502 REAL [ kind-selector ] DOUBLE PRECISION COMPLEX [ kind-selector ] CHARACTER [char-selector ] LOGICAL [ kind-selector ] TYPE ( type-name ) underscore _ 303 Upper-bound Specification-expr 516 use-name name 0 use-stmt USE module-name [, rename-list ] 1107

335 variable USE module-name, ONLY : [only-list] scalar-variable-name array-variable-name subobject 601 Vectorsub-script intexpr 621 w int-literal-constant 1006 where-assignment-stmt assignment-stmt 742 where-body-construct where-assignment-stmt where-stmt where-construct where-construct where-construct-stmt 739 { where-body-construct } { masked-elsewhere-stmt { where-body-construct } } { elsewhere-stmt { where-body-construct } } end-where-stmt where-construct-name name 0 where-construct-stmt [ where-construct-name: ] WHERE ( mask-expr ) 740 where-stmt WHERE ( mask-expr ) where-assignment-stmt 738 write-stmt WRITE ( io-control-spec-list ) [ output-item-list ] 910

展开

FY.DOC

FY.DOC 高职高专 21 世纪规划教材 C++ 程序设计邓振杰主编贾振华孟庆敏副主编人民邮电出版社内容提要本书系统地介绍 C++ 语言的基本概念基本语法和编程方法, 深入浅出地讲述 C++ 语言面向对象的重要特征 : 类和对象抽象封装继承等主

More information

Microsoft PowerPoint - OPVB1基本VB.ppt

Microsoft PowerPoint - OPVB1基本VB.ppt 大綱 0.VB 能做什麼? CH1 VB 基本認識 1.VB 歷史與版本 2.VB 環境簡介 3. 即時運算視窗 1 0.VB 能做什麼? Visual Basic =>VB=> 程式設計語言 => 設計程式設計你想要的功能的程式自動化資料庫計算模擬遊戲網路監控實驗輔助自動

More information

<4D F736F F D D342DA57CA7DEA447B14D2DA475B57BBB50BADEB27AC3FEB14DA447B8D5C344>

<4D F736F F D D342DA57CA7DEA447B14D2DA475B57BBB50BADEB27AC3FEB14DA447B8D5C344> 1. 請問誰提出積體電路 (IC) 上可容納的電晶體數目, 約每隔 24 個月 (1975 年更改為 18 個月 ) 便會增加一倍, 效能也將提升一倍, 也揭示了資訊科技進步的速度? (A) 英特爾 (Intel) 公司創始人戈登. 摩爾 (Gordon Moore) (B) 微軟 (Microsoft)

More information

幻灯片 1

幻灯片 1 白色花诗集人民文学出版社 1981 年出版共收七月派诗人阿垅鲁藜孙钿彭燕郊方然冀汸钟瑄郑思曾卓杜谷绿原胡征芦甸徐放牛汉鲁煤化铁朱健朱谷怀罗洛等二十人的诗作一百十九首集名出自阿垅未入选的一首诗中要开作一枝白色花

More information

CC213

CC213 : (Ken-Yi Lee), E-mail: [email protected] 49 [P.51] C/C++ [P.52] [P.53] [P.55] (int) [P.57] (float/double) [P.58] printf scanf [P.59] [P.61] ( / ) [P.62] (char) [P.65] : +-*/% [P.67] : = [P.68] : ,

More information

Microsoft PowerPoint - plan06.ppt

Microsoft PowerPoint - plan06.ppt 程序设计语言原理 Principle of Programming Languages 裘宗燕北京大学数学学院 2012.2~2012.6 6. 基本控制抽象子程序抽象子程序活动和局部环境静态实现模型一般实现模型调用序列和在线展开参数机制泛型子程序异常处理其

More information

z x / +/- < >< >< >< >< > 3 b10x b10x 0~9,a~f,A~F, 0~9,a~f,A~F, x,x,z,z,?,_ x,x,z,z,?,_ h H 0~9,_ 0~9,_ d D 0~7,x,X,z,Z

z x / +/- < >< >< >< >< > 3 b10x b10x 0~9,a~f,A~F, 0~9,a~f,A~F, x,x,z,z,?,_ x,x,z,z,?,_ h H 0~9,_ 0~9,_ d D 0~7,x,X,z,Z Verilog Verilog HDL HDL Verilog Verilog 1. 1. 1.1 1.1 TAB TAB VerilogHDL VerilogHDL C 1.2 1.2 C // // /* /* /* /* SYNOPSY SYNOPSY Design Compiler Design Compiler // //synopsys synopsys /* /*synopsys synopsys

More information

2 34 2 41 2 39 37

2 34 2 41 2 39 37 1955 64 14 1957 4 2 1972 3 1 138 7 20 79 8 7 28 66 14 60 25 2 9 79 17 12 189 190 6 43 1 138 1 2 166 174 145 163 468 31 34 358 1118 131 132 513 514 865 58 292 37 21 1 142 232 244

More information

C/C++ - 函数

C/C++ - 函数 C/C++ Table of contents 1. 2. 3. & 4. 5. 1 2 3 # include # define SIZE 50 int main ( void ) { float list [ SIZE ]; readlist (list, SIZE ); sort (list, SIZE ); average (list, SIZE ); bargragh

More information

CH01.indd

CH01.indd 3D ios Android Windows 10 App Apple icloud Google Wi-Fi 4G 1 ( 3D ) 2 3 4 5 CPU / / 2 6 App UNIX OS X Windows Linux (ios Android Windows 8/8.1/10 BlackBerry OS) 7 ( ZigBee UWB) (IEEE 802.11/a/b/g/n/ad/ac

More information

(\244j\257d\276\307\274\351_201508021-C.indd_70%.pdf)

$(\244j\257d\276\307\274\351_201508021-C.indd_70%.pdf)$ 1847-1852 1872 20 1 1896 8000 20 1896 1950 1 1896 1896 13 1900 1900 3 20 2 4 1910 1950 3 1911 1 2 3 4 1927 4 20 300 6 1906 1930 7 1911 5 1919 8 1914 9 1920 10 11 1902 200 6 12 1930 7 " # #! $! 14 15! "!

More information

四川省普通高等学校

四川省普通高等学校四川省普通高等学校计算机应用知识和能力等级考试考试大纲 (2013 年试行版 ) 四川省教育厅计算机等级考试中心 2013 年 1 月目录一级考试大纲 1 二级考试大纲 6 程序设计公共基础知识 6 BASIC 语言程序设计 (Visual Basic) 9

More information

Computer Architecture

Computer Architecture ECE 3120 Computer Systems Assembly Programming Manjeera Jeedigunta http://blogs.cae.tntech.edu/msjeedigun21 Email: [email protected] Tel: 931-372-6181, Prescott Hall 120 Prev: Basic computer concepts

More information

,,,, (,, - ;, ;, ;, ;, ;,, - ;, - ) (,, ~ ),,,, (, ),,,, ( ), () () ( ),,,,,,,.,, :.,. (,, ) : ( ), ;( ), ;( ) ;( ), :.,. %(,, ),,,,, (,, - ) :( ) ( )

,,,, (,, - ;, ;, ;, ;, ;,, - ;, - ) (,, ~ ),,,, (, ),,,, ( ), () () ( ),,,,,,,.,, :.,. (,, ) : ( ), ;( ), ;( ) ;( ), :.,. %(,, ),,,,, (,, - ) :( ) ( ) * 张文宏阮丹青内容提要 : 本文运用年天津城乡居民社会网的问卷调查资料, 对市民和农民的社会支持网进行了比较研究我们的研究发现 :( ) 亲属在城乡居民的财务支持网中发挥着非常重要的作用 ( ) 亲属在精神支持网中的作用也

More information

## $%& %& ## () #) (( * (+++ () #) #) (+ (+ #) #) ( #, - #)). #))- # ( / / / 0 1 2 0 / $ # ( . 3. 3 ..# 4 #$ 3 ( 5 ) ### 4 $ # 5, $ ## # 4 $# 5 ( %

# # $ %& $ %# ( $ # ( # $ ( $ $ ( ( % ( $ ( $ ( ( % ( % $ ( $ ( ( $ ( ( ( & ( ( ( $ ( ( % %# ( ( $ ( %# % ## $%& %& ## () #) (( * (+++ () #) #) (+ (+ #) #) ( #, - #)). #))- # ( / / / 0 1 2 0 / $ # ( *.

More information

C/C++ - 字符输入输出和字符确认

C/C++ - 字符输入输出和字符确认 C/C++ Table of contents 1. 2. getchar() putchar() 3. (Buffer) 4. 5. 6. 7. 8. 1 2 3 1 // pseudo code 2 read a character 3 while there is more input 4 increment character count 5 if a line has been read,

More information

Microsoft PowerPoint - 07 派生数据类型

Microsoft PowerPoint - 07 派生数据类型能源与动力工程学院目录派生类型陈斌固有数据类型数值型 (numerical) 整型 INTEGER 实型 REAL 复数型 COMPLEX 非数值型字符型 CHARACTER 逻辑型 ( 布尔型 )LOGICAL 自定义数据类型 ( 派生类型, derived type) 派生类型是指用户利用 Fortran 系统内部类型, 如整型实型复数型逻辑型字符型等的组合自行创建出一个新的数据类型,

More information

2 2 3 DLight CPU I/O DLight Oracle Solaris (DTrace) C/C++ Solaris DLight DTrace DLight DLight DLight C C++ Fortran CPU I/O DLight AM

2 2 3 DLight CPU I/O DLight Oracle Solaris (DTrace) C/C++ Solaris DLight DTrace DLight DLight DLight C C++ Fortran CPU I/O DLight AM Oracle Solaris Studio 12.2 DLight 2010 9 2 2 3 DLight 3 3 6 13 CPU 16 18 21 I/O DLight Oracle Solaris (DTrace) C/C++ Solaris DLight DTrace DLight DLight DLight C C++ Fortran CPU I/O DLight AMP Apache MySQL

More information

Ps22Pdf

Ps22Pdf 990 1995 ( ),,,,,,, ( ) ( ) ;, ;,, ( ),, 2000 7 1 ( 1 ) ( 4 ) ( 6 ) ( 15 ) ( 21 ) ( 33 ) ( 36 ) ( 43 ) ( 53 ) ( 60 ) ( 65 ) ( 74 ) ( 84 ) ( 87 ) ( 92 ) ( 97 ) (100) (111) (116) (119) (122) (127) (138)

More information

C/C++程序设计 - 字符串与格式化输入/输出

C/C++程序设计 - 字符串与格式化输入/输出 C/C++ / Table of contents 1. 2. 3. 4. 1 i # include # include // density of human body : 1. 04 e3 kg / m ^3 # define DENSITY 1. 04 e3 int main ( void ) { float weight, volume ; int

More information

投影片 1

投影片 1 真善美幼兒園 102 學年度第二學期小廚師阿諾 @ 活動日期 :2/12~4/11 @ 活動班級 : 獅子班 @ 製作編輯 : 徐淑芬 *. *. 主題目標. *. * 一. 能分享自己長大的志願二. 認識食物金字塔以及食物的營養三. 透過戶外教學到傳統市場挑選新

More information

2006年国家公务员招录考试行测真题（A）

2006年国家公务员招录考试行测真题（A） 2006 年中央国家机关公务员录用考试行政职业能力测验 (A) 真题说明这项测验共有五个部分,135 道题, 总时限为 120 分钟各部分不分别计时, 但都给出了参考时限, 供你参考以分配时间请在机读答题卡上严格按照要求填写好自己的姓

More information

新版明解Ｃ言語入門編

新版明解Ｃ言語入門編 328, 4, 110, 189, 103, 11... 318. 274 6 ; 10 ; 5? 48 & & 228! 61!= 42 ^= 66 _ 82 /= 66 /* 3 / 19 ~ 164 OR 53 OR 164 = 66 ( ) 115 ( ) 31 ^ OR 164 [] 89, 241 [] 324 + + 4, 19, 241 + + 22 ++ 67 ++ 73 += 66

More information

Microsoft Word - 103鐵路佐級-國文(二)

Microsoft Word - 103鐵路佐級-國文(二) 103 年特種考試交通事業鐵路人員考試試題等別 : 佐級鐵路人員考試類科 : 事務管理機械工程機檢工程電力工程電子工程養路工程科目 : 國文 ( 包括公文格式用語 ) 一單一選擇題 : 下列成語, 沒有錯別字的選項是 : 手屈一指載罪立

More information

学习贯彻中央尧省尧市纪委全会精神专栏中国共产党第十八届中央纪律检查委员会第六次全体会议公报渊 2016 年 1 月 14 日中国共产党第十八届中央纪律检查委员会第六次

学习贯彻中央尧省尧市纪委全会精神专栏中国共产党第十八届中央纪律检查委员会第六次全体会议公报渊 2016 年 1 月 14 日中国共产党第十八届中央纪律检查委员会第六次内部资料注意保存渊第三期冤中共六盘水市委讲师团编 2016 年 3 月 15 日学习贯彻中央尧省尧市纪委全会精神专辑音学习贯彻中央尧省尧市纪委全会精神专栏淫中国共产党第十八届中央纪律检查委员会第六次全体会议公报渊 2 冤淫

More information

Microsoft Word - 临政办发12.doc

Microsoft Word - 临政办发12.doc 临沂市人民政府办公室文件临政办发 2016 12 号临沂市人民政府办公室关于印发临沂市乡村教师支持计划 (2015-2020 年 ) 实施细则的通知各县区人民政府, 市政府各部门各直属机构, 临沂高新技术产业开发区管委会, 临沂经济技术开

More information

中共山东省委高校工委

中共山东省委高校工委关于印发中共山东省委高校工委 2016 年工作要点的通知青岛淄博威海日照滨州市委高校工委, 各高等学校党委 : 现将中共山东省委高校工委 2016 年工作要点印发你们, 请认真学习领会, 抓好贯彻落实中共山东省委高校工委 2016 年 1

More information

目录第一部分国家知识产权局概况一主要职能二部门预算单位构成第二部分国家知识产权局 2016 年部门预算表一财政拨款收支总表二一般公共预算支出表三一般公共预算基

目录第一部分国家知识产权局概况一主要职能二部门预算单位构成第二部分国家知识产权局 2016 年部门预算表一财政拨款收支总表二一般公共预算支出表三一般公共预算基国家知识产权局 2016 年部门预算目录第一部分国家知识产权局概况一主要职能二部门预算单位构成第二部分国家知识产权局 2016 年部门预算表一财政拨款收支总表二一般公共预算支出表三一般公共预算基本支出表四一般公共预算

More information

科学技术部2013年度部门预算

科学技术部2013年度部门预算 1 目录第一部分中国侨联概况一主要职能二部门预算单位构成第二部分中国侨联 2016 年部门预算表一财政拨款收支总表二一般公共预算支出表三一般公共预算基本支出表四一般公共预算三公经费支出表五政府性基金预算支出表六

More information

一、二○○二年学校工作的简要回顾

一、二○○二年学校工作的简要回顾北华校字 [2016]13 号北华大学 2016 年硕士研究生招生复试录取工作办法为做好我校 2016 年硕士研究生招生复试录取工作, 规范招生工作程序, 加强招生制度建设, 根据教育部关于印发的

More information

Microsoft Word - 白俄罗斯公司法汉语译文2015年7月15日修改版.docx

Microsoft Word - 白俄罗斯公司法汉语译文2015年7月15日修改版.docx 白俄罗斯共和国公司法条目第一章总则第 1 条关于公司的基本规定第 2 条白俄罗斯共和国关于公司的立法第 3 条本法的适用范围第 4 条公司的名称和住所第 5 条公司的责任第 6 条公司的代表处和分公司第 7 条子公司第 8 条附属公司

More information

第一部分中国气象局职责及概况一主要职责 ( 一 ) 拟定气象工作的方针政策法律法规发展战略和长远规划 ; 制定发布气象工作的规章制度技术标准和规范并监督实施 ; 承担

第一部分中国气象局职责及概况一主要职责 ( 一 ) 拟定气象工作的方针政策法律法规发展战略和长远规划 ; 制定发布气象工作的规章制度技术标准和规范并监督实施 ; 承担中国气象局 2016 年部门预算目录第一部分中国气象局职责及概况一主要职责二机构设置第二部分中国气象局 2016 年部门预算表一财政拨款收支总表二一般公共预算支出表三一般公共预算基本支出表四一般公共预算三公经费支出表

More information

无锡职业技术学院国有资产管理办法第一章总则第一条为加强学校国有资产管理, 合理配置和有效使用国有资产, 确保国有资产安全与完整, 保障和促进学校各项事业发展, 根

无锡职业技术学院国有资产管理办法第一章总则第一条为加强学校国有资产管理, 合理配置和有效使用国有资产, 确保国有资产安全与完整, 保障和促进学校各项事业发展, 根无锡职业技术学院文件锡职院资 2016 2 号关于印发无锡职业技术学院国有资产管理办法的通知各部门各院部 : 现将无锡职业技术学院国有资产管理办法印发给你们, 请遵照执行无锡职业技术学院 2016 年 3 月 28 日 - 1 - 无锡职业技

More information

南昌大学人力资源工作简讯 2015 年第 2 期 ( 总第 27 期 ) 目录 1 人力资源综合信息 2 人员调配及机构编制管理信息 3 劳资工作信息 4 师资管理信息 5 高层次人才及队伍建设

南昌大学人力资源工作简讯 2015 年第 2 期 ( 总第 27 期 ) 目录 1 人力资源综合信息 2 人员调配及机构编制管理信息 3 劳资工作信息 4 师资管理信息 5 高层次人才及队伍建设人力资源工作简讯 2015 年第 2 期 ( 总第 27 期 ) 南昌大学人事处 2015 年 7 月南昌大学人力资源工作简讯 2015 年第 2 期 ( 总第 27 期 ) 目录 1 人力资源综合信息 2 人员调配及机构编制管理信息 3 劳资工作信息 4 师资管理信息 5 高层

More information

三亚市政府投资建设项目代建制管理工作介绍

三亚市政府投资建设项目代建制管理工作介绍三亚市发展和改革委员会 2015 年 9 月一代建制的定义二代建范围规定三代建单位入库资格及要求四代建单位的职责七代建单位管理费拨付和计算五代建项目组织实施程序六资金管理与监督八项目前期费用及工程款拨付九代建项目

More information

目录一部门职责... 1 二预算编报范围... 3 三 2013 年部门预算报表及情况说明... 5 收支预算总表及情况说明... 5 收入预算表及情况说明... 7 支出预算表及情况说明... 1

目录一部门职责... 1 二预算编报范围... 3 三 2013 年部门预算报表及情况说明... 5 收支预算总表及情况说明... 5 收入预算表及情况说明... 7 支出预算表及情况说明... 1 教育部 2013 年部门预算二〇一三年四月十八日目录一部门职责... 1 二预算编报范围... 3 三 2013 年部门预算报表及情况说明... 5 收支预算总表及情况说明... 5 收入预算表及情况说明... 7 支出预算表及情况说明... 11 财政拨款

More information

目录引言... 3 第一部分电价水平基本情况...4 一上网电价...4 二输配电价...6 三销售电价...9 四政府性基金和附加...12 第二部分电价政策执行情况...13 一电价水平调整情

目录引言... 3 第一部分电价水平基本情况...4 一上网电价...4 二输配电价...6 三销售电价...9 四政府性基金和附加...12 第二部分电价政策执行情况...13 一电价水平调整情 2008 年度电价执行情况监管报告国家电力监管委员会二九年十月目录引言... 3 第一部分电价水平基本情况...4 一上网电价...4 二输配电价...6 三销售电价...9 四政府性基金和附加...12 第二部分电价政策执行情况...13 一电价水平

More information

西安邮电学院本科教学工作简报

西安邮电学院本科教学工作简报西安邮电学院本科教学工作简报 (2011 年第一期 ) 西安邮电学院教务处 2011 年 7 月本期要目教学新闻王曙燕教授荣获陕西省教学名师称号 2010 2011 年中央财政专项资金项目使用及申报情况人民邮电出版社西安邮电学院教材出版

More information

2 586 103

More information

( 十 ) 其他会计工作第四条单位不得任用 ( 聘用 ) 不具备会计从业资格的人员从事会计工作不具备会计从业资格的人员, 不得从事会计工作, 不得参加会计专业技术资格考试

( 十 ) 其他会计工作第四条单位不得任用 ( 聘用 ) 不具备会计从业资格的人员从事会计工作不具备会计从业资格的人员, 不得从事会计工作, 不得参加会计专业技术资格考试会计从业资格管理办法 (2012 年 12 月 6 日中华人民共和国财政部令第 73 号公布根据 2016 年 5 月 11 日财政部关于修改 < 会计从业资格管理办法 > 的决定修改 ) 第一章总则第一条为了加强会计从业资格管理, 规范会计人员行为, 根据

More information

<C1ACD6DDCAD0CAD0B3A1BCE0B6BDB9DCC0EDBED6C8A8D4F0C7E5B5A5A3A8B9ABCABEA3A92E786C73>

<C1ACD6DDCAD0CAD0B3A1BCE0B6BDB9DCC0EDBED6C8A8D4F0C7E5B5A5A3A8B9ABCABEA3A92E786C73> 机构编制委员会办公室编 2016 年 2 月 29 日类别数量合计拟调整后保留拟调整小计取消下放转移提请或调整事项行政许可 9 9 1 行政处罚 951 951 行政强制 37 37 行政征收 4 4 行政给付 0 0 行政检查 47 47 行政确认 1 1 行政裁决 1

More information

Microsoft Word - Future CEDAW C CHN 7-8.doc

Microsoft Word - Future CEDAW C CHN 7-8.doc 序言 1. 根据消除对妇女一切形式歧视公约 ( 简称公约 ) 第十八条第一款规定, 中华人民共和国向联合国秘书长提交执行公约第 7 8 次合并报告本报告的撰写遵循了消除对妇女歧视委员会 ( 简称消歧委员会 ) 关于缔约国定期报告的指

More information

本科生手册中南大学学生工作委员会秘书处编印二〇一四年八月社会主义核心价值观富强民主文明和谐自由平等公正法治爱国敬业诚信友善校徽 : 校训 : 校风 : 知行合一经世致用向善求真唯美有容目录一法律法规与上级制度 1 中

More information