imported>Aka: Tippfehler entfernt, Links optimiert, Kleinkram

2025-06-22T16:26:32Z

Tippfehler entfernt, Links optimiert, Kleinkram

Neue Seite

'''Kontrollstrukturen''' sind in der Informatik die Vorgabe, in welcher Reihenfolge die Handlungsschritte eines [[Algorithmus]] abgearbeitet werden. In [[Imperative Programmiersprache|imperativen Programmiersprachen]] werden sie durch [[Kontrollanweisung|'''Kontrollanweisungen''']] ('''Steuerkonstrukte''') implementiert. Mit Kontrollstrukturen können Programme auf verschiedene Zustände reagieren, indem Programmteile nur bedingt ([[Bedingte Anweisung und Verzweigung|bedingte Anweisung]]) oder wiederholt ([[Schleife (Programmierung)|Schleife]]) ausgeführt werden.<ref>{{Literatur |Autor=Reisig, Wolfgang, 1950-, Freytag, Johann Christoph, 1954- |Hrsg= |Titel=Informatik : aktuelle Themen im historischen Kontext |Verlag=Springer |Ort=Berlin |Datum=2006 |ISBN=978-3-540-32743-1 |Seiten=278}}</ref>
[[Datei:Struktogramm.png|mini|Struktogramm]]

== Geschichtliche Entwicklung ==
Kontrollstrukturen helfen, Sprünge mit [[Sprunganweisung|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 (Programmiersprache)|Java]] unterstützt z. B. keine [[Sprunganweisung|Goto]]-Anweisung mehr.

[[Heinz Rutishauser]] entwickelte von 1949 bis 1951 die einfache algebraische Programmiersprache „[[Superplan]]“. Rutishauser kannte [[Konrad Zuse]]s Arbeit über Programmiersprachen, d. h. Zuses [[Plankalkül]] und wählte den Namen in Anlehnung an Zuses Bezeichnung „Rechenplan“ für ein einzelnes Programm. Rutishausers einfache Sprache hatte nur eine Kontrollstruktur: die '''Für'''-Schleife.
'''Für''' i=2(''1'')n: <math>a_i </math> + 3 = <math>a_i </math>
In den frühen 1960er Jahren waren Flussdiagramme und [[Sprunganweisung]]en in Programmen üblich, was größere Programme nahezu [[Wartbarkeit|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.<ref>{{Literatur |Autor=Edsger W. Dijkstra |Titel=Letters to the editor: Go To Statement Considered Harmful |Sammelwerk=Communications of the ACM |Band=11 |Nummer=3 |Datum=1968-03 |Seiten=147–148 |DOI=10.1145/362929.362947}}</ref>

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-[[Anweisung (Programmierung)|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 (Programmiersprache)|Pascal]].

== Kontrollstrukturen ==
Konventionelle Programmiermodelle und -sprachen konstruieren Algorithmen mit Hilfe folgender Kontrollstrukturen:<ref>{{Literatur |Autor=Reisig, Wolfgang, 1950-, Freytag, Johann Christoph, 1954- |Hrsg= |Titel=Informatik : aktuelle Themen im historischen Kontext |Verlag=Springer |Ort=Berlin |Datum=2006 |ISBN=978-3-540-32743-1 |Seiten=301}}</ref>

* Sequenz: die Anweisungen werden linear ausgeführt.
* [[Bedingte Anweisung und Verzweigung]]: die Anweisungen werden nur bei einem bestimmten Zustand ausgeführt.
* [[Schleife (Programmierung)|Schleife]] oder Iteration: die Anweisungen werden nur solange ausgeführt wie oder bis ein bestimmter Zustand erreicht wird.
* [[Rekursion]]: Bei der [[Rekursive Programmierung|rekursiven Programmierung]] ruft sich eine [[Prozedur (Programmierung)|Prozedur]], [[Funktion (Programmierung)|Funktion]] oder [[Methode (Programmierung)|Methode]] in einem [[Computerprogramm]] selbst wieder auf.
* [[Blockstruktur]]: Mehrere Anweisungen werden „gruppiert“ und beschränken ggf. den Gültigkeitsbereich bestimmter Variablen oder Aktionen.
Das [[Programmierparadigma]] der [[Strukturierte Programmierung|Strukturierten Programmierung]] beinhaltet neben dem Paradigma der [[Prozedurale Programmierung|prozeduralen Programmierung]] die Beschränkung auf lediglich drei Kontrollstrukturen Sequenz, Verzweigung und Schleifen.

Die strukturierte Programmierung verhindert das Entstehen von [[Quelltext]], bei dem auf unübersichtliche Weise hin- und hergesprungen wird, dem sogenannten [[Spaghetticode|Spaghetti-Code]]. Die folgenden Regeln dienen der Nutzung von Kontrollstrukturen:
* Anweisungen, die wiederholt werden, sind durch Schlüsselwörter klar gekennzeichnet.
* Bedingungen und Wiederholungen sind sofort erkennbar.
* Sprunganweisungen und [[Sprungmarke]]n werden vermieden.

== Kontrollanweisungen ==
'''Kontrollanweisungen''' (auch '''Kontrollflussanweisungen''', '''Steuerkonstrukte''') sind Anweisungen, die eine Kontrollstruktur implementieren.<ref>{{Literatur |Autor=Steyer, Ralph, |Hrsg= |Titel=Programmierung in Python : Ein kompakter Einstieg für die Praxis |Ort=Wiesbaden |Datum= |ISBN=978-3-658-20705-2 |Seiten=87}}</ref>

=== Blockstrukturanweisung (Sequenz) ===
Blockstrukturanweisungen kennzeichnen Beginn und Ende einer [[Blockstruktur]] (Sequenz) und strukturieren damit Programmteile. In [[Pascal (Programmiersprache)|Pascal]] oder [[Visual Basic .NET|Visual Basic]] werden sie mit <code>begin ... end</code> gekennzeichnet, in einigen Programmiersprachen werden sie durch Klammernpaare gekennzeichnet. Im Quelltext werden die Anweisungen einer Sequenz einheitlich eingerückt, um die Blockstruktur besser sichtbar zu machen. In [[Python (Programmiersprache)|Python]] wird auf Blockstrukturanweisungen verzichtet; die Zugehörigkeit von Anweisungen zu Blöcken wird hier allein durch [[Einzug (Typografie)|Einrückung]] gekennzeichnet.

=== Bedingte Anweisung ===
{{Hauptartikel|Bedingte Anweisung und Verzweigung}}
Eine Bedingte Anweisung ist eine Anweisung, die nur bei der Erfüllung einer bestimmten Bedingung ausgeführt wird. Durch sie kann ein [[Computerprogramm|Programm]] auf unterschiedliche Zustände und Benutzereingaben reagieren. Eine Bedingte Anweisung besteht aus einer Bedingungsprüfung und der eigentlichen Anweisung <code>IF <Bedingung> THEN <Anweisung></code>. Nur dann, wenn eine Bedingung erfüllt ist, wird die Anweisung ausgeführt. Koppelt man eine Bedingungsprüfung und einen Sprungbefehl <code>if bedingung then methode()</code>, so erhält man eine Verzweigung, bei der eine Methode nur bei positiver Auswertung des Bedingungsausdrucks (<code>TRUE</code>) ausgeführt wird. Durch die Prüfung des Zustands einer Zählervariable können auch Schleifen implementiert werden.

=== Verzweigung (Alternative) ===
Für eine alternative Verzweigung bieten viele Programmiersprachen das IF-THEN-ELSE Konstrukt in der Form <code>IF <Bedingung> THEN <Anweisung1> ELSE <Anweisung2></code>. Bei positiver Bedingung wird Anweisung1 ausgeführt. In allen anderen Fällen (ELSE) wird Anweisung2 ausgeführt. So kann ein Programm beispielsweise abhängig von einer Eingabe zwei unterschiedliche Methoden aufrufen. Viele Sprachen erlauben weitere Prüfungen und damit verbundene alternative Verzweigungen in der Form <code>IF [[ELIF],..] ELSE</code> oder ein Konstrukt aus <code>Case</code>- und <code>Switch</code>-Anweisungen.

<u>Beispiel in Python</u> (Die Funktion vorzeichen ermittelt das Vorzeichen des Ausdrucks i):
<syntaxhighlight lang="python">
def vorzeichen(i):
if i>0: #Bedingung
return "positiv +" #bedingte Anweisung1
elif i<0: #weitere Bedingung
return "negativ -" #bedingte Anweisung2
else #anderenfalls
return "neutral 0" #bedingte Anweisung3

</syntaxhighlight>

=== Schleife (Wiederholung, Iterationsanweisung) ===
{{Hauptartikel|Schleife (Programmierung)}}
Schleifen dienen dazu, [[Blockstruktur|Anweisungs-Blöcke]] wiederholt auszuführen. Es gibt viele Erscheinungsformen von Schleifen:

* [[For-Schleife|Zählschleifen (<code>for</code>-Schleife]])
* [[While-Schleife|Bedingungsgesteuerte Schleifen (<code>while</code>-Schleife]])
* [[Foreach|Mengengesteuerte Schleifen (<code>for..in</code> bzw. <code>foreach</code>-Schleife)]]
* [[Endlosschleife (Programmierung)|Endlosschleife]]n
<u>Beispiel in Python</u> (Für die Zahlen −5, 2, 0 und 1000 wird nacheinander das jeweilige Vorzeichen ausgegeben):
<syntaxhighlight lang="python">
for i in (-5,2,0,1000):
print (vorzeichen(i))

</syntaxhighlight>
In den Schleifen gibt es je nach Programmiersprache Anweisungen
* zum vorzeitigen Verlassen von Schleifen (<code>break</code>)
* zur Fortsetzung mit der nächsten Iteration (<code>continue</code>)
* zur Wiederholung der aktuellen Iteration (<code>retry</code>) oder
* zum erneuten Starten der Schleife (<code>redo</code> [[Ruby (Programmiersprache)]])

[[List Comprehension|List-Comprehensions]] erzeugen [[Menge (Datenstruktur)|Mengen]] mit Schleifen- und Bedingungskonstrukten:
<syntaxhighlight lang="python">
m = [x**2 for x in range(12) if x%2 == 0] #ergibt die Quadratzahlen aus geraden x
</syntaxhighlight>

=== Sprunganweisung ===
{{Hauptartikel|Sprunganweisung}}
Die Anweisungen in einer Sequenz werden sequentiell, also nacheinander, abgearbeitet. Bei einem Sprung wird eine durch Adresse oder durch Label festgelegte Sprungmarke angesprungen und der Programmverlauf dort fortgesetzt.

Bedingte Sprunganweisungen (im Maschinencode) sind meist die Grundlage für bedingte Ausführung sowie Schleifen (in der Hochsprache);
unbedingte Sprunganweisungen (im Maschinencode) sind meist die Grundlage für Funktionsaufrufe oder Endlosschleifen.

Beim Aufruf eines Unterprogramms wird zunächst abgespeichert, wohin nach dem Ende des Unterprogramms zurückzukehren ist. Anschließend müssen ggf. Aufrufparameter an eine vereinbarte Stelle gelegt werden; erst danach kann das Unterprogramm angesprungen werden.

Die Verwendung von Sprunganweisungen in Hochsprachen ist [[Sprunganweisung#Umstrittene Verwendung von GOTO|umstritten]], da sie schnell zu Spaghetticode führen kann. Sprunganweisungen lassen sich (in Hochsprachen) durch andere Kontrollstrukturen ersetzen.

=== Rücksprung ===
{{Hauptartikel|Rücksprung}}
Wird bei einem Sprungbefehl ein Unterprogramm oder eine andere Methode aufgerufen, so kann diese mittels <code>return</code> wieder verlassen und das Programm direkt nach dem Absprungpunkt fortgesetzt werden. Dabei können sogenannte [[Rückgabewert]]e übergeben werden.

=== Ereignis- und Ausnahmebehandlung ===
{{Hauptartikel|Ausnahmebehandlung}}
Mit der Ausnahmebehandlung kann ein Programm die Kontrolle bei bestimmten Programmzuständen – meistens Fehlerzuständen – an andere Programmebenen zur Weiterbehandlung weiterzureichen. Ausnahmen oder Exceptions haben in weiten Teilen die Behandlung von Fehlern mittels Fehlercodes oder Sprunganweisungen abgelöst.

== Grafische Darstellung ==
[[Datei:UML-Diagramme.svg|mini|UML-Diagramme]]
Kontrollstrukturen können mittels [[Diagramm]]en visualisiert und modelliert werden.
[[Datei:Flowchart de.svg|mini|Flussdiagramm]]
Aktuell gebräuchlich sind hierfür die [[UML]]-[[Sequenzdiagramm|''Sequenzdiagramme'']] als Weiterentwicklung der [[Struktogramm|''Struktogramme'']] ([[Nassi-Shneiderman-Diagramm|''Nassi-Shneiderman-Diagramme'']]) und UML-[[Aktivitätsdiagramm|''Aktivitätsdiagramme'']] als Weiterentwicklung der [[Flussdiagramm]]e (''Flow Charts'', nach [[ISO 5807]]) bzw. der spezifischeren [[Programmablaufplan|''Programmablaufpläne'']] (sogenannter '''''PAP'''s'', nach DIN 66001).

In Struktogrammen wird die Kontrollstruktur durch entsprechende Symbole für Verzweigung und Schleife deutlicher.

Hierdurch wird nicht nur das Verständnis für Programmabläufe geschult sowie deren Fehlersuche erleichtert, sondern ebenso die Kommunikation darüber mit Personen außerhalb des Bereichs der Softwareentwicklung bzw. ohne Programmiersprachen-Kenntnisse ermöglicht, ohne dass diese eingearbeitet werden müssen. Die grafische Darstellung der Abläufe ist hierbei intuitiver und fehlerfreierer verständlich, als dies beispielsweise eine ebenfalls programmiersprachenunabhängige aber textuelle Beschreibung in sogenanntem [[Pseudocode|''Pseudo-Code'']] leisten kann.

Struktogramme lassen sich dann in einen [[Strukturierte Programmierung|strukturierten Programmcode]] umsetzen.

== Weitere Kategorisierungen ==
Die Arten von Kontrollflussanweisungen, die von verschiedenen Sprachen unterstützt werden, variieren, können nach ihrer Wirkung kategorisiert werden:

* Kennzeichnung des Beginns und Endes einer [[Blockstruktur]] (Blockstrukturanweisung)
* Fortsetzung bei einer anderen Anweisung ([[Sprunganweisung]]en)
* Beenden des Programms oder Prozedur, Methode oder Funktion, Verhindern einer weiteren Ausführung ([[Rücksprung]] bedingungsloser Stopp)
* Ausführen einer (Reihe von) Anweisungen nur, wenn eine Bedingung erfüllt ist ([[Bedingte Anweisung und Verzweigung|bedingte Anweisung oder Verzweigung]])
* Ausführen einer Reihe von Anweisungen in einer [[Schleife (Programmierung)|Schleife]] nicht oder mehrmals, bis oder solange wie eine Bedingung erfüllt ist (Iterationsanweisung)
* Ausführen einer Reihe entfernter Anweisungen, nach Eintritt eines [[Ereignis (Programmierung)|Ereignisses]] (Ereignis- und [[Ausnahmebehandlung]])

Manche Kontrollanweisungen, wie zum Beispiel der unbedingte Sprung, lassen sich nicht eindeutig einer Kontrollstruktur zuordnen oder können für mehrere Kontrollstrukturen notwendig sein.

Viele [[Programmiersprache]]n wie zum Beispiel imperative Sprachen enthalten Kontrollanweisungen.

== Einzelnachweise ==
<references />

[[Kategorie:Programmiersprachelement]]

Kontrollstruktur - Versionsgeschichte

imported>Aka: Tippfehler entfernt, Links optimiert, Kleinkram