Ist dies ein anständiger Anwendungsfall für goto in C?

Ich zögere wirklich, dies zu fragen, weil ich nicht "Debatten, Argumente, Umfragen oder erweiterte Diskussionen anregen" möchte, aber ich bin neu in C und möchte mehr Einsicht in die in der Sprache verwendeten Muster gewinnen.

Ich habe kürzlich eine gewisse Abneigung gegen den gotoBefehl gehört, aber ich habe auch kürzlich einen anständigen Anwendungsfall dafür gefunden.

Code wie folgt:

error = function_that_could_fail_1();
if (!error) {
    error = function_that_could_fail_2();
    if (!error) {
        error = function_that_could_fail_3();
        ...to the n-th tab level!
    } else {
        // deal with error, clean up, and return error code
    }
} else {
    // deal with error, clean up, and return error code
}

Wenn der Aufräum-Teil alles sehr ähnlich ist, könnte etwas hübscher (meiner Meinung nach?) Geschrieben werden:

error = function_that_could_fail_1();
if(error) {
    goto cleanup;
}
error = function_that_could_fail_2();
if(error) {
    goto cleanup;
}
error = function_that_could_fail_3();
if(error) {
    goto cleanup;
}
...
cleanup:
// deal with error if it exists, clean up
// return error code

Ist dies ein gängiger oder akzeptabler Anwendungsfall von gotoin C? Gibt es einen anderen / besseren Weg, dies zu tun?

Die gotoAnweisung (und seine entsprechenden Etiketten) sind ein Stromregel primitiver (zusammen mit bedingter Ausführung einer Anweisung). Damit meine ich, dass sie Ihnen den Aufbau von Netzwerken zur Programmflusssteuerung ermöglichen. Sie können sich diese als Modellierung der Pfeile zwischen den Knoten eines Flussdiagramms vorstellen.

Einige davon können sofort optimiert werden, wenn ein direkter linearer Fluss vorliegt (Sie verwenden nur eine Folge grundlegender Anweisungen). Andere Muster werden am besten durch strukturierte Programmierkonstrukte ersetzt, sofern diese verfügbar sind. Wenn es wie eine whileSchleife aussieht , verwenden Sie eine whileSchleife , OK? Die strukturierten Programmiermuster sind definitiv zumindest potenziell eindeutiger als ein Durcheinander von gotoAussagen.

C enthält jedoch nicht alle möglichen strukturierten Programmierkonstrukte. (Es ist mir nicht klar, dass alle relevanten bereits entdeckt wurden. Die Entdeckungsrate ist jetzt langsam, aber ich würde zögern, zu sagen, dass alle gefunden wurden.) Von denen, die wir kennen, fehlt C definitiv die try/ catch/ finallyStruktur (und Ausnahmen auch). Es fehlt auch Multi-Level- breakFrom-Loop. Dies sind die Arten von Dingen, mit denen gotoman etwas implementieren kann. Es ist möglich, auch andere Schemata zu verwenden - wir wissen, dass C eine ausreichende Menge vongotoPrimitive - aber diese beinhalten oft das Erstellen von Flag-Variablen und viel komplexeren Schleifen- oder Guard-Bedingungen; Durch eine stärkere Verknüpfung der Kontrollanalyse mit der Datenanalyse wird das Programm insgesamt schwerer verständlich. Dies erschwert auch die Optimierung des Compilers und die schnelle Ausführung der CPU (die meisten Flusssteuerungskonstrukte sind - und definitiv goto - sehr billig).

Daher sollten Sie nicht verwenden, es gotosei denn, Sie sollten sich bewusst sein, dass es vorhanden ist und dass es möglicherweise benötigt wird, und wenn Sie es benötigen, sollten Sie sich nicht zu schlecht fühlen. Ein Beispiel für einen Fall, in dem dies erforderlich ist, ist die Freigabe der Ressource, wenn eine aufgerufene Funktion eine Fehlerbedingung zurückgibt. (Das heißt, try/ finally.) Es ist möglich, das zu schreiben, ohne gotoes zu tun, aber das kann Nachteile für sich haben, wie zum Beispiel die Probleme, es zu warten. Ein Beispiel für den Fall:

int frobnicateTheThings() {
    char *workingBuffer = malloc(...);
    int i;

    for (i=0 ; i<numberOfThings ; i++) {
        if (giveMeThing(i, workingBuffer) != OK)
            goto error;
        if (processThing(workingBuffer) != OK)
            goto error;
        if (dispatchThing(i, workingBuffer) != OK)
            goto error;
    }

    free(workingBuffer);
    return OK;

  error:
    free(workingBuffer);
    return OOPS;
}

Der Code könnte noch kürzer sein, aber es reicht aus, um den Punkt zu demonstrieren.

Ja.

Es wird zum Beispiel im Linux-Kernel verwendet. Hier ist eine E-Mail vom Ende eines Threads von vor fast einem Jahrzehnt , der meinen aufdringlich macht:

Von: Robert Love
Betreff: Re: irgendeine Chance auf 2.6.0-Test *?
Datum: 12. Januar 2003 17:58:06 -0500

Am Sonntag, den 12.01.2003 um 17:22 schrieb Rob Wilkens:

Ich sage "Bitte benutze nicht goto" und habe stattdessen eine "cleanup_lock" -Funktion und füge diese vor allen return-Anweisungen hinzu. Es sollte keine Belastung sein. Ja, es fordert den Entwickler auf, etwas härter zu arbeiten, aber das Endergebnis ist besserer Code.

Nein, es ist ekelhaft und bläht den Kernel auf . Es enthält eine Menge Junk für N Fehlerpfade, anstatt den Exit-Code einmal am Ende zu haben. Der Cache-Fußabdruck ist der Schlüssel und Sie haben ihn gerade getötet.

Es ist auch nicht einfacher zu lesen.

Als letztes Argument lässt es uns nicht sauber das übliche stapelartige Auf- und Abwickeln machen , d. H

        do A
        if (error)
            goto out_a;
        do B
        if (error)
            goto out_b;
        do C
        if (error)
            goto out_c;
        goto out;
        out_c:
        undo C
        out_b:
        undo B:
        out_a:
        undo A
        out:
        return ret;

Jetzt hör auf damit.

Robert Love

Das heißt, es erfordert viel Disziplin, sich von der Erstellung von Spaghetti-Code abzuhalten, sobald Sie sich an die Verwendung von goto gewöhnt haben. Wenn Sie also nicht etwas schreiben, das Geschwindigkeit und geringen Speicherbedarf erfordert (wie einen Kernel oder ein eingebettetes System), sollten Sie das wirklich tun Denken Sie darüber nach, bevor Sie das erste Goto schreiben.

Meiner Meinung nach ist der von Ihnen veröffentlichte Code ein Beispiel für eine gültige Verwendung von goto, da Sie nur nach unten springen und ihn nur wie einen primitiven Ausnahmebehandler verwenden.

Aufgrund der alten goto-Debatte meiden Programmierer jedoch seit gotorund 40 Jahren und sind daher nicht daran gewöhnt, Code mit goto zu lesen. Dies ist ein triftiger Grund, um Goto zu vermeiden: Es ist einfach nicht der Standard.

Ich hätte den Code so umgeschrieben, dass er von C-Programmierern leichter gelesen werden kann:

Error some_func (void)
{
  Error error;
  type_t* resource = malloc(...);

  error = some_other_func (resource);

  free (resource);

  /* error handling can be placed here, or it can be returned to the caller */

  return error;
}


Error some_other_func (type_t* resource)  // inline if needed
{
  error = function_that_could_fail_1();
  if(error)
  {
    return error;
  }

  /* ... */

  error = function_that_could_fail_2();
  if(error)
  {
    return error;
  }

  /* ... */

  return ok;
}

Vorteile dieses Designs:

• Die Funktion, die die eigentliche Arbeit ausführt, muss sich nicht mit Aufgaben befassen, die für ihren Algorithmus irrelevant sind, wie z. B. die Zuweisung von Daten.
• C-Programmierern wird der Code weniger fremd erscheinen, da sie Angst vor goto und labels haben.
• Sie können die Fehlerbehandlung und die Freigabe an derselben Stelle außerhalb der Funktion, die den Algorithmus ausführt, zentralisieren. Es macht keinen Sinn, dass eine Funktion mit ihren eigenen Ergebnissen umgeht.

Ein berühmtes Papier, das den Fall einer gültigen Verwendung von beschreibt, war Structured Programming with GOTO Statement von Donald E. Knuth (Stanford University). Das Papier erschien in den Tagen, in denen die Verwendung von GOTO von einigen als Sünde angesehen wurde und als die Bewegung für strukturierte Programmierung ihren Höhepunkt erreichte. Vielleicht möchten Sie einen Blick auf GoTo als schädlich werfen .

In Java würden Sie das so machen:

makeCalls:  {
    error = function_that_could_fail_1();
    if (error) {
        break makeCalls;
    }
    error = function_that_could_fail_2();
    if (error) {
        break makeCalls;
    }
    error = function_that_could_fail_3();
    if (error) {
        break makeCalls;
    }
    ...
    return 0;  // No error code.
}
// deal with error if it exists, clean up
// return error code

Ich benutze das viel. So sehr ich es auch nicht mag goto, in den meisten anderen Sprachen im C-Stil verwende ich Ihren Code. Es gibt keinen anderen guten Weg, dies zu tun. (Das Herausspringen aus verschachtelten Schleifen ist ein ähnlicher Fall. In Java verwende ich eine beschriftete breakund in allen anderen Fällen eine goto.)

Ich denke, es ist ein anständiger Anwendungsfall, aber wenn "error" nichts anderes als ein boolescher Wert ist, gibt es einen anderen Weg, um das zu erreichen, was Sie wollen:

error = function_that_could_fail_1();
error = error || function_that_could_fail_2();
error = error || function_that_could_fail_3();
if(error)
{
     // do cleanup
}

Dies nutzt die Kurzschlussauswertung von Booleschen Operatoren. Wenn dies "besser" ist, hängt es von Ihrem persönlichen Geschmack ab und wie Sie an diese Redewendung gewöhnt sind.

Der Linux Style Guide gibt spezifische Gründe für die Verwendung von goto's, die Ihrem Beispiel entsprechen:

https://www.kernel.org/doc/Documentation/process/coding-style.rst

Das Grundprinzip für die Verwendung von gotos ist:

• Unbedingte Aussagen sind leichter zu verstehen und zu befolgen
• Verschachtelung wird reduziert
• fehler durch nicht aktualisierung einzelner ausgangspunkte bei änderungen werden verhindert
• spart dem Compiler Arbeit, um redundanten Code weg zu optimieren;)

Haftungsausschluss Ich soll meine Arbeit nicht teilen. Die Beispiele hier sind ein bisschen erfunden, bitte tragen Sie mit mir.

Dies ist gut für die Speicherverwaltung. Ich habe kürzlich an Code gearbeitet, der dynamisch zugewiesenen Speicher hatte (zum Beispiel einen char *von einer Funktion zurückgegebenen). Eine Funktion, die einen Pfad untersucht und feststellt, ob der Pfad gültig ist, indem die Token des Pfads analysiert werden:

tmp_string = strdup(string);
token = strtok(tmp_string,delim);
while( token != NULL ){
    ...
    some statements, some involving dynamically allocated memory
    ...
    if ( check_this() ){
        free(var1);
        free(var2);
        ...
        free(varN);
        return 1;
    }
    ...
    some more stuff
    ...
    if(something()){
        if ( check_that() ){
            free(var1);
            free(var2);
            ...
            free(varN);
            return 1;
        } else {
            free(var1);
            free(var2);
            ...
            free(varN);
            return 0;
        }
    }
    token = strtok(NULL,delim);
}

free(var1);
free(var2);
...
free(varN);
return 1;

Für mich ist der folgende Code viel netter und einfacher zu pflegen, wenn Sie Folgendes hinzufügen müssen varNplus1:

int retval = 1;
tmp_string = strdup(string);
token = strtok(tmp_string,delim);
while( token != NULL ){
    ...
    some statements, some involving dynamically allocated memory
    ...
    if ( check_this() ){
        retval = 1;
        goto out_free;
    }
    ...
    some more stuff
    ...
    if(something()){
        if ( check_that() ){
            retval = 1;
            goto out_free;
        } else {
            retval = 0;
            goto out_free;
        }
    }
    token = strtok(NULL,delim);
}

out_free:
free(var1);
free(var2);
...
free(varN);
return retval;

Jetzt hatte der Code alle möglichen anderen Probleme, nämlich dass N irgendwo über 10 lag und die Funktion über 450 Zeilen mit 10 Verschachtelungsebenen an einigen Stellen.

Aber ich habe meinem Vorgesetzten angeboten, es umzugestalten, was ich auch getan habe, und jetzt gibt es eine Reihe von Funktionen, die alle kurz sind und alle den Linux-Stil haben

int function(const char * param)
{
    int retval = 1;
    char * var1 = fcn_that_returns_dynamically_allocated_string(param);
    if( var1 == NULL ){
        retval = 0;
        goto out;
    }

    if( isValid(var1) ){
         retval = some_function(var1);
         goto out_free;
    }

    if( isGood(var1) ){
         retval = 0;
         goto out_free;
    }

out_free:
    free(var1);
out:
    return retval;
}

Wenn wir das Äquivalent ohne gotos betrachten:

int function(const char * param)
{
    int retval = 1;
    char * var1 = fcn_that_returns_dynamically_allocated_string(param);
    if( var1 != NULL ){

       if( isValid(var1) ){
            retval = some_function(var1);
       } else {
          if( isGood(var1) ){
               retval = 0;
          }
       }
       free(var1);

    } else {
       retval = 0;
    }

    return retval;
}

Für mich ist es im ersten Fall offensichtlich, dass NULLwir hier raus und zurückkehren , wenn die erste Funktion zurückkehrt 0. Im zweiten Fall muss ich nach unten scrollen, um zu sehen, dass das if die gesamte Funktion enthält. Zugegeben, der erste zeigt mir dies stilistisch an (der Name " out") und der zweite macht es syntaktisch. Der erste ist noch offensichtlicher.

Außerdem bevorzuge ich es sehr, free()Anweisungen am Ende einer Funktion zu haben. Dies liegt meiner Erfahrung nach zum Teil daran, dass free()Aussagen in der Mitte von Funktionen schlecht riechen und mir signalisieren, dass ich ein Unterprogramm erstellen sollte. In diesem Fall habe ich var1in meiner Funktion erstellt und konnte es nicht free()in einem Unterprogramm, aber das ist der Grund goto out_free, warum der Goto-Out-Stil so praktisch ist.

Ich denke, Programmierer müssen in dem Glauben erzogen werden, dass gotoes böse ist. Wenn sie dann ausgereift sind, sollten sie den Linux-Quellcode durchsuchen und den Linux-Styleguide lesen.

Ich sollte hinzufügen, dass ich diesen Stil sehr konsequent verwende, jede Funktion hat ein int retval, ein out_freelabel und ein out label. Aufgrund der stilistischen Konsistenz wird die Lesbarkeit verbessert.

Bonus: Bricht und geht weiter

Angenommen, Sie haben eine while-Schleife

char *var1, *var2;
char line[MAX_LINE_LENGTH];
while( sscanf(line,... ){
    var1 = functionA(line,count);
    var2 = functionB(line,count);

    if( functionC(var1, var2){
         count++
         continue;
    }

    ...
    a bunch of statements
    ...

    count++;
    free(var1);
    free(var2);
}

An diesem Code sind andere Dinge falsch, aber eine Sache ist die continue-Anweisung. Ich würde das Ganze gerne umschreiben, hatte aber den Auftrag, es ein wenig zu modifizieren. Ich hätte Tage gebraucht, um es auf eine Weise umzugestalten, die mich zufriedenstellte, aber die eigentliche Änderung war ungefähr ein halber Tag Arbeit. Das Problem ist, dass wir, auch wenn wir " continue" noch frei var1und brauchen var2. Ich musste ein hinzufügen var3, und es brachte mich dazu, kotzen zu müssen, um die free () -Anweisungen zu spiegeln.

Ich war zu der Zeit ein relativ neuer Praktikant, aber ich hatte vor einiger Zeit zum Spaß den Linux-Quellcode angesehen und meinen Vorgesetzten gefragt, ob ich eine goto-Anweisung verwenden könnte. Er sagte ja und ich tat dies:

char *var1, *var2;
char line[MAX_LINE_LENGTH];
while( sscanf(line,... ){
    var1 = functionA(line,count);
    var2 = functionB(line,count);
    var3 = newFunction(line,count);

    if( functionC(var1, var2){
         goto next;
    }

    ...
    a bunch of statements
    ...
next:
    count++;
    free(var1);
    free(var2);
}

Ich denke, die Fortsetzung ist im besten Fall in Ordnung, aber für mich sind sie wie ein Goto mit einem unsichtbaren Etikett. Das gleiche gilt für Pausen. Ich würde es immer noch vorziehen, fortzufahren oder abzubrechen, es sei denn, wie hier, es zwingt Sie, Änderungen an mehreren Stellen zu spiegeln.

Und ich sollte hinzufügen, dass diese Verwendung von goto next;und das next:Etikett für mich unbefriedigend sind. Sie sind lediglich besser als das Spiegeln free()der count++Aussagen und Aussagen.

gotosind fast immer falsch, aber man muss wissen, wann sie gut zu gebrauchen sind.

Eine Sache, die ich nicht besprochen habe, ist die Fehlerbehandlung, die in anderen Antworten behandelt wurde.

Performance

Man kann sich die Implementierung von strtok () ansehen: http://opensource.apple.com//source/Libc/Libc-167/string.subproj/strtok.c

#include <stddef.h>
#include <string.h>

char *
strtok(s, delim)
    register char *s;
    register const char *delim;
{
    register char *spanp;
    register int c, sc;
    char *tok;
    static char *last;


    if (s == NULL && (s = last) == NULL)
        return (NULL);

    /*
     * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
     */
cont:
    c = *s++;
    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
        if (c == sc)
            goto cont;
    }

    if (c == 0) {       /* no non-delimiter characters */
        last = NULL;
        return (NULL);
    }
    tok = s - 1;

    /*
     * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
     * Note that delim must have one NUL; we stop if we see that, too.
     */
    for (;;) {
        c = *s++;
        spanp = (char *)delim;
        do {
            if ((sc = *spanp++) == c) {
                if (c == 0)
                    s = NULL;
                else
                    s[-1] = 0;
                last = s;
                return (tok);
            }
        } while (sc != 0);
    }
    /* NOTREACHED */
}

Bitte korrigieren Sie mich, wenn ich falsch liege, aber ich glaube, dass das cont:Label und die goto cont;Aussage der Leistung dienen (sie machen den Code mit Sicherheit nicht besser lesbar). Sie könnten durch lesbaren Code ersetzt werden

while( isDelim(*s++,delim));

Begrenzer zu überspringen. Um jedoch so schnell wie möglich zu sein und unnötige Funktionsaufrufe zu vermeiden, tun sie dies auf diese Weise.

Ich habe die Zeitung von Dijkstra gelesen und finde sie ziemlich esoterisch.

google "dijkstra goto statement" als schädlich eingestuft, da ich nicht genug Reputation habe, um mehr als 2 Links zu posten.

Ich habe gesehen, dass es als ein Grund angeführt wurde, goto's nicht zu verwenden, und dass das Lesen nichts daran geändert hat, was meine Verwendung von goto's angeht.

Nachtrag :

Ich habe mir eine ordentliche Regel ausgedacht, während ich darüber nachdachte, wie es weitergeht und wie es weitergeht.

• Wenn Sie in einer while-Schleife eine continue-Anweisung haben, sollte der Rumpf der while-Schleife eine Funktion und die continue-Anweisung eine return-Anweisung sein.
• Wenn Sie in einer while-Schleife eine break-Anweisung haben, sollte die while-Schleife selbst eine Funktion und die break-Anweisung eine return-Anweisung sein.
• Wenn Sie beide haben, ist möglicherweise etwas nicht in Ordnung.

Aufgrund von Umfangsproblemen ist dies nicht immer möglich, aber ich habe festgestellt, dass es dadurch viel einfacher ist, über meinen Code nachzudenken. Mir war aufgefallen, dass es mir immer ein schlechtes Gefühl gab, wenn eine while-Schleife eine Pause oder ein Fortsetzen hatte.

Persönlich würde ich es eher so umgestalten:

int DoLotsOfStuffThatCouldFail (paramstruct *params)
{
    int errcode = EC_NOERROR;

    if ((errcode = FunctionThatCouldFail1 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail2 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail3 (params)) != EC_NOERROR) return errcode;
    if ((errcode = FunctionThatCouldFail4 (params)) != EC_NOERROR) return errcode;

    return EC_NOERROR;
}

void DoStuff (paramstruct *params)
{
    int errcode = EC_NOERROR;

    InitStuffThatMayNeedToBeCleaned (params);

    if ((errcode = DoLotsOfStuffThatCouldFail (params)) != EC_NOERROR)
    {
         CleanupAfterError (params, errcode);
    }
}

Das wäre motivierter, wenn man das Deep Nesting vermeidet, als wenn man das Goto vermeidet (IMO ein schlimmeres Problem mit dem ersten Codebeispiel), und wäre natürlich davon abhängig, dass CleanupAfterError außerhalb des Geltungsbereichs möglich ist (in diesem Fall "params") Eine Struktur, die einen zugewiesenen Speicher enthält, den Sie freigeben müssen, eine Datei *, die Sie schließen müssen, oder was auch immer.

Ein wesentlicher Vorteil, den ich bei diesem Ansatz sehe, ist, dass es sowohl einfacher als auch sauberer ist, einen hypothetischen zukünftigen zusätzlichen Schritt zwischen beispielsweise FTCF2 und FTCF3 einzufügen (oder einen vorhandenen aktuellen Schritt zu entfernen), sodass sich die Wartbarkeit (und die Person, die dies tut) verbessern erbt meinen Code, will mich nicht lynchen!) - beiseite, die verschachtelte Version hat das nicht.

Sehen Sie sich die C-Codierungsrichtlinien der MISRA (Motor Industry Software Reliability Association) an, die es ermöglichen, unter strengen Kriterien zu arbeiten (die Ihr Beispiel erfüllt).

Wo ich arbeite, wird derselbe Code geschrieben - es ist nicht erforderlich - unnötige religiöse Debatten über sie zu vermeiden, ist ein großes Plus in jedem Softwarehaus.

error = function_that_could_fail_1();
if(!error) {
  error = function_that_could_fail_2();
}
if(!error) {
  error = function_that_could_fail_3();
} 
if(!error) {
...
if (error) {
  cleanup:
} 

oder für "goto in drag" - etwas noch zwielichtigeres als goto, aber umgeht das "no goto ever !!!" camp) "Sicherlich muss es OK sein, verwendet nicht Springen" ....

do {
  if (error = function_that_could_fail_1() ){
    break 
  }
  if (error = function_that_could_fail_2() ){
    break 
  }
  ....... 
} while (0) 
cleanup();
.... 

Wenn die Funktionen denselben Parametertyp haben, legen Sie sie in eine Tabelle und verwenden Sie eine Schleife.

Ich benutze auch, gotowenn das alternative do/while/continue/breakHackery weniger lesbar wäre.

gotos haben den Vorteil, dass ihre Ziele einen Namen haben und sie lesen goto something;. Dies kann besser lesbar als breakoder continuewenn Sie nicht wirklich stoppen oder etwas fortsetzt.

for (int y=0; y<height; ++y) {
    for (int x=0; x<width; ++x) {
        if (find(x, y)) goto found;
    }
}
found:

Es wird immer Lager geben, die sagen, dass ein Weg akzeptabel ist und ein anderer nicht. Unternehmen, für die ich gearbeitet habe, haben die Stirn gerunzelt oder von der Verwendung dringend abgeraten. Persönlich kann ich mir keine Zeit vorstellen, in der ich eine verwendet habe, aber das bedeutet nicht, dass sie schlecht sind, sondern nur eine andere Art, Dinge zu tun.

In C mache ich normalerweise Folgendes:

• Auf Bedingungen prüfen, die die Verarbeitung verhindern könnten (fehlerhafte Eingaben usw.) und "return"
• Führen Sie alle Schritte aus, die eine Ressourcenzuweisung erfordern (z. B. Mallocs).
• Führen Sie die Verarbeitung durch, wobei mehrere Schritte auf Erfolg prüfen
• Geben Sie bei erfolgreicher Zuordnung alle Ressourcen frei
• Ergebnisse zurückgeben

Für die Verarbeitung würde ich anhand Ihres goto-Beispiels Folgendes tun:

error = function_that_could_fail_1 (); if (! error) {error = function_that_could_fail_2 (); } if (! error) {error = function_that_could_fail_3 (); }

Es gibt keine Verschachtelung, und innerhalb der if-Klauseln können Sie Fehlerberichte erstellen, wenn der Schritt einen Fehler generiert hat. Es muss also nicht "schlimmer" sein als eine Methode mit gotos.

Ich bin noch nicht auf einen Fall gestoßen, in dem jemand Dinge hat, die mit einer anderen Methode nicht gemacht werden können und die genauso lesbar / verständlich sind, und das ist der Schlüssel, IMHO.