第1页 / 共94页
第2页 / 共94页
第3页 / 共94页
第4页 / 共94页
第5页 / 共94页
第6页 / 共94页
第7页 / 共94页
第8页 / 共94页
Fortran编程基础.pdf
Fortran语言
（Fortran77结构化程序设计）
第二章
计算机和计算机程序
第二章 计算机和计算机程序
2.1 计算机是实现算法的有效工具
2.2 计算机的基本组成
2.3 计算机中存储信息的方法
2.4 计算机语言和计算机程序
2.5 程序运行环境
2.6 程序开发的步骤
2.4 计算机语言和计算机程序
一、计算机语言的分类
1、机器语言：面向机器
2、汇编语言（符号语言）：面向机器
3、高级语言（算法语言）：可移植性
如：BASIC，FORTRAN，C，PASCAL，C++，JAVA等
二、计算机程序
程序 = 算法 + 数据结构
2.5 程序运行环境
一、编辑源程序
二、翻译程序：将源程序翻译成机器语言的过程
1、汇编语言：
2、高级语言：
三、连接程序
2.6 程序开发的步骤
分析问题，画流程图，书写源程序（课堂）
输入、编辑源程序
编译
连接
运行
第一章 算法
1.1 概念
算法是为了解决一个问题所采取的步骤
1.2 算法举例
【例1.1】求累加和：1+2+3+…+10
方法一：步骤1：1+2=3
步骤2：3+3=6
…
实现：每一步都使用上一步的结果，并且所有数字都必须存储在不同的存储单元中。
繁琐，不可取
方法二：设置3个变量S，X，I
步骤1：将存放累加和的S清0：S=0
步骤2：将计数器I清0：I=0
步骤3：读入一个数存放到X中
步骤4：计数器增1：I=I+1
步骤5：判断I是否大于10（否--6；是--7）
步骤6：将X中的数累加到S中：S+XàS
重复执行步骤3、4、5
步骤7：输出累加和S的值
1.2 算法举例
【例1.2】将50个学生成绩中的80分以上的成绩打印出来
思路：同样设置变量：X存放成绩，I为计数器
步骤1：计数器清0：I=0
2:读入一个学生成绩，存入X中
3：计数：I=I+1
4：判断I是否>50？
5：判断X是否>80？
6：返回执行步骤2
7：结束
1.3 算法的特性
有穷性
确定性
有零个或多个输入
有一个或多个输出
有效性
1.4 算法的表示方法
1、自然语言
2、流程图：传统流程图，改进的流程图
【例1.1】求累加和：1+2+3+…+10
流程图：
【例1.2】将50个学生成绩中的80分以上的成绩打印出来
3、结构化程序的三种基本结构
结构化包括两方面的内容：
（1）模块化
（2）三种基本结构为程序的基本单元
顺序结构
选择结构（分支结构）
循环结构
第三章
FORTRAN语言程序设计初步
3.1 FORTRAN语言发展概况
Formula Translation
适用于工程及科学计算的一种高级程序设计语言
1951年由约翰·贝克斯等人开始研究Fortran语言；
1957年第一个Fortran程序在IBM704机上运行；
1958和1962年先后推出FortranⅡ和FortranⅣ；
1966和1978年先后颁布Fortran66和Fortran77；
1991年颁布了Fortran90
3.2 简单的FORTRAN程序分析
【例3.1】求三个数的平均值
源程序：c calculate the average
x=90.5
y=87.0
z=68.5
aver=(x+y+z)/3.0
write (*,*) ‘平均值为’,aver
end
3.2 简单的FORTRAN程序分析
【例3.2】试求3!，6!，9!的值
主程序： 子程序：
c main program c subprogram
j=k(3) function k(n)
l=k(6) k=1
m=k(9) i=2
write(*,*)j,l,m 5 if (i.le.n) then
end k=k*i
i=i+1
goto 5
endif
return
end
3.2 简单的FORTRAN程序分析
Fortran程序的基本结构：
⑴一个Fortran源程序由一个或多个程序单位组成，每个独立的程序单位以“end”语句结束。
⑵每个程序单位包括若干行
-语句行（执行语句和非执行语句行）
-非语句行（注释行）
* 不能一行写多条语句，但可以几行写一条语句
⑶语句前可不设标号，也可根据需要设标号。
⑷各类语句在程序单位中的位置有一定规则。
⑸程序必须按规定格式书写。
3.3 FORTRAN 源程序的书写格式
Fortran77源程序必须按以下格式书写：
⑴每行只能在80列内书写，并把80列分为4个区。
⑵ 1～5列：标号区
（ 1～5 位整数；第1列为“*”或“c”时，为注释行）
⑶ 第6列：续行标志区
（非空格或非零字符；最多19个续行）
⑷ 7～72列：语句区
（书写语句；一行只能写一条语句）
⑸ 73～80列：语句注释区
（一般作编号注释）
3.4 Fortran程序的编辑与运行
Fortran 开发环境简介
3.4 Fortran程序的编辑与运行
一、Fortran 源程序编辑软件进入
进入DOS状态→找到fortran目录并进入→在当前路径下键入edit并回车。
二、创建源程序文件并编写源程序
在出现的编辑界面中按[alt]+f键激活file菜单，选择save选项，出现“save as”保存界面，以for为扩展名（即为xxx.for）命名文件，按回车键→开始编辑（编写程序过程中，应经常存盘）→编写完毕后用file菜单中exit选项退出。
3.4 Fortran程序的编辑与运行
三、编译并连接源文件
在当前路径（即fortran目录）键入fl 源文件名→等待编译提示信息→若有错误在当前路径键入edit 源程序文件名再次进入编辑状态，直到编译成功，产生可执行文件xxx.exe。
3.4 Fortran程序的编辑与运行
四、运行程序
在正确路径下键入xxx即可运行
五、打开源程序文件（两种方式）
1.在fortran目录下键入edit 源程序文件名
2.键入edit进入编辑界面，利用file菜单中
open选项
3.5 常 量
常量 — 在程序执行期间其值固定不变的量
Fortran处理六种类型的常量：
⑴整型常量（Integer）ü
⑵实型常量（Real） ü
⑶双精度常量（Double precision）
⑷复型常量（Complex）
⑸逻辑型常量（Logical）
⑹字符型常量（Character）
3.5.1 整型常量
整数（Integer）
包括正、负整数和零
如：5，-13，0，…
说明：
①在（16位）微机中，整数的取值范围为：
-215～215-1（-32768～32767）
②在（32位）微机中，整数的取值范围为：
-231～231-1（-2147483648～2147483648 ）
3.5.2 实型常量
实数（real）
两种表示形式
⒈小数形式
如：15.8，-21.05，1.0 ,14.，.17，0.0 ,…
⒉指数形式（通常表示较大或较小的数）
如：100000000→1.0E+8
0.0000125→1.25E-05
数字部分 指数部分
3.5.2 实型常量
说明：
⑴一个数值用指数形式表示时有两种表达方式：
①一个基本实数后面跟指数部分。
如： 0.876 → 8.76E-1
-2589.4 → -2.5894E+3
②一个整数后面跟指数部分。
如： 0.876 → 876E-3
-2589.4 → -25894E-1
3.5.2 实型常量
⑵同一个数值可用不同的指数形式表示。
如： 0.876→8.76E-1→87.6E-2→876E-3
⑶计算机在输出时，按标准化指数形式输出。
如：0.28→2.800000E-01
-59.58E+12→-5.958000E+13
即数字部分大于1，且小数点前只有一位非零数字的指数输出形式。
⑷在微机中，一般用四个字节存放一个实数，其取值范围为：10-38～1038。超出此范围时为“溢出”错误。
3.5.2 实型常量
⑸下列形式为不合法的指数形式：
①单独的小数点和单独的指数部分。
如：.E5， E10
②指数部分只能是整数，不能带小数点。
如：8E0.5， 12.3E1.5
3.6 变 量
3.6.1 变量的概念
变量——在程序执行期间其值可以改变的量
Fortran为每一个变量分配一个相应的存储单元；
每个变量在每个时刻只能有一个确定的值。
如：x=4.5 x
x=8.0 x
注：在程序中用到的变量都必须要有确定的值
3.6 变 量
3.6.2 变量名
变量名——标识一个变量所用的名字。
命名规则：
变量名的第一个字符必须是字母;
在第一个字符后可跟1～5个字母或数字。
如：
x，m1，total，k123，…
3.6 变 量
注意几点：
⑴变量名不区分大小写字母。
如：TOTAL，Total，total 代表同一变量
⑵变量名中的空格不起作用。
如：abc，a bc，ab c，a b c 代表同一变量
⑶允许变量名与语言中具有特定含义的字（“保留字”）同名。但建议不要使用。
如：sin，read，open，end，…
⑷尽量“见名知义”，如:root,aver,result等
3.6 变 量
3.6.3 变量类型
不同类型的变量用来存放不同类型的常量数据
由于常量具有六种类型,因此变量同样具有六种类型
这里只先介绍两种：
整型变量 - 存放整型常量
实型变量 - 存放实型常量
不同类型的数据在内存中的存储长度是不同的，
因此,在程序中使用变量,应首先对其类型进行说明
3.6 变 量
变量类型的三种说明方法
⒈隐含约定
以I、j、k、l、m、n开头的变量为整型变量，以其它字母开头的变量为实型变量（“I～N规则”）
如：imax，m5，number，… 为整型变量
v，h2，aver，… 为实型变量
注：方便，只能用来区分整型与实型。
3.6 变 量
3.6 变 量
3.6 变 量
几点说明：
1、三种类型说明的优先级：
高 类型说明语句（显式说明）
implicit语句说明
低 “I～N规则”
2、均为非执行语句,位于所有可执行语句的前面
3、implicit语句应放在所有的说明语句的前面
4、只在本程序单位内有效
3.7 Fortran内部函数
在编制Fortran程序时，经常要用到一些基本的数学函数，如三角函数、指数函数、对数函数等(P61)。为方便用户，Fortran编译系统已提供了这些函数的计算程序，需要时即可调用。
Fortran内部函数调用格式：
函数名（自变量）
3.7 Fortran内部函数
如：sin(90*3.14159/180) →1.0
sqrt(9.0) →3.0
abs(-5.6) →5.6
int(6.75) →6
exp(3.0) →20.085540
3.7 Fortran内部函数
注意几点：
⑴函数自变量(参数)必须用括号括起来(一个或多个)
如：sinx+cosx → sin(x)+cos(x)
⑵函数自变量可以是常量、变量或表达式。
如： exp(3.0)，sin (x+cos(x))
⑶函数的类型是由函数值的类型确定的,但有些函数
的类型是由自变量的类型确定的。
如：mod(8.0,3.0) →2.0；mod(8,3) →2
⑷三角函数的角度单位是“弧度”而不是“度”。
⑸注意书写方式
3.8 Fortran算术表达式
表达式—是用一些特定的运算符将Fortran基本成分
连接起来的具有确定意义的式子。
基本成分包括：常量,变量,函数,字符串,数组等
Fortran规定有四种表达式：
算术表达式ü
逻辑表达式（第四章）
字符表达式
关系表达式（第四章）
3.8 Fortran算术表达式
3.8.1 算术运算符和运算优先级
1、5种算术运算符：
+，-，*，/，**（乘方）
2、优先级：（） _ ** _ *，/ _ +，-
3.8.2 算术运算式
运算符：算术运算符
各运算元素：都是算术量
表达式的结果：也是算术量
3.8 Fortran算术表达式
例：2.34*A， B**2-SQRT（C）/D
（A+B）/2.*H
注意：
1、书写问题：
① “/”号，如：（A+B）/（C+D）
② “*”不能省略，如：2AB — 2*A*B
③括号不分大小，均用（）表示，成对出现
如：((((A+1)+1）+1)+1)
3.8 Fortran算术表达式
④多次乘方按“先右后左”的原则处理。
如：4**3**2 4**（3**2）
⑤单边运算符：“-”号
注：运算符不能连续出现,要用小括号隔开
如：A*（-B）-T/（-Q）
2、运算顺序：
（） 函数 ** *，/ +，-
3.8 Fortran算术表达式
3.8.3 表达式运算中的类型问题
两种情况：
1、运算类型相同：结果仍为原类型
注意：两个整数相除，结果仍为整数，不正确
解决办法：先转换为实数在相除（2→2.0）
2、运算类型不同：编译系统自动转换为同一类型
整型 实型
注意：类型转换从左到右进行，遇到不同类型运算时才进行转换。例：4/5+3*2.4
3.8 Fortran算术表达式
3.8.4 运算的误差问题
1、溢出：超出有效数值范围
解决：很大或很小的数用实型的指数形式表示
2、误差：由于有效数字的位数限制，实型数运算存在误差
解决1：转换为双精度型
解决2：避免因书写不当造成有效数字的丢失
如：0.001+1234567.0-1234566.0
3.9 赋值语句
作用—将一个确定的值赋给一个变量
一般格式： V = e
变量 = 表达式
例：x=3.2
Y=SQRT(x+5.0)/2.0
说明：1、“=” 为赋值号
其作用为：x ï 3.2
特殊：I=I+1(计数器）
2、左端只能是变量名，如：x+y=5是不合法的
3.9 赋值语句
3、类型转换问题
类型相同，直接赋值（I=3）
类型不同，计算表达式的值—将结果类型转换为左端变量的类型
例： I=3.6*5+1.5
X=（5+6）/（8-5）
为避免出现类型转换过程中的错误，应保证两侧类型一致。
3.10 简单输出语句
输出语句的作用— 将内存的数据传送到显示器、打印机或保存到磁盘指定区域。
输入/输出三要素：
对象：哪些数据
格式
设备
输出语句的分类：
格式输出（第七章）
表控格式输出（系统标准格式）ü
无格式输出
3.10.2 表控输出语句
按计算机系统规定的格式输出
系统自动为每种类型的数据规定了列数
一、表控输出格式
⒈整数的表控格式输出
规定：每个整数占11列，数印右端，左补空格
例：print *，123，-1128
输出结果：
︺︺︺︺︺︺︺︺123︺︺︺︺︺︺-1128
3.10.2 表控输出语句
⒉实数的表控格式输出
规定：每个实数占15列，数印右端，左补空格,小数部分占6列。
例：print *，15.4，-321.45
输出结果：
︺︺︺︺︺︺15.400000︺︺︺︺-321.450000
3.10.2 表控输出语句
当实数值的绝对值≥107或＜1是时，按标准的指数形式输出。
共占15列，指数4列，小数6列
例：print *，-10000000.，0.98
输出结果：
︺︺-1.000000E+07︺︺︺9.800000E-01
3.10.2 表控输出语句
二、表控格式输出语句
一般格式：
print ﹡,〈输出表列〉
write (﹡,﹡)〈输出表列〉
例1： print ﹡,56.8,125
或 write (﹡,﹡) 56.8,125
例2： print ﹡,a, b, c
或 write (﹡,﹡) a, b, c
3.10.2 表控输出语句
例3： x=12.5
y=90.5
z=x+y
print *, x, y
print *, 'z=', z
end
运行结果：
12.500000 90.500000
Z= 103.000000
3.11 简单输入语句
输入语句的作用— 将外部介质（键盘、磁盘）上的数据传送到内存变量指定的单元中。
输入/输出三要素：
对象：哪些数据
格式
设备
输入语句的分类：
格式输入（第七章）
表控格式输入（系统标准格式）ü
无格式输入
3.11.2 表控输入语句
自由格式输入
语句： read ﹡,〈输入表列〉
read (﹡,﹡)〈输入表列〉
注意：1、执行时，程序会停止，等待用户从键盘 上输入数据。
2、输入时，数据间以“,”或空格间隔。
3、变量名称为输入表。
4、输入的数据应和输入表的变量个数、类型，次序严格地一一对应。
3.11.2 表控输入语句
例1：read(*,*) a,b,I,j
输入：108.6，-37.8，5（回车）
---少一个数，则j没有被赋值，程序停止等待
输入：108.6，-37.8，5，6，9（回车）
---多一个数，则输入的9不起作用，程序正常执行
例2： read(*,*) a,b,I,j，c, k,l,p
输入：25.8，-8.2 （回车）
5，8，2.7 （回车）
2，6，6.9 （回车）
---数据太多，可以分几个记录输入
记录：以回车结束的一批输入/输出数据
3.11.2 表控输入语句
例3：read(*,*) A,B,C,D,E,F,G
输入：7*3.5
---相同的数据可以用重复系数输入
例4：read(*,*)A,B,C
read(*,*)D,I,J
输入：2.3，-63.5 （回车）
6.4，91.0 （回车）
5，8 （回车）
3.11.2 表控输入语句
结果：A=2.3，B=-63.5，C=6.4，D=5.0，I=8
J未被赋值
---每个read语句从一个新的记录开始读数
例5：read(*,*)A,B,C
read(*,*)D,I,J
write(*,*)A,B,C,D
write(*,*)I,J
end
输入：2.3，63.5，6.4 （回车）
91.0，5，6 （回车）
3.11.2 表控输入语句
输出：
-…--2.300000--…-63.500000-…-6.400000--.-91.000000
--…--5--…--6
---每个write语句也是从一个新的记录开始输出
3.12参数语句（parameter语句）
作用—将程序中经常用到的常数定义成一个符号常量，其值不可改变。
语句：parameter(p1=c1[,p2=c2,…,pn=cn])
其中： pn——符号常量； cn——常量
例：parameter (r=6.2 ,PI=3.1415926)
s=PI*r**2
L= 2*PI*r
write(*,*) s,L
end
3.12 参数语句
注意：
1、符号常量的命名规则与变量名相同,但它不同于变量,它的值不改变,在程序中不能对它赋值。
例：PI=5.6 或 read(*,*) r
2、符号变量也有类型,也可用三种方法说明类型
3、参数语句是非执行语句,也位于所有可执行语句的前面,但位于类型说明语句后面。
4、一条语句可以定义多个符号常量。
例如：parameter (PI=3.14159,r=25,I=9)
5、优点：方便修改程序
3.13 END，STOP，PAUSE语句
3.13.1 END语句 *
结束标志；有且仅有一条
3.13.2 STOP语句
停止运行程序；用于调试程序
3.13.3 PAUSE语句
暂停执行；用于调试程序
3.14 程序举例
顺序结构
【例3.3】求三角形面积
公式：S=√S(S-A)(S-B)(S-C),S=（A+B+C）/2
源程序：read(*,*) A,B,C
S=(A+B+C)/2
area=SQRT(S*(S-A)*(S-B)*(S-C))
write(*,*)’A=‘,A,’B=‘,B,’C=‘,C
write(*,*)’the area is‘,area
end
3.14 程序举例
【例3.4】求五边形面积
3.14 程序举例
【例3.4】求五边形面积
源程序： write(*,*)’Input A,B,C,D,E,F,G’
read(*,*) A,B,C,D,E,F,G
S=(A+B+C)/2
S1=SQRT(S*(S-A)*(S-B)*(S-C))
S=(C+D+E)/2
S2=SQRT(S*(S-C)*(S-D)*(S-E))
S=(D+E+F)/2
S3=SQRT(S*(S-D)*(S-E)*(S-F))
AREA=S1+S2+S3
write(*,*)’area=‘,area
end
3.14 程序举例
【例3.5】编程将十进制数407转换成八进制数
源程序：m=407
i1=mod(m,8)
i2=mod(m/8,8)
i3=mod(m/8/8,8)
write(*,*)i3,i2,i1 ; 按高位到低位顺序
end
第三章总结
顺序结构程序主要用于进行确定的显式计算
一般结构：由5部分组成
说明部分（说明语句，非执行语句）
赋初值部分（赋值语句，read语句）
计算部分（数学公式¦算术表达式）
输出部分（write，print部分）
结束部分（END语句）
第四章
逻辑运算和选择结构
4.1 引言
分支结构--控制转向语句
分类：GOTO类：无条件GOTO语句
计算GOTO语句
IF类（条件类）：逻辑IF语句 ü
块IF语句 ü
例
4.2 关系表达式
条件：关系表达式
逻辑表达式
4.2 关系表达式
是构成选择结构判断条件的基本式子
算术表达式---由算术运算符将常量，变量，函数等基本成分连接在一起的式子
关系表达式---由关系运算符将算术表达式连接起来的式子
一、关系运算符
.gt. （大于） .ge. （大于等于）
.eq. （等于） .lt. （小于）
.le. （小于等于） .ne. （不等于）
4.2 关系表达式
二、关系表达式的一般形式
〈算术量〉〈关系运算符〉〈算术量〉
例：x+y>15.4 ─→ x+y.gt.15.4
注：
1、运算元素：算术量
2、运算结果:逻辑值:真（True),假（False）
3、运算顺序：算术运算¦关系运算
如：a+b.ne.a-b等同于(a+b).ne.(a-b)
4.2 关系表达式
例：b2-4ac ≥ 0 ?
关系表达式：b**2-4*a*c .ge. 0.0
若A=2，B=4，C=5，则结果为：
缺点：关系表达式只能表达简单的关系，如： 5≤x≤10
就不能用关系表达式表达，此时要用逻辑表达式。
4.3 逻辑表达式
一、逻辑运算符
.and. （逻辑与）
.or. （逻辑或）
.not. （逻辑非）
.eqv. （逻辑等）
.neqv.（逻辑不等）
二、逻辑表达式的一般形式
〈逻辑量〉〈逻辑运算符〉〈逻辑量〉
4.3 逻辑表达式
⑴逻辑表达式是由逻辑运算符将两个逻辑量连接起来的式子。
⑵运算元素：逻辑量
结果：逻辑量:真(.True.)或假(.False.)
逻辑量包括:
逻辑常量
逻辑变量
关系表达式
4.3 逻辑表达式
三、逻辑常量
两个：①.true.(真) ②.false.(假)(书写)
四、逻辑变量
—用于存放逻辑常量的变量。
逻辑变量可以通过赋值语句来接受逻辑
常量的值，但在使用前，要进行类型说明。
例： logical a, b
a=.true.
b=.false.
4.3 逻辑表达式
五、逻辑运算符的运算规则
若a,b为两个逻辑量，则：
a.and.b—(当a、b同时为真时，为真)
a.or.b—(当a、b中任意一个为真或同时为真时,
为真)
.not.a—(当a为真，其值为假；当a为假，其值真)
a.eqv.b—(当a、b为同一逻辑常量时，为真)
a.neqv.b—(当a、b不为同一逻辑常量时，为真)
4.3 逻辑表达式
六、逻辑表达式的运算次序
运算次序为：
算术运算→关系运算→逻辑运算
逻辑运算：
.not.→.and.→.or.→.eqv.→.neqv.
4.3 逻辑表达式
例1：写出下列条件的逻辑表达式。
⑴5≤k≤10
⑵│f│≤3g或│f│＝5t
⑶1≤a≤8和1≤b≤8
4.3 逻辑表达式
例2：若a=2.5,b=7.5,c=5.0,d=6.0,求下列逻辑表达式的值。
⑴(a.lt.b).and.(b.lt.c)
⑵c/2.0+d.lt.a.and..not..true..or.c.le.d
4.4 用块 if 实现选择结构
有以下三种典型的块if选择结构：
⑴基本形式：
if (条件) then （块If语句）
块1 (then块)
else （else语句）
块2 (else块)
endif （endif语句）
4.4 用块 if 实现选择结构
说明：
1、IF…THEN语句—块IF结构的入口语句
2、ENDIF语句---出口语句
3、必须一一对应，配对使用
4、THEN块、ELSE块是一条或多条可执行语句
5、执行过程：
条件为真（T）¦ THEN块 ¦ ENDIF语句后的语句
条件为真（F）¦ ELSE块 ¦ ENDIF语句后的语句
程序举例
【例4.1】学生考试成绩，高于60分为“及格”，否则为“不及格”
源程序：c print score grade
read(*,*) score
if (score.ge.60.0) then
print *,’及格’
else
print *,’不及格’
end if
end
4.4 用块 if 实现选择结构
（2）简单结构：
if (条件) then (块if语句)
块 (then块)
endif (endif语句)
注：不包含ELSE块，可实现单边选择的功能
4.4 用块 if 实现选择结构
（3）嵌套结构：
4.4 用块 if 实现选择结构
if (条件1) then
块1
else if (条件2) then
块2 (else if块)
┆
else if (条件n) then
块n
[else
块(n+1)]
endif
程序举例
【例4.2】学生考试成绩,低于60分为“不及格”,60-69为“D”,70-79为“C”,80-89为“B”,90-100为“A”
程序举例
源程序： read(*,*) g
if(g.lt.60.0) then
print *,’不及格‘
else if(g.lt.70) then
print *,’D’
else if(g.lt.80) then
print *,’C’
else if(g.lt.90) then
print *,’B’
else
print *,’A’
endif
end
4.4 用块 if 实现选择结构
说明：
⑴每个块if中可以完整地包含一个（或多个）块if结构，即构成块if 的嵌套结构。如：
if (条件1) then if (条件1) then
块1 if (条件2) then
else 块2
if (条件2) then endif
块2 else
endif 块1
endif endif
4.4 用块 if 实现选择结构
⑵一个块if 语句必须和一个endif语句相对应。
⑶块if 中的“then块”、“else块”和“else if块”可为空块。
程序举例
程序举例
编程如下：
read*,x else if (x.lt.50.0) then
if (x.lt.-10.0) then y=50.0-x
y=0.0 else
else if (x.lt.0.0) then y=0.0
y=2.0*x+20.0 endif
else if (x.lt.20.0) then print*,’y=‘,y
y=20.0 end
else if (x.lt.40.0) then
y=30.0-0.5*x
程序举例
【例4.4】求一元二次方程ax2+bx+c=0的根
（在a≠0的情况下，当b2-4ac≥0时有两个实根，
b2-4ac＜0时有两个复根。）
【例4.5】将三个数a,b,c从小到大排序并输出
思路：两两比较，交换位置
程序举例
4.5 逻辑IF语句
逻辑IF语句也是一种选择结构，但与块if 不同，主要表现在：
①只用一行表示一个选择结构；
②仅当条件成立时执行，并且只执行一条语句。
相对而言，称为行IF语句
流程图：
4.5 逻辑IF语句
逻辑if语句的一般形式：
If〈条件〉语句
实现单边选择
例：if (n.le.100) n=n+1
块IF语句中，当else块是空块，then块只有一条语句时，用逻辑IF语句更方便
4.5 逻辑IF语句
【例4.1】学生考试成绩，高于60分为“及格”，否则
为“不及格”
逻辑IF源程序：
read(*,*) score
if (score.ge.60.0) then if (score.ge.60.0) print *,’及格’
print *,’及格’ if (score.lt.60.0) print *,’不及格’
else
print *,’不及格’
end if
end
4.5 逻辑IF语句
【例4.6】计算分段函数：
y=
①y=3.0*x+6
if(x.lt.0.0)y=-x**2+2.0*x-8.0
②if(x.ge.0.0)y=3.0*x+6
y=-x**2+2.0*x-8.0
③if(x.ge.0.0)y=3.0*x+6
if(x.lt.0.0)y=-x**2+2.0*x-8.0
4.5 逻辑IF语句
【例4.7】输入三个数x,y,z，选出最大数输出源程序： read *,x,y,z
big=x
if(y.gt.big) big=y
if(z.gt.big) big=z
print *,’the bigest is’,big
end
第五章 循环结构的实现
第五章 循环结构的实现
所谓循环，是指在程序执行过程中需要重复执行的程序段。
在实际问题中，我们经常遇到循环，如：求 ∑n，n!，…
循环结构包括：
(1)循环体：由一些可执行语句组成
(2)循环控制语句：控制循环的开始和结束
第五章 循环结构的实现
根据循环控制语句，将循环结构分类：
两类：
条件型循环
计数型循环--- DO循环
5.1 用goto语句实现循环
goto语句的一般形式：
goto 其中：s1——语句标号。
功能：程序执行到此语句时，无条件的转向标号为s1的语句去执行。
例：求1～10的累加和。
编写程序段： integer x,sum
x=0.0
sum=0.0
10 x=x+1
sum=sum+x
goto 10
5.1 用goto语句实现循环
如果我们把以上goto语句作为逻辑if语句中的执行语句，则就可以实现有条件的循环。即：
integer x,sum
x=0.0
sum=0.0
10 x=x+1
sum=sum+x
if(x.lt.10)goto 10
print*,sum
end
5.2 用do语句实现循环
当循环的初值、终值和循环次数都已知时，可用do语句实现循环。
用do语句实现的循环称为“do循环”。do循环是由一个do语句和循环体组成。
一、一般形式
do s[,] v=e1, e2 [,e3]
┆
s <终端语句>
5.2 用do语句实现循环
例： do 10 I=1,19,2
L=I*I
write (*,*) ‘L=‘,L
10 continue
write (*,*)’L=‘,L,’I=‘,I
end
Do语句：do 10 I=1,19,2
5.2 用do语句实现循环
注意：
1、标号为本程序单位中另一可执行语句的标号
2、步长可以省略，缺省值=1
例：do 10 n=1,15,1 → do 10 n=1,15
3、循环初值（e1)，终值(e2)和步长(e3)都可以是常量，变量，表达式。
例： do 30 k=3,16,A+1
do 100 n=k1,k2,k3
4、由于实数在内存中存储的误差，v, e1, e2, e3尽可能用整型量。
5.2 用do语句实现循环
5、e1,e2,e3可正可负，e1,e2可为0，但e3不能为0
执行过程（分四种情形）
⑴当e2>e1且e3>0 ：
⑵当e2>e1且e3<0 ：
5.2 用do语句实现循环
⑶当e20 ：
⑷当e2
5.2 用do语句实现循环
二、具体执行过程
例：do 60 L=m,2*m-1,m/5 （m=10)
k=L+L
write(*,*) k
60 continue
执行步骤：
①执行do语句，计算e1,e2,e3的值。
do 60 L=10,19,2
②将e1赋给循环变量L，即执行赋值语句：L=10
③计算循环次数:r=INT((e2-e1+e3)/e3)
④检查循环次数：r=0?
5.2 用do语句实现循环
r≠0—执行循环体，r=0---跳出循环体
⑤执行循环终端语句：v=v+e3
⑥r=r-1
⑦返回④继续执行
流程图：P102
程序举例
例1：从键盘输入30个学生的单科成绩，并将其中及格以上的学生序号和成绩打印出来。
编程如下：
do 10 i=1, 30
read*, x
10 if (x.ge.60) print*, i, x
end
程序举例
例2：求 ∑n！
n=1
累乘，累加混合
源程序： read *,n
sum=0.0
fact=1.0
do 100 I=1,n
fact=fact*I
sum=sum+fact
100 continue
print *,sum
end
5.2 用do语句实现循环
三、继续语句（continue语句）
我们知道，循环终端语句必须是可执行语句。那么，这种作为循环终端语句的语句具有双重作用：一是作为循环终端的标志，二是要完成自身的功能。因此影响了程序的可读性。
Fortran用一个专门的语句作为do循环的终端语句，即continue语句。
一般形式：
s1 continue
5.2 用do语句实现循环
四、一些规定：
1、循环变量在循环体内只能被引用，不能被赋值
例：do 10 I=2,30,2
I=I**2
print *, I
2、在执行DO循环体期间，e1,e2,e3的值不能改变
因为，它们决定了循环次数
即：不能对它们使用赋值语句，READ语句等
例： do 10 I=K1,K2,M
5.2 用do语句实现循环
3、离开DO循环时，循环变量仍有意义，可以在循环体外被引用，此时它的值为脱离循环时最后一次被赋的值。
例： do 11 k=1,3
j=k
write(*,*) ‘j=‘,j
11 continue
print *,’j=‘,j,’k=‘,k
end
例：do 10 j=2,10,2
do 20 m=5,-1,-2
5.2 用do语句实现循环
4、程序中用到转移语句，规定：
允许：从循环 体内 →体外
不允许：从体外 ¦ 体内
例： do 100 i=1,100
t=float(i)**3
if(t.ge.1.0e6) goto 50
write(*,*) i,t
10 continue
50 stop
end
5.2 用do语句实现循环
例： …
if ( n.le.0.0) goto 100
do 200 I=1,5
n=n*I
Print *,n
200 continue
…
5、循环终端语句必须是可执行语句（但除goto, 块if, endif, end和stop语句外 ）
程序举例
例3：从1~1000的自然数中，分别求出奇数的平方根和偶数的立方根
源程序：do 10 i=1,1000,2
odd=sqrt(i)
even=(i+1)**(1.0/3.0)
print *,odd,even
10 continue
end
运行结果
程序举例
例4：从键盘上读入N组数据，每次读三个实数X，Y，Z，计算N组数之和（X+Y+Z）及其平均值，并输出
源程序： read *,N
do 20 k=1,N
read *,x,y,z
sum=x+y+z
aver=sum/3.0
print *,x,y,z
print *,’sum=‘,sum,’aver=‘,aver
20 continue
end
5.2 用do语句实现循环
五、do循环的嵌套
在一个do循环中还可以包含一套或多套完整的
do循环，这就是do循环的嵌套。
一般形式:（以双重循环为例）
do 10 i=1, 10
┆
do 20 j=1, 10
┆
20 continue
┆
10 Continue
五、do循环的嵌套
例5：一个学校30个班，每班N个学生，每个学生三门考试成绩，求每个学生总分及平均分
源程序：do 10 L=1,30
read *,N
do 20 k=1,N
read *,x,y,z
sum=x+y+z
aver=sum/3.0
print *,x,y,z
print *,’sum=‘,sum,’aver=‘,aver
20 continue
10 continue
end
五、do循环的嵌套
例6：打印“九九表”。
编程如下：do 10 i=1,9
do 20 j=1,9
k=i*j
print*, i,’*’,j, ‘=‘,k
20 continue
print *,’ ’
10 continue
end
执行过程
五、do循环的嵌套
注意：
1、嵌套要完整，不能交叉
2、循环变量的名字，规定：
并列的循环：循环变量可以同名
嵌套的循环：循环变量不能同名
3、若多层循环的结束语句在同一个地方，可以共用一条continue语句
4、控制转向语句的使用（体内→体外）
五、do循环的嵌套
例7：有等式：ABCD
-） CDC
ABC
其中A，B，C，D均为0~9中任一数字，ABCD为一个四位非负整数，CDC和ABC为三位非负整数。
试遍写一程序，找出A，B，C，D的值。
integer a,b,c,d,x,y,z
do 10 a=1,9
do 10 b=0,9
do 10 c=1,9
do 10 d=0,9
x=1000*a+100*b+10*c+d
y=100*c+10*d+c
z=100*a+10*b+c
if(x-y.eq.z) then
write(*,*) a,b,c,d
write(*,*)x,y,z
endif
10 Continue
end
5.3 当型循环的实现
在无法确定循环次数的情况下
当型循环，是指执行循环体要依据事先给定的条件。当条件成立时执行循环，否则就不执行循环。
流程图：
5.3 当型循环的实现
一、用do while语句实现当型循环
一般形式 do s1[,] while (条件)
┆
s1 <终端语句>
结构类似do循环的结构
执行情况：
条件：真—执行循环体
假---退出循环体
5.3 当型循环的实现
例：求n!
编程如下：
read *,n
m=1
i=1
do 10 while (i.le.n)
m=m*i
i=i+1
10 continue
print *,m
end
5.3 当型循环的实现
二、用块if和goto语句实现循环
一般形式：
s1 if (条件) then
块
goto s1
endif
5.3 当型循环的实现
例：求n!
编程如下： read*,n
m=1
i=1
10 if (i.le.n) then
m=m*i
i=i+1
goto 10
endif
print*,m
end
5.4 直到型循环的实现
所谓直到型循环，是指先执行循环体，再判断条件。如果条件为“假”，继续执行循环，直到条件为“真”时终止循环。
一、用逻辑if语句实现直到型循环
一般形式
s1 循环体
if (条件) goto s1
5.4 直到型循环的实现
例1：求n!
编程如下： read*,n
m=1
i=1
10 continue
m=m*i
i=i+1
if (i.le.n) goto 10
print*,m
end
5.4 直到型循环的实现
例2：求 的值。
5.5几种循环形式的关系和比较
一、DO循环适用于已知循环次数的情况
二、几种循环可以互换
DO循环---条件型循环（可用次数作条件）
当型循环—直到型循环
当型—块IF语句(单边)+GOTO语句(先判断后执行)
直到型---逻辑IF语句+GOTO语句(先执行后判断)
三、各种循环可以相互嵌套。
课后练习题
P126 ：第一~三题
（要求：一、用当型循环完成
二、三题、DO，DO..WHILE，当型，直到型
经过上机调试，将.for的源程序作为附件发送）
第六章 FORTRAN的数据结构
6.1程序中的数据结构
1.程序代数表达式:
算法+数据结构=程序
2.对于同一个问题的求解，即一个程序的实现，可以采用不同的数据结构和不同的算法。选择合适的数据结构可以降低算法的复杂度。
6.1程序中的数据结构
在计算机高级语言中用数据类型来表示不同的数据结构。
数据结构一般有以下三类：
基本类型（Fortran支持）
构造类型（Fortran支持）
指针类型
6.1程序中的数据结构
Fortran支持如下几种基本类型：
整型（第三章）
实型（第三章）
双精度型
复型
字符型
逻辑型（第四章）
6.1程序中的数据结构
Fortran支持如下几种构造类型：
数组（第九章）
记录（第十三章）
文件（第十三章）
6.2双精度数据类型
由于实型数据提供的有效数字的位数有限（微型计算机一般提供7位），一方面满足不了精度的需要，另一方面还会产生误差。
双精度类型以两倍于实型的字节（一般为8个字节）来存储数据，提供15~17位有效数字，解决了上述的问题。
6.2双精度数据类型
Fortran中双精度常数要用指数表示：
如：12.3456789→ 1.2345656789D+1
-0.123456789→ -1.23456789D-1
Fortran中双精度变量使用前要用类型说明语句或IMPLICIT语句加以说明：
如：double precision A,B,C
implicit double precision(a-c)
程序举例
例6.1：求一个分数序列前20项的和（P130）
Double precision a,b,c,s
s=0.0D0
a=1.0D0
b=1.0D0 b=c
c=a+b c=a+b
do 10,i=1,20 10 continue
s=s+c/b print*,’s=’,s
a=b end
6.3复型类型数据
Fortran中复型常数要用一个括弧中的两个实数来表示，第一个实数表示复数中的实部，第二个实数表示复数中的虚部。
如：1+2.5i →（1。0，2。5）
-5.4i →（0。0，5。4）
Fortran中复型变量使用前要用类型说明语句或IMPLICIT语句加以说明：
如：complex A,B,C
implicit complex(a-c)
6.3复型类型数据
直接赋值
如： c=(3.0,4.0)
d=(8.76E+5,-6.8E-3)
当实部和虚部不是常数，而是表达式时，则应该用CMPLX函数将实部和虚部组成复型数据再赋给复型变量
如： C=cmplx( 3.0*A,6.0+B )
6.3复型类型数据
如果CMPLX函数只有一个自变量，则它代表实部
如：cmplx(3.0) →(3.0,0.0)
在内存中一个复型数据占两个实数的存储单元，在PC中通常为8个字节
程序举例
例6.2：求一元二次方程Ax2+Bx+C=0的根
6.4四种数值型数据之间的转换和运算
不同类型数据之间的运算的规则
（P134-135表6.1和表6.2）
不同类型数据的赋值规则（P135表6.3）
类型转换函数（P136表6.4）
不同类型数据间的比较规则（P136表6.5）
6.5字符型数据
Fortran77不仅可以支持数值计算，而且也支持非数值处理，如文字处理。
一、字符型常量：又称字符串，是用撇号
括起来的若干个字符
如：’CHINA’，’U.S.A’
6.5字符型数据
Fortran77规定在程序语句中可以使用的字符如下：
（1）英文字母26个（不分大小写）
（2）数字0-9，共10个字符
（3）专用字符，共13个：
︺ ’ $ ( ) + - * / , = . :
6.5字符型数据
注意：
1.空格也是有效字符
2.Fortran77规定字符和系统字符之间的区别
3.Fortran77字符型常量允许使用系统可以使
用的字符集即系统字符
如：‘How are you?’
‘abc@sina.com.cn’
都是合法字符串
4.当字符串本身有撇号时，用两个撇号表示
如：’That’’s right’
6.5字符型数据
二、字符型变量:用来存放字符型常量的变量
字符型变量在使用前必须先定义。可以用IMPLICIT语句和CHARACTER语句
如：
Implicit character*5(A-C),character*4(x)
character*5 str1,str2,str3
character name*20,addr*30,code*10
6.5字符型数据
如果在CHARACTER语句中不指定长度则隐含指定长度为1
如：character A,B,C
定义了长度为1的A，B，C字符型变量
如果统一指定的字符长度与变量个别指定的长度不一致，则以个别指定的长度为准
如：character*5 A,B*6,C*7
则定义A为长度为5的字符型变量，B的长度为6，c的长度为7
6.5字符型数据
三、字符变量的赋值
用赋值语句直接对字符型变量赋值
如： character*5 A,B*6,C*7
A=’CHINA’
B=’NANJING’
C=’NJUT’
A B C
6.5字符型数据
通过READ语句从键盘或其它输入设备读入字符常量给字符变量。用表控语句进行输入字符串时要用撇号将字符串括起来，如可以用READ语句代替上面的三个赋值语句
READ*，A，B，C
输入：
’CHINA’，’NANJING’，’NJUT’
6.5字符型数据
四、子字符串：一个字符串连续的一部分
如：一个字符串nanjing
则na，nan，nanj，nanji，…都是其子串
子串表示形式
字符变量名（e1,e2）
e1和e2是整型表达式，分别表示子字符串在原字符串中的起止位置,且1≤e1≤e2≤L，L是字符变量的长度。
6.5字符型数据
如：str=’structured programming in fortran’
子字符串 子串的值 备注
str(12:22) programming
str(27:) fortran 与str(27:33)相同
str(:10) structured 与str(1:10)相同
str(5:5) c
str(:) 原字符串 与str(1:33)相同
6.5字符型数据
可以将一个子字符串赋给一个字符变量或另一个子字符串
如：name=str(27:33)
str(1:10)= str(27:33)
赋值号两侧的子串不能相互覆盖
如：str(25:29)= str(27:33) 是不行的
6.5字符型数据
五、字符表达式
Fortran77只提供一种字符运算符“//”，即为字符连接符，其功能是把前后两个字符型数据连接起来
如：’a’//’b’ → ’ab’
6.5字符型数据
六、字符关系表达式
格式：
<字符(串)> <关系运算符> <字符(串)>
如：’A’.GT.’B’
’NANJING’.EQ.’NANJING’
比较规则
按其字符ASCII码的值进行比较（P140）
6.5字符型数据
两个单个字符比较，以其代码比较，代码大者为大
如：’A’<’B’
两个字符常量（字符串）比较，将两个字符串中的字符自左向右进行比较，如有差别，则代码大者为大，否则两者相等。
如：’SHANGHAI’<’SHANGKONG’
如果两个字符串长度不等，则系统会自动将短的字符补以空格，使两者等长再比较。
如：’the’<’then’ → ’the ︺’<’then’
6.5字符型数据
七、用于字符处理的内部函数
1.LEN(A)
2.LGT(a,b)
3.LGE(a,b)
4.LLT(a,b)
5.LLE(a,b)
6.INDEX(a,b)
7.CHAR(I)
8.ICHAR(a)
程序举例
例6.7翻译密码（P142）
character*80 line1,line2
character L1,L2
print*,'enter the original code:'
read*,line1
do 10,k=1,80
L1=line1(k:k)
if((lge(L1,'a').and.lle(L1,'z')).OR.
$ (lge(L1,'A').and.lle(L1,'Z')))then
i=ichar(L1)
j=i+5
if((j.gt.122).or.((j.gt.90).and.(j.lt.96)))j=j-26
L2=char(j)
line2(k:k)=L2
第七章 数据的输入和输出
7.1 概 述
在程序设计中总是要有输入和输出。一般说来，在进行输入或输出时要确定三个基本要素：
①输入输出设备
②输入输出格式
③输入输出数据
注：系统隐含的输入输出设备为：键盘、显示器和打印机。
7.2 有格式的输出
一、有格式的输出语句
一般形式：
① write(*,s1) <输出表列>
s1 format(格式说明）
② print s1, <输出表列>
s1 format(格式说明）
其中：“格式说明”是由各种“格式编辑符”构成的。
7.2 有格式的输出
二、格式说明符
主要介绍：I、F、E、X、纵向走纸、’（撇号）、r（重复系数）、/（斜杠）
⒈ I编辑符
作用：用于整型数据的输出。
一般形式：
① Iw
② Iw.m
其中：I—整型输出;w—字段宽度；
m—输出数据的最少数字位数。
7.2 有格式的输出
例1： k=254
M=12
n=48
write(*, 100) k,m,n
100 Format (1x,i8,i6,i6.3)
End
输出结果：
︺︺︺︺︺254︺︺︺︺12︺︺︺048
7.2 有格式的输出
例2： i=300
j=1250
print 50,i,j
50 Format (1x,i6,i3)
End
输出结果：
︺︺︺300***
注：format语句可以出现在program和function语句之后、end语句之前的任何位置。
7.2 有格式的输出
⒉ F编辑符
作用：用于实数的小数形式输出。
一般形式：
Fw.d
其中：F—实数的小数形式输出;
w—字段宽度；
d—输出数据的小数位数
7.2 有格式的输出
例： x=12.5
y=12.3457
z=-12.8467
print 100,x,y,z
100 Format (1x,f8.2,f10.3,f10.1)
End
输出结果：
︺︺︺12.50︺︺︺︺12.346︺︺︺︺︺-12.8
7.2 有格式的输出
⒊ E编辑符
作用：用于实数的指数形式输出。
一般形式：
Ew.d
其中：E—实数的指数形式输出;
w—字段宽度；
d—数字部分的小数位数。
7.2 有格式的输出
例： a=246.0
b=0.0000025
write(*,100)a,b
100 Format (1x,e9.3,e9.3)
End
输出结果：
.246e+03 .250e-05
9列 9列
7.2 有格式的输出
⒋ X编辑符
作用：用于输出空格。
一般形式：
nX
其中：X—输出空格;
n—输出空格数。
7.2 有格式的输出
例： a=246.0
b=0.0000025
write(*,100)a,b
100 Format (1x,e9.3,3x,e9.3)
End
输出结果：
.246e+03︺︺︺ .250e-05
9列 9列
7.2 有格式的输出
⒌ H编辑符
作用：用于输出字符常量。
一般形式：
nH
其中：H—输出字符常量;
n—输出字符个数。
7.2 有格式的输出
例： x=12.5
y=12.3457
write(*,100) x,y
100 Format (1x,2hx=,f4.1,2x,2hy=,f6.3)
End
输出结果：
x=12.5︺︺y=12.346
7.2 有格式的输出
⒍ ’（撇号编辑符)
作用：用于输出字符常量，即把撇号内的字符串原样照打。
例： i=140
j=2000
write(*,100)i,j
100 format(1x,’i=’,i3,’︺︺j=’,i4)
end
输出结果：
i=140︺︺j=2000
7.2 有格式的输出
注：如果输出的字符中包含撇号，则用两个连续的撇号代表一个要输出的撇号。
例：
write(*,100)
100 format(1x,’He’’s a student.’)
end
输出结果：
He’s a student.
7.2 有格式的输出
⒎ 纵向走纸编辑符
Fortran规定：将输出记录中的第一个字符作为纵向走纸控制符，这个字符不再被打印出来，而从输出记录的第二个字符开始输出。
记录中第一个打印字符与纵向走纸的关系（见右表）：
7.2 有格式的输出
例1： integer x,y
x=3250
y=405
write(*,100)x,y
100 Format (i4,3x,i3)
End
输出结果：
250︺︺︺405 （即把3“吃”掉了）
所以，在format语句中一定要预设一个走纸控制符
7.2 有格式的输出
例2： integer x,y
x=3250
y=405
write(*,100)x,y
100 Format (i6,3x,i3)
End
输出结果：
7.2 有格式的输出
⒏ 重复系数r
在format语句中，如果出现几个（或几组）相同的格式编辑符，则可以利用重复系数而只写一个（或一组）编辑符。
r——可重复使用的次数。
例1：
format(1x,i10,i10,f8.3,f7.2,f7.2,f7.2)
↓
format(1x,2i10,f8.3,3f7.2)
7.2 有格式的输出
例2：
format(1x,i5，f8.2,f8.2, i5，f8.2,f8.2)
↓
format(1x,2(i5，f8.2,f8.2))
⒐ 斜杠编辑符“/”
作用：将输出转入下一行记录。
7.2 有格式的输出
例1： i=246
j=35
x=12.3
y=173.5
write(*,100)i,x,j,y
100 Format (1x,i5,f7.1/1x,i5,f7.1)
End
输出结果：
7.2 有格式的输出
例2： i=246
j=35
x=12.3
y=173.5
write(*,100)i,x,j,y
100 Format (1x,i5,f7.1//1x,i5,f7.1/)
End
输出结果：
7.3 有格式的输入
一、有格式的输入语句
一般形式：
read(*,s1) <输入表列>
s1 format(格式说明）
其中：“格式说明”是由各种“格式编辑符”构成。
7.3 有格式的输入
例1：
read(*,100)i,j
100 Format (i4,i5)
End
键盘输入：
︺345︺︺456↙
7.3 有格式的输入
例2：
read(*,100)a,b,c
100 Format(f5.1,e12.2,f7.2)
End
键盘输入：
︺15.7︺2345.67e+04︺705.83↙
7.4 在print,write和read语句中包含格式说明
在格式输入输出时,也可以将format语句中的格式说明放到print、write和read语句中。
例1： print 100,k,y
100 format(i8,f7.2)
↓
print ’(i8,f7.2)’,k,y
注意写法：‘（…）’
7.4 在print,write和read语句中包含格式说明
例2： write(*,100)k,y
100 format(i8,f7.2)
↓
write(*,’(i8,f7.2)’) k,y
例3： read(*,100)k,y
100 format(i8,f7.2)
↓
read(*,’(i8,f7.2)’)k,y
课后练习题
P169～170：第六～八题。
（要求编程。经上机调试后观察输出结果，然后将源程序作为附件发送）
第八章
常用算法的程序设计举例
8.1 数 值 积 分
主要介绍求一个函数f(x)在区间[a,b]上的定积分 的程序设计方法。
从几何意义上看，它代表一个曲边梯形面积（见下图）。
我们知道，整个曲边
梯形面积S可看作若干个
小曲边梯形面积si之和。
即：
8.1 数 值 积 分
常用求解小曲边梯形面积的方法有：
①矩形法
②梯形法
③抛物线法（辛普生法）
一、梯形求解法
即应用小梯形面积代替小曲边梯形面积的的设计方法。
8.1 数 值 积 分
显然，第一个小梯形面积为：
S1=(f(a)+f(a+h))h/2
第i个小梯形面积为：
Si=(f(a+(i-1)h)+f(a+ih))h/2
则：
8.1 数 值 积 分
二、算法设计
画N～S图
三、举例
求
编程如下：
8.1 数 值 积 分
read(*,*)a,b,n
h=(b-a)/real(n)
s=0.0
f1=sin(a)
do 10 i=1,n
f2=sin(a+i*h)
si=(f1+f2)*h/2.0
s=s+si
f1=f2
10 continue
print 100,a,b,n,s
100 format (1x,'a=',f3.1,3x,
$'b=',f3.1,3x,'n=',i4/1x,'s=',f7.3)
end
8.2 解一元方程
常用求解一元方程f(x)=0根的方法有：
①迭代法
②牛顿迭代法
③二分法
④弦截法
一、牛顿迭代法（求f(x)=0在x0附近的实根）
基本原理和步骤为：
8.2 解一元方程
⑴选一个近似根x1，有f(x1)，见图(P179)。
⑵过点f(x1)作切线，交于x2。
因：f’(x1)= f(x1)/x1-x2
故：x2=x1- f(x1)/ f’(x1)
⑶再由x2，有f(x2)。
⑷过点f(x2)作切线，交于x3，得：
x3=x2- f(x2)/ f’(x2)
┆
再点f(xn)作切线，交于xn+1，得：
xn+1=xn- f(xn)/ f’(xn)
若：│xn+1-xn │≤ε，
则： xn+1为所求。
8.2 解一元方程
二、举例
用牛顿迭代法求方程
x3-2x2+4x+1=0
在x=0附近的实根。
（设ε=10-6）
解例：
①画N～S图
②编程
8.2 解一元方程
read(*,*)x
n=1
10 x1=x
f=x1**3-2.0*x1**2+4.0*x1+1.0
f1=3.0*x1**2-4.0*x1+4.0
x=x1-f/f1
print 100,n,x1,x
100 format (1x,'n=',i3,3x,'x1=',f15.7,3x,'x=',f15.7)
n=n+1
if (abs(x-x1).gt.1e-06) goto 10
end
课后练习题
P192：第一、四题。
（要求编程。经上机调试后观察输出结果，然后将源程序作为附件发送。）
第九章 数 组
第九章 数 组
引例：求出全班30个学生的总分和平均分
循环结构： sum=0.0
do 10 I=1,30
read *,x
sum=sum+x
10 continue
aver=sum/30.0
print *,’总分=‘,sum,’平均分=‘,aver
end
第九章 数 组
注意：
1、执行时，输入数据的操作
2、X这个变量表示一个存储单元，每次累加后就被刷新了
又例：要求求出每人的成绩与全班平均成绩的差值
第九章 数 组
源程序：read *,x1,x2,…x30
ave=(x1+x2+…x30)/30.0
a1=x1-ave
a2=x2-ave
┆
write(*,*) a1,a2,…a30
end
第九章 数 组
在实际问题中，往往遇到要处理的数据是一组或一批同类型的量，而且它们是按一定次序进行排列的。如，
某班30名学生的单科成绩：
85,79,81,68,… （分）
某年（12个月）水文资料：
15.8,12.4,10.2,… （m3/s）
（它们都是一组同类性质的量）
所谓数组是指一组有序同类数据的集合。
第九章 数 组
对上述问题如不用数组，欲保留学生成绩则需要定义30个变量；保留水文资料则需要定义12个变量。
若有1个班和5年的水文资料，就需要定义大量变量来保存这些数据，显然这会使程序笨长，也不便于阅读。
使用数组可以解决这一问题。
第九章 数 组
如：对成绩，定义数组：x(30)
x(1),x(2),x(3),…,x(30)
用于存放30名学生的成绩。
对水文资料，定义数组：q(5,12)
q(1,1),x(1,2),x(1,3),…,x(1,12)
q(2,1),x(2,2),x(2,3),…,x(2,12)
┆
q(5,1),x(5,2),x(5,3),…,x(5,12)
用于存放5年的水文资料。
这里的x(i), q(i,j)称为数组元素(或下标变量)
第九章 数 组
引例采用数组实现：
源程序：dimension x(30)
sum=0.0
read *,x
do 10 I=1,30
sum=sum+x(I)
10 continue
ave=sum/30.0
第九章 数 组
概念：一组同类型的变量
一批连续的存储单元
表示：一个名字加不同的编号表示不同的单元
第九章 数 组
在Fortran中要使用数组同样必须遵循“先说明，后使用”的原则。
说明的目的是通知编译系统为数组分配相应的存贮单元。
用两种方法说明数组：
⑴用类型说明语句（“显式说明”）
⑵用dimension语句（“隐式说明”）
9.1 数组的说明和数组元素的引用
一、用类型语句说明数组
一般形式：
类型说明 数组说明符，…
其中,数组说明符的一般形式为：
数组名(维说明符, …)
其中,维说明符由“下标下界:下标上界”组成
9.1 数组的说明和数组元素的引用
例：real xn(1:10),w(1:2,1:3),kw(10:20)
Integer bc(1:100),py(0:2,0:3,0:5)
二、用dimension语句说明数组
一般形式：
dimension 数组说明符，…
9.1 数组的说明和数组元素的引用
例1：
dimension x1(1:10),nw(1:2,1:3)
例2：
dimension tk(1:100),imax(1:2,1:3)
integer tk
real imax
9.1 数组的说明和数组元素的引用
说明几点：
⑴在数组说明符中，维说明符（下标）的个数称为数组的维数。
⑵维说明符只能使用整型常量或整型符号常量表达式。
例： parameter (i=1,j=10)
real kx(i:j+5)
9.1 数组的说明和数组元素的引用
⑶维说明符的下标下界为1时，可以省略。
例：integer bc(1:100),w(1:2,1:10)
↓
integer bc(100),w(2,10)
⑷数组说明语句必须写在所有可执行语句之前。（属于非执行语句）
⑸数组的体积--每个下标值的乘积
9.1 数组的说明和数组元素的引用
三、数组元素的引用
一般形式：
数组名（下标，…）
即要有确定的数组名和下标值。
例：xn(5),w(1,3),kw(1,2,3)
引用数组元素时，下标可用算术表达式。
例：bc(i),py(i+j,k)
9.1 数组的说明和数组元素的引用
注意：数组元素与数组说明符
例： dimension x(5)
a=x(1)
sum=x(1)+x(2)+x(3)+x(4)+x(5)
┆
9.2 数组的逻辑结构和存储结构
数组的逻辑结构——数组所表示的实际数据结构。
数组的存储结构——数组在机内存储时的排列结构。
一、一维数组
此逻辑结构为一组依次排列的一串数据。
例：a(5)→ a(1),a(2),a(3),a(4),a(5)
此存储结构为一组连续存放的一列数据块。
例：a(5)→ a(1) a(2) a(3) a(4) a(5)
9.2 数组的逻辑结构和存储结构
二、二维数组
此逻辑结构为一张二维表数据。
例：a(3,4)可以看作一张3行4列的二维表数据。即：
9.2 数组的逻辑结构和存储结构
此存储结构为一组按列连续存放的数据块。
例：a(3,4)
a(1,1) a(2,1) a(3,1) a(1,2) a(2,2) a(3,2) a(1,3) a(2,3) a(3,3) a(1,4)
a(2,4) a(3,4)
三、三维数组
此逻辑结构为若干张二维表数据。
9.2 数组的逻辑结构和存储结构
例：a(2,2,3) ←2行2列的表，共3页。此逻辑结构为：
9.2 数组的逻辑结构和存储结构
此存储结构为一组按页连续存放的数据块。
例：a(2,2,3)
了解数组的逻辑结构和存储结构，对我们合理地选用数组和对数组进行输入输出有很大好处。
9.3 数组的输入和输出
有三种方式：
①用do循环
②用隐含do循环
③用数组名
一、用do循环进行数组的输入输出
例：试输入以下2名学生3门功课的成绩。
9.3 数组的输入和输出
编程如下： 键盘输入(按行输入)：
integer g(2,3) 86↙
do 10 i=1,2 75↙
do 20 j=1,3 72↙
read(*,*)g(i,j) 87↙
20 Continue 70↙
10 Continue 83↙
end 注：存储结构是按列存放的。
9.3 数组的输入和输出
由上可知，用do循环进行数组的输入输出既有优点也有缺陷。
优：数组元素的输入输出次序可由用户控制。
缺：作一次循环就换行输入或输出。
二、用隐含do循环进行数组的输入输出
用隐do循环进行数组的输入输出，使我们既能控制数组元素的输入输出次序，又能控制一行内输入输出数据的个数。
仍以2名学生3门功课的成绩为例，编程如下：
9.3 数组的输入和输出
integer g(2,3)
read(*,*) ((g(i,j),j=1,3),i=1,2)
write(*,*) ((g(i,j),j=1,3),i=1,2)
end
由于是一个read语句，所以既可以一行输入，也可以分多行输入。键盘输入如下：
86,75,72↙
87,70,83↙
9.3 数组的输入和输出
要记注：一个read语句可以分多行输入，而有多个read语句时，每一个read语句必须从新的一行读数。
将上例问题编成一个较完整的程序如下：
9.3 数组的输入和输出
parameter (m=30,n=5)
dimension kd(m,n)
character num(m)*5
read(*,*)(num(i),(kd(i,j),j=1,n),i=1,m)
print *,’序号 学号 语文 英语 数学 物理 化学'
print 100,(i,num(i),(kd(i,j),j=1,n),i=1,m)
100 format(1x,i3,3x,a5,2x,5i4)
end
9.3 数组的输入和输出
输出结果的形式为：
序号 学号 语文 英语 数学 物理 化学
1 00101 78 84 90 80 91
2 00102 — — — — —
┆
30 00130 — — — — —
9.3 数组的输入和输出
三、用数组名进行数组的输入输出
在用数组名进行数组的输入输出时，其顺序要与数组元素在机内的存储顺序一致。
例1：dimension k(5)
read *,k ←对数组的整体进行操作
等价于： ↓
read *,k(1),k(2),k(3),k(4),k(5)
也等价于： ↓
read *,(k(i),i=1,5)
9.3 数组的输入和输出
例2： integer g(2,3)
read *,((g(i,j),j=1,3),i=1,2)
print *,g
等价于： ↓
print *,g(1,1) g(2,1) g(1,2) g(2,2)
g(1,3) g(2,3)
也等价于： ↓
print *,((g(i,j),i=1,2),j=1,3)
9.3 数组的输入和输出
例3：interger A(3,4)
read *,A
print *,A
read *,((A(m,n),n=4),m=3)
do 10 i=1,3
do 10 j=1,4
print *,A(i,j)
10 continue
end
9.4 使用data语句给数组赋初值
在Fortran程序中，可用data语句给变量或数组赋初值。
一般形式：
data 变量表/初值表/,变量表/初值表,…
功能：在程序编译期间给变量或数组赋初值。
其中，变量表可以是变量名、数组名、数组元素、隐do循环；初值表只能是常量，不允许出现任何形式的表达式。
9.4 使用data语句给数组赋初值
例1：
data x,y,z/15.7,42.4,108.5/
例2：
data a,b/7.85,9.1/,i,j,k/5,10,15/
例3：
dimension k(2,3)
data((k(i,j),j=1,3),i=1,2)/90,23,20,42,14,32/
或：
data k/90,42,23,14,20,32/
9.4 使用data语句给数组赋初值
例4：
dimension a(10)
data a/10*-1.0/ (表示“10个-1.0”)
注：data语句属说明语句，但它可以放在end语句之前的任意行；当程序中有多个data语句给同一个变量赋初值时，以最后一条data语句为准；程序在编译期间给变量赋定初值，在程序执行期间，data语句不起任何作用。
9.5 数组应用举例
一、一维数组程序举例：(排序问题）
例1：设计一个程序，对N个整数按升序排列。(用交换法)
①算法：先将第一个元素与后面的N－1个元素比较，若符合递增顺序则不变，否则两者交换。交换后的第一个元素继续与后面未比较过的元素比较，这样在第一轮扫描结束后，第一个元素就是最小的元素。第二轮扫描再对第二个元素重复以上过程。(N个数需要N－1轮扫描）
9.5 数组应用举例
②画N～S图： ③编程： integer x(1000),temp
read *,n
read *,(x(i),i=1,n)
do 50 i=1,n-1
k=i+1
do 50 j=k,n
if(x(i).le.x(j)) then
goto 50
else
temp=x(i)
x(i)=x(j)
x(j)=temp
endif
50 continue
print *,(x(i),i=1,n)
end
二、二维数组的程序举例
1、输出格式问题（输出语句）
例2：打印乘法九九表（输出下三角阵）[杨辉三角]
integer M(9,9)
do 10 i=1,9
do 10 j=1,9
m(i,j)=i*j
10 continue
do 20 i=1,9
write(*,100) (i,'*',j,'=',m(i,j),j=1,i)
100 format(1x,9(1x,i1,a1,i1,a1,i2))
20 continue
end
二、二维数组的程序举例
2、表格数据处理问题（计算，输入，输出）
例3：10个学生，考3门课的成绩，要求求出每人的平均成绩，并输出一张成绩表
分析：二维数组G（10，3）存放学生成绩
一维数组AVG（10）存放平均成绩
程序包含：①构造二维数组（输入）
②计算平均成绩
③输出数组（一维，二维）
源程序： dimension g(10,3),avg(10)
read *,((g(I,j),j=1,3),I=1,10)
do 30 I=1,10
sum=0.0
do 20 j=1,3
sum=sum+g(I,j)
20 continue
avg(I)=sum/3.0
30 continue
write (*,100)
100 format(1x,’ I’,6x,’g1’,6x,’g2’,6x,’g3’,5x,’avg’)
write(*,200)(I,(g(I,j),j=1,3),avg(I),I=1,10)
200 format(1x,i3,4f8.1)
end
例4：设计一个程序，统计学生考试成绩各分数段人数。（见P207）
课后练习题
P225：第一、三题。
（要求编程，经上机调试后观察输出结果）
第十章 语句函数
第十章 语句函数
在第三章§3.7中我们介绍了FORTRAN的内部函数.FORTRAN编译程序把一些常用的运算(如求平方根,绝对值,三角函数……)编程为一个一个内部子程序，当我们程序中出现这些内部函数时，系统就会自动调用相应的子程序以完成所需的运算。但我们实际需要用到的函数是远远不止这些基本的内部函数，这个时候，我们就有必要自己定义一些我们需要的函数-语句函数或者子程序（第十一章）。
10.1 语句函数的定义
一、语句函数的定义形式
定义形式如下：
f(x1,x2,…xn)=e
f ：语句函数名
x1,x2,…xn：语句函数的虚拟参数
e：语句函数的表达式
例： g（x1,x2）=x1*x2+x1+x2+1.0
10.1 语句函数的定义
1.语句函数名f
f代表一个语句函数名，其函数值也具有类型，所以在使用之前，必须对函数名象变量的类型说明一样对其进行类型说明。
10.1 语句函数的定义
2.语句函数的虚拟参数x1,x2…xn
x1,x2…xn代表语句函数的自变量,称为虚拟参数。它们本身是没有值的,只有在函数被引用时用实在变量(实在参数)代替虚拟参数时,函数才能得到函数值；当然一个语句函数可以没有虚拟参数，但函数名后面的一对括号不能少；虚拟参数名可以和变量名相同,但它们之间除了名字相同外，没有任何其他联系
10.1 语句函数的定义
3.语句函数的表达式e
e是语句函数的表达式。e中除了包含有关虚拟参数外，还可以包含常量、变量、数组元素引用、外部和内部函数和已定义过的语句函数。
例如：
sum(a,b,c)=a+b+c
aver(a,b,c)=sum(a,b,c)/3.0
这里sum和aver都是语句函数名
10.1 语句函数的定义
二、定义语句函数的一些规则
1.语句函数名不能与本程序单位中的任何其他对象(变量，数组…)名字相同
2.当函数可以用一条语句定义时才可以使用
3.语句函数定义语句是非执行语句.它应放在所有可执行语句的前面和所有的说明语句之后
4.语句函数只在其所在的程序单位中才有意义
5.语句函数中的虚拟参数应是变量形式,不可以是常量、表达式和数组元素，并且所有的虚拟参数必须在函数表达式中出现
10.2 语句函数的引用
语句函数一旦被定义后，就可以在同一个程序单位中引用它。引用的形式和引用内部函数一样，即用实参代替虚参。实参可以是与虚参类型一致的常量、变量、或表达式，实参必须有确定的值。
例如：
f(k)=k+1
y=f(f(3)) //y值为4.0
课后练习题
P232：第一、二、三、四题。
（要求编程，经上机调试后观察输出结果）
第十一章 子程序
第十一章 子程序
在实际工作中，我们经常要编制一些求解特定问题的程序，如：排序、求积分、解线性方程组、插值等。如果每使用一次就编写一次，程序就会显得冗长、累赘。因此常把它们编制成独立的程序单位，需要时可随时调用。
即：将那些比较复杂，但又需要经常用到的操作编写成具有独立名字的子程序。由主程序随时调用。
子程序——完成某一特定功能的程序单位。
Fortran子程序包括：
ü函数子程序
ü子例行程序
数据块子程序（第十二章）
执行时：从主程序开始执行，遇到调用语句再执行相应的子程序。
不同类型的子程序，关键字不同，调用方法也不同。
11.1 函数子程序
从使用的角度讲，“函数子程序”就是一种可以作为函数来调用的子程序（也称“外部函数”）。
用法类似内部函数，如sin(x)。
一、函数子程序的定义
一般形式：
类型说明 function 函数名([虚参表])
┆ ⑴
end
function 函数名([虚参表])
类型说明 函数名 ⑵
┆
end
其内容由两部分组成：FUNCTION语句
子程序体
1、FUNCTION语句
是函数子程序的第一条语句，标志着该函数子程序的开始。
类型说明 function 函数名([虚参表])
注意：
⑴虚元也有类型，可在子程序体中说明
例： real function intep(x1,x2,x3)
integer x1,x2,x3
⑵函数名的命名规则和类型都与变量相同
⑶虚参可以是变量名、数组名和子程序名，但不允许用常量和数组元素。
例：function fat(n,x(i))
它表示了函数自变量的个数，顺序和类型
2、子程序体
用来完成具体任务的一个程序段，结构：
说明语句
可执行语句
END语句—独立的程序单位，单独编译
注意：
⑴若无虚参时，括号不能省。
例：function proc( )
⑵函数子程序中所有变量和标号（除函数名和虚参外），与其它程序单位无任何联系。
⑶函数体的说明部分包括对虚参和本函数体内所用变量和数组的说明。
例： function rdh(a,x)
integer a,b,c
dimension x(2,3)
┆
end
⑷函数体中可设置一条或多条return语句，表示执行到此语句时返回调用程序。当然也可以不设return语句。
例： function fat(n)
┆
[return]
┆
end
两种情况：
①当return语句和end语句紧挨着时，可省略return语句。
②需从中间返回时，return语句必不可少
⑸函数名的作用
函数名在函数体中，至少要有一次出现在赋值语句的左边，即：函数名=表达式。（因为函数名要负责把函数值带回调用程序。）
例：求一个一维数组A(n)的各数组元素之和。
Function sum(A,n)
Dimension A(50)
Sum=0.0
Do 10 i=1,n
sum=sum+A(i)
10 Continue
return
end
这里，sum是函数子程序的名字，它应作为一个变量名出现在程序体中，并且至少被赋值一次。
这样，它才有值，在被调用后将值带回到主程序中。
例2：编一个求n!的子程序
function fac(n)
p=1.0
do 15 i=1,n
p=p*i
15 continue
return
end
二、函数子程序的调用
调用方式与内部函数相似。
一般形式：
① 函数名（实参表）
② 函数名（）
类似：sin(x),上例可用：fac(9)
注：在子程序中，如果函数名的类型未使用隐含规则，在主程序中则先要对子程序函数名进行显式说明，以保证函数名类型一致。
例：求1!+3!+5!+…+9!（调用子程序）
C main program
sum=0.0
do 10 k=1,9,2
sum=sum+fac(k)
10 continue
print*,sum
end
函数子程序调用过程为：
c program main c subprogram
┆ functiom np(x,n)
km=np(a,m) ┆
┆ ┆
end end
执行过程：
⑴虚实结合（k→n)
⑵执行函数子程序体，其间得到函数fac(n)
⑶遇到返回语句，将函数值带回到主程序中fac(k)
说明几点：
①调用程序中函数名必须与函数子程序中定义的函数名相同。
②实参与虚参在个数、类型、位置上必须一一对应，但名字可以不同。
如：主程序 子程序
kh=erg(a,m,x) function erg(x,n,q)
③当虚参是变量名时，实参可以是常量、变量、数组元素或表达式；但当虚参要在函数体中被赋值时，则实参不能为常量或表达式。（因虚参和实参共用一个存储单元）
④函数子程序是一个独立的程序单位，可以作为一个单独的源文件进行存贮和编译，并与调用程序连编后才能起作用。（也可以与调用程序放在同一文件中。）
程序举例
例1：分别求半径r为1、3、5的圆周长（要求把计算圆周长的部分用函数子程序编写）。
c main program c subprogram
integer r function s(a)
do 10 r=1,5,2 integer a
c=s(r) pi=3.14159
print 100,r,c s=2*pi*a
10 continue return
100 format(1x,’r=’,i1,’ c=‘,f6.3) end
end
例2：求a,b,c三个数的平均值。
c main program c subprogram
read *,a,b,c function s(x,y,z)
aver=s(a,b,c) s=(x+y+z)/3.0
print *,’aver=’,aver return
end end
例3：计算n个数的平均值。
c main program c subprogram
dimension s(1000) function cpt(x,m)
read *,n dimension x(1000)
read *,(s(i),i=1,n) t=0.0
aver=cpt(s,n) do 10 i=1,m
print *,’aver=‘,aver t=t+x(i)
end 10 continue
cpt=t/m
return
end
11.2 子例行程序
子例行程序也是Fortran77的子程序，它与函数子程序的主要差别在于：
⑴名字的作用不同：函数子程序名除了供调用外，还代表函数值，而子例行程序名只供调用。
⑵要求返回值的方式不同：函数子程序是通过函数名将函数值带回调用程序，而子例行程序是通过“虚实结合”将其新值转送回调用程序。
⑶调用方式不同：函数子程序的调用总是出现在表达式中，而子例行程序必须用一条独立的语句调用。
11.2 子例行程序
一、子例行程序的定义
一般形式：
subroutine 子例行程序名(虚参表)
┆
end
说明几点：
⑴子例行程序名的命名规则与变量名相同。（但不标识类型）
⑵如果没有虚参，括号可以省略。
例：subroutine abc
⑶虚参可以是变量名、数组名和子程序名，但不允许用常量和数组元素。
⑷它的说明部分包括对虚参和本子例行程序所用变量和数组的说明。
11.2 子例行程序
⑸子例行程序的名字只起标识作用，没有值的概念，仅仅为了调用。因此，在子例行程序体中，它不允许出现。
二、子例行子程序的调用
一般形式：
call 子例行程序名（实参表）
call 子例行程序名
执行过程：类似函数子程序
程序举例
例1:编写子例行程序分别求出5×5矩阵两个对角线上元素之和
program main subroutine opp(a,s1,s2)
real w(5,5) real a(5,5)
read *,((w(i,j),j=1,5),i=1,5) s1=0.0
call opp(w,x1,x2) do 10 i=1,5
print 50,x1,x2 s1=s1+a(i,i)
50 format(1x,'x1=',f5.2, 10 continue
$2x,'x2=',f5.2) s2=0.0
end do 20 i=1,5
j=5-i+1
运行结果： s2=s2+a(i,j)
x1=15.00 x2=25.00 20 continue
end
程序举例
例2：编写子例行程序用于打印以下图案。
program main subroutine ast
call ast print 10
print *,’ hello!’ 10 format(1x,15(’*’))
call ast end
end
运行结果：
***************
hello!
***************
总结
函数子程序和子例行子程序的不同点：
1、定义语句不同
2、名字的作用不同
3、调用方法不同
4、用途不同：
函数子程序带回一个值。
子例行子程序可以带回一批值（数组），或者完成特定的操作。（如：交换，排序等）
11.3 实参和虚参之间的数据传递
在Fortran程序设计中子程序的虚参可以是变量名、数组名、函数名、子例行程序名和星号‘*’。
下面分别讨论当虚参为变量名、数组名、子程序名以及星号‘*’时的实参和虚参之间的数据传递问题，也称“虚实结合”问题。
一、变量名作虚参时的虚实结合
对应的实参可为同类型的常量、变量或数组元素。
⒈ 结合方式
是按地址结合的。即虚参和实参共用一个存储单元。
⒉ 结合过程
program main
integer a,b,c,d
data a,b/10,15/
call sub(a,b,c,d)
print *,a,b,c,d
end
subroutine sub(w,x,y,z)
integer w,x,y,z
y=w*x
z=x*y
w=x
x=y
end
注意：当实参是数组元素时，虚实结合的过程和变量名相同。
例：program main subroutine sub(x,a)
integer a,c(3) integer x,a
data c/3*0 a=2*x
a=100 x=2*a
call sub(a,c(2)) end
print *,’a=‘,a,’c(2)=‘,c(2)
end
二、数组名作虚参时的虚实结合
（仅说明数值型数组）
此时，对应的实参必须为同类型的数组名或数组元素。
⒈ 实参为数组名时的虚实结合
是按地址结合的。即实参数组的第一个元素与对应虚参数组的第一个元素结合；
实参数组的第二个元素与对应虚参数组的第二个元素结合，…，依此类推。
几种情况：
①同维同体积（不同体积）：
例： program main subroutine ctx(b)
dimension a(8) dimension b(5)
call ctx(a) ┆
┆ end
end
若数组a,b均为二维数组，如a(2,3)，b(2,3)则：
②不同维不同体积:
若主程序中a(2,3),子程序中b(5),则:
⒉ 实参为数组元素时的虚实结合
仍按地址结合，但该数组元素与对应虚参数组的第一个元素结合；该数组元素的下一个元素与对应虚参数组的第二个元素结合，…，依此类推。
注：虚参数组的最后一个元素必须落在实参数组范围内。
对上例而言，若定义y(6)，则会出现“超界错”。
例：分别计算二维数组a(15,15),b(15,15)的主对角线元素之积P，Q，再求P*Q。
三、虚参是可调数组
从数组的虚实结合规则可知，如果虚参数组的下标不可调，那么就会极大地影响子程序的通用性和灵活性。设计可调数组可以较好地解决这一问题。
可调数组：只能在子程序中使用，其上、下界可以是整型虚参变量，其值可以通过对应的实参传递过来。
如果只想求一部分元素之积，可以再多设一个虚参变量，增加灵活性。
注意：
1、可调数组只能出现在子程序中，不允许出现在主程序里。
2、可调数组的数组名和界都必须作为虚参出现在虚参表中。这样，通过虚实结合后，它们就会被赋值。
例：
program main subroutine sub(x,nx,y,n1,n2)
parameter(m1=4,m2=3) dimension x(nx),y(n1,n2)
dimension a(10),b(m1,m2) ┆
call sub(a,10,b,m1,m2) end
┆
end
例：编一个通用的子程序，求任意矩阵的各行元素绝对值之和。
Subroutine sumlin(a,sum,m,n)
dimension a(m,n),sum(m)
do 20 i=1,m
Sum(i)=0.0
do 20 j=1,n
sum(i)=sum(i)+a(i,j)
20 continue
end
SUBROUTINE SUB(A,N,X,F)
DIMENSION A(N)
Y=F(I)+1 //由于未出现对F的说明,因此编译程
序确定F为函数名
X=A(I)+1 //A(I)是数组的引用
┆
END
SUBROUTINE SUM(X,P)
┆
CALL P //由于P出现在CALL后，所以是
┆ 子例行程序名
END
1.在调用程序单位中，如果实在参数中出现函数子程序名或子例行程序名时，必须在调用程序单位的说明部分用EXTERNAL语句说明这些名字。
2.如果在实在参数表中出现内部函数名时，必须在调用程序的说明部分用INTRINSIC语句说明这些名字。
注意：凡在INTRINSIC语句中说明的名字必须是FORTRAN中合法的内部函数名，在EXTERNAL语句中说明的名字必须代表完整的程序中确实存在的子程序名。
程序举例
编写一个函数子程序，通过函数名的传送，使之既能求正切TAN值（X）又能求余切值CTN（X）
取函数名: TRIANGLE（ F1，F2，X ）
函数表达式: TRIANGLE=F1(X)/F2(X)
F1，F2是虚拟函数名，X是自变量（弧度）
当把SIN传给F1,把COS传给F2时,求正切
当把COS传给F1,把SIN传给F2时,求余切
c main program
intrinsic sin,cos
x=3.14159/5.0
y1=triangle(sin,cos,x)
y2=triangle(cos,sin,x)
write(*,100)’tan(’,x*180/314159,’)=’,y1
write(*,100)’ctn(’,x*180/314159,’)=’,y2
100 format(1x,a,f6.2,a,e13.6)
end
Function triangle(F1,F2,X)
triangle=F1(X)/F2(X)
END
五、虚参是星号‘*’
当虚参表中出现一个*号时，对应的实参应该是一个冠有*号的语句标号。例如：
程序举例
例1：编程实现一个一维数组的反转处理。
设一维数组的体积n≤600个元素。
分析：头尾倒转：n=600时，1-600，2-599
第i—n+1-i
Subroutine change(a,b)
t=a
a=b
b=t
end
Subroutine run(x,n)
Dimension x(600)
Read *,n
If(n.gt.600) then
Print *,’n is too large’
Return
Endif
Read *,(a(I),I=1,n)
Do 15 I=1,n/2
call change(x(I),x(n+1-I))
15 continue
end
例2：阅读下列程序，请写出该程序运行后的结果。（注意：不同程序单位中同名变量互不干扰）
subroutine exten(a,b,w,x)
a=a+1.0
b=b+2.0
y=1.0
w =x+y
write(*,200) y
200 format(1x,’y=‘,f8.4)
end
例3：编写一个函数子程序计算二维数组x(5,4)中任意行或任意列的元素之和。
然后调用它来计算a(5,4),b(5,4)数组任一行或任一列元素之和。
分析：①任一行或任一列用变量L表示
②设置一个逻辑变量LOC，来控制行或列：LOC=.true.----第L行
LOC=.false.---第L列
Function sum(x,L,LOC)
dimension x(5,4)
logical LOC
sum=0.0
if(LOC)then
do 20 i=1,4
sum=sum+x(L,i)
20 continue
else
do 30 i=1,5
sum=sum+x(i,L)
30 continue
endif
end
课后练习题
1、编写一个子程序将数组a(n,m)转置后送入数组b(m,n) ，再设计一个主程序调用它来求下列矩阵的转置矩阵。
4 5 3
10 4 6
9 8 7
6 1 9
2、编写一个子程序，调用它来计算矩阵
A（100，100）的左上角n阶方阵的对角线元素之和以及对角线元素之积。
设 n=5，10，15，20，…，90，95。
练习：阅读下列程序，写出程序执行的结果
c main program
real a(200),b(200)
x=1.0
do 10 i=1,100
a(i)=x
b(i)=x**2
x=x+1.0
10 continue
call sub(x,a(10),a(10),b(20),y)
write(*,100) y
100 format(1x,f10.2)
end
第十二章
数据共用存储单元
数据块子程序
12.1 等价语句 (EQUIVALENCE语句）
12.1 等价语句 (EQUIVALENCE语句）
例1：
EQUIVALENCE （W，ST）
例2：
EQUIVALENCE （W，ST）,(x,y,z)
例3：
EQUIVALENCE (R,K)
R=1.2
X=K
此时X=？
12.1 等价语句 (EQUIVALENCE语句）
二、等价语句的使用规则：
1.等价语句是说明语句，它必须出现在程序单位的执行语句之前。
2.等价语句每对括号中的变量可以具有不同类型（但建议大家不这样使用，因为其中的变量容易失去定义），但是FORTRAN77规定字符变量必须与字符变量等价。
12.1 等价语句 (EQUIVALENCE语句）
3.数组的等价。如：
dimension a(8),b(2,4),c(2,2,2)
equivalence (a,b,c)
相当于：
equivalence (a(1),b(1,1),c(1,1,1))
a,b,c三数组在内存中的存储分配如下：
12.1 等价语句 (EQUIVALENCE语句）
如果有以下语句：
dimension a(2,3),b(4)
equivalence (a(1,2),b(1))
a,b两数组在内存中的存储分配如下：
12.1 等价语句 (EQUIVALENCE语句）
4.不能利用等价关系建立矛盾的等价关系
如： dimension A(10)
equivalence （x,A(1)）,（x,A(3)）
此处A(1)和A(3)是同一个数组中的元素， A(1)和A(3)不可能分配同一个存储单元，所以X既要和A(1)分配的单元相同，又要和A(3)分配的单元相同，明显不可能。
12.2 公用语句
通过第十一章的学习，我们知道程序中不同程序单位之间的数据交换是通过虚实结合来完成的。另外FORTRAN还可以通过建立公用区的方法来实现各程序单位之间的数据交换。
公用区和虚实结合比较起来有其缺点——程序阅读性下降；有其优点——运行速度快（特别当有大量数据需要传送时）。
12.2.1 无名公用区
在不同的程序单位中，各自的变量是相互独立的，尽管它们的变量名有时相同。但如果我们在主程序和子程序中都加上一条COMMON语句的话，如：
COMMON X
此时编译程序在存储区中开辟了一个公用数据区。这时主程序和子程序中的两个变量X就共用一个存储单元，而不是相互独立了。
在FORTRAN中，用COMMON语句来开辟无名和有名公用区
12.2.1 无名公用区
一、开辟无名公用区的COMMON语句的一般格式：
COMMON a1，a2，…
其中a1、a2、…允许是普通变量名、数组名和数组说明符（不是数组元素）
例如：
在主程序中写：COMMON X，Y，K，Z（3）
在子程序中写：COMMON A，B，J，T（3）
此时，在无名公用区中变量X和A，Y和B，K和J分别被分配在同一个存储单元中；数组Z和T同占3个存储单元。
12.2.1 无名公用区
解释：FORTRAN编译程序在编译时为以上的COMMON语句开辟一个无名公用区，当把不同的程序单位连编在一起的时候，不同的程序单位在COMMON语句中的变量按其在语句中出现的先后顺序，依次连续的占用无名公用区的存储单元，也就是说每个程序单位中的COMMON语句总是把出现在语句中的第一个变量分配在无名公用区的第一个存储单元位置。
程序举例：解一元二次方程的根
[例12.1]完全通过虚实结合交换数据
主程序： READ*,A1,A2,A3
CALL QUAD(A1,A2,A3,Z1,Z2)
WRITE(*,*)Z1,Z2
END
子程序：SUBROUTINE QUAD(A,B,C,X1,X2)
P=-B/(2.0*A)
Q=SQRT(B*B- 4.0*A*C)/(2.0*A)
X1=P+Q
X2=P- Q
END
程序举例：解一元二次方程的根
[例12.2]通过虚实结合和公用区两种方式交换数据
主程序： COMMON Z1，Z2
READ*,A1,A2,A3
CALL QUAD(A1,A2,A3)
WRITE(*,*)Z1,Z2
END
子程序：SUBROUTINE QUAD(A,B,C)
COMMON X1，X2
P=-B/(2.0*A)
Q=SQRT(B*B- 4.0*A*C)/(2.0*A)
X1=P+Q
X2=P- Q
END
程序举例：解一元二次方程的根
[例12.3]完全通过公共区交换数据
主程序： COMMON Z1,Z2,A1,A2,A3
READ*,A1,A2,A3
CALL QUAD
WRITE(*,*)Z1,Z2
END
子程序：SUBROUTINE QUAD()
COMMON X1,X2,A,B,C
P=-B/(2.0*A)
Q=SQRT(B*B- 4.0*A*C)/(2.0*A)
X1=P+Q
X2=P- Q
END
12.2.1 无名公用区
二、无名公用区的COMMON语句使用规则
1.COMMON语句是说明语句，必须出现在所有可执行语句之前
2. COMMON语句中只允许出现变量名、数组名或数组说明符，后者意味着可用COMMON语句说明数组
例： COMMON A，B，NP(15)，LOC(2，4)
等价于：
DIMENSION NP(15)，LOC(2，4)
COMMON A，B，NP，LOC
12.2.1 无名公用区
3.用于COMMON语句中的变量在编译时已经被分配在实在的存储单元中，因此在COMMON语句中不能出现虚拟参数。同样，在编译时，可调数组的大小不定，无法分配固定的存储单元，因此可调数组名也不能出现在COMMON语句中。但是可调数组的维的上、下界变量可以通过COMMON语句传送
例：SUBROUTINE SUB(A,B)
COMMON NA, NB
DIMENSION A(NA),B(NB)
12.2.1 无名公用区
4.一个程序在运行过程中只有一个无名公用区。在同一个程序单位中可以出现几个COMMON语句，它们的作用相当于一个
例： COMMON A,B,C,D
COMMON A1,B1,C1,D1
相当于：
COMMON A,B,C,D ,A1,B1,C1,D1
12.2.1 无名公用区
5.各程序单位COMMON语句中的变量类型必须按位置一一对应一致才能正确传送数据
例：
主程序： COMMON A(5), I
子程序： COMMON B(4),J,P
主程序中A数组元素是实型，而数组元素A(5)和子程序中的变量J共用存储单元，还有主程序中的I和子程序中的P共用存储单元都是错误的
12.2.1 无名公用区
6.在一个程序单位中，分配在公用区中的名字只能在COMMON语句中出现一次
例： COMMON A，B，C
COMMON A1，B1，C
错误：因为C在COMMON语句中出现了两次
7.在不同的程序单位中，无名公用区中的变量个数可以不一样。但必须保证对应的变量类型要一致
12.2.1 无名公用区
8.如果公用区中出现字符型数据或字符数组，则要求整个公用区中的变量为字符类型，不允许字符变量与其他类型变量放在同一个公用区中
12.2.2 有名公用区
我们已经知道，无名公用区中各程序单位之间数据传送按公用区中变量名的排列顺序一一对应进行。但我们在实际使用中常常会遇到下面的问题。
例：我们的主程序要和两个子程序进行数据传送。
主程序： COMMON A, B，C，J，K，L
子程序1需要与主程序传送A,B,C三个数据；
子程序2需要与主程序传送J,K,L三个数据；
12.2.2 有名公用区
根据一一对应的原则
解决方法一：
主程序： COMMON A, B，C，J，K，L
子程序1：COMMON A1,B1,C1
子程序2：COMMON A2,B2,C2,J2,K2,L2
此时子程序2中的A2,B2,C2，从语法角度是必需的,但它们从使用角度却是冗余的。当一个主程序和若干个子程序间进行大量的数据传送时，书写COMMON语句就显得很烦琐，而且也容易出错
12.2.2 有名公用区
解决方法二：利用有名公用区
主程序： COMMON A, B，C /C2/ J,K,L
子程序1：COMMON A1,B1,C1
子程序2：COMMON /C2/ J2,K2,L2
此时A,B,C仍放在无名公用区中；而J,K,L放在名为C2的公用区中。
利用有名公用区就避免了无名公用区的弊病,使之做到公用之中有“专用”,我们只需在各个程序单位中做到同名共用区中数据顺序一一对应就行了
12.2.2 有名公用区
一、开辟有名公用区的COMMON语句的一般格式：
COMMON /n1/变量表1，/n2/变量表2，…
其中，n1,n2为公用区名，它们放在两个斜杠“/”之间，它们的取名方法与变量名同；变量表代表各有名公用区中的变量名、数组名或数组说明符。我们也可以用两个连续的斜杠来表示无名公用区，
例如： COMMON X，Y，Z/C2/A，B，C
可以写成：
COMMON // X，Y，Z/C2/A，B，C
或者：COMMON /C2/A，B，C // X，Y，Z
12.2.2 有名公用区
COMMON语句中的公用区的变量可以“化整为零”，只要它们在有名公用区中的顺序不变。
例如： COMMON X，Y，Z/C2/A，B，C
可以写成：
COMMON /C2/A //X，Y，Z/C2/B，C
也可以写成下面两句：
COMMON /C2/A
COMMON X，Y，Z/C2/B，C
12.2.2 有名公用区
建议：一个有名公用区用一条COMMON语
句来完成
例如：
COMMON X，Y，Z
COMMON /C1/A，B，C
COMMON /C2/J，K，L
COMMON /C3/R
12.2.2 有名公用区
二、有名公用区和无名公用区规则的区别
1.各程序单位的同名公用区的大小必须
相同，而无名公用区则无此要求
2.有名公用区的成员可以通过下节§12.3
所介绍的数据块子程序赋初值，而对
无名公用区的成员则无任何方法赋初值
3.在执行RETURN语句或END语句时，有时
会导致有名公用区中的成员变为无定义，
但无名公用区中的成员不存在这个问题
12.3 数据块子程序
功能：是一种特殊的子程序，它只是用来给
有名公用区中的变量赋初值。
数据块子程序格式和规则说明如下：
1.数据块子程序必须以BLOCK DATA作为第一个语句,以END作为最后一条语句。说明形式如下
BLOCK DATA 子程序名
┇
END
可以没有子程序名,这时的数据块子程序称为无名数据块子程序；一个程序中只能有一个无名数据块子程序,可以有任意多个有名数据块子程序。
12.3 数据块子程序
2.数据块子程序只是用来给有名公用区的变量赋值，不能被被别的程序单位调用。
3.在数据块子程序中不允许出现可执行语句，只允许出现COMMON、 DIMMENSION、 DATA、EQUIVALENCE和类型说明语句。其中DATA和COMMON语句是必不可少的。（数据块子程序由 DATA语句给指定变量赋初值，并由COMMON语句与其他相连接的程序单位沟通）
4.数据块子程序中的DATA语句只能给有名公用区中的变量赋初值，不允许给无名共用区中的变量赋初值
12.3 数据块子程序
5.指定的某个有名公用区中所有变量（即使其中有些变量不要求在DATA语句中赋初值），都必须一一按顺序列在COMMON语句中。
例如： BLOCK DATA INIT
DIMMENSION A(10),B(5)
COMMON /COM/A,X,Y,Z,B,I
INTEGER X,Y,Z
DATA X,Y,Z/3*0/,B/5*0.0/
END
这是一个完整的的数据块子程序。虽然DATA语句只需给COM共用区中X，Y，Z变量和B数组赋初值，但仍需列出COM中所有的变量
12.3 数据块子程序
6.一个FORTRAN程序可以包含任意多个数据块子程序，但每个有名公用区中的变量只能在一个数据块子程序中赋一次初值，不允许把一个有名公用区中的变量分在几个数据块子程序中赋值。
课后练习题
P301第一、二、三、四、五、六题
第十三章 文 件
13.1 概述
使用文件的目的：
FORTRAN程序结构：
输入数据（赋值，read）--从键盘输入
计算
输出结果（write,print）--输出到屏幕
end
例：求5个学生的平均成绩
read *,g1,g2,g3,g4,g5
avg=(g1+g2+g3+g4+g5)/5.0
print *,avg
end
输入：
①赋值语句：不易修改，需重新编译
②read语句：输入量很大时，麻烦，且易出错
输出：只能看到屏幕或打印纸上的结果（.exe）
要看结果，必须首先运行程序
解决办法：使用文件
输入：将要输入的数据存放在文件中—数据文件
用任何编辑工具均可建立，word、wps、
记事本等。在程序中用read语句读入，并
可以反复使用。
输出：将结果保存在文件中，方便
13.2 文件的基本概念
一、文件的定义：
FORTRAN中，文件指存储在外部介质上的数据集合。由文件名代表。
取名字：字符串，*.dat，与其它命名规则类似。
作为文件的标识，可在程序中反复引用
不取名字：临时性使用
不同于操作系统：FORTRAN中的文件仅指数据文件—原始数据、中间结果、最终结果等。（整型或实型等常数）
二、文件的组成
文件是由记录组成，FORTRAN中对文件的存取以记录为单位。而每个记录又是由字段（数据项）组成。
例：
三、文件的分类
按存取方式（读取记录的顺序）
⑴顺序存取文件——从第一个记录开始，一个接一个地依次存取记录。
⑵直接存取文件——可对任意指定的记录进行存取（也称随机文件）。
按存放形式
⑴有格式存放（也称字符形式存放）。
⑵无格式存放（也称二进制形式存放）。
13.3 数据文件的建立和使用
一、数据文件的建立
⒈利用编辑程序或Fortran开发环境编辑器建立。（存放原始数据）
⒉在程序执行期间建立。（存放中间结果和最终结果）
二、数据文件的使用
一般形式：
open(说明项)
┆
read /write(控制项),输入/出表列
┆
close(设备号)
例1：建立一个存放5个学生的平均成绩的有格式顺序数据文件。
open(5,file=‘score.dat’,status=‘old’)
read (5,*) x1,x2,x3,x4,x5
aver=(x1+x2+x3+x4+x5)/5.0
write(*,100) aver
100 format(1x,’aver=‘,f4.1)
close(5)
end
其中：
1、open语句：形式为：open(说明符）
作用为：打开一个已存在的文件（对文件操作的前提），实现一个设备号和一个文件的连接。若不存在，则新建一个指定文件名的文件
元素：open(5,file=‘score.dat’,status=‘old’)
OPEN语句所包含的说明项：
⑴设备号说明：[unit=]u （其值为1～99）
⑵文件名说明：file=fn （其值为数据文件名）
⑶状态说明：status=st (其值为old,new）
⑷存取方式说明：access=acc （其值为sequential,direct。缺省为seqential ）
⑸记录格式说明：form=fm （其值为formatted,unformatted。缺省时，顺序文件为有格式，直接文件为无格式）
⑹记录长度说明：recl=rl （其值＞0 ，仅用于直接文件）
对于有格式顺序存取文件，OPEN语句中的ACCESS=和FORM=两项可以省略
2、close语句：对应open语句
作用：用来解除文件和设备号的连接
形式：close（设备号）。如：close(5)
设备号---对应open语句中的设备号
3、read/write语句：格式同前述
通用：read(设备号，格式） 输入表
这里：read(5,*)x1,x2,x3,x4,x5
注意：
①如果用格式输入，则文件中数据的格式一定要严格按照格式的要求。
②表控格式时，与普通键盘输入有区别：
键盘输入时：数据可多可少
文件输入时：可多，不可少，将剩余的变量赋值0。
③同样要注意新记录的问题。
例：read (5,*) x1,x2,x3
read (5,*) x4,x5
4、该例中，文件的作用是用于将原始数据输入（read语句）；还可以保存中间数据与最终结果数据（write语句）。
5、使用时，数据文件与源程序文件最好位于同一个目录下。
例2：调用score.dat文件，将全班30个同学的三门课成绩求和，且保存在文件order.dat文件中。
源程序：dimension a(30,3),sum(30)
open(8,file=‘score30.dat’,status=‘old’)
read(8,*)((a(i,j),j=1,3),i=1,30)
do 10 i=1,30
sum(i)=0.0
do 10 j=1,3
sum(i)=sum(i)+a(i,j)
10 continue
open(9,file=‘order.dat’,status=‘new’)
write(9,100)(sum(i),i=1,30)
100 format(3f8.2/)
close(8)
close(9)
end
这里：
1、open(9,file=‘order.dat’,status=‘new’)
中文件用来保存运算结果。
2、write语句的格式与read语句类似。
write(9,100)(sum(i),i=1,30)
3、与普通格式说明语句不同的是：
Format语句中不需要 1x 纵向走纸控制符。
4、这里的status=‘new’。若当程序再次运行时，会出现错误。
解决方法：
A、在再次运行前，将生成的文件删除
B、用status=‘unknown’。此时，编译系统会自动检索目录，若存在，则取值‘old’，将原数据覆盖；否则，=‘new’
5、生成的文件位于与源程序文件相同的文件夹中。
课后练习题
一、从键盘输入10个学生的学号和5门功课的考试成绩，并将每个学生的学号和考试成绩作为一个记录存入有格式的顺序数据文件。
二、利用上例所建文件中的数据，再建一个每个学生学号、总分和平均分的有格式的直接存取数据文件。
The End
Fortran语言
（Fortran77结构化程序设计）
第二章第二章
计算机和计算机程序
计算机和计算机程序
第二章 计算机和计算机程序
2.1 计算机是实现算法的有效工具
2.2 计算机的基本组成
2.3 计算机中存储信息的方法
2.4 计算机语言和计算机程序
2.5 程序运行环境
2.6 程序开发的步骤
2.4 计算机语言和计算机程序
一、计算机语言的分类
一、计算机语言的分类
1、机器语言：面向机器
2、汇编语言（符号语言）：面向机器
3、高级语言（算法语言）：可移植性
如：BASIC，FORTRAN，C，PASCAL，C++，JAVA等
二、计算机程序
二、计算机程序
程序 = 算法 + 数据结构
2.5 程序运行环境
一、编辑源程序
一、编辑源程序
二、翻译程序：将源程序翻译成机器语言的过程
二、翻译程序
1、汇编语言：
2、高级语言：
三、连接程序
三、连接程序
2.6 程序开发的步骤
分析问题，画流程图，书写源程序（课堂）
输入、编辑源程序
编译
连接
运行
第一章 算法
第一章 算法
1.1 概念概念
算法是为了解决一个问题所采取的步骤
1.2 算法举例算法举例
1.2
【例1.1】求累加和：1+2+3+…+10
方法一：步骤1：1+2=3
步骤2：3+3=6
…
实现：每一步都使用上一步的结果，并且所有数字都必须存储在
不同的存储单元中。
繁琐，不可取
方法二：设置3个变量S，X，I
步骤1：将存放累加和的S清0：S=0
步骤2：将计数器I清0：I=0
步骤3：读入一个数存放到X中
步骤4：计数器增1：I=I+1
步骤5：判断I是否大于10（否--6；是--7）
步骤6：将X中的数累加到S中：S+XàS
重复执行步骤3、4、5
步骤7：输出累加和S的值
1.2 算法举例
算法举例
1.2
【例1.2】将50个学生成绩中的80分以上的成绩打印出来
思路：同样设置变量：X存放成绩，I为计数器
步骤1：计数器清0：I=0
2:读入一个学生成绩，存入X中
3：计数：I=I+1
4：判断I是否>50？
5：判断X是否>80？
6：返回执行步骤2
7：结束
1.3 算法的特性
有穷性
确定性
有零个或多个输入
有一个或多个输出
有效性
1.4 算法的表示方法
1、自然语言
2、流程图：传统流程图，改进的流程图
【例1.1】求累加和：1+2+3+…+10
流程图：
【例1.2】将50个学生成绩中的80分以上的成绩打印出来
3、结构化程序的三种基本结构
结构化包括两方面的内容：
（1）模块化
（2）三种基本结构为程序的基本单元
顺序结构
选择结构（分支结构）
循环结构
第三章第三章
FORTRAN语言程序设计初步
语言程序设计初步
FORTRAN
3.1 FORTRAN语言发展概况
Formula Translation
适用于工程及科学计算的一种高级程序设计语言
1951年由约翰·贝克斯等人开始研究Fortran语言；
1957年第一个Fortran程序在IBM704机上运行；
1958和1962年先后推出FortranⅡ和FortranⅣ；
1966和1978年先后颁布Fortran66和Fortran77；
1991年颁布了Fortran90
3.2 简单的FORTRAN程序分析
【例3.1】求三个数的平均值
源程序：c calculate the average
x=90.5
y=87.0
z=68.5
aver=(x+y+z)/3.0
write (*,*) ‘平均值为’,aver
end
3.2 简单的FORTRAN程序分析
【例3.2】试求3!，6!，9!的值
主程序： 子程序：
c main program c subprogram
j=k(3) function k(n)
l=k(6) k=1
m=k(9) i=2
write(*,*)j,l,m 5 if (i.le.n) then
end k=k*i
goto 5
endif
return
i=i+1
end
3.2 简单的FORTRAN程序分析
Fortran程序的基本结构：
⑴一个Fortran源程序由一个或多个程序单位组成，每个独立的程序单位以
“end”语句结束。
⑵每个程序单位包括若干行
-语句行（执行语句和非执行语句行）
-非语句行（注释行）
* 不能一行写多条语句，但可以几行写一条语句
⑶语句前可不设标号，也可根据需要设标号。
⑷各类语句在程序单位中的位置有一定规则。
⑸程序必须按规定格式书写。
3.3 FORTRAN 源程序的书写格式
Fortran77源程序必须按以下格式书写：
⑴每行只能在80列内书写，并把80列分为4个区。
⑵ 1～5列：标号区
（ 1～5 位整数；第1
“或 c”时，为注释行）
“列为 *”
⑶ 第6列：续行标志区
（非空格或非零字符；最多19个续行）
⑷ 7～72列：语句区
（书写语句；一行只能写一条语句）
⑸ 73～80列：语句注释区
（一般作编号注释）
3.4 Fortran程序的编辑与运行
Fortran 开发环境简介
3.4 Fortran程序的编辑与运行
一、Fortran 源程序编辑软件进入
进入DOS状态→找到fortran目录并进入→在当前路径下键入edit并
回车。
二、创建源程序文件并编写源程序
在出现的编辑界面中按[alt]+f键激活file菜单，选择save选项，出
“现 save as”保存界面，以for为扩展名（即为xxx.for）命名文件，
按回车键→开始编辑（编写程序过程中，应经常存盘）→编写完毕
后用file菜单中exit选项退出。
3.4 Fortran程序的编辑与运行
三、编译并连接源文件
在当前路径（即fortran目录）键入fl 源文件名→等待编
译提示信息→若有错误在当前路径键入edit 源程序文件名
再次进入编辑状态，直到编译成功，产生可执行文件
xxx.exe。
3.4 Fortran程序的编辑与运行
四、运行程序
在正确路径下键入xxx即可运行
五、打开源程序文件（两种方式）
1.在fortran目录下键入edit 源程序文件名
2.键入edit进入编辑界面，利用file菜单中
open选项
3.5 常 量
常量 — 在程序执行期间其值固定不变的量
Fortran处理六种类型的常量：
⑴整型常量（Integer）ü
⑵实型常量（Real） ü
⑶双精度常量（Double precision）
⑷复型常量（Complex）
⑸逻辑型常量（Logical）
⑹字符型常量（Character）
3.5.1 整型常量
整数（Integer）
包括正、负整数和零
如：5，-13，0 …，
说明：
①在（16位）微机中，整数的取值范围为：
-215～215-1（-32768～32767）
②在（32位）微机中，整数的取值范围为：
-231～231-1（-2147483648～2147483648 ）
3.5.2 实型常量
实数（real）
两种表示形式
⒈小数形式
如：15.8，-21.05，1.0 ,14.，.17，0.0 ,…
⒉指数形式（通常表示较大或较小的数）
如：100000000 1.0E+8
0.0000125→1.25E-05
数字部分 指数部分
→
3.5.2 实型常量
说明：
⑴一个数值用指数形式表示时有两种表达方式：
8.76E-1
→
-2.5894E+3
①一个基本实数后面跟指数部分。
如： 0.876
-2589.4
→
②一个整数后面跟指数部分。
如： 0.876
-2589.4
→
876E-3
→
-25894E-1
3.5.2 实型常量
⑵同一个数值可用不同的指数形式表示。
如： 0.876 8.76→ E-1 87.6E-2 876E-3
→
→
⑶计算机在输出时，按标准化指数形式输出。
→
如：0.28 2.800000E-01
-59.58E+12 -5.958000E+13
即数字部分大于1，且小数点前只有一位非零数字的指数输出形式。
→
⑷在微机中，一般用四个字节存放一个实数，其取值范围为：10-38～
1038
。超出此范围时为 溢出 错误。
“
”
3.5.2 实型常量
⑸下列形式为不合法的指数形式：
①单独的小数点和单独的指数部分。
如：.E5， E10
②指数部分只能是整数，不能带小数点。
如：8E0.5， 12.3E1.5
3.6 变 量
3.6.1 变量的概念
变量的概念
3.6.1
——变量 在程序执行期间其值可以改变的量
Fortran为每一个变量分配一个相应的存储单元；
每个变量在每个时刻只能有一个确定的值。
如：x=4.5 x
x=8.0 x
注：在程序中用到的变量都必须要有确定的值
相关推荐
2023年江西萍乡中考道德与法治真题及答案.doc
2012年重庆南川中考生物真题及答案.doc
2013年江西师范大学地理学综合及文艺理论基础考研真题.doc
2020年四川甘孜小升初语文真题及答案I卷.doc
2020年注册岩土工程师专业基础考试真题及答案.doc
2023-2024学年福建省厦门市九年级上学期数学月考试题及答案.doc
2021-2022学年辽宁省沈阳市大东区九年级上学期语文期末试题及答案.doc
2022-2023学年北京东城区初三第一学期物理期末试卷及答案.doc
2018上半年江西教师资格初中地理学科知识与教学能力真题及答案.doc
2012年河北国家公务员申论考试真题及答案-省级.doc
2020-2021学年江苏省扬州市江都区邵樊片九年级上学期数学第一次质量检测试题及答案.doc
2022下半年黑龙江教师资格证中学综合素质真题及答案.doc
