Switch-Anweisung fällt durch ... sollte es erlaubt sein? [geschlossen]

So lange ich mich erinnern kann, habe ich es vermieden, die switch-Anweisung fall-through zu verwenden. Eigentlich kann ich mich nicht erinnern, dass es jemals in mein Bewusstsein eingedrungen ist, um Dinge zu tun, da mir schon früh in den Kopf gebohrt wurde, dass es nichts weiter als ein Fehler in der switch-Anweisung war. Heute bin ich jedoch auf Code gestoßen, der ihn von Natur aus verwendet, und habe mich sofort gefragt, was alle in der Community über das Durchfallen von switch-Anweisungen denken.

Ist es etwas, das eine Programmiersprache explizit nicht zulassen sollte (wie C #, obwohl es eine Problemumgehung bietet), oder ist es eine Funktion einer Sprache, die leistungsfähig genug ist, um sie in den Händen des Programmierers zu belassen?

Bearbeiten: Ich war nicht spezifisch genug für das, was ich mit Durchfall meinte. Ich benutze diesen Typ oft:

    switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something
            break;
        case 2:
        case 3:
        case 4:
            // Do something
            break;
   }

Ich mache mir jedoch Sorgen um so etwas.

   switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something, but fall through to the other cases
            // after doing it.

        case 2:
        case 3:
        case 4:
            // Do something else.
            break;
   }

Auf diese Weise wird immer dann, wenn der Fall 0, 1 ist, alles in der switch-Anweisung ausgeführt. Ich habe dies beabsichtigt und weiß nur nicht, ob ich damit einverstanden bin, dass switch-Anweisungen auf diese Weise verwendet werden. Ich denke, das erste Codebeispiel ist sehr nützlich und sicher. Der zweite scheint irgendwie gefährlich zu sein.

Es kann davon abhängen, was Sie als Durchfall betrachten. Ich bin mit so etwas einverstanden:

switch (value)
{
  case 0:
    result = ZERO_DIGIT;
    break;

  case 1:
  case 3:
  case 5:
  case 7:
  case 9:
     result = ODD_DIGIT;
     break;

  case 2:
  case 4:
  case 6:
  case 8:
     result = EVEN_DIGIT;
     break;
}

Aber wenn Sie eine Fallbezeichnung haben, gefolgt von Code, der zu einer anderen Fallbezeichnung durchfällt, würde ich das so ziemlich immer für böse halten. Vielleicht wäre es besser, den gemeinsamen Code in eine Funktion zu verschieben und von beiden Stellen aus aufzurufen.

Und bitte beachten Sie, dass ich die C ++ - FAQ- Definition von "böse" verwende.

Es ist ein zweischneidiges Schwert. Es ist manchmal sehr nützlich, aber oft gefährlich.

Wann ist es gut Wenn Sie möchten, dass 10 Fälle alle gleich verarbeitet werden ...

switch (c) {
  case 1:
  case 2:
            ... Do some of the work ...
            /* FALLTHROUGH */
  case 17:
            ... Do something ...
            break;
  case 5:
  case 43:
            ... Do something else ...
            break;
}

Die einzige Regel, die ich mag, ist, dass Sie, wenn Sie jemals etwas Besonderes tun, bei dem Sie die Pause ausschließen, einen klaren Kommentar / * FALLTHROUGH * / benötigen, um anzuzeigen, dass dies Ihre Absicht war.

Hast du von Duffs Gerät gehört ? Dies ist ein großartiges Beispiel für die Verwendung von Switch Fallthrough.

Es ist eine Funktion, die verwendet und missbraucht werden kann, wie fast alle Sprachfunktionen.

Fall-through ist wirklich eine praktische Sache, je nachdem, was Sie tun. Betrachten Sie diese übersichtliche und verständliche Art, Optionen zu arrangieren:

switch ($someoption) {
  case 'a':
  case 'b':
  case 'c':
    // Do something
    break;

  case 'd':
  case 'e':
    // Do something else
    break;
}

Stellen Sie sich vor, Sie tun dies mit if / else. Es wäre ein Chaos.

Es kann einige Male sehr nützlich sein, aber im Allgemeinen ist kein Durchfall das gewünschte Verhalten. Durchfallen sollte erlaubt sein, aber nicht implizit.

Ein Beispiel zum Aktualisieren alter Versionen einiger Daten:

switch (version) {
    case 1:
        // Update some stuff
    case 2:
        // Update more stuff
    case 3:
        // Update even more stuff
    case 4:
        // And so on
}

Ich würde eine andere Syntax für Fallbacks in Schaltern lieben, so etwas wie äh.

switch(myParam)
{
  case 0 or 1 or 2:
    // Do something;
    break;
  case 3 or 4:
    // Do something else;
    break;
}

Hinweis: Dies wäre bereits mit Aufzählungen möglich, wenn Sie alle Fälle in Ihrer Aufzählung mit Flags deklarieren, oder? Es klingt auch nicht so schlecht; Die Fälle könnten (sollten?) bereits Teil Ihrer Aufzählung sein.

Vielleicht wäre dies ein guter Fall (kein Wortspiel beabsichtigt) für eine fließende Schnittstelle mit Erweiterungsmethoden? So etwas wie, ähm ...

int value = 10;
value.Switch()
  .Case(() => { /* Do something; */ }, new {0, 1, 2})
  .Case(() => { /* Do something else */ } new {3, 4})
  .Default(() => { /* Do the default case; */ });

Obwohl das wahrscheinlich noch weniger lesbar ist: P.

Wie bei allem: Bei sorgfältiger Anwendung kann es ein elegantes Werkzeug sein.

Ich denke jedoch, dass die Nachteile mehr als rechtfertigen, es nicht zu verwenden und es schließlich nicht mehr zuzulassen (C #). Zu den Problemen gehören:

• Es ist leicht, eine Pause zu "vergessen"
• Für Code-Betreuer ist es nicht immer offensichtlich, dass eine ausgelassene Unterbrechung beabsichtigt war

Gute Verwendung eines Schalters / Gehäuses:

switch (x)
{
case 1:
case 2:
case 3:
 Do something
 break;
}

Baaaaad Verwendung eines Switch / Case Fall-Through:

switch (x)
{
case 1:
    Some code
case 2:
    Some more code
case 3:
    Even more code
    break;
}

Dies kann meiner Meinung nach mit if / else-Konstrukten ohne Verlust umgeschrieben werden.

Mein letztes Wort: Halten Sie sich wie im schlechten Beispiel von Fall-Through-Fallbezeichnungen fern , es sei denn, Sie pflegen Legacy-Code, in dem dieser Stil verwendet und gut verstanden wird.

Es ist mächtig und gefährlich. Das größte Problem beim Durchfallen ist, dass es nicht explizit ist. Wenn Sie beispielsweise auf häufig bearbeiteten Code stoßen, der einen Schalter mit Fall-Throughs hat, woher wissen Sie, dass dies beabsichtigt und kein Fehler ist?

Überall, wo ich es benutze, stelle ich sicher, dass es richtig kommentiert ist:

switch($var) {
    case 'first':
        // Fall-through
    case 'second':
        i++;
        break;
 }

Die Verwendung von Fall-Through wie in Ihrem ersten Beispiel ist eindeutig in Ordnung, und ich würde es nicht als echten Fall-Through betrachten.

Das zweite Beispiel ist gefährlich und (wenn nicht ausführlich kommentiert) nicht offensichtlich. Ich lehre meine Schüler nicht solche Konstrukte zu verwenden , es sei denn , sie halten es für die Mühe wert, einen Kommentarblock dafür zu verwenden, der beschreibt, dass dies ein absichtlicher Durchfall ist und warum diese Lösung besser ist als die Alternativen. Dies entmutigt die schlampige Verwendung, macht es aber dennoch in den Fällen zulässig, in denen es zu einem Vorteil verwendet wird.

Dies entspricht mehr oder weniger dem, was wir in Weltraumprojekten getan haben, als jemand gegen den Kodierungsstandard verstoßen wollte: Er musste eine Ausnahmegenehmigung beantragen (und ich wurde aufgefordert, über das Urteil zu beraten).

Ich mag es nicht, wenn meine switchAussagen durchfallen - es ist viel zu fehleranfällig und schwer zu lesen. Die einzige Ausnahme ist, wenn mehrere caseAnweisungen genau ausgeführt werden dasselbe tun.

Wenn es einen gemeinsamen Code gibt, den mehrere Zweige einer switch-Anweisung verwenden möchten, extrahiere ich diesen in eine separate gemeinsame Funktion, die in jedem Zweig aufgerufen werden kann.

In einigen Fällen ist die Verwendung von Fall-throughs für den Programmierer ein Akt der Faulheit - sie könnten eine Reihe von || verwenden Anweisungen zum Beispiel, verwenden jedoch stattdessen eine Reihe von "catch-all" -Schalterfällen.

Davon abgesehen habe ich festgestellt, dass sie besonders hilfreich sind, wenn ich das irgendwann weiß werde ich die Optionen sowieso (zum Beispiel in einem Menü - Antwort) benötigen, aber noch nicht alle Entscheidungen umgesetzt. Wenn Sie sowohl für 'a' als auch für 'A' einen Fall-Through durchführen, finde ich es wesentlich sauberer, den Switch-Fall-Through als eine zusammengesetzte if-Anweisung zu verwenden.

Es ist wahrscheinlich eine Frage des Stils und der Denkweise der Programmierer, aber ich mag es im Allgemeinen nicht, Komponenten einer Sprache im Namen der "Sicherheit" zu entfernen - weshalb ich mich mehr für C und seine Varianten / Nachkommen interessiere als beispielsweise Java. Ich mag es, mit Zeigern und dergleichen herumzuspielen, auch wenn ich keinen "Grund" dazu habe.

Fall-through sollte nur verwendet werden, wenn es als Sprungtabelle in einen Codeblock verwendet wird. Wenn es einen Teil des Codes gibt, der vor weiteren Fällen eine bedingungslose Unterbrechung aufweist, sollten alle Fallgruppen auf diese Weise enden.

Alles andere ist "böse".