Oberon编程教程：从基础到面向对象

需积分: 10 135 浏览量更新于2024-07-24 收藏 326KB PDF 举报

"Oberon教程文档是一本详细介绍Oberon编程语言的教材，由Niklaus Wirth撰写，基于Modula-2语言。该教材适用于编译原理Project3的逆向工程学习，但请注意，它是英文版。教程分为四个部分，深入讲解了Oberon语言的基础语法、程序结构、数据类型、控制结构、模块化编程以及面向对象编程概念。" 在Oberon教程中，首先介绍了编程的基本概念和第一个示例，帮助读者快速入门。接着，教程采用特定的语法描述Oberon的结构，阐述了程序的表示方式。内容涵盖语句和表达式，包括重复语句（如循环）和条件语句，提供了丰富的控制流程结构。教程详细讲解了基本数据类型，如整型(INTEGER)、实型(REAL)、布尔型(BOOLEAN)、字符型(CHAR)和集合型(SET)，这些是构建程序的基础。此外，还介绍了常量和变量声明，以及数组的使用，这些都是程序中数据存储和处理的关键元素。 Part2深入探讨了过程（Procedures）和函数，包括局部性原则、参数传递机制，如变量参数、值参数和开放数组参数。函数过程（Function Procedures）和递归编程也在此部分有所阐述，这对于解决复杂问题至关重要。类型声明、记录类型（Record Types）以及动态数据结构和指针的介绍，进一步增强了程序设计的灵活性。 Part3引入了模块（Modules）的概念，详细解析了定义与实现的关系，以及如何通过模块进行程序的分解，提高了代码的组织性和可维护性。关于序列的概念，教程讲解了输入输出操作、文件和骑行者（Riders）、文本、读写器以及标准输入输出，这是进行I/O操作的基础。最后的Part4聚焦于面向对象编程（Object-oriented Programming），追溯其起源，并介绍了Oberon中的面向对象特性。虽然Oberon相对于其他现代语言在面向对象方面可能较为简洁，但它仍然支持类的创建和继承，允许程序员以面向对象的方式思考和解决问题。 Oberon教程文档是一份详尽的参考资料，适合想要掌握或深入了解Oberon语言及其在编译原理项目中的应用的读者。通过学习，读者不仅可以掌握Oberon的基本语法和编程技巧，还能理解其背后的模块化和面向对象设计思想。

statement = [ assignment | ProcedureCall |

WhileStatement | RepeatStatement | ForStatement |

IfStatement | ReturnStatement ].

Several of these forms are structured statements, i.e. some of their components may be statements again.

Hence, the definition of statement is, like that of expressions, recursive.

The most basic structure is the sequence. A computation is a sequence of actions, where each action is

specified by a statement, and is executed after the preceding action is completed. This strict sequentiality

in time is an essential assumption of sequential programming. If a statement S1 follows S0, then we

indicate this sequentiality by a semicolon

S0; S1

This statement separator (not terminator) indicates that the action specified by S0 is to be followed

immediately by the action corresponding to S1. A sequence of statements is syntactically defined as

StatementSequence = statement {";" statement}.

The syntax of statements implies that a statement may consist of no symbols at all. In this case, the

statement is said to be empty and evidently denotes the null action. This curiosity among statements has a

definite reason: it allows semicolons to be inserted at places where they are actually superfluous, such as

at the end of a statement sequence.

6. Control Structures

It is a prime characteristic of computers that individual actions can be selected, repeated, or performed

conditionally depending on some previously computed results. Hence the sequence of actions performed

is not always identical with the sequence of their corresponding statements. The sequence of actions is

determined by control structures indicating repetition, selection, or conditional execution of given

statements.

6.1 Repetitive Statements

The most common situation is the repetition of a statement or statement sequence under control of a

condition: the repetition continues as long as the condition is met. This is expressed by the while

statement. Its syntax is

WhileStatement = "WHILE" expression "DO" StatementSequence "END".

and its corresponding action is

1. Evaluate the condition which takes the form of an expression yielding the value TRUE or FALSE,

2. If the value is TRUE, execute the statement sequence and then repeat with step 1; if the value is

FALSE, terminate.

The expression is of type BOOLEAN. This will be further discussed in the chapter on data types. Here it

suffices to know that a simple comparison is a Boolean expression. An example was given in the

introductory example, where repetition terminates when the two comparands have become equal. Further

examples involving while statements are:

1. Initially, let q = 0 and r = x; then count the number of times y can be subtracted from x, i.e. compute

the quotient q = x DIV y, and remainder r = x MOD y, if x and y are natural numbers.

WHILE r >= y DO r := r-y; q := q+1 END

2. Initially, let z = 1 and i = k; then multiply z k times by x, i.e. compute z = x^k, if z and k are natural

numbers:

WHILE i > 0 DO z := z*x; i := i-1 END

When dealing with repetitions, it is important to remember the following points:

1. During each repetition, progress must be made towards meeting the goal, namely "getting closer" to

satisfying the termination condition. An obvious corollary is that the condition must be somehow

affected from within the repeated computation. The following statements are either incorrect or

dependent on some critical precondition as stated.

WHILE i > 0 DO

k := 2*k (*i is not changed*)

END

WHILE i # 0 DO

i := i-2 (*i must be even and positive*)

END

WHILE n # i DO

n := n*i; i := i+1

END

2. If the condition is not satisfied initially, the statement is vacuous, i.e. no action is performed.

3. In order to obtain a grasp of the effect of the repetition, we need to establish a relationship that is

stable, called an invariant. In the division example above, this is the equation q*y + r = x holding each

time the repetition is started. In the exponentiation example it is z * x

= x

which, together with the

termination condition i = 0 yields the desired result z = x

4. The repetition of identical computations should be avoided (although a computer has infinite patience

and will not complain). A simple rule is to avoid expressions within repetitive statements, in which no

variable changes its value. For example, the statement

WHILE i < 3*N DO tab[i] := x + y*z + z*i; i := i+1 END

should be formulated more effectively as

n := 3*N; u := x + y*z;

WHILE i < n DO tab[i] := u + z*i; i := i+1 END

In addition to the while statement, there is the repeat statement, syntactically defined as

RepeatStatement = "REPEAT" StatementSequence "UNTIL" expression.

The essential difference to the while statement is that the termination condition is checked each time after

(instead of before) execution of the statement sequence. As a result, the sequence is executed at least

once. An advantage is that the condition may involve variables that are undefined when the repetition is

started.

REPEAT i := i+5; j := j+7; k := i DIV j UNTIL k > 23

REPEAT r := r-y; q := q+1 UNTIL r < y

6.2 Conditional Statements

The conditional statement, also called if statement, has the form

IfStatement = "IF" expression "THEN" StatementSequence

{"ELSIF" expression "THEN" StatementSequence}

["ELSE" StatementSequence]

"END".

The following example illustrates its general form.

IF R1 THEN S1

ELSIF R2 THEN S2

ELSIF R3 THEN S3

ELSE S4

END

The meaning is obvious from the wording. However, it must be remembered that the expressions R1 ...

R3 are evaluated one after the other, and that as soon as one yields the value TRUE, its corresponding

statement sequence is executed, whereafter the IF statement is considered as completed. No further

conditions are tested. Examples are:

IF x = 0 THEN s := 0

ELSIF x < 0 THEN s := -1

ELSE s := 1

END

IF ODD(k) THEN z := z*x END

IF k > 10 THEN k := k-10; d := 1 ELSE d := 0 END

The constructs discussed so far enable us to develop a few simple, complete programs as subsequently

described. The first example is an extension of our introductory example computing the greatest common

divisor gcd of two natural numbers x and y. The extension consists in the addition of two variables u and

v, and statements which lead to the computation of the least common multiple (lcm) of x and y. The lcm

and the gcd are related by the equation

lcm(x,y) * gcd(x,y) = x*y

As explained earlier, this and following examples will be formulated as command procedures and are

assumed to be embedded in module Pattern defined in Chap. 2 which imports modules Texts and

Oberon.

PROCEDURE gcdlcm*;

VAR x, y, u, v: INTEGER; S: Texts.Scanner;

BEGIN Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos);

Texts.Scan(S); x := S.i; Texts.WriteString(W, " x ="); Texts.WriteInt(W, x, 6);

Texts.Scan(S); y := S.i; Texts.WriteString(W, " y ="); Texts.WriteInt(W, y, 6);

u := x; v := y;

WHILE x # y DO

(*gcd(x,y) = gcd(x0,y0), x*v + y*u = 2*x0*y0*)

IF x > y THEN

x := x - y; u := u + v

ELSE

y := y - x; v := v + u

END

END ;

Texts.WriteInt(W, x, 6); Texts.WriteInt(W, (u+v) DIV 2, 6); Texts.WriteLn(W);

Texts.Append(Oberon.Log, W.buf)

END gcdlcm.

This example again shows the nesting of control structures. The repetition expressed by a while

statement includes a conditional structure expressed by an if statement, which in turn includes two

statement sequences, each consisting of two assignments. This hierarchical structure is made transparent

by appropriate indentation of the "inner" parts.

Another example demonstrating a hierarchical structure computes the real number x raised to the power

i, where i is a non-negative integer.

PROCEDURE Power*;

VAR i: INTEGER; x, z: REAL; S: Texts.Scanner;

BEGIN Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos); Texts.Scan(S);

WHILE S.class = Texts.Real DO

x := S.x; Texts.WriteString(W, " x ="); Texts.WriteReal(W, x, 16);

Texts.Scan(S); i := S.i; Texts.WriteString(W, " i ="); Texts.WriteInt(W, i, 4);

z := 1.0;

WHILE i > 0 DO

(* z * x^i = x0^i0 *)

z := z*x; i := i-1

END ;

Texts.WriteReal(W, z, 16); Texts.WriteLn(W); Texts.Scan(S)

END ;

Texts.Append(Oberon.Log, W.buf)

END Power.

Here we subject the computation to yet another repetition: Each time a result has been computed, another

value pair x, i is requested. This outermost repetition is controlled by the relation S.class = Texts.Real,

剩余64页未读，继续阅读

Ming宽

粉丝: 0
资源: 14

Oberon编程教程：从基础到面向对象

Native Oberon-开源

Oberon中的编程-超越Pascal和Modula的步骤Programming in Oberon - Steps Beyond Pascal and Modula

language-oberon：Atom中的Oberon语言支持

entry标签在xml中应用的代码实例

ifs：IFS是Oberon-7的模块，基于Reiser和Wirth的“编程Oberon，超越Pascal和Modula-2的步骤”中的示例

Oberon语言的编译器

【发文无忧】基于雾凇优化算法RIME-Kmean-Transformer-GRU实现数据回归预测算法研究Matlab代码.rar

粮食波动率等相关农业数据（2011-2022）-最新出炉.zip

【创新发文无忧】Matlab实现开普勒优化算法KOA-Kmean-Transformer-GRU故障诊断算法研究.rar

【DOA估计】2T4RFMCW雷达模拟器和MUSIC算法高分辨率DOA估计【含Matlab源码 8884期】.mp4

最新资源