Kontrollstruktur

	Dieser Artikel wurde im Portal Informatik zur Verbesserung eingetragen. Hilf mit, ihn zu bearbeiten, und beteilige dich an der Diskussion!
Vorlage:Portalhinweis/Wartung/Informatik

Lemma seit zehn Jahren ungeklärt (siehe Diskussionsseite). --Gebu (Diskussion) 18:34, 4. Jan. 2021 (CET)

Kontrollstrukturen sind in der Informatik die Vorgabe, in welcher Reihenfolge die Handlungsschritte eines Algorithmus‘ abgearbeitet werden. In imperativen Programmiersprachen werden sie durch Kontrollanweisungen (Steuerkonstrukte) implementiert. Mit Kontrollstrukturen können Programme auf verschiedene Zustände reagieren, indem Programmteile nur bedingt (bedingte Anweisung) oder wiederholt (Schleife) ausgeführt werden.

Struktogramm

Konventionelle Programmiermodelle und -sprachen konstruieren Algorithmen mit Hilfe folgender Kontrollstrukturen:

• Sequenz: die Anweisungen werden linear ausgeführt.
• Bedingte Anweisung und Verzweigung: die Anweisungen werden nur bei einem bestimmten Zustand ausgeführt.
• Schleife oder Iteration: die Anweisungen werden nur solange ausgeführt wie oder bis ein bestimmter Zustand erreicht wird.
• Rekursion: Bei der rekursiven Programmierung ruft sich eine Prozedur, Funktion oder Methode in einem Computerprogramm selbst wieder auf.

Das Programmierparadigma der Strukturierten Programmierung beinhaltet neben dem Paradigma der prozeduralen Programmierung die Beschränkung auf lediglich drei Kontrollstrukturen Sequenz, Verzweigung und Schleifen.

Die Verwendung von Kontrollstrukturen verhindert das Entstehen von Quelltext, bei dem auf unübersichtliche Weise hin- und hergesprungen wird, dem sogenannten Spaghetti-Code. Die folgenden Merkmale kennzeichnen ein Programm bei Verwendung von Kontrollstrukturen:

• Anweisungen, die wiederholt werden, sind durch Schlüsselwörter klar gekennzeichnet
• Bedingungen und Wiederholungen sind sofort erkennbar
• Vermeidung von Goto und Sprungmarken.

Visualisierung

Kontrollstrukturen können mittels Diagrammen visualisiert werden.

Flussdiagramm

Aktuell gebräuchlich sind hierfür die UML-Sequenzdiagramme als Weiterentwicklung der Struktogrammen (Nassi-Shneiderman-Diagrammen).

In Struktogrammen wird die Kontrollstruktur durch entsprechende Symbole für Verzweigung und Schleife deutlicher. Struktogramme lassen sich dann in einen strukturierten Programmcode umsetzen.

Kontrollanweisungen

Kontrollanweisungen sind Anweisungen, die die Kontrollstruktur implementieren:

• Entscheidungsanweisungen: Diese suchen auf Grund einer Bedingung einen Programmfluss heraus. Man spricht hier auch von einem Zweig, denn der Programmfluss verzweigt in verschiedene Varianten.
• Iterationsanweisungen: Diese wiederholen eine bestimmte Anzahl an Anweisungen.
• Sprunganweisungen: Diese verlassen eine Struktur.

Folgende Programmiersprachen eignen sich unter anderem zur strukturierten Programmierung:

• Ada
• Algol
• C und C++
• C#
• COBOL (ab COBOL 85)
• Fortran (ab Fortran 77)
• Java
• Pascal, Modula-2, Oberon und Component Pascal
• Python
• Visual Basic
• Go (Programmiersprache)

Sprung- und Entscheidungsanweisungen

Ohne Kontrollstrukturen müssen Wiederholungen und Bedingungen durch Sprünge (GOTO, IF … GOTO – englisch: springen zu, Wenn … springen zu) realisiert werden. Die Ausgabe der Zahlen von 1 bis 100, jedoch ohne den Bereich 40 bis 60, wird ohne Kontrollstruktur etwa so realisiert (Pseudocode, in Anlehnung an BASIC)

     I := 1
 M1: PRINT I                  -- Ausgabe von I
     IF I=39 THEN GOTO M2     -- Wenn ... springen (bedingte Ausführung)
     I := I+1
     IF I<=100 THEN GOTO M1   -- Wenn ... springen (wiederholte Ausführung)
     END                      -- Programmende
 M2: I := 61
     GOTO M1                  -- Sprung nach M1

Iterationsanweisungen

Unstrukturiertes Programm: Ausgabe der Zahlen 1, 2, ..., 39, 61, 62, 63, ..., 99, 100

Die Verwendung von Kontrollstrukturen ist auch Bestandteil der strukturierten Programmierung. Jede Kontrollstruktur besteht wenigstens aus einem Anfangs- und meistens einem Endeschlüsselwort. Sprachen wie Pascal, C, Modula-2 (und auch neuere Varianten der Sprache BASIC) verfügen über Kontrollanweisungen für Wiederholungen

     REPEAT
       ''Anweisungen''
     UNTIL ''Bedingung''

und bedingte Ausführung von Anweisungen:

     IF ''Bedingung'' THEN
        ''Anweisungen''
     ELSE
        ''Anweisungen''
     ENDIF

Die Schlüsselwörter rahmen dabei die Anweisungen ein, die mehrfach oder bedingt ausgeführt werden. Die obenstehende Programmieraufgabe kann dann folgendermaßen realisiert werden:

     I := 1
     REPEAT              -- Wiederhole
        PRINT I
        IF I=39 THEN     --    Wenn ... Dann
           I := 61
        ELSE             --    Sonst
           I := I+1
        ENDIF            --    EndeWenn
     UNTIL I>100         -- bis
     END                 -- Programmende

Strukturiertes Programm: Ausgabe der Zahlen 1, 2, ..., 39, 61, 62, 63, ..., 99, 100

Das Programm erhält eine Struktur, welche meist noch durch Einrückungen verdeutlicht wird. Die neuen Schlüsselwörter und die Formatierung erleichtern das Verständnis des Programmcodes.

Entwicklung

Kontrollstrukturen helfen Sprünge mit Goto zu vermeiden, da fast jede Programmieraufgabe mit Hilfe von Bedingungs- und Wiederholungsstrukturen gelöst werden kann. Programmierung ohne Goto unter Verwendung einer modernen Sprache ist heute der Normalfall. Die Programmiersprache Java unterstützt z. B. keine Goto-Anweisung mehr.

In den frühen 1960er Jahren waren Flussdiagramme und Sprunganweisungen in Programmen üblich, was größere Programme nahezu unwartbar machte, da sie schnell unüberschaubar wurden. 1968 sprach sich Edsger W. Dijkstra in seinem Aufsatz Go To Statement Considered Harmful (der Titel geht allerdings auf Niklaus Wirth zurück), für eine Abschaffung des GOTO-Befehls in allen höheren Programmiersprachen aus.

Im Mai 1966 publizierten Böhm und Jacopini in der Zeitschrift Communications of the ACM einen Artikel, in dem sie zeigten, dass jedes Programm, das Goto-Anweisungen enthält, in ein Goto-freies Programm umgeschrieben werden kann, das nur mit Verzweigung (IF THEN ELSE) und einer Schleife (WHILE Bedingung DO Anweisung) arbeitet, gegebenenfalls unter Zuhilfenahme von etwas Code-Doppelung und der Einführung von booleschen Variablen (true/false).

Anfang der 1970er Jahre wurde damit begonnen, diesen Ansatz zur Selbstbeschränkung auf wenige, typische Elemente umzusetzen. Wegweisend war die Arbeit von Niklaus Wirth mit seiner Programmiersprache Pascal.