Single-entry/single-exit-Regel

Habe ich gelesen, die in der Regel irgendwo:

Folgen Sie den single-entry/single-exit-Regel. Schreiben Sie niemals mehrere return-Anweisungen in derselben Funktion.

Ist diese Aussage wahr? Wenn das so ist, könnten Sie bitte geben Sie mehr Details, warum sollten wir diese Regel befolgen?

  • "Ist das wahr?" Sowie Sie nicht haben, um ihm zu Folgen, die Sprache ist vollkommen glücklich, mit mehreren return Aussagen, und meiner Meinung nach, es ist in Ordnung, Sie zu benutzen. Das problem ist, wenn Sie haben eine Menge von returns in kompliziert verschachtelten Logik. Das kann schwierig sein, zu Folgen. Wenn die Funktion eine Menge returns, die Sie wahrscheinlich benötigen, zu überarbeiten. Sie könnten auch interessiert zu wissen, dass in Fortran-Funktionen können mehrere Einstiegspunkte sowie, und die Leute tun Sie verwenden.
  • Ich dachte immer, die Regel ist dumm, in der coding-Regeln
  • Es ist auch zu Bedenken, dass Ihre Funktionen kann die Ausfahrt über eine Ausnahme, wie gut, die Dinge komplizieren sich weiter, und es ist oft schwierig zu wissen, wo Sie kommen könnte.
  • Das klingt wie etwas, was ein C-Programmierer sagen könnte. In C++, vorzeitiger Ausstieg ist ein sehr nützliches idiom.
  • SESE nicht viel hinzuzufügen Wert in garbage Collection-Sprachen wie C# und Java, aber es ist eine gute übung für C und C++. Lecks oder Abstürze durch fehlende oder falsche clean-up-Logik ist ein sehr häufiger Fehler. Selbst wenn Sie makellos sind, sicherzustellen, dass jeder Ausgangspunkt in Ihren Funktionen reinigt richtig -, Wartungs-Programmierer sind viel eher zu Fehlern führen, wenn Sie fügen Sie eine zusätzliche Prüfung für die Bedingungen, die waren nicht zunächst erwartet, zeigte sich aber während der Prüfung. SESE sorgt dafür, dass es nur ein Stück code, pro-Funktion, die Griffe clean-up, und es gibt keinen Weg, um es zu umgehen.
  • Ich werde nur hinzufügen, dass ich nennen würde SESE, eine 'gute Praxis', in der Regel nicht. Wenn kann eine Funktion eine Ausnahme werfen, die Sie brauchen, um es zu fangen, so dass Sie Aufräumen können, bevor erneute auslösen oder beenden in der Regel. Wenn Sie brauchen, um rethrow die Ausnahme, können Sie feststellen, dass mehrere Punkte zu beenden, jedes mit seiner eigenen Kopie des clean-up-code ist die beste option.
  • Es ist eine Frage, die auf das Thema der SE-Software Engineering, mit sehr guten Antworten : Wo haben die Vorstellung von "eine Rückkehr nur" kommen?. (Ich lasse das hier, weil ich denke, es könnte helfen, Menschen auf der Suche nach Materialien zum Thema)
  • Es ist falsch. das Prinzip der "single-entry-single-exit-Unterprogramm" stammt aus einer Zeit, als die Menschen versuchten, zur Förderung der "strukturierten Programmierung". C++ als Sprache, strukturiert ist. Außer für longjmp() alle Funktionen haben einen einzigen Ausgang, unabhängig davon, wie viele return-Anweisungen sind dort, weil Sie alle zurück an den gleichen Ort (die Funktionen aufrufen-site). In den 1960er Jahren war das nicht unbedingt wahr in Programme. So wurde die Zuordnung von IEC61508 der Begriff "single-exit", um eine "Rückkehr" in C++ ist falsch!

InformationsquelleAutor Nayana Adassuriya | 2012-10-05
  1. 0

    Ich bin persönlich nicht gegen zu früh verlassen, aber ich werde vorschlagen, eine Dritte alternative zu SingerOfTheFall für die Prüfung.

    Vorteile:

    • normalen code flow (d.h. nicht-Fehler) fließt sauber durch den oberen Rand
      der code
    • keine chance, zu scheitern einer "etwas" und vorbei an einem anderen
      "etwas" versehentlich ausführen eines code-block
    • können Sie erzwingen Bereich auf code-Blöcke; darunter auch sauber-bis auf exit-Möglichkeiten für die Dinge verwendet, die in sub-code-Blöcke

    Nachteil:

    • Vertiefungen hinzufügen können (obwohl dies kann gemildert werden durch brechen
      in sub-Funktionen)
    • ohne Klammer-matching in Ihrem editor kann es entsprechend schwierig sein Fehler mit fehlerhaften Zustand
    int foo() 
{ 
int errorCode = 0; 
if(!etwas) { 
//100 Zeilen code 
if(!etwas) { 
//100 Zeilen code 
if(!etwas) { 
//100 Zeilen code 
} 
else { 
errorCode = -1; 
} 
} 
else { 
errorCode = 11; 
} 
} 
else { 
errorCode = 1; 
} 
return errorCode; 
}
    InformationsquelleAutor mark
  2. 18

    Ist das wahr?

    Dass das, was die Regel sagt, in Orten, wo es verwendet wird und durchgesetzt werden. Ist es eine gute Regel? Ich Kämpfe gegen seine Einführung zahn-und Nagelpflege. Ich denke es ist eine blöde Regel. Schlimmer als dumm: Es ist eine schädliche Regel für C++.

    Ich bin einverstanden mit dem ersten Teil der Regel, "single entry". Die Fortran - entry - Anweisung bewirkt, dass viel mehr Probleme, als es löst. Dieser erste Teil der Regel nicht beziehen sich auf C oder C++, aus dem einfachen Grund, dass weder Sprache bietet eine multiple-entry-point-Mechanismus. "Single entry" ist eine no-op in C und C++.

    Also, was über "single-exit"? Die vorzeitige Rückreise muss nicht unbedingt zu Problemen führen. Andernfalls Umgang mit Ressourcen zugewiesen vor der Rückgabe ist das, was Probleme verursacht. Die richtige Regel ist, "clean up your mess", oder " don ' T leave baumeln Ressourcen. Eine Ausfahrt nicht dieses problem lösen, weil es nicht sagen, eine Sache zu bereinigen Ihre Durcheinander.

    In C, die single-entry /single-exit-Regel, die in der Regel hand in hand geht mit erlaubt (und sogar ermutigt) die Verwendung von goto für die Fehlerbehandlung. Ich kann sehen, dass der Platz für goto wie für die Fehlerbehandlung in den Linux-kernel-code. Aber nicht in C++. Dies ist der Grund, warum ich schrieb, dass single-entry /single-exit wird schädlich in C++. Diese Regel vermeidet die Verwendung von RAII und exception-sicher Programmieren, und ermutigt die Verwendung von goto.

    • Ihre Antwort und SingerOfTheFall die kombiniert werden sollen, auf einer einzigen, zu erklären, warum die einzige Ausfahrt ist ziemlich lächerlich.
    • Ich denke, der ursprüngliche Zweck der Regel war es, zu vermeiden, die 500-Linie lange Methoden/Prozeduren/Funktionen und halten Sie Sie kurz und einfach, aber Sie bekam aus der hand: Die eine Methode/Prozedur/Funktion ist eine Sache und eine Sache nur, bereinigen Ihre Verwirrung und zu versuchen, halten Nebenwirkungen auf ein minimum was sein sollte, dachte stattdessen, wenn überhaupt. Mehr als 30 Zeilen pro Methode/Prozedur/Funktion ist ein code smell. Keine Regel ist absolut, sondern der Vereinfachung der code, wie dies mit guten Namenskonventionen in der Regel bekommt Sie portable-und wartbaren code und vermeidet Redundanz.
    InformationsquelleAutor David Hammen
  3. 13

    Nein, das ist nicht die Regel, und manchmal ist es auch schwer/unmöglich zu erreichen. Der code einer entry-und eine exit-Punkt ist einfacher zu verstehen und zu Debuggen obwohl. Vergleichen Sie dies:

    int foo()
{
    if(something)
        return 0;
    //100 lines of code
    if(something)
        return 11;
    //100 lines of code
    if(something)
        return -1;
    //100 lines of code
    return 0;
}

    und so:

    int foo()
{
    int errorCode = 0;
    if(something)
        errorCode = 1;
    //100 lines of code
    if(something)
        errorCode = 11;
    //100 lines of code
    if(something)
        errorCode = -1;
    //100 lines of code
    return errorCode;
}

    Jetzt haben wir nur einen exit-Punkt, und (unter Berücksichtigung der Variablen-name auch), es ist viel einfacher zu verstehen, was die Funktion tut. Sie können auch einen breakpoint auf die Letzte zurück und wissen, dass dies ist der Punkt, wo die Funktion endet, und, dass Sie definitiv schlagen.

    • Das Beispiel mit errorCode vielleicht nicht die beste, da möchten Sie vielleicht, um tatsächlich zu stoppen, Ausführung rechts, wo der Fehler Auftritt, aber ich hoffe, Sie bekommen die Idee.
    • Tatsächlich, dein zweites Beispiel könnte verbuggt sein, wenn es tun soll die gleiche wie die erste, da "return" beendet die Ausführung der Funktion, in der Erwägung, dass Sie weiterhin mit dem code, der folgt. In Fällen wie diesem, ich in der Regel überprüfen Sie den Rückgabewert für eine spezielle "nicht festgelegt" - Wert, der festgelegt wird, am Anfang.
    • Sieber : die Reihenfolge auf dem zweiten Beispiel sollte -1,11,0 statt 1,11,-1 auf die erste, aber es ist nicht wirklich wichtig. Es ist ganz klar, was es will, zu veranschaulichen: Eine Ausfahrt ist weniger effizient und schwieriger zu Lesen, zumindest in den Fällen so.
    • Das größte problem mit diesem code, oder der code in die akzeptierte Antwort ist ein 310-line-long Funktion. Das ist lange auch von den meisten C-Normen.
    InformationsquelleAutor SingerOfTheFall
  4. 5

    Dieser Regel kann gelten in C, aber es kann als obsolet werden in C++ wegen der Ausnahmen. Sobald Sie Ihre Funktion löst eine exception aus oder ruft eine Funktion, die werfen können, haben Sie eine zusätzliche exit-Punkt:

    int f()
{
  //...
  g(); //g() may throw: you have an exit point here
  //...
  throw exc; //another possible exit point
  //...
  return returnValue; //Nice try, but you have additional exit points
}

    Neben dem Punkt, auf den in anderen Antworten: diese Regel beabsichtigt, um den code leichter zu Folgen, aber es ist leicht, Beispiele zu finden, wo das ist nicht wahr. Viel besser:

    if (condition)
  return a;
if (condition2)
  return b;
if (condition3)
  return c;

//Insert all your code for the general case

    als:

    int returnValue;    
if (!condition) {
  if (!condition2) {
    if (!condition3) {
      //Insert your code here
    }
    else {
      returnValue = c;
    }
    returnValue = b;  //Where am I now?
  }
  returnValue = a;
}
return returnValue;

    Und dann haben Sie auch dann der Fall, wenn Sie sich entscheiden, den Rückgabewert in einer switch:

    switch (a)
{
  case 1: return 10;
  case 2: return 20;
  case 3: return 40;
  default: return 50;
}

    statt:

    int returnValue;
switch (a)
{
  case 1: returnValue = 10; break;
  case 2: returnValue = 20; break;
  case 3: returnValue = 40; break;
  default: returnValue = 50; break;
}
return returnValue; //Where is the clarity gained?
    • Einige coding-standards haben eine "keine Ausnahmen" - Regel. Diejenigen, die auch einen "single point of entry / single-point-of-exit" - Regel rechtfertigen, die "keine Ausnahmen" in der Regel auf der Grundlage dieser einmalig in der Regel schlecht.
    • Ah, sicher. Danke.
    InformationsquelleAutor Gorpik
  5. 2

    Auch mehrere Ausgänge sein könnte, einige performance-Problem: wenn der Prozessor führt den aktuellen Befehl an der gleichen clock tick it-Prozesse einige weiter Befehle und führt einige Operationen mit Ihnen. Also, wenn Ihr code hat mehrere Ausgänge, so:

    if (condition)
  return a;
DoSomething();
if (condition2)
  return b;

    und erste Bedingung wahr ist, wird die Extraktion von DoSomething() Befehl wird nutzlos sein.
    Tatsächlich, mit der branch prediction ist es noch in Ordnung sein kann, aber trotzdem ist es besser, halten diese Sache im Auge.

    • Nein, es ist nicht performance-Problem in der Tat low-level-Programmierung ähnlich. Es nur Programmier-Stil.
    • Es spielt keine Rolle, was Sie tun: high-level oder low level, Ihr Programm kann sequentiell oder enthalten cross-code springt auf Sie beide. Jedenfalls Sprünge sind nicht gut für die Leistung, da der parallel instruction Handhabung im Prozessor. Was ist genau der Punkt, den du mit mir nicht einverstanden?
    • Springen verursachen schwer Fehler ein code, warum strukturelle Programmierung kommen im Konzept. Aber die Ausführung Effizienz ist nicht ein Problem in der high-level Programmierung(wenn Ihr nicht ein Teil des Algorithmus). Also deine Antwort ist nicht im Zusammenhang zur gestellten Frage....alle Möglichkeiten, die ich nicht bewusst war, dass "die Sprünge sind nicht gut für die Leistung, da der parallel instruction Handhabung im Prozessor". Guter Punkt.
    • In einer rein-funktionalen Ansatz weiter, multi-Ausgang ist die Regel.
    InformationsquelleAutor Choufler
  6. 0

    Können Sie speichern Ihren Rückgabewert in einer Variablen, wenn Sie wollen, um dies zu erreichen, aber es ist nicht wahr. Sie können mehrere gibt in der gleichen Funktion ohne Probleme.

    InformationsquelleAutor Lajos Arpad
Schreibe einen Kommentar