goto ist böse

[_maddin]

hi leute

ich hab mal eine grundsätzliche verständnisfrage:

ZITAT (RN WIKI)
Gleichwohl sei angemerkt, daß die Verwendung von goto einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:

goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.

ich persönlich versteh nich ganz was an programmsprüngen so schlimm sein soll (hab früher viel assembler gemacht, bin daher nichts anderes gewohnt). zwar verwende ich in C programmen recht selten goto, aber wenn ich es verwende, habe ich niemals das gefühl, dass das programm dadurch unübersichtlicher wird als ohne.

MfG
maddin

[Tido]

Hallo,

ich kann's auch nicht verstehen. Habe dies auch häufiger gehört (und ignoriert) und weiterhin mein 'goto' eingesetzt. Bisher ohne jegliche Übersicht-Probleme. Ganz im Gegenteil finde ich es mit 'goto' sogar viel übersichtlicher.
Wenn ich kompliziertere Programmteile schreibe, fange ich (der Übersicht wegen) sogar mit vielen 'goto' an und sobald es läuft, entferne ich das eine oder andere goto wieder (so dass sich "logische" [zusammenhängende] Gruppen bilden).

(progge übrigends auschließlich in CCBasic und Basic++)

[franzl]

hallo,
also goto wird deshalb als böse bezeichnt weil man eigentlich kein richtiges programm mehr hat. man springt ja nur wahlos hin und her. dabei könnte man dies auch in funktionen gliedern was dann programmtechnisch schon erheblich besser währe.
mfg franz

[Tido]

Hi franzl,

worin besteht der Unterschied, ob ich eine Funktion aufrufe oder per 'goto' zu einem Programmteil springe?
Ob ich in der Funktion oder meinem 'goto'-Programmteil etwas suche, ich muß doch in beiden Fällen erst diesen Teil im Programm suchen?!

Den einzigen "Vorteil" den ich sehe wäre der, dass ich meine "bewährten" Funktionen per 'include' nicht jedesmal neu schreiben bzw. ins Programm kopieren muß.

[chr-mt]

Hi,
ich sehe das "goto" auch nicht als "böse" an.
Ich verwende es zwar fast nie, aber finde auch nicht, daß es ein Programm zwangsläufig unübersichtlich macht.
Klar, früher als man in Basic ständig mit "goto Zeilennummer" rumspringen musste, war das sehr unübersichtlich.
Wenn man aber zu einem Label sprint, daß einen selbsterklärenden Namen hat, dann ist es eigentlich kein Problem.
Wie _maddin schon erwähnte, ist ein Sprungbefehl in Assembler ja auch nicht "böse", obwohl er von der Funktion das selbe macht wie "goto" .

Gruß
Christopher

[Johann H.]

ich goto ist es möglich programme so dermaßen unübersichtlich zu machen , dass man nach kurzer zeit nichit mehr durchblickt und vorallem nicht mehr den Sinn in den Sprüngen erkennt.

Einfache Aufgabe, zeichne einfach ein Nassi-Shneiderman-Diagramm für deinen Code ^^...

klar kann man auch mit goto programmieren, aber dann möchte ich den code nicht in die hände bekommen...

man könnte das jetzt groß ausführen aber das lasse ich mal

[SIGINT]

Hi Tido,
ob GOTO oder Funktion: Das Programm wird mit beidem klarkommen.
Allerdings wird GOTO als schlechter Programmierstil angesehen, da bei Funktionen ein Programmblock als funktional abgeschlossenen Einheit auftauchen kann... bei GOTO kannst du von einer Stelle zur anderen springen ohne zu wissen in welchem Programmblock du dich befindest. Da den Überblick zu behalten ist bei größeren Programmen echt kompliziert.
Dazu kommt bei Funktionen noch die Möglichkeit lokale Variablen definieren zu können... wie willst du das bei GOTO machen???
Ich hab mir auch in Assembler angewöhnt mit Funktionen (rcall) statt mit GOTO (rjmp) zu arbeiten... das ist einfach praktischer.

Gruß,
SIGINT

[Felix G]

Also ich persönlich habe in einem C-Programm noch nie ein Goto benötigt...

worin besteht der Unterschied, ob ich eine Funktion aufrufe oder per 'goto' zu einem Programmteil springe?

Bei einem Goto springst du einfach nur irgendwo hin, musst aber nicht unbedingt wieder zurück kommen. Bei einer Funktion hingegen kannst du dir sicher sein, daß das Programm nach dem Funktionsaufruf fortgesetzt wird sobald die Funktion fertig ist.

Funktionen bieten generell mehr Komfort und Übersichtlichkeit als direkte Sprünge zu irgendwelchen Programmteilen. So siehst du z.B. sofort ob der Funktion Parameter übergeben werden, und welche. Das gleiche gilt für den evtl. vorhandenen Rückgabewert.

nehmen wir z.B. mal eine Funktion namens "add" die 2 Zahlen addiert:

erg = add(1, 4);

und jetzt machen wir das nochmal mit Goto (in der schlimmsten möglichen Version):

a = 1;
b = 4;

goto add;

add_return: erg = c;


Bei der ersten Variante sieht jeder sofort, welche Parameter übergeben werden und daß das Ergebnis danach wohl in erg steht. Bei der zweiten hingegen muss man sich schlimmstenfalls erstmal durch den gesamten Code wühlen um herauszufinden daß in den (globalen) Variablen a und b die Parameter, und in c das Ergebnis stehen. Außerdem kann man die goto-Variante nur an einer einzigen Stelle im Programmcode benutzen, die Funktion aber beliebig oft (sogar verschachtelt).


Ich würde Goto nur dann verwenden wenn ein Sprung ohne Rückkehr explizit gewünscht ist. Das kann z.B. der Fall sein wenn man nach einem schwerwiegenden Fehler in eine Fehlerbehandlungsroutine springen möchte. (die dann z.B. einen Reset auslöst oder ähnliches)

[SprinterSB]

@maddin

Der Text ausm Wiki ist von mir, und es ist ein Smiley dran. So einer

Wie überall ist da ein Funke Wahrheit drin.

Zunähchst mal

1. Man kann jedes Programm ohne goto schreiben
2. Das allein ist noch kein Grund, auf goto zu verzichten... Man kann auch jedes Programm ohne Funktionsaufrufe schreiben und/oder ohne lokale Variablen (auch rekursive)
3. Ein C-Programm ist strukturiert. Eine Funktion hat Blöcke und ein Block wieder Teilblöcke. Idealerweise führt diese Strukturierung zu einem gut leserlichen Programm. goto durchbricht diese Systematik, denn mit goto kann man von einem Blick in einen anderen springen und zb mitten in den Gültigkeitsbereich einer Variablen, also zB ohne an einer Deklaration vorbei zu kommen. Compiler komman damit klar, aber schön ist das nicht.

IMHO kann goto in einigen wenigen Fällen die Lesbarkeit erhöhen. In Programmiersprachen wie C++/Java etc gibt es einen Exception-Mechanismus. Gibt es eine ungültige Operation, wirft man eine Ausnahme und braucht sich weiter keine Gedanken mehr darum zu machen.

Würde man ständig die Fehlerbedingung mit rumschleppen und abfragen müssen, würde das logischerweise das Programm aufblähen und schwerer verständlich machen, weil man sich nicht nur auf das Wesentliche konzentriert, sondern ständig die Fehlerbedingungen am Bein hat. Ähnlich kann man goto vorteilhaft nutzen. Ein Analogon zur Exception wäre aber eher ein "return" mitten in einer Funktion.

Auch ein return mitten in einer Funktion macht den Programmablauf klarer. Man ist eben fertig, was soll man noch x Zeilen in der Funktion rumlungern.... Sich den Rückgabewert zu merken und mitzuschleppen bis zum Ende des Funktionsblocks, ist zwar schön strukturiert, aber besser verständlich wird es nicht...

Wirklich übel ist ein nonlocal-Goto (in C longjump), also ein goto, das von einer Funktion in eine andere springt. Das ist alle sandere als trivial, denn der Stack etc. muss ja abgebaut werden.

Ich persönlich habe zweimal goto einmal angewandt (eigentlich mehrfach, da ein Makro u.a. zu "goto" ausexpandierte. Beide Male war die Codegröße der Grund dafür, goto zu verwenden. Selbst mit inline-Funktionen wäre der Code deutlich größer geworden...

Via goto kann man übrigens auch indirekt springen, also doe Label zB in ein Array legen, skizzenhaft aufgezeigt in "Verwendung von Labels" ganz am Ende des Abschnitts
https://www.roboternetz.de/wissen/in...ate_Machine.29

Mit goto ist es möglich programme so dermaßen unübersichtlich zu machen , dass man nach kurzer zeit nichit mehr durchblickt[...]

Ja, mit goto lässt sich leicht ein unübersichtliches Programm bauen. Das freilich, ist auch mit endlos verschachtelten if-else-Konstrukten möglich, gobalen Variablen, miesen Bezeichnern, Zeiger-Gecaste, ... Grundsätzlich kann man in C jedes Konstrukt dafür hernehmen, einen undurchschaubaren Programmfluß zu bekommen...

Übrigens: Auch Java kennt das Schlüsselwort "goto", aber nur, um zu sagen, daß es nicht unterstützt wird, wenn man es anwenden will...


@Felix G
Was du wohl meinst ist Parameterübergabe mit globalen Variablen? So wie es bei dir dasteht gibt es jedenfalls nen Compiler-Fehler...

[phaidros]

Die Sache geht auf einen Artikel von Dijkstra zurück: "GOTO considered harmful". Gibt's bestimmt im Netz. Der leitete den Trend zur strukturierten Programmierung ein und war daher sehr wichtig.
ABER:
Es gibt (zumindest in C und Assembler) viele Situationen, wo es Sinn macht, GOTO zu verwenden. Der Linux-Kernel enthält etliche GOTOs, und ich denke, die entsprechenden Leute können programmieren.
Gruß
Phaidros