Diskussion:Sprunganweisung

Diskussion:Sprunganweisung

Meines Wissens beschreibt Dijkstra auch Fälle in denen der Einsatz von GoTo sinnvoll sei. Hat irgendwer mal das komplette Dokument gelesen und kann das bestätigen bzw. negieren? Florian Rittmeier 12:44, 26. Aug 2005 (CEST)

Es gibt außerdem ein Papier von Tom di Marco, das den Nutzen des GOTO-Befehls bei der Fehlerbehandlung hervorhebt.

GOTO erhöht die Lesbarkeit

Den folgenden Satz habe ich aus dem Kapitel "Problematische Verwendung von Goto" entfernt: "In einigen Fällen, wie dem obigen C-Beispiel, kann ein Goto-Befehl die Lesbarkeit des Codes verbessern. Als wichtigste Regel gilt, nur aus einem Block und niemals in einen Block zu springen."

Hier sollte allgemein anerkanntes Wissen stehen. Wenn dieses wie hier kritisiert wird, dann gehört dazu schon eine Begründung. In dem C-Programm, das als Beispiel angeführt wird würde es vollkommen ausreichen den zu überspringenden Block mit einem else zu versehen. --16:31, 2. Okt 2006 (CEST)

In einigen Fällen ist goto oder das ihm sehr nahestehende break einfach von der Sprache gefordert und kann dann relativ gut gelesen werden. So muß (aus historischen Gründen?) in C-verwandten Sprachen am Ende jedes Case-Abschnitts einer Switch-Schleife break stehen; in diesem Fall wäre das Fehlen von break, weil man zufällig auch noch den nächsten Case-Abschnitt auchnoch abarbeiten will, unverständlicher Spaghetticode. In Visual Basic dagegen kann man ein simples return nur realisieren, indem man ein Label "EndOfSubroutine" (o. ä.) unmittelbar ans Ende der Subroutine setzt und darauf dann mit einem Goto springt...--131.159.76.192 19:56, 28. Mär. 2017 (CEST)

GOTO-Kritik: Karikatur

Hallo, vielleicht könnte man diese humorvolle Kritik an der Verwendung von GOTO-Befehlen einbauen? http://xkcd.com/292/ Liebe Grüsse--DeBrouver 13:16, 3. Jun. 2011 (CEST)

Lesbarkeit

Ich glaube die folgenden Beispiele sollten klar machen dass goto gelegentlich die lesbarkeit erhöht. Zwar ist das alles geschmackssache, aber durchaus viele programmierer sehen gotos als probates mittel in einigen situationen an.

1 for(;;) {
2     switch(i) {
3         case foo:
4             break;
5         default:
6             // would like to break out to after line 8
7     }
8 }

1  bool break_for = false;
2  for(;;) {
3      switch(i) {
4          case foo:
5              break;
6          default:
7              break_for = true;
8      }
9      if( break_for ) break;
10 }

1  try {
2      for(;;) {
3          switch(i) {
4              case foo:
5                  break;
6              default:
7                  throw loop_breaker;
8          }
9      }
10 catch( const loop_breaker& ) { }

1 for(;;) {
2     switch(i) {
3         case foo:
4             break;
5         default:
6             goto end_of_for_loop;
7     }
8 }
9 end_of_for_loop:

andere Sprunganweisungen?

Wieso gibt nicht wenigstens ne Liste mit anderen. Es mag ja sein dass goto gekannt ist, aber der Artikel heißt ja nicht goto (Sprunganweisung) - und wenn es nur in C ist break oder continue - ich kann da leider nichts drüber schreiben, kenn ich nur vom hören-sagen, aber ich wollte eben was drüber lernen und stoße hier auf ne kleine Blockade. Grüße --WissensDürster 12:45, 24. Feb. 2009 (CET)

PS: zu denen von C steht sogar in den Wikibooks ein wenig - aber leider zu konkrete Beispiele - gesucht wird eine einfache Abstraktion b:C-Programmierung:_Sprachbeschreibung:_Anweisungen#Sprunganweisungen --WissensDürster 12:52, 24. Feb. 2009 (CET)

Eine vollständige Liste mit anderen Sprungbefehlen wird es kaum geben und alle bekannteren Programmiersprachen verwenden (falls es überhaupt "wilde" Sprunganweisungen gibt) GOTO. Den Befehl gibt es seit Urzeiten - auch in Assembler. break ist ein schwieriges Thema, weil sie je nach Art der Programmiersprache manchmal Sprunganweisungen sind, manchmal aber auch nicht. Das muss man IMO entweder sehr ausführlich darstellen oder es führt zu mehr Verwirrung. z.B. in Java wird ein "break" vom Compiler ähnlich einem "return null;" umgesetzt und ist deshalb eher eine Abbruchbedingung. continue verhält sich zumindest nach Außen wie eine Sprunganweisung. -- Merlissimo 13:40, 24. Feb. 2009 (CET)

Also gibt es kein allgemein abstraktes Modell von Sprunganweisungen? Die Dinger aus C lassen sich so schön übersetzen, also das Sprung-Konzept Abbruch, Weiter, Gehe Zu Nach der hier angeführten Def wäre sowas wie break ja eh keine, weil sie nicht "springt" - continue auch nicht - und nichts was mir einfällt, d.h. der Artikel bezieht sich in Definition und Beispiel nur auf das (sooo bekannte) Beispiel goto ... das ist nicht grad sehr wissenhschaftlich. Schade drum. --WissensDürster 01:14, 26. Feb. 2009 (CET)

Vielleicht sollte man Sprunganweisung wie das GOTO in Assembler behandeln. Das mit dem "springenden" Stackpointer ist ja schön anschaulich und man kann es 1:1 auf einige "normale" Programmiersprachen übertragen und hat eine klare Abgrenzung. Man würde zwar die Entwicklung in den letzen Jahren vernachlässigen, wäre aber IMO nicht schlimm. Bei den massenhaften Befehlssatzerweiterungen der letzten Jahre blickt ja eh keiner mehr durch. -- Merlissimo 02:26, 26. Feb. 2009 (CET)

Kann sein, kann nicht sein. Das mit den Assemblern hab ich schnell vergessen, muss das nächstes Jahr wiederholen 0:) Danke trotzdem --WissensDürster 11:15, 26. Feb. 2009 (CET)

Mit den von Dir genannten aus C: Wenn das wie in Java funktioniert (würde ich mal vermuten), dann ist ein break oder ein continue auch eine Sprunganweisung - lediglich mit einem bereits beinhalteten Zielschlüssel. Und das return genauso. Oder?--Flash1984 01:32, 3. Mär. 2009 (CET)

Ja genau, und eigentlich wollte ich nur, dass das jemand genau so wie du es sagst auch im Artikel erwähnt. Ich kam ja nur zu dem Artikel weil ich mehr über break und continue lesen wollte... --WissensDürster 11:37, 3. Mär. 2009 (CET)

Schau mal, ob der letzte Abschnitt (hab noch continue eingefügt) das ist, was Du meintest. Grüße --Flash1984 00:47, 4. Mär. 2009 (CET)

goto GOTO Goto GoTo

Hallo. Ich finde die überaus uneinheitliche Schreibung von goto GOTO Goto GoTo ein wenig komisch. Kann man bitte kurz abstimmen, wie das einheitlich geschrieben werden soll. Es kommt einfach zu oft vor, da kann man es nicht überall anders schreiben. Ich wäre für Goto der GoTo. Grüße --WissensDürster 18:08, 26. Feb. 2009 (CET)

Dann ändere es doch einfach ab, dafür ist Wiki ja da ;-). Am sinnvollsten fände ich GoTo,weil dort eben die beiden Wortbestandteile am deutlichsten werden. Allerdings gibt es eben auch einige Sprachen, die bspw. ein GOTO oder goto verwenden. Nichtsdestotrotz: Ändere es doch einfach auf GoTo, dann sind wir schon zwei dafür und jeder andere sollte dagegen argumentieren (da es eher eine Formalie ist, sollte da ja nichts dagegen sprechen, oder?). Grüße --Flash1984 00:38, 2. Mär. 2009 (CET)

GoTo ist aber kein richtiges Deutsch, weil Majuskeln im Wortinneren verkehrt sind. Oder sind Sie aus der Werbeabteilung? "Goto" ist m. E. die einzig annehmbare Schreibweise. --195.244.237.69 11:31, 10. Sep. 2009 (CEST)

Ok ich denke, alles ist nun auf GoTo geändert, außer natürlich die konkreten Verwendungen in den Programmiersprachen, da muss die Syntax natürtlich erhalten bleiben - aber für deutschen Sprachgebrauch und die intuitive Sinnerschließung ist GoTo gut geeignet, weil die Bestandteile eben schnell klar werden. GehZu. Grüße --WissensDürster 11:54, 4. Mär. 2009 (CET)

Ich bin der Meinung, dass man Goto schreiben sollte. Das ist vernünftiges Deutsch und wird auch von anderen Autoren so verwendet.

Zum Beispiel: http://de.wikiquote.org/wiki/Niklaus_Wirth

--195.244.237.69 11:40, 10. Sep. 2009 (CEST)

Goto ist meiner Meinung nach auch die beste Schreibweise im Deutschen. Ein Binnenmajuskel ist hier nicht notwendig oder üblich. --Fomafix 23:05, 10. Sep. 2009 (CEST)

Das hättest Du aber trotzdem jetzt nicht einfach ändern sollen, finde ich. Schließlich habe ich es nur auf ein altes Diskussionsergebnis geändert. Im Übrigen finde ich Goto einfach unverständlich, weil nicht deutlich wird, dass es sich aus zwei Wörtern zusammensetzt. Wenn überhaupt dann bitte GOTO, dann kann man wenigstens erahnen, dass das kein deutscher Eigenname sein soll. Außerdem wäre es dann konsequent verglichen mit dem Artikel zu GOTO-Programmen. Grüße--Flash1984 14:34, 11. Sep. 2009 (CEST)

Genau!! GOTO zeigt den Ursprung als Programmiersprachensyntax (auch wenn moderne Sprachen Kleinschreibung zulassen). Aus Konsistenzgründen zu anderen Wiki-Einträgen ist es auch besser. Hab's mal versuchsweise geändert.--Cami de Son Duc 19:13, 14. Sep. 2009 (CEST)

Gelabelter Break?

Tut mir leid, aber ein break oder continue mit Marke, die nunmal keine Sprungmarke ist, weil sie nicht angesprungen wird, ist kein goto. Anderenfalls wäre alles goto, weil ja alles auf goto abgebildet wird, auch das implizite break-Kommando. --195.244.237.69 10:01, 10. Sep. 2009 (CEST)

Weblink-Quelle

Es ist unkorrekt, Dijkstra alleine als Autor anzugeben, denn der Autor des Papers ist Tribble! --Cami de Son Duc 18:52, 14. Sep. 2009 (CEST)

Bei Apple-Produkten [..]

"Bei Apple-Produkten führten fehlerhafte GOTO-Befehle zum Auftreiten einer Sicherheitslücke, welche Man-in-the-middle-Angriffe erlaubt."

• Auftreten

Finde ich sehr unspezifisch. Wie wäre es mit "in Apples SSL Implementierung für iOS und OSX[...]". Zudem lag der Fehler eher an dem komischen(oder nicht eingehaltenen?) Coding Standard, bei nur einem if-statement nicht zu klammern. (nicht signierter Beitrag von 212.202.222.47 (Diskussion) 15:27, 4. Apr. 2014 (CEST))

... die Goto-Anweisung ist komplett unschuldig

Fehler war eine fehlerhafte IF-Anweisung.

Kodiert wurde:

    ...
    if ((err = ReadyHash(hashRef, &hashCtx)) != 0)
        goto fail;
    if ((err = hashRef->update(&hashCtx, &clientRandom)) != 0)
        goto fail;
    if ((err = hashRef->update(&hashCtx, &serverRandom)) != 0)
        goto fail;
    if ((err = hashRef->update(&hashCtx, &signedParams)) != 0)
        goto fail;
        goto fail;
    if ((err = hashRef->final(&hashCtx, &hashOut)) != 0)
        goto fail;

    if (sigAlg.signature==SSL_SignatureAlgorithmRSA) {
        err = sslRsaSign(ctx, ctx->signingPrivKeyRef, &algId, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    } else {
        err = sslRawSign(ctx, ctx->signingPrivKeyRef, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    }
    if (err) {
        sslErrorLog("SSLDecodeSignedServerKeyExchangeTls12: sslRawVerify returned %d\n", (int)err);
        goto fail;
    }

fail:
    SSLFreeBuffer(&signedHashes);
    SSLFreeBuffer(&hashCtx);
    return err;
}

Fehlerfrei waere gewesen, wenn auch urspruenglich nicht so beabsichtigt:

    ...
    if ((err = ReadyHash(hashRef, &hashCtx)) != 0)
    {
        goto fail;
    }
    if ((err = hashRef->update(&hashCtx, &clientRandom)) != 0)
    {
        goto fail;
    }
    if ((err = hashRef->update(&hashCtx, &serverRandom)) != 0)
    {
        goto fail;
    }
    if ((err = hashRef->update(&hashCtx, &signedParams)) != 0)
    {
        goto fail;
        goto fail;
    }
    if ((err = hashRef->final(&hashCtx, &hashOut)) != 0)
    {
        goto fail;
    }

    if (sigAlg.signature==SSL_SignatureAlgorithmRSA) {
        err = sslRsaSign(ctx, ctx->signingPrivKeyRef, &algId, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    } else {
        err = sslRawSign(ctx, ctx->signingPrivKeyRef, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    }
    if (err) {
        sslErrorLog("SSLDecodeSignedServerKeyExchangeTls12: sslRawVerify returned %d\n", (int)err);
        goto fail;
    }

fail:
    SSLFreeBuffer(&signedHashes);
    SSLFreeBuffer(&hashCtx);
    return err;
}

Genauso fehlerhaft waere gewesen die aequivalente goto-freie Version (die uebrigens schwerer zu verifizieren ist):

    ...
    OSStatus sumerr = false;

    if ((err = ReadyHash(hashRef, &hashCtx)) != 0)
        sumerr = true;
    if ((err = hashRef->update(&hashCtx, &clientRandom)) != 0)
        sumerr = true;
    if ((err = hashRef->update(&hashCtx, &serverRandom)) != 0)
        sumerr = true;
    if ((err = hashRef->update(&hashCtx, &signedParams)) != 0)
        sumerr = true;
        sumerr = true;
    if ((err = hashRef->final(&hashCtx, &hashOut)) != 0)
        sumerr = true;

    if (sigAlg.signature==SSL_SignatureAlgorithmRSA) {
        err = sslRsaSign(ctx, ctx->signingPrivKeyRef, &algId, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    } else {
        err = sslRawSign(ctx, ctx->signingPrivKeyRef, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    }
    if (err)
        sumerr = true;

    if (sumerr) {
        sslErrorLog("SSLDecodeSignedServerKeyExchangeTls12: sslRawVerify returned %d\n", (int)err);
    }

    SSLFreeBuffer(&signedHashes);
    SSLFreeBuffer(&hashCtx);
    return sumerr;
}

Dagegen wieder in Ordnung, wenn auch nicht so beabsichtigt:

    ...
    OSStatus sumerr = false;

    if ((err = ReadyHash(hashRef, &hashCtx)) != 0)
    {
        sumerr = true;
    }
    if ((err = hashRef->update(&hashCtx, &clientRandom)) != 0)
    {
        sumerr = true;
    }
    if ((err = hashRef->update(&hashCtx, &serverRandom)) != 0)
    {
        sumerr = true;
    }
    if ((err = hashRef->update(&hashCtx, &signedParams)) != 0)
    {
        sumerr = true;
        sumerr = true;
    }
    if ((err = hashRef->final(&hashCtx, &hashOut)) != 0)
    {
        sumerr = true;
    }

    if (sigAlg.signature==SSL_SignatureAlgorithmRSA) {
        err = sslRsaSign(ctx, ctx->signingPrivKeyRef, &algId, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    } else {
        err = sslRawSign(ctx, ctx->signingPrivKeyRef, dataToSign, dataToSignLen, signature.data, signature.length, actSigLen);
    }
    if (err)
    {
        sumerr = true;
    }

    if (sumerr) {
        sslErrorLog("SSLDecodeSignedServerKeyExchangeTls12: sslRawVerify returned %d\n", (int)err);
    }

    SSLFreeBuffer(&signedHashes);
    SSLFreeBuffer(&hashCtx);
    return sumerr;
}

Der eigentliche Fehler ist die IF-Anweisung, garniert um eine zusaetzliche Verschleierung durch eine den Compiler nicht interessierende Einrueckung. In Ada ist diese Art der bedingten Anweisung nicht ohne Grund gar nicht erlaubt. Dort sieht die IF-Anweisung immer so aus:

    if Bedingung then
        sumerr := true;
    end if;

Weiterhin gibt es in Ada umfangreichere Kontrollstrukturanweisung, die wirklich selten den Wunsch nach goto's aufkommen lassen. Und dann gibt es in Ada bessere Strukturen als break und continue, die in C teilweise zu noch schlechter lesbarem Code als goto's fuehren. (nicht signierter Beitrag von 195.33.171.8 (Diskussion) 19:27, 29. Okt. 2014 (CET))

Was soll das ...

... zur Verbesserung des Artikels beitragen? Zumal das mit 'GOTO' praktisch nichts zu tun hat, und außerdem mit diesen inhaltlichen Details in einer Enzyklopädie "fehl am Platze" ist. --VÖRBY (Diskussion) 15:41, 30. Okt. 2014 (CET)

Da kein Feedback mehr:

Dieser Abschnitt kann archiviert werden. VÖRBY (Diskussion) 17:03, 31. Okt. 2014 (CET)

continue

Der continue Befehl ist ja verdammt knapp abgehandelt, Unter Continue = Computerspieloption 9_9 verweist ein schmaler BK-Hinweis auf den umseitigen Artikel und hier kommt der Begriff genau einmal vor. -- itu (Disk) 21:29, 22. Mai 2015 (CEST)

Umstrittene Verwendung von GOTO

GOTO ist umstritten???? Wie will man denn höhere Anwendungen ohne Sprünge zu anderen Programmteilen realisieren? Als jemand der sehr viel von Informatik versteht und bereits seit dem Jahr 1985 Software entwickelt, sehe ich solche Aussagen eher so an, als ob da jemand die Grundlagen der Informatik nicht verstanden hat. Für PHP wird aktuell sogar über die Einführung von GOSUB / RETURN nachgedacht! --77.20.212.62 19:29, 7. Jan. 2018 (CET)

Nun, ich bin ohne besagte Erfahrung, aber: Indem man die fraglichen Teile in Funktionen auslagert und die aufruft, z. B.. Oder indem man Variablen setzt (bool continueloop = true; if wasauchimmer continueloop = false; und dann das eventuell zu überspringende in ein if continueloop einschließen. Gehen tut das. Ich bin aber schon auch der Meinung, daß goto manches einfacher machen kann, insbesondere wenn es kein break oder etwa gar kein return gibt (siehe das oben von mir angesprochene "GoTo EndOfSubroutine" in Visual Basic).--131.159.76.237 19:40, 19. Jan. 2018 (CET)

Ein Standardbeispiel für Goto sind endliche Automaten oder Kellerautomaten. Die haben einen Zustand, der festlegt, was danach gemacht wird. Natürlich könnte man ein GOTO vermeiden, indem man schreibt „do if (state == 1) {...} elsif (state ==2) { ...“, aber das kaschiert nur, dass die Zustände eben Labels sind. Das Programm soll ja gar nicht selbst wartbar sein, sondern kommt so aus einem Scanner- bzw. Parsergenerator, und wer etwas daran ändern will (z.B. semantische Funktionen einbauen), soll ja nicht den erzeugten Quellcode verstehen, sondern die zugrundeliegenden Parsertabellen. --Lantani (Diskussion) 23:27, 16. Mär. 2018 (CET)

Dann gebe ich jetzt auch noch meinen Senf dazu... Wie heißt es im Artikel so schön? (Zitat) "...da nahezu jedes Goto..." Eben! "Nahezu" aber nicht "jedes". Es gibt viele Dinge, die man ohne GOTO gar nicht programmieren kann. Wie will man denn erreichen, dass der Programmablauf unter vorgegebenen Bedingungen, zu mehreren verschiedenen Stelle im Code zurückspringen kann? Das kann man unter vielen Situationen ohne GOTO gar nicht programmieren. Außerdem ist jede andere Lösung grundsätzlich immer langsamer als GOTO. Wenn ich ganze Programmteile, die unter bestimmten Bedingungen nicht abgearbeitet werden sollen, in ein IF-THEN stecke, dann wird das zwar funktionieren, aber mit dem Ergebnis, dass man hier ein absurdes Konstrukt schafft, das langsamer läuft und zudem eine Spagetti-Programmierung darstellt. Wenn ich den Programmablauf direkt zu einer anderen Stelle im Code schicken will, dann werde ich das immer mit GOTO machen. Die Diskussionen um die Verwendung von GOTO, halte ich außerdem genauso für unsinnig, wie die Diskussionen darüber, ob es für Radfahrer auf der Straße sicherer ist, als auf einem Radweg. Ist es nämlich nicht, wie die Unfallzahlen beweisen. Der Radweg wurde zur Kaiserzeit ja deshalb erfunden und eingeführt, weil es auf den Straßen für Radfahrer immer gefährlicher wurde. Mit den Radwegen gab es dann dieses Problem nicht mehr. Und heute, wo der Verkehr noch wesentlich dichter ist als zur Kaiserzeit, da meinen einige Menschen die Radfahrer wieder auf die Straße holen zu müssen, also wieder näher an die Gefahr. Das ist der gleiche Unsinn, wie über die Verwendung von GOTO zu diskutieren. Herr Dijkstra hat da 1968 eine vollkommen unsinnige These in die Welt gesetzt und erschreckender Weise, folgen ihr auch heute noch Informatiker / programmierende Menschen und springen wie die Lemminge von einer Klippe, ohne zu hinterfragen, ob das nicht kompletter Unsinn ist. Ich selbst programmiere übrigens bereits seit Ostern 1983 und werde mich daher auf keinen Fall auf derartige Irrwege begeben. GOTO ist für mich der zweitwichtigste Befehl von allen und es gibt aus meiner Sicht weder eine Alternative dazu, noch macht es Sinn auf ihn zu verzichten. --77.21.163.85 20:34, 14. Dez. 2020 (CET)

BKL "Rücksprung"

Rücksprung leitet auf S weiter. Es hat aber auch die Bedeutung eines antiken Winkelmaßes, nämlich, um welche Strecke eine geneigte Linie von der Senkrechten zurückweicht bzw. "-springt", wenn man sich um eine Einheit vertikal nach oben bewegt, bzw. in moderner Notation: der Kotangens des Winkels. --77.0.151.211 04:05, 29. Dez. 2021 (CET)

Computed GOTO fehlt im Artikel

Das sollte im Artikel noch erwähnt und erklärt werden. Hier gibt es einen Artikel dazu: https://eli.thegreenplace.net/2012/07/12/computed-goto-for-efficient-dispatch-tables --84.140.194.104 02:20, 5. Apr. 2024 (CEST)