Sollten switch-Anweisungen immer eine Standardklausel enthalten?

In einer meiner ersten Codeüberprüfungen (vor einiger Zeit) wurde mir gesagt, dass es empfehlenswert ist, eine Standardklausel in alle switch-Anweisungen aufzunehmen. Ich habe mich kürzlich an diesen Rat erinnert, kann mich aber nicht erinnern, was die Rechtfertigung war. Es klingt jetzt ziemlich seltsam für mich.

1. Gibt es einen vernünftigen Grund, immer eine Standardanweisung einzuschließen?

2. Ist diese Sprache abhängig? Ich kann mich nicht erinnern, welche Sprache ich damals verwendet habe - vielleicht gilt dies für einige Sprachen und nicht für andere?

Switch Cases sollten fast immer einen defaultCase haben.

Gründe für die Verwendung von a default

1.Um einen unerwarteten Wert zu "fangen"

switch(type)
{
    case 1:
        //something
    case 2:
        //something else
    default:
        // unknown type! based on the language,
        // there should probably be some error-handling
        // here, maybe an exception
}

2. Um 'Standard'-Aktionen zu behandeln, bei denen es sich um besondere Verhaltensweisen handelt.

Sie sehen dies VIEL in menügesteuerten Programmen und Bash-Shell-Skripten. Dies wird möglicherweise auch angezeigt, wenn eine Variable außerhalb des Switch-Falls deklariert, aber nicht initialisiert wird und in jedem Fall auf etwas anderes initialisiert wird. Hier muss die Standardeinstellung ebenfalls initialisiert werden, damit der Zeilencode, der auf die Variable zugreift, keinen Fehler auslöst.

3. Um jemandem, der Ihren Code liest, zu zeigen, dass Sie diesen Fall behandelt haben.

variable = (variable == "value") ? 1 : 2;
switch(variable)
{
    case 1:
        // something
    case 2:
        // something else
    default:
        // will NOT execute because of the line preceding the switch.
}

Dies war ein stark vereinfachtes Beispiel, aber der Punkt ist, dass sich jemand, der den Code liest, nicht fragen sollte, warum er variablenicht etwas anderes als 1 oder 2 sein kann.

Der einzige Fall, den ich mir vorstellen kann , NICHT zu verwenden, defaultist, wenn der Schalter etwas überprüft, bei dem es ziemlich offensichtlich ist, dass jede andere Alternative glücklich ignoriert werden kann

switch(keystroke)
{
    case 'w':
        // move up
    case 'a':
        // move left
    case 's':
        // move down
    case 'd':
        // move right
    // no default really required here
}

Nein.

Was ist, wenn es keine Standardaktion gibt? Der Kontext ist wichtig. Was ist, wenn Sie nur auf wenige Werte reagieren möchten?

Nehmen Sie das Beispiel des Lesens von Tastendrücken für ein Spiel

switch(a)
{
   case 'w':
     // Move Up
     break;
   case 's':
     // Move Down
     break;
   case 'a':
     // Move Left
     break;
   case 'd':
     // Move Right
     break;
}

Hinzufügen:

default: // Do nothing

Ist nur Zeitverschwendung und erhöht die Komplexität des Codes ohne Grund.

In einigen Situationen kann es tatsächlich von Vorteil sein, NICHT den Standardfall zu haben.

Wenn es sich bei Ihren Switch-Fällen um Aufzählungswerte handelt und Sie keinen Standardfall haben, können Sie eine Compiler-Warnung erhalten, wenn Sie Fälle vermissen. Auf diese Weise können Sie sich beim Kompilieren über das Problem informieren, wenn in Zukunft neue Aufzählungswerte hinzugefügt werden und Sie vergessen, Fälle für diese Werte im Switch hinzuzufügen. Sie sollten weiterhin sicherstellen, dass der Code geeignete Maßnahmen für nicht behandelte Werte ergreift, falls ein ungültiger Wert in den Aufzählungstyp umgewandelt wurde. Dies funktioniert also am besten in einfachen Fällen, in denen Sie innerhalb des Enum-Falls zurückkehren können, anstatt zu brechen.

enum SomeEnum
{
    ENUM_1,
    ENUM_2,
    // More ENUM values may be added in future
};

int foo(SomeEnum value)
{
    switch (value)
    {
    case ENUM_1:
        return 1;
    case ENUM_2:
        return 2;
    }
    // handle invalid values here
    return 0;
 }

Ich würde immer eine Standardklausel verwenden, egal in welcher Sprache Sie arbeiten.

Dinge können und können schief gehen. Werte werden nicht das sein, was Sie erwarten, und so weiter.

Wenn Sie keine Standardklausel einfügen möchten, können Sie sicher sein, dass Sie die möglichen Werte kennen. Wenn Sie glauben, die Menge der möglichen Werte zu kennen, möchten Sie darüber informiert werden, wenn der Wert außerhalb dieser Menge möglicher Werte liegt - es ist sicherlich ein Fehler.

Aus diesem Grund sollten Sie immer eine Standardklausel verwenden und einen Fehler auslösen, beispielsweise in Java:

switch (myVar) {
   case 1: ......; break;
   case 2: ......; break;
   default: throw new RuntimeException("unreachable");
}

Es gibt keinen Grund, mehr Informationen als nur die "nicht erreichbare" Zeichenfolge anzugeben. Wenn dies tatsächlich passiert, müssen Sie sich ohnehin die Quelle und die Werte der Variablen usw. ansehen, und die Ausnahmestapelverfolgung enthält diese Zeilennummer, sodass Sie keine Zeit damit verschwenden müssen, mehr Text in die Ausnahmemeldung zu schreiben.

In meinem Unternehmen schreiben wir Software für den Avionik- und Verteidigungsmarkt und fügen immer eine Standardanweisung hinzu, da ALLE Fälle in einer switch-Anweisung explizit behandelt werden müssen (auch wenn es sich nur um einen Kommentar mit der Aufschrift "Nichts tun" handelt). Wir können es uns nicht leisten, dass sich die Software nur schlecht verhält oder bei unerwarteten (oder sogar für unmöglich gehaltenen) Werten abstürzt.

Es kann diskutiert werden, dass ein Standardfall nicht immer notwendig ist, aber indem er immer benötigt wird, kann er von unseren Codeanalysatoren leicht überprüft werden.

Sollte eine "switch" -Anweisung immer eine Standardklausel enthalten? Nein, sollte es normalerweise eine Standardeinstellung enthalten.

Das Einfügen einer Standardklausel ist nur dann sinnvoll, wenn etwas zu tun ist, z. B. eine Fehlerbedingung geltend zu machen oder ein Standardverhalten bereitzustellen. Das Einschließen eines "nur weil" ist eine Frachtkult-Programmierung und bietet keinen Wert. Es ist das "switch" -Äquivalent zu der Aussage, dass alle "if" -Anweisungen ein "else" enthalten sollten.

Hier ist ein triviales Beispiel dafür, wo es keinen Sinn macht:

void PrintSign(int i)
{
    switch (Math.Sign(i))
    {
    case 1:
        Console.Write("positive ");
        break;
    case -1:
        Console.Write("negative ");
        break;
    default: // useless
    }
    Console.Write("integer");
}

Dies entspricht:

void PrintSign(int i)
{
    int sgn = Math.Sign(i);
    if (sgn == 1)
        Console.Write("positive ");
    else if (sgn == -1)
        Console.Write("negative ");
    else // also useless
    {
    }
    Console.Write("integer");
}

Soweit ich es sehe, ist die Antwort "Standard" optional. Die Aussage, dass ein Schalter immer eine Standardeinstellung enthalten muss, ist wie die Aussage, dass jedes "if-elseif" ein "else" enthalten muss. Wenn standardmäßig eine Logik ausgeführt werden muss, sollte die Anweisung 'default' vorhanden sein. Andernfalls kann der Code weiterhin ausgeführt werden, ohne dass etwas unternommen wird.

Eine Standardklausel zu haben, wenn sie nicht wirklich benötigt wird, ist defensive Programmierung. Dies führt normalerweise zu Code, der aufgrund von zu viel Fehlerbehandlungscode zu komplex ist. Dieser Fehlerbehandlungs- und Erkennungscode beeinträchtigt die Lesbarkeit des Codes, erschwert die Wartung und führt schließlich zu mehr Fehlern als behoben.

Ich glaube also, wenn der Standard nicht erreicht werden sollte, müssen Sie ihn nicht hinzufügen.

Beachten Sie, dass "sollte nicht erreicht werden" bedeutet, dass es ein Fehler in der Software ist, wenn es erreicht wird. Sie müssen Werte testen, die aufgrund von Benutzereingaben usw. unerwünschte Werte enthalten können.

Ich würde sagen, es hängt von der Sprache ab, aber in C ist es wahrscheinlich besser, wenn Sie einen Aufzählungstyp einschalten und jeden möglichen Wert verarbeiten, KEINEN Standardfall einzuschließen. Auf diese Weise gibt Ihnen ein kompetenter Compiler eine Warnung über den fehlenden Fall, wenn Sie später ein zusätzliches Enum-Tag hinzufügen und vergessen, es dem Switch hinzuzufügen.

Wenn Sie wissen, dass die switch-Anweisung immer nur einen streng definierten Satz von Beschriftungen oder Werten enthält, tun Sie dies einfach, um die Basen abzudecken. Auf diese Weise erhalten Sie immer ein gültiges Ergebnis. Setzen Sie einfach die Standardeinstellung über die Beschriftung, die programmgesteuert / logisch wäre Seien Sie der beste Handler für andere Werte.

switch(ResponseValue)
{
    default:
    case No:
        return false;
    case Yes;
        return true;
}

Zumindest ist es in Java nicht obligatorisch. Laut JLS kann höchstens ein Standardfall vorliegen. Dies bedeutet, dass kein Standardfall akzeptabel ist. Es hängt manchmal auch vom Kontext ab, in dem Sie die switch-Anweisung verwenden. In Java beispielsweise erfordert der folgende Switch-Block keinen Standardfall

private static void switch1(String name) {
    switch (name) {
    case "Monday":
        System.out.println("Monday");
        break;
    case "Tuesday":
        System.out.println("Tuesday");
        break;
    }
}

Bei der folgenden Methode, bei der erwartet wird, dass ein String zurückgegeben wird, ist der Standardfall hilfreich, um Kompilierungsfehler zu vermeiden

    private static String switch2(String name) {
    switch (name) {
    case "Monday":
        System.out.println("Monday");
        return name;

    case "Tuesday":
        System.out.println("Tuesday");
        return name;

    default:
        return name;
    }
}

Sie können zwar Kompilierungsfehler für die oben beschriebene Methode vermeiden, ohne einen Standardfall zu haben, indem Sie am Ende nur eine return-Anweisung haben. Wenn Sie jedoch einen Standardfall angeben, wird diese besser lesbar.

Einige (veraltete) Richtlinien sagen dies, wie beispielsweise MISRA C :

Voraussetzung für eine endgültige Standardklausel ist die defensive Programmierung. Diese Klausel muss entweder geeignete Maßnahmen ergreifen oder einen geeigneten Kommentar dazu enthalten, warum keine Maßnahmen ergriffen werden.

Dieser Rat ist veraltet, da er nicht auf derzeit relevanten Kriterien basiert. Die krasse Auslassung war das, was Harlan Kassler sagte:

Wenn Sie den Standardfall weglassen, kann der Compiler optional warnen oder fehlschlagen, wenn ein nicht behandelter Fall angezeigt wird. Die statische Überprüfbarkeit ist schließlich besser als jede dynamische Prüfung und daher kein würdiges Opfer, wenn Sie auch die dynamische Prüfung benötigen.

Wie Harlan ebenfalls demonstrierte, kann das funktionale Äquivalent eines Standardfalls nach dem Wechsel neu erstellt werden. Was trivial ist, wenn jeder Fall eine vorzeitige Rückkehr ist.

Die typische Notwendigkeit einer dynamischen Prüfung ist im weitesten Sinne die Eingabebehandlung. Wenn ein Wert außerhalb der Kontrolle des Programms liegt, kann er nicht als vertrauenswürdig eingestuft werden.

Hier vertritt Misra auch den Standpunkt einer extrem defensiven Programmierung. Solange ein ungültiger Wert physisch darstellbar ist, muss er überprüft werden, unabhängig davon, ob das Programm nachweislich korrekt ist. Dies ist sinnvoll, wenn die Software bei Hardwarefehlern so zuverlässig wie möglich sein muss. Aber wie Ophir Yoktan sagte, ist es für die meisten Software besser, Fehler nicht zu "behandeln". Die letztere Praxis wird manchmal als anstößige Programmierung bezeichnet .

Sie sollten eine Standardeinstellung haben, um unerwartete Werte abzufangen.

Ich bin jedoch nicht mit Adrian Smith einverstanden, dass Ihre Standardfehlermeldung etwas völlig Bedeutungsloses sein sollte. Möglicherweise gibt es einen nicht behandelten Fall, den Sie nicht vorhergesehen haben (was der Punkt ist), den Ihr Benutzer am Ende sehen wird, und eine Nachricht wie "nicht erreichbar" ist völlig sinnlos und hilft niemandem in dieser Situation.

Wie oft hatten Sie ein völlig bedeutungsloses BSOD? Oder eine schwerwiegende Ausnahme @ 0x352FBB3C32342?

Wenn der Schaltwert ( Schalter (Variable )) den Standardfall nicht erreichen kann, wird der Standardfall überhaupt nicht benötigt. Selbst wenn wir den Standardfall beibehalten, wird er überhaupt nicht ausgeführt. Es ist toter Code.

Es ist eine optionale Codierungskonvention. Abhängig von der Verwendung ist, ob es benötigt wird oder nicht. Ich persönlich glaube, wenn Sie es nicht brauchen, sollte es nicht da sein. Warum etwas hinzufügen, das vom Benutzer nicht verwendet oder erreicht wird?

Wenn die Fallmöglichkeiten begrenzt sind (dh ein Boolescher Wert), ist die Standardklausel redundant !

Wenn eine switchAnweisung keinen Standardfall enthält , kann das Verhalten unvorhersehbar sein, wenn dieser Fall zu einem bestimmten Zeitpunkt auftritt, der in der Entwicklungsphase nicht vorhersehbar war. Es ist eine gute Praxis, einen defaultFall aufzunehmen.

switch ( x ){
  case 0 : { - - - -}
  case 1 : { - - - -}
}

/* What happens if case 2 arises and there is a pointer
* initialization to be made in the cases . In such a case ,
* we can end up with a NULL dereference */

Eine solche Vorgehensweise kann zu einem Fehler wie NULL-Dereferenzierung , Speicherverlust sowie anderen Arten schwerwiegender Fehler führen .

Zum Beispiel nehmen wir an, dass jede Bedingung einen Zeiger initialisiert. Wenn jedoch ein defaultFall auftreten soll und wir in diesem Fall nicht initialisieren, besteht jede Möglichkeit, mit einer Nullzeigerausnahme zu landen. Daher wird empfohlen, eine defaultcase-Anweisung zu verwenden, auch wenn diese möglicherweise trivial ist.

Der Standardfall ist in dem von enum verwendeten Switch möglicherweise nicht erforderlich. Wenn der Schalter alle Werte enthielt, wird der Standardfall niemals ausgeführt. In diesem Fall ist dies also nicht erforderlich.

Hängt davon ab, wie der Switch in einer bestimmten Sprache funktioniert. In den meisten Sprachen wird die Ausführung jedoch ohne Warnung durch die switch-Anweisung geleitet, wenn kein Fall übereinstimmt. Stellen Sie sich vor, Sie haben eine Reihe von Werten erwartet und diese im Schalter behandelt, erhalten jedoch einen anderen Wert in der Eingabe. Nichts passiert und Sie wissen nicht, dass nichts passiert ist. Wenn Sie den Fall in Verzug geraten, wissen Sie, dass etwas nicht stimmt.

Ich bin mit der oben am häufigsten gewählten Antwort von Vanwaril nicht einverstanden.

Jeder Code erhöht die Komplexität. Auch Tests und Dokumentationen müssen dafür durchgeführt werden. Es ist also immer gut, wenn Sie mit weniger Code programmieren können. Meiner Meinung nach verwende ich eine Standardklausel für nicht erschöpfende switch-Anweisungen, während ich keine Standardklausel für erschöpfende switch-Anweisungen verwende. Um sicherzugehen, dass ich das richtig gemacht habe, verwende ich ein statisches Code-Analyse-Tool. Gehen wir also auf die Details ein:

1. Nicht erschöpfende switch-Anweisungen: Diese sollten immer einen Standardwert haben. Wie der Name schon sagt, handelt es sich um Aussagen, die nicht alle möglichen Werte abdecken. Dies ist möglicherweise auch nicht möglich, z. B. eine switch-Anweisung für einen ganzzahligen Wert oder für einen String. Hier möchte ich das Beispiel von Vanwaril verwenden (Es sollte erwähnt werden, dass er dieses Beispiel verwendet hat, um einen falschen Vorschlag zu machen. Ich verwende es hier, um das Gegenteil zu sagen -> Verwenden Sie eine Standardanweisung):

   switch(keystroke)
   {
     case 'w':
       // move up
     case 'a':
       // move left
     case 's':
       // move down
     case 'd':
       // move right
     default:          
       // cover all other values of the non-exhaustive switch statement
   }
   

   Der Spieler kann jede andere Taste drücken. Dann konnten wir nichts tun (dies kann im Code nur durch Hinzufügen eines Kommentars zum Standardfall angezeigt werden) oder es sollte zum Beispiel etwas auf dem Bildschirm gedruckt werden. Dieser Fall ist möglicherweise relevant.

2. Vollständige switch-Anweisungen: Diese switch-Anweisungen decken alle möglichen Werte ab, z. B. eine switch-Anweisung für eine Aufzählung von Gradsystemtypen. Bei der ersten Codeentwicklung ist es einfach, alle Werte abzudecken. Da wir Menschen sind, besteht jedoch eine geringe Chance, einige zu vergessen. Wenn Sie später einen Aufzählungswert hinzufügen, sodass alle switch-Anweisungen angepasst werden müssen, um sie wieder vollständig zu machen, wird der Pfad zur Fehlerhölle geöffnet. Die einfache Lösung ist ein statisches Code-Analyse-Tool. Das Tool sollte alle switch-Anweisungen überprüfen und prüfen, ob sie vollständig sind oder einen Standardwert haben. Hier ein Beispiel für eine vollständige switch-Anweisung. Zuerst brauchen wir eine Aufzählung:

   public enum GradeSystemType {System1To6, SystemAToD, System0To100}
   

   Dann brauchen wir eine Variable dieser Aufzählung wie GradeSystemType type = .... Eine vollständige switch-Anweisung würde dann folgendermaßen aussehen:

   switch(type)
   {
     case GradeSystemType.System1To6:
       // do something
     case GradeSystemType.SystemAToD:
       // do something
     case GradeSystemType.System0To100:
       // do something
   }
   

   Wenn wir also GradeSystemTypebeispielsweise um erweitern, sollte System1To3das statische Code-Analyse-Tool erkennen, dass es keine Standardklausel gibt und die switch-Anweisung nicht vollständig ist, sodass wir sicher sind.

Nur eine zusätzliche Sache. Wenn wir immer eine defaultKlausel verwenden, kann es vorkommen, dass das statische Code-Analyse-Tool keine erschöpfenden oder nicht erschöpfenden switch-Anweisungen erkennen kann, da es die defaultKlausel immer erkennt . Dies ist sehr schlecht, da wir nicht informiert werden, wenn wir die Aufzählung um einen anderen Wert erweitern und vergessen, sie einer switch-Anweisung hinzuzufügen.

Sollten switch-Anweisungen immer eine Standardklausel enthalten? Ohne Standardfall können keine Switch-Fälle existieren. Im Switch-Fall löst der Standardfall switch(x)in diesem Fall den Switch-Wert x aus, wenn er nicht mit anderen Fallwerten übereinstimmt.

Ich glaube, das ist ziemlich sprachspezifisch und für den C ++ - Fall ein kleiner Punkt für Enum-Klasse . Welches scheint sicherer als traditionelle C enum. ABER

Wenn Sie sich die Implementierung von std :: byte ansehen, ist es ungefähr so:

enum class byte : unsigned char {} ;

Quelle: https://en.cppreference.com/w/cpp/language/enum

Und bedenken Sie auch Folgendes:

Andernfalls, wenn T ein Aufzählungstyp ist, der entweder einen Gültigkeitsbereich hat oder nicht mit einem festen zugrunde liegenden Typ versehen ist, und wenn die Klammer-Init-Liste nur einen Initialisierer enthält und wenn die Konvertierung vom Initialisierer zum zugrunde liegenden Typ nicht einschränkend ist, und wenn Bei der Initialisierung handelt es sich um eine Direktlisteninitialisierung. Anschließend wird die Aufzählung mit dem Ergebnis der Konvertierung des Initialisierers in den zugrunde liegenden Typ initialisiert.

(seit C ++ 17)

Quelle: https://en.cppreference.com/w/cpp/language/list_initialization

Dies ist ein Beispiel für eine Enum-Klasse, die Werte darstellt, die nicht als Enumerator definiert sind. Aus diesem Grund können Sie Enums nicht vollständig vertrauen. Je nach Anwendung kann dies wichtig sein.

Ich mag jedoch sehr, was @Harlan Kassler in seinem Beitrag gesagt hat, und werde diese Strategie in einigen Situationen selbst anwenden.

Nur ein Beispiel für eine unsichere Enum-Klasse:

enum class Numbers : unsigned
{
    One = 1u,
    Two = 2u
};

int main()
{
    Numbers zero{ 0u };
    return 0;
}