Strukturierte Programmierung

Grundkonzepte der strukturierten Programmierung

• Bildung von logischen Programmeinheiten,
• hierarchische Programmorganisation,
• Definition einer zentralen Programmsteuerung,
• Beschränkung der Ablaufsteuerung,
• Beschränkung der Datenverfügbarkeit.

grafische Darstellungsmittel

meist in Form von Struktogrammen (Nassi-Shneiderman-Diagramme), die verwendeten grafischen Symbole (Strukturblöcke) können sowohl formale als auch verbale Texte aufnehmen; für die verschiedenen Strukturblöcke existieren variierende Darstellungsformen.

Pseudocode

Mischung von formalen und verbalen Darstellungsmitteln in Textform,

höhere Programmiersprache

moderne Sprach(version)en sind gut auf die Anforderungen der strukturierten Programmierung abgestimmt, für ältere Sprach(version)en trifft dies oft nicht zu.

Im folgenden wird zunächst auf die Ablaufsteuerung und auf mögliche Darstellungsmittel eingegangen. Benutzt wird zum einen die Struktogrammtechnik, zum anderen werden die Ausdrucksmittel wichtiger prozeduraler Sprachen wie Ada, ALGOL, BASIC, C, COBOL, Fortran, Modula-2, PL1 und Pascal angegeben. Bei den sprachbezogenen Angaben sind unterschiedliche Dialekte und Sprachversionen zu beachten. Dies betrifft vor allem BASIC, aber auch COBOL, FORTRAN und Pascal.

Kommentare

Für die syntaktische Darstellung von Kommentaren gilt:

1. Ein Kommentar beginnt mit einem speziellen Symbol.
   Dies kann sein
   • ein Schlüsselwort
     meist nur in älteren Sprach(version)en
   • einem Sonderzeichen bzw. einer Folge von Sonderzeichen
     z.B. { // /* (* C * --
   Mitunter sind spezielle Kommentarzeilen vorgeschrieben, meist können innerhalb einer Zeile aber sowohl Kommentare als auch "normale" Anweisungen stehen.
2. Ein Kommentar endet entweder
   • mit dem Zeilenende oder
   • einem Sonderzeichen bzw. einer Folge von Sonderzeichen
     z.B. } */ *)
   Einige Sprachen sehen für ein- und mehrzeilige Kommentare spezielle syntaktische Konstruktionen vor.
   Das Ineinanderschachteln von Kommentaren ist oft nicht oder nur eingeschränkt möglich.

   Ada

   Kommentare beginnen mit -- und enden mit dem Zeilenende.

   ALGOL-60, Simula

   Ein Kommentar beginnt mit COMMENT und wird mit einem Semikolon ; beendet, er kann sich über mehrere Zeilen erstrecken.

   BASIC

   Kommentare beginnen mit REM (remark) und schließen mit dem Zeilenende ab.
   In Standard BASIC kann anstelle von REM auch ein Ausrufezeichen ! notiert werden.

   COBOL

   Kommentarzeilen beginnen mit einem * in Spalte 7.

   C, C++, Java

   Kommentare werden durch das Zeichenpaar /* bzw. */ begrenzt und können über mehrere Zeilen gehen.
   Zusätzlich in C++ und Java:
   Ein mit // beginnender Kommentar schließt mit dem Zeilenende ab.

   Fortran

   Kommentarzeilen beginnen mit einem C in Spalte 1.
   Fortran 77:
   Die gleiche Wirkung erzielt ein * in Spalte 1.
   Fortran 90:
   Einzeiliger Kommentar zum Abschluß einer Anweisungszeile kann durch ! eingeleitet werden.

   Modula-2, Oberon-2

   Kommentare werden durch das Zeichenpaar (* bzw. *) begrenzt und können über mehrere Zeilen gehen.

   Pascal

   Kommentare werden in geschweifte Klammern { ... } eingeschlossen und können über mehrere Zeilen gehen.
   Alternativ dazu kann auch (* ... *) verwendet werden.

   PL1

   Kommentare werden durch das Zeichenpaar /* bzw. */ begrenzt und können über mehrere Zeilen gehen.

   Es ist zu beachten, daß in einer Reihe von Sprachsystemen Compilerdirektiven die syntaktische Form von Kommentaranweisungen annehmen. Compilerdirektiven beeinflussen die Arbeit des Compilers. Einige Compilerdirektiven bestimmen lediglich Äußerlichkeiten, wie z.B. das Aussehen von Übersetzungsprotokollen, andere können aber auch indirekt Einfluß auf den Ablauf des erzeugten Programms nehmen, wie z.B. durch Speicherausrichtung auf Wortgrenzen, Einfügung von speziellen Prüfbedingungen für Ausnahmesituationen usw.

   Ablaufstrukturen (Kontrollstrukturen)

   Jeder beliebige Algorithmus läßt sich mit Hilfe von nur drei grundlegenden Ablaufstrukturen darstellen:
   • Sequenz,
   • Alternative,
   • Iteration.
   Vorgegangen wird nach folgenden Prinzipien:
   • Der Steuerungsfluß wird auf die Grundelemente zurückgeführt und konsequent von oben nach unten dargestellt. Explizite Rücksprünge im Steuerungsfluß sind nicht erlaubt.
   • Komplexe Aktionen werden schrittweise verfeinert.
   • Ein Grundelement kann beliebige weitere Grundelemente einschließen.
   Für die Arbeit mit Struktogrammen gilt folgende Orientierung:
   • Für die Darstellung der Abläufe in Unterprogrammen werden jeweils eigene Struktogramme angefertigt.
   • Ein Struktogramm sollte eine bestimmte Komplexität nicht überschreiten, um überschaubar zu bleiben.
     Als Orientierungspunkt kann genommen werden, daß der Mensch nicht mehr als fünf bis neun verschiedene Informationen gleichzeitig erfassen kann.

   Sequenz

   Eine Sequenz ist eine lineare Abfolge von Aktionen. Die Aktionen können elementarer oder auch komplexer Natur sein. Eine Sequenz wird prinzipiell nur einmal von oben nach unten durchlaufen.

   

   <anweisung> kann substituiert werden durch

   • eine einzelne Aktion (z.B. Wertzuweisung, Unterprogrammaufruf) oder
   • einen anderen Strukturblock der strukturierten Programmierung (damit werden Verzweigungen und Wiederholungen möglich).
   In einigen Sprachen sind Anweisungen stark zeilenorientiert, d.h. sie sind dem Zeilenende abgeschlossen, eine Fortsetzung der Anweisung auf einer neuen Zeile ist speziell zu markieren. In den meisten Sprachen sind jedoch mehrere Anweisungen pro Zeile erlaubt. Das Anweisungsende ist dann entweder stets explizit auszuweisen oder wird durch ein nachfolgendes Schlüsselwort erkannt. In vielen Sprachen dient das Semikolon als Endemarkierung bzw. als Trennzeichen.

   Ada
     x := x+1;        { Wertzuweisung }
     y := Sin(x);     { Funktionsaufruf }
     up(x,y,z);       { Unterprogrammaufruf }
   
   ALGOL 60, Simula
     x := x+1;        ! Wertzuweisung
     y := Sin(x);     ! Funktionsaufruf
     up(x,y,z);       ! Unterprogrammaufruf
   
   BASIC
     LET x = x + 1    ! Wertzuweisung
     LET y = Sin(x)   ! Funktionsaufruf
     CALL up(x,y,z)   ! Unterprogrammaufruf
   
   C, C++, Java
     x = x + 1;       /* oder:  x++;  */
     y = Sin(x);
     up(x,y,z);
   
   COBOL
     ADD 1 TO x
     PERFORM up
   
   Fortran
     x = x+1          ! Wertzuweisung
     y = Sin(x)       ! Funktionsaufruf
     CALL up(x,y,z)   ! Unterprogrammaufruf
   
   Modula-2, Oberon-2
     x := x+1;        (* Wertzuweisung *)
     y := Sin(x);     (* Funktionsaufruf *)
     up(x,y,z);       (* Unterprogrammaufruf *)
   
   Pascal
     x := x+1;        { Wertzuweisung }
     y := Sin(x);     { Funktionsaufruf }
     up(x,y,z);       { Unterprogrammaufruf }
   
   PL1
     x = x + 1;
     y = Sin(x);
     up(x,y,z);
   

   Verbundanweisung

   In einer Reihe von (vor allem älteren) Sprachen darf nach bestimmten syntaktischen Konstruktionen (z.B. THEN, ELSE, DO) nur eine einzige Anweisung stehen. Das Einfügen von Anweisungsfolgen an dieser Stelle ist dann mit Hilfe von sogenannten Verbundanweisungen möglich:
   Die Anweisungsfolge wird mit Hilfe spezieller Sprachsymbole eingeklammert und gilt dann syntaktisch wie eine einzige Anweisung.

   Ada, BASIC, Fortran, Modula-2, Oberon-2
     nicht erforderlich
   
   C, C++, Java
     { anweisung_1; ... anweisung_n; }
   
   Pascal, ALGOL-60, Simula
     BEGIN anweisung_1; ... anweisung_n; END
   
   PL1
     DO; anweisung_1; ... anweisung_n; END;
   

   Vereinfachung der Verwendung mehrstufiger Bezeichner

   In einer Reihe von Sprachen werden mehrstufige Bezeichner gebildet, z.B. bei der Arbeit mit Datenstrukturen (Records) oder mit Objekten:

     datensatz.komponente
     objekt.komponente
   

   Um die häufige Angabe der vorderen Namensstufen vermeiden zu können, kann für eine Folge von Anweisungen festgelegt werden, daß nichtidentifizierbare Bezeichner automatisch um solche Namensstufen ergänzt werden.

   Oberon-2
     WITH heute: datum DO
       Writeln(tag, monat, jahr)
     END;
   
     WITH
         figur: rectangle DO
           draw_rectangle(x1, y1, x2, y2)
       | figur: circle DO
           draw_circle(xm, ym, r)
     END;
   
   Pascal
     WITH heute DO
       Writeln(tag, monat, jahr);
                                                    anstelle von 
     Writeln(heute.tag, heute.monat, heute.jahr);
   

   Sequentielle Abarbeitung

   Anweisungen werden in der Reihenfolge ausgeführt, wie notiert sind.

   Zu beachten ist, daß unter bestimmten Umständen nicht alle Anweisungen ausgeführt werden !
   Dies ist z.B. beim Auftreten von Ausnahmesituationen (z.B. nicht aktives Ein- oder Ausgabegerät, fehlende Zugriffsrechte, unzulässige arithmetische Operation) der Fall.
   In solchen Situationen erfolgen oft Verzweigungen. Diese werden entweder explizit durch das Programm oder implizit durch das Laufzeitsystem der Sprache veranlaßt.
   Anschließend erfolgt die Programmfortsetzung an einer explizit festgelegten Stelle oder eine automatische Programmfortsetzung mit dem nächsten Befehl bzw. ein Programmabbruch.

   Kollaterale und parallele Abarbeitung

   Während bei einer sequentiellen Abarbeitung die Anweisungen in der Reihenfolge ihrer Notation ausgeführt werden, bleibt die Reihenfolge bei einer kollateralen Abarbeitung offen.
   Dies setzt natürlich voraus, daß die entsprechenden Aktionen unabhängig voneinander sind. Es kann dann - automatisch - versucht werden, die Abarbeitung so zu gestalten, daß sie "optimal" verläuft.
   Als Spezialfall der kollateralen Abarbeitung kann die parallele Abarbeitung aufgefaßt werden.

   Die wenigsten der gegenwärtig verfügbaren Sprachen unterstützen entsprechende Beschreibungsmittel.

   ALGOL 68
     BEGIN aktion_1; aktion_2; ... aktion_n END      sequentielle Abarb.
   
     BEGIN aktion_1, aktion_2, ... aktion_n END      kollaterale Abarb.
     ( aktion_1; aktion_2; ... aktion_n )            kollaterale Abarb.
     PAR( aktion_1; aktion_2; ... aktion_n )         parallele Abarb.
   
   OCCAM
     PAR              -- zwei Anweisungsblöcke können parallel ablaufen
       SEQ            -- Anweisungsblock 1 mit sequentieller Abarbeitung
         aktion_11
         aktion_12
       SEQ            -- Anweisungsblock 2 mit sequentieller Abarbeitung
         aktion_21
         aktion_22
   

   Selektion

   Bei der Selektion (Auswahl) können verschiedene Spezialsituationen unterschieden werden, für deren Darstellung jeweils spezielle Strukturblöcke zur Verfügung stehen.

   Alternative Auswahl (vollständige Alternative)

   

   In Abhängigkeit von der Auswertung der Bedingung werden alternative Aktionen ausgeführt.
   Die Formulierung komplexer Bedingungen ist im allgemeinen möglich.

   Pseudocode
     IF bedingung THEN
       anweisungsfolge_1
     ELSE
       anweisungsfolge_2
     END IF
   
   Ada
     IF bezahlt THEN
       ausliefern;
     ELSE
       mahnung;
     END IF;
   
   ALGOL-60, Simula
     IF bezahlt THEN
       ausliefern            ! einzelne Anweisung oder Verbundanweisung
     ELSE
       mahnung;              ! einzelne Anweisung oder Verbundanweisung
   
   ALGOL-68
     IF bezahlt THEN
       ausliefern;
     ELSE
       mahnung;
     FI;
                                              oder
     ( bezahlt | ausliefern | mahnung )
   
   BASIC
     IF bezahlt = 1 THEN
       CALL ausliefern
     ELSE
       CALL mahnung
     END IF
   
   C, C++, Java
     if ( bezahlt )
       ausliefern();         /* einzelne Anweisung oder Verbundanweisung */
     else
       mahnung();            /* einzelne Anweisung oder Verbundanweisung */
   
   COBOL 85
     IF bezahlt
       PERFORM ausliefern
     ELSE
       PERFORM mahnung
     END-IF
   
   Fortran
     IF ( bezahlt ) THEN
       CALL ausliefern
     ELSE
       CALL mahnung
     END IF
   
   Modula-2, Oberon-2
     IF bezahlt THEN
       ausliefern;
     ELSE
       mahnung;
     END;
   
   Pascal
     IF bezahlt THEN
       ausliefern           { einzelne Anweisung oder Verbundanweisung }
     ELSE
       mahnung;             { einzelne Anweisung oder Verbundanweisung }
   
   PL1
     IF bezahlt THEN
       CALL ausliefern;     /* einzelne Anweisung oder Verbundanweisung */
     ELSE
       CALL mahnung;        /* einzelne Anweisung oder Verbundanweisung */
   

   Bedingte Auswahl (unvollständige Alternative)

   

   Im Unterschied zur vollständigen Alternative wird nur dann eine Aktion ausgeführt, wenn die Bedingung erfüllt ist.

   Pseudocode
     IF bedingung THEN
       anweisungsfolge_1
     END IF
   
   Ada
     IF ( preis < 500 ) AND ( konto >= preis ) THEN
       bestellen;
     END IF;
   
   ALGOL-60, Simula
     IF preis < 500 AND konto >= preis THEN
       bestellen;             ! einzelne Anweisung oder Verbundanweisung
   
   ALGOL-68
     IF preis < 500 AND konto >= preis THEN
       bestellen
     FI;
   
   BASIC
     IF preis < 500 AND konto >= preis THEN
       CALL bestellen
     END IF
   
   C, C++, Java
     if (( preis < 500 ) && ( konto >= preis ))
       bestellen();          /* einzelne Anweisung oder Verbundanweisung */
   
   COBOL
     IF preis IS LESS THAN 500
       AND konto IS GREATER THAN OR EQUAL TO preis
         PERFORM bestellen
     END-IF
             oder
     IF preis < 500 AND konto >= preis
       PERFORM bestellen
     END-IF
   
   Fortran
     IF ( ( preis .LT. 500 ) .AND. ( konto .GE. preis ) ) THEN
       CALL bestellen
     END IF
   
   Modula-2, Oberon-2
     IF ( preis < 500 ) AND ( konto >= preis ) THEN
       bestellen;
     END;
   
   Pascal
     IF ( preis < 500 ) AND ( konto >= preis ) THEN
       bestellen;           { einzelne Anweisung oder Verbundanweisung }
   
   PL1
     IF ( preis < 500 ) & ( konto >= preis ) THEN
       CALL bestellen;    /* einzelne Anweisung oder Verbundanweisung */
   

   Fallauswahl

   

   Bei der Fallauswahl handelt es sich um eine Mehrfachverzweigung, die auch über eine Folge von ineinandergeschachtelten vollständigen Alternativen dargestellt werden kann. Um eine bessere Lesbarkeit zu erreichen, enthalten viele Programmiersprachen jedoch eigene Ausdrucksmittel. Die Verzweigung erfolgt in Abhängigkeit von dem Wert, der sich durch Auswertung des Ausdrucks ergibt.

   Pseudocode
     SELECT ausdruck
       CASE fall_1: anweisungsfolge_1
       CASE fall_2: anweisungsfolge_2
       ...
       ELSE anweisungsfolge_n
     END SELECT
   
   Ada
     CASE wochentag IS
       WHEN samstag => feiern;
       WHEN sonntag => ausruhen;
       WHEN OTHERS => arbeiten;
     END CASE;
   
   ALGOL-60, Simula
     Keine besonderen Sprachmittel verfügbar
   
   BASIC
     SELECT CASE wochentag
       CASE samstag
         CALL feiern
       CASE sonntag
         CALL ausruhen
       CASE ELSE
         CALL arbeiten
      END SELECT
   
   C, C++, Java
     switch ( wochentag ) {
       case samstag: feiern(); break;
       case sonntag: ausruhen(); break;
       default: arbeiten();
     }
   
   COBOL 85
     EVALUATE wochentag
       WHEN samstag
         PERFORM feiern
       WHEN sonntag
         PERFORM ausruhen
       WHEN OTHER
         PERFORM arbeiten
     END-EVALUATE
   
   Fortran
     SELECT CASE ( wochentag )             ! nicht in FORTRAN 77
       CASE ( samstag )
         CALL feiern
       CASE ( sonntag )
         CALL ausruhen
       CASE DEFAULT
         CALL arbeiten
      END SELECT
   
   Modula-2, Oberon-2
     CASE wochentag OF
         samstag: feiern;
       | sonntag: ausruhen;
       ELSE arbeiten;
     END;
   
   Pascal
     CASE wochentag OF
       samstag: feiern;
       sonntag: ausruhen;
       OTHERWISE arbeiten;               { Extended Pascal }
     END;
   
   PL1
     Keine besonderen Sprachmittel verfügbar
   

   Bei der Realisierung einer derartigen Fallauswahl in Programmiersprachen wird oft gefordert, daß der Ausdruck einen Wert liefert, der zu einem ordinalen Datentyp gehört.

   Für die Situationen, in denen sich die Selektionsbedingung nicht auf einen einfachen Ausdruck reduzieren läßt, gibt es in einer Reihe von Sprachen spezielle Ausdrucksmittel (meist Spezialformen der IF-THEN-ELSE-Anweisung).

   

   Pseudocode
     IF bedingung_1 THEN
       anweisungsfolge_1
     ELSIF bedingung_2 THEN
       anweisungsfolge_2
      ...
     ELSE
       anweisungsfolge_n
     END IF
   
   Ada
     IF (wochentag = samstag) AND ( konto > minimum ) THEN
       feiern;
     ELSIF (wochentag = sonntag) AND ( konto > minimum ) THEN
       ausruhen;
     ELSE
       arbeiten;
     END IF;
   
   ALGOL-60, Simula
     IF wochentag = samstag  AND  konto > minimum  THEN
       feiern
     ELSE IF wochentag = sonntag  AND  konto > minimum  THEN
       ausruhen
     ELSE
       arbeiten;
   
   BASIC
     IF wochentag = samstag AND konto > minimum THEN
       CALL feiern
     ELSEIF wochentag = sonntag AND konto > minimum THEN
       CALL ausruhen
     ELSE
       CALL arbeiten
     END IF
   
   C, C++, Java
     if ((wochentag == samstag) && ( konto > minimum ))
       feiern();
     else if ((wochentag == sonntag) && ( konto > minimum ))
       ausruhen();
     else
       arbeiten();
   
   COBOL 85
     EVALUATE TRUE
       WHEN wochentag = samstag AND konto > minimum
         PERFORM feiern
       WHEN wochentag = sonntag AND konto > minimum
         PERFORM ausruhen
       WHEN OTHER
         PERFORM arbeiten
     END-EVALUATE
   
   Fortran
     IF ((wochentag .EQ. samstag) .AND. ( konto .GT. minimum )) THEN
       CALL feiern
     ELSE IF((wochentag .EQ. sonntag) .AND. ( konto .GT. minimum )) THEN
       CALL ausruhen
     ELSE
       CALL arbeiten
     END IF
   
   Modula-2, Oberon-2
     IF (wochentag = samstag) AND ( konto > minimum ) THEN
       feiern;
     ELSIF (wochentag = sonntag) AND ( konto > minimum ) THEN
       ausruhen;
     ELSE
       arbeiten;
     END;
   
   Pascal
     IF (wochentag = samstag) AND ( konto > minimum ) THEN
       feiern
     ELSE IF (wochentag = sonntag) AND ( konto > minimum ) THEN
       ausruhen
     ELSE
       arbeiten;
   
   PL1
     IF (wochentag = samstag) & ( konto > minimum ) THEN
       CALL feiern
     ELSE IF (wochentag = sonntag) & ( konto > minimum ) THEN
       CALL ausruhen
     ELSE
       CALL arbeiten;
   

   Verzweigung bei Auftreten von Fehlern

   Durch einige Sprachen werden spezielle Sprachmittel bereitgestellt, um auf Ausnahmesituationen reagieren zu können. In anderen Sprachen sind die Möglichkeiten zur Ausnahmebehandlung systemabhängig.

   Ada
     Ausnahmen: CONSTRAINT_ERROR, NUMERIC_ERROR, PROGRAM_ERROR,
       STORAGE_ERROR, TASKING_ERROR
       STATUS_ERROR, MODE_ERROR, NAME_ERROR, USE_ERROR,
       DEVICE_ERROR, END_ERROR, DATA_ERROR
   
     BEGIN
         anweisungsfolge...
       EXCEPTION
         WHEN NUMERIC_ERROR =>
           Put("...");
         WHEN OTHERS =>
           Put("...");
     END;
   
   C, C++
     Viele Standardfunktionen liefern Rückkehrcodes, die auswertbar
     sind
   
   COBOL 85
     ADD wert1 wert2 GIVING ergebnis
       ON SIZE ERROR DISPLAY "Additionsfehler"
     END-ADD
   
   Fortran
     Ausnahmebehandlung bei Ein- und Ausgabeoperationen (einschließlich
     Dateiarbeit) ist im Sprachstandard (ab FORTRAN 77) vorgesehen
   
     READ(*,*,IOSTAT=io) n
     IF ( io .NE. 0 ) THEN
       WRITE(*,*) 'Eingabefehler'
     END IF
   
   PL1
     Unterschieden werden vier Gruppen von Unterbrechungsbedingungen:
     - Berechnungsbedingungen
       CONVERSION     Versuch einer nicht erlaubten Konvertierung
       FIXEDOVERFLOW  Wertebereichsüberschreitung bei Festpunktoperation
       OVERFLOW       Exponent wird bei Gleitpunktoperation zu groß
       UNDERFLOW      Exponent wird bei Gleitpunktoperation zu klein
       ZERODIVIDE     Division durch Null
       SIZE           Verlust signifikanter Stellen
     - Ein- und Ausgabebedingungen
       ENDFILE        Dateiende bei sequentiellem Lesen erreicht
       ENDPAGE        Überschreiten der Seitenbegrenzung bei Ausgabe
       RECORD         Fehler bei satzweiser Ein- oder Ausgabe
     - Programmprüfungsbedingungen
     - sonstige Unterbrechungen
   
     Beispiel:
     ON ZERODIVIDE CALL error(0);
   

   Iteration

   Die wiederholte Ausführung von bestimmten Aktionen (Iteration, Zyklus, Schleife) kann auf verschiedenen Wegen realisiert werden. Dabei ist zu unterscheiden
   • ob die Anzahl der Wiederholungen vor Beginn der Iteration feststeht oder abhängig von den auszuführenden Aktionen ist,
   • an welcher Stelle über Abbruch bzw. Weiterführung der Iteration entschieden wird.

   Abweisschleife

   

   Es wird eine Wiederholbedingung formuliert. Der Anweisungsteil wird solange ausgeführt, wie diese Bedingung erfüllt ist. Auf Grund der Position der Bedingung kann es auftreten, daß der Anweisungsteil der Iteration völlig übergangen wird.

   Pseudocode
     WHILE bedingung DO
       anweisungsfolge
     END WHILE
   
   Ada
     WHILE konto > minimum LOOP
       bestellen;
     END LOOP;
   
   ALGOL-60, Simula
     WHILE konto > minimum DO            ! nur Simula
       bestellen;
   
     FOR p:=q WHILE Abs(q) >= eps DO
       q := p*p;
   
   BASIC
     DO WHILE konto > minimum    oder    DO UNTIL konto <= minimum
       CALL bestellen                      CALL bestellen
     LOOP                                LOOP
   
   C, C++, Java
     while ( konto > minimum )
       bestellen();
   
   COBOL
     PERFORM WITH TEST BEFORE UNTIL konto <= minimum
       ...
     END-PERFORM
   
   Fortran
     DO WHILE ( konto .GT. minimum )
       CALL bestellen
     END DO
   
   Modula-2, Oberon-2
     WHILE konto > minimum DO
       bestellen;
     END;
   
   Pascal
     WHILE konto > minimum DO
       bestellen;
   
   PL1
     DO WHILE ( konto > minimum );
       CALL bestellen;
     END;
   

   Nichtabweisschleife

   

   Es wird eine Abbruchbedingung formuliert. Der Anweisungsteil wird solange ausgeführt, bis diese Bedingung erfüllt ist. Auf Grund der Position der Bedingung wird der Anweisungsteil der Iteration immer mindestens einmal ausgeführt.
   Meist wird die Bedingung als Abbruchbedingung formuliert, mitunter ist jedoch auch eine Wiederholbedingung anzugeben.

   Pseudocode
     REPEAT
       anweisungsfolge
     UNTIL bedingung
   
   Ada
     LOOP
       bestellen;
       EXIT WHEN konto < minimum;
     END LOOP;
   
   ALGOL-60, Simula
     Keine besonderen Sprachmittel verfügbar
   
   BASIC
     DO                           oder   DO
       CALL bestellen                      CALL bestellen
     LOOP UNTIL konto < minimum          LOOP WHILE konto >= minimum
   
   C, C++, Java
     do
       bestellen();
     while ( konto >= minimum );
   
   COBOL
     PERFORM WITH TEST AFTER UNTIL konto < minimum
       ...
     END-PERFORM
   
   Fortran
     DO                                   ! FORTRAN 90
       CALL bestellen
       IF ( konto .LT. minimum ) EXIT
     END DO
   
   Modula-2, Oberon-2
     REPEAT
       bestellen;
     UNTIL konto < minimum;
   
   Pascal
     REPEAT
       bestellen;
     UNTIL konto < minimum;
   

   Verallgemeinerter Zyklus mit Austrittsbedingung

   

   Es wird eine Austrittsbedingung formuliert: Der Zyklus wird beendet, wenn die Austrittsbedingung erfüllt ist.
   Während der erste Anweisungsteil wird immer mindestens einmal ausgeführt wird, muß dies für den zweiten Anweisungsteil nicht gelten.

   Pseudocode
     LOOP
       anweisungsfolge_1
       WHEN bedingung THEN EXIT
       anweisungsfolge_2
     END LOOP
   
   Ada
     LOOP
       bestellen_1;
       EXIT WHEN rechnungsbetrag > maximum;
       bestellen_2;
     END LOOP;
   
   ALGOL-60, Simula
     Keine besonderen Sprachmittel verfügbar
   
   BASIC
     DO
       CALL bestellen_1
       IF rechnungsbetrag > maximum THEN EXIT DO
       CALL bestellen_2
     LOOP
   
   C, C++, Java
     for(;;) {
       bestellen_1();
       if ( rechnungsbetrag > maximum ) break;
       bestellen_2();
     }
   
   Fortran
     DO                                         ! FORTRAN 90
       CALL bestellen_1
       IF ( rechnungsbetrag .GT. maximum ) EXIT
       CALL bestellen_2
     END DO
   
   Modula-2, Oberon-2
     LOOP
       bestellen_1;
       IF rechnungsbetrag > maximum THEN EXIT END;
       bestellen_2;
     END;
   
   Turbo Pascal 7.0
     WHILE ( TRUE ) DO BEGIN
       bestellen_1;
       IF rechnungsbetrag > maximum THEN Break;
       bestellen_2;
     END;
   

   Verallgemeinerter Zyklus mit Auslassungsbedingung

   

   Es wird eine Auslassungsbedingung formuliert: Der Zyklus wird mit der Abarbeitung von Anweisungsteil 1 fortgesetzt, Anweisungsteil 2 wird - im aktuellen Wiederholungsschritt - ausgelassen.
   Während der erste Anweisungsteil wird immer mindestens einmal ausgeführt wird, muß dies für den zweiten Anweisungsteil nicht gelten.
   Für diesen Spezialfall stellen nur relativ wenige Sprachen gesonderte Mittel bereit.

   Pseudocode
     LOOP
       anweisungsfolge_1
       WHEN bedingung THEN CONTINUE
       anweisungsfolge_2
     END LOOP
   
   C, C++, Java
     for(;;) {
       bestellen_1();
       if ( rechnungsbetrag > maximum ) continue;
       bestellen_2();
     }
   
   Fortran
     DO                                            ! FORTRAN 90 
       CALL bestellen_1
       IF ( rechnungsbetrag .GT. maximum ) CYCLE
       CALL bestellen_2
     END DO
   
   Turbo Pascal 7.0
     WHILE ( TRUE ) DO BEGIN
       bestellen_1;
       IF rechnungsbetrag > maximum THEN Continue;
       bestellen_2;
     END;
   

   Zählschleife

   Bei der Zählschleife steht die Anzahl der Wiederholungen vorab fest. Die Iteration wird über eine Laufvariable gesteuert. Der Laufvariablen wird zunächst ein Anfangswert zugewiesen, der solange um den Wert der Schrittweite erhöht wird, bis der Endwert erreicht ist.
   Meist hat die Laufvariable den Datentyp Integer (oder einen anderen ordinalen Datentyp) und es wird standardmäßig mit der Schrittweite 1 gearbeitet.

   Pseudocode
     FOR laufvariable:=anfangswert TO endwert STEP schrittweite DO
       anweisungsfolge
     END FOR
   
   Ada
     FOR i IN 1..n LOOP                -- i = 1, 2, ..., n-1, n
       kaufe(produkt(i));
     END LOOP;
   
   ALGOL-60, Simula
     FOR i:=1 STEP 1 UNTIL n DO        ! i = 1, 2, ..., n-1, n
       kaufe(produkt[i]);
   
     FOR i:=n STEP -1 UNTIL 1 DO       ! i = n, n-1, ..., 2, 1
       count_down(i);
   
     FOR i:=1,3,7,15 DO                ! i = 1, 3, 7, 15
       do_something(i);
   
   ALGOL-68
     FOR i FROM 1 TO n DO              ! i = 1, 2, ..., n-1, n
       kaufe(produkt[i]);
   
     FOR i FROM n BY -1 TO 1 DO        ! i = n, n-1, ..., 2, 1
       count_down(i);
   
   BASIC
     FOR i=1 TO n                      ! i = 1, 2, ..., n-1, n
       CALL kaufe(produkt(i))
     NEXT i
   
     FOR i=n TO 1 STEP -1              ! i = n, n-1, ..., 2, 1
       CALL count_down(i)
     NEXT i
   
   C, C++, Java
     for ( i=1; i<=n; i++ )            /* i = 1, 2, ..., n-1, n */
       kaufe(produkt[i]);
   
     for ( i=n; i>=1; i-- )            /* i = n, n-1, ..., 2, 1 */
       count_down(i);
   
   COBOL 85
     MOVE 0 TO i
     PERFORM n TIMES
       ADD 1 TO i
       ...
     END-PERFORM
   
     PERFORM WITH TEST BEFORE
       VARYING i FROM n BY -1 UNTIL i = 0
       ...
     END-PERFORM
   
   Fortran
     DO 1 i = 1,n                      ! i = 1, 2, ..., n-1, n
       CALL kaufe(produkt(i))
     1 CONTINUE
   
     DO i = n,1,-1                     ! i = n, n-1, ..., 2, 1
       CALL count_down(i)              ! Fortran 90
     END DO
   
   Modula-2, Oberon-2
     FOR i := 1 TO n DO                (* i = 1, 2, ..., n-1, n *)
       kaufe(produkt[i]);
     END;
   
     FOR i := n TO 1 BY -1 DO          (* i = n, n-1, ..., 2, 1 *)
       count_down(i);
     END;
   
   Pascal
     FOR i := 1 TO n DO                { i = 1, 2, ..., n-1, n }
       kaufe(produkt[i]);
   
     FOR i := n DOWNTO 1 DO            { i = n, n-1, ..., 2, 1 }
       count_down(i);
   
   PL1
     DO i = 1 TO n;                    /* i = 1, 2, ..., n-1, n */
       CALL kaufe(produkt[i]);
   
     DO i := n TO 1 BY -1;             /* i = n, n-1, ..., 2, 1 */
       CALL count_down(i);
   

   Anstelle des Datentyps Integer ist gegebenenfalls auch ein ordinaler Datentyp möglich. Bei Verwendung eines reellen Datentyps - meistens ist dies nicht zugelassen - ist auf die eventuelle Auswirkung von Rundungsfehlern beim Aufsummieren der Schrittweite zu achten.
   In der Regel werden Zählschleifen als Abweisschleifen realisiert, es sind jedoch auch Realisierungen bekannt, die mit einer Nichtabweisschleife arbeiten (Fortran 66). Die Art der Realisierung ist immer dann von Bedeutung, wenn bereits mit dem Anfangswert der Endwert erreicht wurde.

   Sprunganweisungen

   Die Verwendung von expliziten Sprüngen kann in modernen höheren Programmiersprachen prinzipiell vermieden werden und ist in manchen Sprachen auch nicht möglich. Die Vermeidung von expliziten Sprüngen fördert im Normalfall die Übersichtlichkeit von Programmen. In Ausnahmesituationen kann gegebenenfalls die sparsame und gezielte Anwendung von Sprunganweisungen zu einer einfacheren Programmstruktur bzw. zu effektiverem Programmcode führen. Prinzipiell sollte jedoch immer zuerst nach einer einfachen Lösung gesucht werden, die einen expliziten Sprung vermeidet.

   Das Ziel einer Sprunganweisung kann immer nur eine Anweisung der gleichen Programmeinheit sein, die entsprechende Anweisung muß eine Marke (label) tragen.

   Ada
     GOTO marke;         -- marke: Bezeichner
   
   ALGOL-60, Simula
     GOTO marke;         ! marke: Bezeichner
   
   BASIC
     GOTO zeilennummer
   
   C, C++
     goto marke;         /* marke: Bezeichner */
   
   COBOL
     GOTO marke;
   
   Fortran
     GOTO marke          ! marke: maximal fünfstellige Ziffernfolge
   
   Modula-2, Oberon-2, Java
     ein GOTO-Befehl ist nicht verfügbar
   
   Pascal
     GOTO marke;         { marke: zu deklarierender ganzzahliger Wert }
   
   PL1
     GOTO marke;         /* marke: Bezeichner */
   

   Ältere Sprachen lassen mitunter bedingte Sprunganweisungen zu. Zu erkennen ist in diesen Sprachen noch die Nähe zur maschinennahen Programmierung, die nicht zuletzt auch den damals sehr knappen Ressourcen an Rechenzeit und Speicherplatz geschuldet ist.

   ALGOL-60, Simula
     GOTO IF bedingung THEN marke1 ELSE marke2;
   
     SWITCH verteiler := marke_1, ..., marke_n;
     ...
     GOTO verteiler[i];
   
   FORTRAN
     ASSIGN marke TO marken_var
     ...
     GOTO marken_var
   

   Bemerkung: In einigen Sprachen vorhandene Befehle wie Break, Continue, Exit sind spezielle Formen des Sprungsbefehls, die jeweils an einen speziellen Einsatzzweck gebunden sind und damit eine bessere Lesbarkeit des Programms garantieren als ein undifferenziertes Goto.

   ---

   P. Böhme, 29.07.1996