goto ist böse

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

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++)

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

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ß.

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

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

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

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

Zitat:

---

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)

@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

Zitat:

---

Zitat von Johann H.

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...

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

nabend

interessant wie unterschiedlich die meinungen zu goto doch sind.
@sprinterSB: vielen dank, dass du dir überhaupt die mühe gemacht hast ein C tutorial zu schreiben, ich fand manches daraus sehr hilfreich am anfang !!!
zweitens danke für die antwort, jetzt verstehe ich die ganze problematik (werde jedoch trotzdem weiterhin munter "goto" verwenden ^^)

MfG maddin

Zitat:

---

Zitat von SprinterSB

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

---

huch?
Naja egal, wie du trotz Compilerfehler schon richtig erkannt hast soll das eine Parameterübergabe mit globalen Variablen sein, oder kurz gesagt: ganz ganz böse ;)

[quote="Felix G"]

Zitat:

---

Zitat von SprinterSB

[...] eine Parameterübergabe mit globalen Variablen sein, oder kurz gesagt: ganz ganz böse ;)

---

Seh ich nicht so krass. Dort wo man in einer objektorientierten Sprache ein Singleton verwenden würde, ist in C doch ein globales Objekt in Ordnung. Oder?

Und ohne Betriebssystem und ohne globale Objekte ist die Datenübergabe zwischen ISR und Applikation auch nicht ganz einfach...

Ich habe bisher keinen (!) einzigen Fall erlebt, wo goto in C oder C++ Code erforderlich oder besonders nützlich war. Aber ich lasse mich gerne eines Besseren belehren, wenn man mir ein Beispiel zeigt.

Erstmal ein kleines Vorwort:
Ich entwickle seit 1972 Software (beruflich!!!). Die Diskussion um GOTO - ja oder nein habe ich also ziemlich heftig mitgemacht. Lang lang ists her...

Hintergrund der ganzen Sache (goto considered to be harmful):
Ende der 1960-er Jahre fand die berühmte NATO-Konferenz über die "Software-Krise" statt. Dijkstras Idee, goto möglichst zu vermeiden fand in der Folge viele Anhänger, die das Ganze dogmatisierten (ala "goto ist böse").

Nach einer sechsstelligen Anzahl geschriebener und einer sicher siebenstelligen Anzahl gelesener Lines Of Code denke ich inzwischen folgendermaßen über das Thema Software und Softwarestruktur:

Die folgenden Konstrukte reichen aus:
- Sequenz (Ein Statement nach dem Anderen)
- Abfrage (if then else bzw. switch)
- Schleife (for)
- Unterprogramm-Aufruf.

Wenn ein Stück Programm kompliziert wird, also der Programmierer z.B. einen "Breitwand-Fernseher" benötigt, um mit der Schachtelungstiefe noch klarzukommen, oder aus Verzweiflung zum GOTO übergeht, dann stimmt seine Logik nicht!!!

In einem solchen Fall wird es Zeit, das Problem noch einmal zu durchdenken und von oben bis unten - von den Anforderungen an bis zur Implementierung - auf den Prüfstand zu stellen. Der Zeitaufwand für ein derartiges Redesign ist bereits auf mittlere Sicht wesentlich geringer als der Aufwand für das Weiterverfolgen des komplizierten ersten Ansatzes.

Aber einmal geschriebene Software schmeißt man nicht so einfach auf die Mülle!

Unter der Folge - unergonomische Bananenprodukte - leiden alle:
- Der Anwender darf die Software-Fehler "heraustesten".
- Der Entwickler hat einen "Pflegefall" am Bein, der sich sehr schnell in eine "lebende Leiche" verwandelt
- Das Hersteller-Unternehmen ruiniert seinen Ruf (siehe "Winzweich")

Das waren meine paar Cent eigene Meinung und Erfahrung.

Schönen Sonntag noch!

Barny Geröllheimer

Hallo,

Im Zusammenhang mit der Prog.-Sprache 'C' (also wie in diesem Thread) und auch vielen anderen trifft das 'goto ist böse' bestimmt zu.
In einigen Prog.-Sprachen wie CCBaic lässt es sich dennoch oft nicht vermeiden, wenn zum Beispiel 'if-end-if-Blöcke' nicht erlaubt sind, und dadurch der Code durch "ums-goto-drumherumschreiben" ebenfalls sehr schwierig wird.