Der Block

In imperativen Programmiersprachen ist es möglich, eine Anweisung aus verschiedenen anderen Anweisungen, den echten Teilanweisungen, zusammenzusetzen. So entsteht der Block: Eine Anweisung, die aus einer Folge (Sequenz) mehrerer Anweisungen besteht und die ausgeführt wird, indem alle ihre Anweisungen in der durch den Text gegebenen Reihenfolge zeitlich hintereinander ausgeführt werden. Die Wirkung dieser Anweisung ergibt sich also durch Eintritt der Wirkungen aller Teilanweisungen in der gegebenen Reihenfolge. Der Nachzustand jeder Anweisung ist der Vorzustand einer eventuell folgenden Anweisung.

Der Block wird auch Verbundanweisung (engl.: “compound statement ”) oder Anweisungsverbund genannt.

Im Struktogramm (Nassi-Shneidermann-Diagramm) wird der Block geschrieben, indem die Rechtecke für die einzelnen Teilanweisungen untereinandergesetzt werden und das so entstandene Rechteck in ein anderes eingesetzt wird. (Das äußere Rechteck kann aber auch entfallen, wenn der Block selber nicht mehr Teil eines anderen Blocks ist.) Oben kann in das äußere Rechteck noch eine Blockbeschreibung (hier "1 und 2 ausgeben") oder ein Blockname geschrieben werden.

Ausgabe von "1" und danach Ausgabe von "2" [Struktogramm DIN 66261 - A]

  Einfacher Block 
.-----------------------------------------------. 
|   1 und 2 ausgeben                            | 
| .-------------------------------------------. | 
| | 1 ausgeben                                | | 
| |-------------------------------------------| | 
| | 2 ausgeben                                | | 
| '-------------------------------------------' | 
'-----------------------------------------------'

Ausgabe

Das folgende Struktogramm zeigt einen in einem anderen Block enthaltenen Block. Diesmal ist der innere Block nicht benannt. Beim Entwurf eines Programmes mit einem Struktogramm ist es empfehlenswert, Blöck zu benennen. In dieser Lektion wird nur deshalb gelegentlich darauf verzichtet, um die Analogie mit vielen Programmiersprachen zu betonen, in denen Blöck oft nicht benannt werden können (wenn sie an derselben Stelle bleiben sollen, ohne daß ein Aufruf nötig wird). Eine Blockbenennung oder Blockbeschreibung kann aber auch in solchen Programmiersprachen als Kommentar an den Anfang des Blockes geschrieben werden.

Blockanweisung im Struktogramm [Struktogramm DIN 66261 - A]

  Block mit innerem Block 
.-------------------------------------------. 
| 0 ausgeben                                | 
|-------------------------------------------| 
|                                           | 
| .---------------------------------------. | 
| | 1 ausgeben                            | | 
| |---------------------------------------| | 
| | 2 ausgeben                            | | 
| '---------------------------------------' | 
|-------------------------------------------| 
| 3 ausgeben                                | 
'-------------------------------------------'

Ausgabe

Sequenzpunkte

In einer Sequenz, also einer Folge von Anweisungen innerhalb eines Blocks, lassen sich den Anweisungen Sequenzpunkte zuordnen. Es handelt sich hierbei um Zeitpunkte zwischen aufeinanderfolgenden Ausführungen von Sprachelemente mit Wirkungen, wie beispielsweise Anweisungen. Bei jedem Sequenzpunkt zwischen wirkenden Sprachelementen (Aktionen) sind alle Wirkungen eventuell vorhandener vorheriger Sprachelemente eingetreten und noch keine Wirkungen eventuell vorhandener folgender Sprachelemente eingetreten. Zwischen zwei aufeinanderfolgenden Anweisungen in einer Sequenz existiert immer ein Sequenzpunkt. Das bedeutet, daß alle Wirkungen einer Anweisung eingetreten sind, bevor die nächste Anweisung begonnen wird.

Ausgabe von "1" und danach Ausgabe von "2" [Struktogramm DIN 66261 - A]

  Einfache Sequenz 
.-------------------------------------------. <--- Sequenzpunkt 0 
| 1 ausgeben                                | 
|-------------------------------------------| <--- Sequenzpunkt 1 
| 2 ausgeben                                | 
'-------------------------------------------' <--- Sequenzpunkt 2

Ohne Sequenzpunkte zwischen ihnen ist die Reihenfolge von Aktionen nicht festgelegt. Tatsächlich gibt es einige Sprachen, in denen Aktionen verlangt werden können, ohne daß es Sequenzpunkte zwischen ihnen geben muß. Das bedeutet dann, daß die Reihenfolge, in der die Wirkungen der Aktionen eintreten, nicht definiert ist. Die Aktionen können dann also in beliebiger zeitlicher Reihenfolge oder auch gleichzeitig ablaufen. Dieses Thema wird für die betreffenden Sprachen in anderen Lektionen ausführlicher behandelt.

Man kann die Sequenz mit einem Einkaufszettel vergleichen.

Einkaufszettel ohne Sequenzpunkt

Kaffee 
Kartoffeln 
Tomaten 
Emmentaler

Beim Einkaufszettel ist die Reihenfolge der Abarbeitung der Anweisungen egal. Wenn man zuerst die Tomaten sieht, dann kann man sie kaufen und auf dem Zettel abhacken. Es ist hier nicht nötig, die Reihenfolge auf dem Zettel beim Einkauf zu beachten. Bei der Sequenz muß die vorgegebene Reihenfolge anders als bei einem Einkaufszettel aber streng beachtet werden. Der Einkaufszettel zeigt, daß dies nicht selbstverständlich ist. Man kann das auch so sagen: Ein Einkaufszettel hat normalerweise keine Sequenzpunkte.

Es kann aber sein, daß der Kaffee besonders dringend benötigt wird. Wenn es sein könnte, daß die Zeit knapp ist (beispielsweise kurz vor Ladenschluß), dann sollte deswegen geplant werden, zuerst den Kaffee zu besorgen. Dies kann man auf dem folgenden Einkaufzettel sehen.

Einkaufszettel mit Sequenzpunkt

Zuerst Kaffee kaufen! 
                          <----- Sequenzpunkt

Danach: 
Kartoffeln 
Tomaten 
Emmentaler

Zuerst soll Kaffee gekauft werden und danach Kartoffeln, Tomaten und Emmentaler, wobei die Reihenfolge dann wieder egal ist. In diesem Fall hat der Einkaufszettel einen Sequenzpunkt, nämlich nach dem Kaffee.

Die Kontrolle und der Kontrollfluß

Kontrolle um 12:00 Uhr [Struktogramm DIN 66261 - A]

  Einfache Sequenz 
.-------------------------------------------.  
| 1 ausgeben [Kontrolle]                    | 
|-------------------------------------------| 
| 2 ausgeben                                | 
'-------------------------------------------'

Eine Anweisung, die gerade ausgeführt wird, kontrolliert gewissermaßen den Ausführer (Prozessor oder Interpretierer). Daher sagt man auch, sie habe die Kontrolle. Bei der Ausführung der einfachen Sequenz aus dem abgebildeten Struktogramm hat zuerst die Anweisung "1 ausgeben" die Kontrolle und danach die zweite Anweisung "2 ausgeben".

Kontrolle um 12:00 Uhr und 12 Nanosekunden [Struktogramm DIN 66261 - A]

  Einfache Sequenz 
.-------------------------------------------.  
| 1 ausgeben                                | 
|-------------------------------------------| 
| 2 ausgeben [Kontrolle]                    | 
'-------------------------------------------'

Dies kann auch so interpretiert werden, daß die Kontrolle sich von der ersten zur zweiten Anweisung „bewegt“ oder von der ersten zur zweiten Anweisung „strömt“ oder „gleitet“, was man auch als „Kontrollfluß “ bezeichnet. Diese Bezeichnung geht vielleicht auf das englische “control flow ” zurück, wobei aber “flow ” soviel wie „Ablauf“, „Bewegung“, „Durchlauf“ oder „Strom“ bedeutet. Eine passendere, aber unübliche, Bezeichnung wäre daher Kontrollstrom.

Eingänge und Ausgänge

Den Sequenzpunkt vor einer Anweisung, die bei einer gegebenen Sequenz zuerst ausgeführt wird, bezeichnet man auch als ihren Eingang und den Sequenzpunkt nach einer Anweisung, die bei einer gegebenen Sequenz zuletzt ausgeführt wird, bezeichnet man auch als ihren Ausgang. Die Kontrolle „betritt“ eine Sequenz beim Eingang der Sequenz und „verläßt“ sie wieder beim Ausgang der Sequenz. Eine Sequenz hat nur einen Eingang und einen Ausgang: Der Eingang ist am Anfang und der Ausgang am Ende.

Die zeitliche Abfolge der Anweisungen nennt man auch einen Ausführungspfad. Bei der Sequenz ist der Ausführungspfad schon durch den Text der Sequenz gegeben, weil die Anweisungen in der zeitlichen Reihenfolge ausgeführt werden, in der sie im Programmtext hintereinander stehen. Bei anderen Anweisungen kann die Ermittlung des Ausführungspfads allerdings komplizierter sein oder erst zur Laufzeit des Programms erfolgen.

Sequenz mit Ein- und Ausgang [Struktogramm DIN 66261 - A]

 
                  Kontrolle 
                      | 
  Einfache Sequenz    |S 
.-------------------- |t -------------------. <--- Eingang 
| erste  Anweisung    |r                    | 
|-------------------- |o -------------------| 
| zweite Anweisung    |m                    | 
|-------------------- |  -------------------| 
| dritte Anweisung    |                     | 
'-------------------- | --------------------' <--- Ausgang 
                      V

Durch den einfachen Aufbau von Sequenzen können diese leicht kombiniert werden: Wenn zwei Sequenzen aufeinander folgen, werden sie hintereinander ausgeführt. Die Kontrolle verläßt die erste Sequenz am Ausgang der erste Sequenz und betritt die zweite Sequenz danach am Eingang der zweiten Sequenz.

Elementare und Komplexe Anweisungen

Man unterscheidet zwischen elementaren Anweisungen (Elementaranweisungen) und komplexen (zusammengesetzten) Anweisungen (Kontrollstrukturen, strukturierten Anweisungen). Eine elementare Anweisung ist nicht weiter in echte Teilanweisungen zerlegbar. Eine komplexe Anweisung enthält noch weitere echte Teilanweisungen. Das obige Struktogramm stellt insgesamt eine komplexe Anweisung dar, die aus zwei Elementaranweisungen besteht. Ein Block ist also im allgemeinen eine komplexe Anweisung.

Formatierung

Fast seitdem es überhaupt Programmiersprachen gibt, kann man zwei verschiedene Art von Sprachen unterscheiden: Bei manchen Sprachen (wie FORTRAN, BASIC oder COBOL) muß bei einer Folge mehrerer Anweisungen jede Anweisung auf eine eigene Zeile geschrieben werden.

Eine BASIC-Sequenz mit zwei Anweisungen

10 PRINT 1; 
20 PRINT 2;

Bei den Sprachen mit „freier Formatierung“ (wie Pascal, C++ oder Java ) können Anweisungen fast beliebig auf Zeilen verteilt werden.

Ein Pascal-Block mit zwei Anweisungen

begin Write( 1 ); Write( 2 ) end

Bei freier Formatierung muß entweder jede Anweisung bereits selber erkennen lassen, wann sie beendet ist (wie z.B. in C++ oder Java ) oder es muß unter bestimmten Umständen ein Sprachelement zur Trennung zwischen zwei Anweisungen geben (wie beispielsweise teilweise das Semikolon ";" in Pascal ), da das Zeilenende hier nicht diese Funktion erfüllen kann.

Blöcke zur Gliederung

Das folgende Struktogramm beschreibt die Ausgabe der ersten Hälfte des Liedes „Auf einem Baum ein Kuckuck saß.“.

Auf einem Baum ein Kuckuck sass [Struktogramm DIN 66261 - A]

.--------------------------------------------------. 
| "Auf einem Baum ein Kuckuck, -" ausgeben         | 
|--------------------------------------------------| 
| "Sim sa la dim, bam ba," ausgeben                | 
|--------------------------------------------------| 
| "Sa la du, sa la dim -" ausgeben                 | 
|--------------------------------------------------| 
| "Auf einem Baum ein Kuckuck sass." ausgeben      | 
|--------------------------------------------------| 
| "Da kam ein junger Jäger, -" ausgeben            | 
|--------------------------------------------------| 
| "Sim sa la dim, bam ba," ausgeben                | 
|--------------------------------------------------| 
| "Sa la du, sa la dim -" ausgeben                 | 
|--------------------------------------------------| 
| "Da kam ein junger Jägersmann." ausgeben         | 
|--------------------------------------------------| 
| "Der schoss den armen Kuckuck, -" ausgeben       | 
|--------------------------------------------------| 
| "Sim sa la dim, bam ba," ausgeben                | 
|--------------------------------------------------| 
| "Sa la du, sa la dim -" ausgeben                 | 
|--------------------------------------------------| 
| "Der schoss den armen Kuckuck tot." ausgeben     | 
'--------------------------------------------------'

Man erkennt, daß sich der Liedtext hier in drei Strophen gliedert. Diese können durch Blöcke erkennbar hervorgehoben werden.

Auf einem Baum ein Kuckuck sass, 1 [Struktogramm DIN 66261 - A]

.--------------------------------------------------. 
|                                                  | 
| .----------------------------------------------. | 
| | "Auf einem Baum ein Kuckuck, -" ausgeben     | | 
| |----------------------------------------------| | 
| | "Sim sa la dim, bam ba," ausgeben            | | 
| |----------------------------------------------| | 
| | "Sa la du, sa la dim -" ausgeben             | | 
| |----------------------------------------------| | 
| | "Auf einem Baum ein Kuckuck sass." ausgeben  | | 
| '----------------------------------------------' | 
|--------------------------------------------------| 
|                                                  | 
| .----------------------------------------------. | 
| | "Da kam ein junger Jäger, -" ausgeben        | | 
| |----------------------------------------------| | 
| | "Sim sa la dim, bam ba," ausgeben            | | 
| |----------------------------------------------| | 
| | "Sa la du, sa la dim -" ausgeben             | | 
| |----------------------------------------------| | 
| | "Da kam ein junger Jägersmann." ausgeben     | | 
| '----------------------------------------------' | 
|--------------------------------------------------| 
|                                                  | 
| .----------------------------------------------. | 
| | "Der schoss den armen Kuckuck, -" ausgeben   | | 
| |----------------------------------------------| | 
| | "Sim sa la dim, bam ba," ausgeben            | | 
| |----------------------------------------------| | 
| | "Sa la du, sa la dim -" ausgeben             | | 
| |----------------------------------------------| | 
| | "Der schoss den armen Kuckuck tot." ausgeben | | 
| '----------------------------------------------' | 
'--------------------------------------------------'

Auch der Refrain kann durch einen eigenen Block hervorgehoben werden.

Auf einem Baum ein Kuckuck sass, 2 [Struktogramm DIN 66261 - A]

.--------------------------------------------------. 
|                                                  | 
| .----------------------------------------------. | 
| | "Auf einem Baum ein Kuckuck, -" ausgeben     | | 
| |----------------------------------------------| | 
| |                                              | | 
| | .------------------------------------------. | | 
| | | "Sim sa la dim, bam ba," ausgeben        | | | 
| | |------------------------------------------| | | 
| | | "Sa la du, sa la dim -" ausgeben         | | | 
| | '------------------------------------------' | | 
| |----------------------------------------------| | 
| | "Auf einem Baum ein Kuckuck sass." ausgeben  | | 
| '----------------------------------------------' | 
|--------------------------------------------------| 
|                                                  | 
| .----------------------------------------------. | 
| | "Da kam ein junger Jaeger, -" ausgeben       | | 
| |----------------------------------------------| | 
| |                                              | | 
| | .------------------------------------------. | | 
| | | "Sim sa la dim, bam ba," ausgeben        | | | 
| | |------------------------------------------| | | 
| | | "Sa la du, sa la dim -" ausgeben         | | | 
| | '------------------------------------------' | | 
| |----------------------------------------------| | 
| | "Da kam ein junger Jaegersmann." ausgeben    | | 
| '----------------------------------------------' | 
|--------------------------------------------------| 
|                                                  | 
| .----------------------------------------------. | 
| | "Der schoss den armen Kuckuck, -" ausgeben   | | 
| |----------------------------------------------| | 
| |                                              | | 
| | .------------------------------------------. | | 
| | | "Sim sa la dim, bam ba," ausgeben        | | | 
| | |------------------------------------------| | | 
| | | "Sa la du, sa la dim -" ausgeben         | | | 
| | '------------------------------------------' | | 
| |----------------------------------------------| | 
| | "Der schoss den armen Kuckuck tot." ausgeben | | 
| '----------------------------------------------' | 
'--------------------------------------------------'

Durch die Strukturierung wird die schon an der graphischen Form leicht erkennbare Oberflächenstruktur eines Textes an die inhaltliche Tiefenstruktur so angepaßt, daß die sichtbaren Oberflächenstruktur möglichst gut mit der inhaltlichen Tiefenstruktur übereinstimmt. Dies erleichtert das Verständnis des Inhalts. In dem obigem Struktogramm ist die Unterteilung des Liedes in Strophen und Refrain jetzt mit einem Blick erkennbar und es ist dadurch leichter lesbar als das erste „monolithische“ (aus einem Block bestehende) Struktogramm.

Die Anweisungen eines Blocks sollten immer einen bestimmten Sinn ergeben, also eine Sinneinheit bilden, und nicht nur willkürlich zusammengewürfelt sein. Das ist dann gegeben, wenn man mit einem Wort oder mit wenigen Worten zusammenfassen kann, was der Block macht.

Wieviele Blöcke gibt es?

Wenn ein Block mehrere Blöcke enthält, so gilt er (nach außen hin) doch als ein Block.

Wenn man zwei Pakete an einen Empfänger schicken will, aber die Post nur ein Paket entgegennimmt, so kann man ja auch beide Pakete in ein größeres Paket legen und dieses als ein Paket aufgeben. Dem Paket kann man von außen nicht ansehen, daß es noch zwei weitere Pakete enthält: Es ist ein Paket und somit ist die Bedingung der Post erfüllt.

Ein Block mit zwei inneren Blöcken

.---------------------------------------------. 
|                                             | 
|   .-------------------------------------.   | 
|   | "Alle meine Entchen" ausgeben       |   | 
|   |-------------------------------------|   | 
|   | "schwimmen auf dem See," ausgeben   |   | 
|   '-------------------------------------'   | 
|                                             | 
|   .-------------------------------------.   | 
|   | "Alle meine Täubchen" ausgeben      |   | 
|   |-------------------------------------|   | 
|   | "gurren auf dem Dach" ausgeben      |   | 
|   '-------------------------------------'   | 
|                                             | 
'---------------------------------------------'