Warum verwenden einige Kernel-Programmierer goto statt einfacher While-Schleifen?

Als ich C lernte, sagte mir der Lehrer den ganzen Tag: “Benutze nicht goto, das ist eine schlechte Angewohnheit, es ist hässlich, es ist gefährlich!” usw.

Warum verwenden dann einige Kernel-Programmierer gotozum Beispiel in dieser Funktionwo es durch ein einfaches ersetzt werden könnte

while(condition) {} 

oder

do {} while(condition);

Ich kann das nicht verstehen. Ist es in manchen Fällen besser, statt goto zu verwenden? while/do–while? Und wenn ja, warum?

Historischer Zusammenhang: Wir sollten uns daran erinnern, dass Dijkstra schrieb Gehe zu Wird als schädlich angesehen im Jahr 1968, als viele Programmierer benutzten goto als Ersatz für strukturierte Programmierung (if, while, foretc.).

Es ist 44 Jahre später und es ist selten, diese Verwendung von zu finden goto in der Wildnis. Die strukturierte Programmierung hat schon längst gewonnen.

Fall Analyse:

Der Beispielcode sieht so aus:

    SETUP...
again:
    COMPUTE SOME VALUES...
    if (cmpxchg64(ptr, old_val, val) != old_val)
        goto again;

Die strukturierte Version sieht so aus:

SETUP...
do {
    COMPUTE SOME VALUES...
} while (cmpxchg64(ptr, old_val, val) != old_val);

Wenn ich mir die strukturierte Version anschaue, denke ich sofort: „Das ist eine Schleife“. Wenn ich mir die ansehe goto Version, ich stelle es mir als eine gerade Linie mit einem “versuchen Sie es noch einmal”-Fall am Ende vor.

Das goto Version hat beides SETUP und COMPUTE SOME VALUES in derselben Spalte, was betont, dass der Kontrollfluss die meiste Zeit durch beide fließt. Die strukturierte Version setzt SETUP und COMPUTE SOME VALUES auf verschiedenen Spalten, was betont, dass die Kontrolle unterschiedlich durch sie hindurchgehen kann.

Die Frage hier ist, welche Art von Betonung möchten Sie in den Code legen? Damit kann man vergleichen goto zur Fehlerbehandlung:

Strukturierte Version:

if (do_something() != ERR) {
    if (do_something2() != ERR) {
        if (do_something3() != ERR) {
            if (do_something4() != ERR) {
                ...

Goto-Version:

if (do_something() == ERR)  // Straight line
    goto error;             // |
if (do_something2() == ERR) // |
    goto error;             // |
if (do_something3() == ERR) // |
    goto error;             // V
if (do_something4() == ERR) // emphasizes normal control flow
    goto error;

Der generierte Code ist im Grunde derselbe, sodass wir ihn uns als typografisches Problem vorstellen können, wie z. B. Einrückungen.

Bei diesem Beispiel vermute ich, dass es darum ging, die SMP-Unterstützung in Code nachzurüsten, der ursprünglich nicht SMP-sicher geschrieben wurde. Hinzufügen eines goto again; Pfad ist viel einfacher und weniger invasiv als die Umstrukturierung der Funktion.

Ich kann nicht sagen, dass ich diesen Stil sehr mag, aber ich denke auch, dass es falsch ist, ihn zu vermeiden goto aus ideologischen Gründen. Ein Sonderfall von goto Verwendung (anders als in diesem Beispiel) ist wo goto wird nur verwendet, um sich in einer Funktion vorwärts zu bewegen, niemals rückwärts. Diese Klasse von Verwendungen führt niemals zu Schleifenkonstrukten, die daraus entstehen gotound es ist fast immer der einfachste und klarste Weg, das erforderliche Verhalten zu implementieren (was normalerweise das Aufräumen und Zurückgeben bei Fehlern ist).

Sehr gute Frage, und ich denke, nur der Autor kann eine endgültige Antwort geben. Ich füge meine Spekulation hinzu, indem ich sage, dass es damit hätte beginnen können, es für die Fehlerbehandlung zu verwenden, wie von @Izkata erklärt, und die Tore waren dann offen, um es auch für grundlegende Schleifen zu verwenden.

Die Verwendung der Fehlerbehandlung ist meiner Meinung nach in der Systemprogrammierung legitim. Eine Funktion weist im Laufe ihres Fortschritts nach und nach Speicher zu, und wenn ein Fehler auftritt, wird dies der Fall sein goto das entsprechende Etikett, um die Ressourcen ab diesem Punkt in umgekehrter Reihenfolge freizugeben.

Wenn also der Fehler nach der ersten Zuordnung auftritt, wird zum letzten Fehlerlabel gesprungen, um nur eine Ressource freizugeben. Wenn der Fehler nach der letzten Zuweisung auftritt, springt er ebenso zum ersten Fehlerlabel und wird von dort aus ausgeführt, wodurch alle Ressourcen bis zum Ende der Funktion freigegeben werden. Ein solches Muster für die Fehlerbehandlung muss dennoch sorgfältig verwendet werden, insbesondere wenn Code geändert wird, Valgrind und Komponententests werden dringend empfohlen. Aber es ist wohl lesbarer und wartbarer als die alternativen Ansätze.

Eine goldene Nutzungsregel goto ist es, den sogenannten Spaghetti-Code zu vermeiden. Versuchen Sie, Linien zwischen den einzelnen zu ziehen goto Anweisung und das entsprechende Etikett. Wenn Sie Linien haben, die sich kreuzen, nun, Sie haben eine Linie überschritten :). Eine solche Verwendung von goto ist sehr schwer zu lesen und eine häufige Quelle für schwer zu verfolgende Fehler, da sie in Sprachen wie BASIC gefunden werden, die sich darauf verlassen, um den Fluss zu kontrollieren.

Wenn Sie nur eine einfache Schleife machen, werden sich keine Linien kreuzen, so dass es immer noch lesbar und wartbar ist und weitgehend eine Frage des Stils wird. Da sie jedoch genauso einfach mit den von der Sprache bereitgestellten Schleifenschlüsselwörtern ausgeführt werden können, wie Sie in Ihrer Frage angegeben haben, wäre meine Empfehlung immer noch, die Verwendung zu vermeiden goto for-Schleifen, einfach weil die for, do/while oder while Konstrukte sind von Natur aus eleganter.