imported>Laserjones: /* Bekannte Sprunganweisungen */

2026-04-13T00:42:29Z

Bekannte Sprunganweisungen

Neue Seite

Eine '''Sprunganweisung''' oder ein '''Sprungbefehl''' ist eine [[Anweisung (Programmierung)|Anweisung]] in einer [[Programmiersprache]]. In [[Computerprogramm]]en dient sie dazu, die Verarbeitung nicht mit dem nachfolgenden Befehl, sondern an einer beliebigen Stelle fortzuführen.

== Bekannte Sprunganweisungen ==
Die bekannteste Sprunganweisung ist das sogenannte '''Goto''' (von {{enS|go to}} gehe zu, nach). Dies ist in der [[Programmierung]] ein Befehl im Programmcode, der einen Sprung zu einer anderen Stelle im [[Computerprogramm|Programm]] bewirkt.

Verzweigungen zu [[Unterprogramm]]en (auch: [[Subroutine]] und [[Funktion (Programmierung)|Function]]) werden mittels '''Call''' oder ähnlich lautenden Befehlen (je nach Programmiersprache und Unterprogrammtyp) ausgeführt.

Ein '''Rücksprung''' ist die Rückkehr zu der Stelle, an der das (Haupt-)Programm nach einem solchen Aufruf und der Ausführung eines Unterprogramms fortzusetzen ist – häufig veranlasst durch eine '''Return'''-Anweisung im Unterprogramm.

Jedoch wird auch der Sprung zurück an eine schon einmal besuchte Stelle im Programmcode, also die Wiederholung eines Programmabschnitts in einer [[Schleife (Programmierung)|Schleife]], als Rücksprung bezeichnet.
Anstelle von Goto-Anweisungen werden in modernen Programmierverfahren sogenannte [[Kontrollstruktur]]en verwendet; Details siehe [[#Kontrollstruktur|unten]].

== Sprunganweisungen auf Maschinenebene ==


Im Unterschied zu den Hochsprachen spricht man hier häufiger von ''Sprungbefehlen'' als von ''Sprunganweisungen''.

[[Prozessor]]en kennen in der Regel mehrere verschiedene Sprungbefehle. Diese kann man einteilen in:

; ''unbedingt'' oder ''bedingt''
: Der Sprung wird entweder immer ausgeführt oder nur wenn bestimmte Flags im [[Statusregister]] bestimmte, geforderte Werte haben. Um welche Werte und Flags es sich handelt, ist dabei in der Sprunganweisung codiert (Beispiel: JNZ bedeutet Jump (if) Not Zero).
; ''absolut, relativ, Register'' oder ''Speicher''
* Das Programm wird an der angegebenen Adresse fortgeführt.
* Es erfolgt der Sprung relativ zur aktuellen Position. Damit ist verschiebbarer (relozierbarer) Code möglich.
* Die Zieladresse steht in einem Register <code>JMP reg</code>.
* Die Adresse des Sprungziels steht im Speicher <code>JMP [reg]</code> oder <code>JMP [reg+offs]</code>.

Eine besondere Form von Sprungbefehlen sind [[Unterprogramm]]aufrufe, d. h. Sprünge mit Rückkehrabsicht. Bei deren Ausführung wird zuerst die Adresse des Folgebefehls gesichert (auf dem [[Stapelspeicher|Stack]] oder in einem Register),<ref>{{Internetquelle |url=http://bitsavers.org/pdf/ibm/360/princOps/A22-6821-0_360PrincOps.pdf |titel=IBM System/360 Principles of Operation |hrsg=[[IBM]] |seiten=64 |datum=1964 |format=PDF |sprache=en |kommentar=Befehlsbeschreibung zu „Branch and Link“: BAL, BALR |abruf=2015-02-02}}</ref> erst dann wird an die Zieladresse gesprungen. Über ''Rücksprungbefehle'' kann das Unterprogramm wieder an die ursprüngliche Position zurückkehren und das Programm so fortgesetzt werden. Die Rücksprungadresse wird vom Stack entnommen oder steht in einem Register.

== Sprunganweisungen auf Hochsprachenebene ==
In höheren [[Programmiersprache]]n ist eine ''Sprunganweisung'' eine Anweisung der Form
goto ''Markenname''
oder
if ''Bedingung''
goto ''Markenname''
Im ersten Fall wird sie ''unbedingte Sprunganweisung'', im zweiten ''bedingte Sprunganweisung'' genannt. Dabei steht <code>Markenname</code> für den Namen einer [[Label (Programmierung)|Sprungmarke]], die an einer anderen Stelle des Programms definiert ist. Bei der Abarbeitung des Programms wird an der Stelle fortgesetzt, an der die Sprungmarke steht.

{{Anker|Kontrollstruktur}}
Im Prinzip könnte man allein mit bedingten Sprunganweisungen und einigen Zusatzfunktionen für Datenein- und -ausgabe jeden [[Algorithmus]] programmieren. Die entstehenden Programme sind allerdings ab einer gewissen Größe nahezu [[Wartbarkeit|unwartbar]]. In aktuellen Programmiersprachen werden explizit formulierte Sprunganweisungen deshalb selten verwendet. Stattdessen werden häufiger höherwertige [[Kontrollstruktur]]en, insbesondere Schleifen, Unterprogrammaufrufe und bedingt auszuführende Programmblöcke, eingesetzt, in denen die logisch dazugehörenden Verzweigungs- und Rückverzweigungsbefehle implizit, d. h. vom [[Übersetzer]] im [[Maschinencode]] eingefügt werden, ohne dass ein Goto programmiert werden muss.

== GOTO-Varianten ==

In der maschinennahen Programmierung dient der Goto-Befehl dazu, zu einer anderen [[#Sprunganweisungen auf Maschinenebene|Stelle im Programm]] zu verzweigen, entweder unbedingt oder von einer Bedingung abhängig. In manchen [[Assemblersprache]]n heißt der entsprechende Goto-Befehl ''JMP'' ({{enS|jump}} Sprung) oder BR ({{enS|branch}} verzweigen).

In höheren [[Programmiersprache]]n (die ggf. auch eine Kleinschreibung erlauben) wird durch einen Goto-Befehl entweder eine Code-Zeilennummer (zum Beispiel in alten [[BASIC]]-Dialekten) oder eine definierte Sprungmarke (''Label'', zum Beispiel in [[C (Programmiersprache)|C]] oder [[Pascal (Programmiersprache)|Pascal]]) angesprochen.

Beispiel eines einfachen Programms mit Goto in Pascal:

<syntaxhighlight lang="pascal">
PROGRAM beispiel;
LABEL 10;
BEGIN
10:
writeln('Endlosschleife');
GOTO 10;
END.
</syntaxhighlight>

Das folgende Programmbeispiel (aus dem Essay ''Coding Style'' von [[Linus Torvalds]])<ref>[https://www.kernel.org/doc/html/latest/process/coding-style.html#centralized-exiting-of-functions Linux kernel coding style, Chapter 7: Centralized exiting of functions] (englisch)</ref> zeigt die Verwendung eines Goto-Befehls <code>goto out</code> in [[C (Programmiersprache)|C]]:

<syntaxhighlight lang="c">
int fun(int a) {
int result = 0;
char *buffer = kmalloc(SIZE);

if (buffer == NULL)
return -ENOMEM;

if (condition1) {
while (loop1) {
// ...
}

result = 1;
goto out;
}

// ...
out:
kfree(buffer);
return result;
}
</syntaxhighlight>

In frühen Varianten älterer Programmiersprachen wie [[Fortran]] oder [[BASIC]] stellten Goto-Befehle noch die wichtigste, teilweise sogar die einzige Möglichkeit zur Steuerung des Programmflusses dar; diese wurden deshalb auch zur Realisierung von Schleifen und bedingter Ausführung verwendet. Dies führte zu [[Spaghetticode]].

Mit der Programmiersprache [[ALGOL]] wurden 1960 eigene Kontrollstrukturen wie <code>while</code>, <code>for</code>, <code>if-else</code> zur Programmierung von Schleifen und [[Bedingte Anweisung und Verzweigung|bedingten Anweisungen und Verzweigungen]] eingeführt. Diese Neuerungen wurden bald in andere Programmiersprachen übernommen. So machen <code>while</code> als Ersatz für Rücksprünge und <code>if</code> als Ersatz für Vorwärtssprünge bei geeigneter Umstrukturierung eines jeden Programms die Goto-Anweisung theoretisch überflüssig.

Die [[strukturierte Programmierung]] und die GOTO-Programmierung sind jedoch aus Sicht der theoretischen Informatik äquivalent; alle solchen Programme fallen in die Kategorie der [[GOTO-Programm]]e.

Auch in anderer Hinsicht sind die Befehle der strukturierten Programmierung mit dem GOTO äquivalent: Der Befehlssatz eines Prozessors enthält in der Regel keine explizite Unterstützung von Konstrukten wie <code>while</code>, <code>repeat</code>, <code>for</code>, <code>if-else</code> etc. Daher werden diese bei der Kompilierung eines Programms vom Compiler mittels unbedingter und bedingter Sprunganweisungen (Mnemonik: JP, JMP, J''cond'', BR, B''cc'', …) nachgebildet. Die genannten Konstrukte bieten also keine neuen Möglichkeiten, sie sind jedoch sinnvoll, um lesbaren und damit wartungsfreundlicheren Code zu forcieren.

== Umstrittene Verwendung von GOTO ==
1968 sprach sich [[Edsger W. Dijkstra]] in seinem Aufsatz ''Go To Statement Considered Harmful'' (ursprünglich: ''A Case against the GO TO Statement''; der spätere Titel geht auf [[Niklaus Wirth]] zurück), für eine Abschaffung des Goto-Befehls in allen [[Höhere Programmiersprache|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> Das ist ohne weiteres möglich, da nahezu jedes Goto durch sogenannte [[Kontrollstruktur]]anweisungen wie <code>do</code>, <code>for</code> oder <code>while</code> ersetzt werden kann (siehe auch [[GOTO-Programm#Simulation durch WHILE-Programm|Simulation GOTO durch WHILE]]). Nach anfänglichem Widerstand wurde diese Meinung in der Programmierausbildung bald zum Dogma erhoben; in einigen Sprachen wie [[Java (Programmiersprache)|Java]] wurde bewusst überhaupt kein Goto-Befehl eingeführt, jedoch ersatzweise ein ''<span lang="en">labeled break</span>'' und später ein ''<span lang="en">labeled continue</span>''. Dennoch ist <code>goto</code> als Schlüsselwort auch in Java reserviert. Evtl. behält man sich die Implementierung vor, wahrscheinlich aber auch aus praktischen Gründen. Ansonsten wäre ''goto'' ein gültiger Bezeichner. Andererseits unterstützen zahlreiche neue imperative Programmiersprachen noch Goto, z. B. [[C++]], und selbst das 2000 entwickelte [[C-Sharp|C#]] sowie das 2007 publizierte [[D (Programmiersprache)|D]]. 2009 wurde Goto nachträglich auch in die Skriptsprache [[PHP]] ab Version 5.3 eingeführt und war in der neuen Sprache [[Go (Programmiersprache)|Go]] enthalten.

Eine weniger kritisierte Variante des Goto-Befehls ist das vorzeitige Verlassen eines Unterprogramms durch <code>return</code>, das Abbrechen einer Schleife durch <code>break</code> oder Abbrechen eines bestimmten Schleifendurchlaufs und den Beginn des nächsten Durchlaufs durch <code>continue</code>. Trotzdem gilt es in einigen Programmiersprachen als guter [[Programmierstil]], wenn ein Block genau einen [[Einsprungpunkt]] und genau einen Ausstiegspunkt hat. In Sprachen, welche [[Ausnahmebehandlung]]en erlauben, wird dagegen die Ein-Ausstiegspunkt-Regel als obsolet angesehen, da <code>throw</code>-Anweisungen die Argumentation hinter dieser Regel ad absurdum führen.

In der Praxis hat sich jedoch gezeigt, dass der Verzicht auf Goto zwar möglich ist, jedoch in einigen Fällen zu sehr aufwändigen Konstrukten führt.<ref>{{Literatur |Autor=Frank Rubin |Hrsg=ACM |Titel=“GOTO Considered Harmful” Considered Harmful |Sammelwerk=Communications of the ACM |Band=30 |Nummer=3 |Datum=1987-03 |Seiten=195–196 |DOI=10.1145/214748.315722 |Online=[https://web.archive.org/web/20090320002214/http://www.ecn.purdue.edu/ParaMount/papers/rubin87goto.pdf web.archive.org] |Format=PDF |KBytes=208 |Abruf=2021-09-11}}</ref> So hält [[Donald E. Knuth]] Goto für die optimale Lösung einiger üblicher Programmierprobleme.<ref>{{Literatur |Autor=Donald E. Knuth |Hrsg=ACM |Titel=Structured Programming with go to Statements |Sammelwerk=Computing Surveys |Band=6 |Nummer=4 |Datum=1974 |Seiten=261–301 |DOI=10.1145/356635.356640 |Online=[http://www.clifford.at/cfun/cliffdev/p261-knuth.pdf Online] |Format=PDF |KBytes=2900 |Abruf=2021-09-11}}</ref> Besonders in zeitkritischen Programmteilen ist ein Goto deutlich effizienter, als am Ende von mehreren geschachtelten Schleifen jeweils eine Abbruchprüfung durchzuführen.

Von einigen Entwicklern wurde auf der Linux-Kernel-Mailing-Liste die häufige Verwendung von Goto im Quellcode von [[Linux]] diskutiert. [[Linus Torvalds]] sagte dabei, dass die Verwendung von Goto die Lesbarkeit des Quellcodes in vielen Fällen sogar deutlich erhöhen könne.<ref>{{Internetquelle |url=http://kerneltrap.org/node/553/2131 |titel=Linux: Using goto In Kernel Code |hrsg=kerneltrap.org |sprache=en |archiv-url=https://web.archive.org/web/20051128093253/http://kerneltrap.org/node/553/2131 |archiv-datum=2005-11-28 |offline=1 |abruf=2010-09-21}}</ref>

== Siehe auch ==
* [[Sprungtabelle]]

== Weblinks ==
* Edsger W. Dijkstra: ''Go To Statement Considered Harmful.'' In: ''[[Communications of the ACM]].'' Vol. 11, No. 3, März 1968, S. 147–148 ([http://portal.acm.org/ft_gateway.cfm?id=362947&type=pdf&coll=GUIDE&dl=GUIDE&CFID=86187909&CFTOKEN=55343279 PDF])
* David R. Tribble: [http://david.tribble.com/text/goto.html ''Go To Statement Considered Harmful: A Retrospective''.] 27. November 2005

== Einzelnachweise ==
<references />

[[Kategorie:Programmiersprachelement]]

Sprunganweisung - Versionsgeschichte

imported>Laserjones: /* Bekannte Sprunganweisungen */