Warum warnt mich Clang / LLVM vor der Verwendung von default in einer switch-Anweisung, in der alle aufgezählten Fälle behandelt werden?

Betrachten Sie die folgende enum- und switch-Anweisung:

typedef enum {
    MaskValueUno,
    MaskValueDos
} testingMask;

void myFunction(testingMask theMask) {
    switch (theMask) {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
        default: {} //deal with an unexpected or uninitialized value
    }
};

Ich bin ein Objective-C-Programmierer, aber ich habe dies für ein breiteres Publikum in reinem C geschrieben.

Clang / LLVM 4.1 mit -Alles warnt mich in der Standardzeile:

Standardbeschriftung im Schalter, die alle Aufzählungswerte abdeckt

Jetzt kann ich irgendwie nachvollziehen, warum dies so ist: In einer perfekten Welt würden die einzigen Werte, die in das Argument theMaskeingegeben werden, in der Aufzählung stehen, sodass keine Standardwerte erforderlich sind. Aber was ist, wenn ein Hack auftaucht und ein nicht initialisiertes Int in meine schöne Funktion wirft? Meine Funktion wird als Ablage in der Bibliothek bereitgestellt, und ich habe keine Kontrolle darüber, was dort hineingelangen könnte. Verwenden defaultist eine sehr ordentliche Art, damit umzugehen.

Warum halten die LLVM-Götter dieses Verhalten für ihres teuflischen Geräts unwürdig? Sollte ich dem eine if-Anweisung voranstellen, um das Argument zu überprüfen?

Hier ist eine Version, die weder unter der Meldung des Problem-Clangs noch unter der Version leidet, vor der Sie sich schützen:

void myFunction(testingMask theMask) {
    assert(theMask == MaskValueUno || theMask == MaskValueDos);
    switch (theMask) {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
    }
}

Killian hat bereits erklärt, warum Clang die Warnung ausgibt: Wenn Sie die Aufzählung verlängern, fallen Sie in den Standardfall, der wahrscheinlich nicht Ihren Wünschen entspricht. Das Richtige ist, den Standardfall zu entfernen und Warnungen für nicht behandelte Bedingungen abzurufen .

Jetzt befürchten Sie, dass jemand Ihre Funktion mit einem Wert aufrufen könnte, der außerhalb der Aufzählung liegt. Das hört sich so an, als würde die Funktionsvoraussetzung nicht erfüllt: Es ist dokumentiert, dass ein Wert von der testingMaskAufzählung erwartet wird, aber der Programmierer hat etwas anderes übergeben. Machen Sie also einen Programmierfehler mit assert()(oder NSCAssert()wie Sie sagten, Sie verwenden Objective-C). Lassen Sie Ihr Programm mit einer Meldung abstürzen, die erklärt, dass der Programmierer es falsch macht, wenn der Programmierer es falsch macht.

Ein defaultEtikett hier ist ein Indikator dafür, dass Sie sich nicht sicher sind, was Sie erwarten. Da Sie alle möglichen enumWerte explizit ausgeschöpft haben, defaultkann das nicht ausgeführt werden, und Sie brauchen es auch nicht, um sich vor zukünftigen Änderungen zu schützen, denn wenn Sie das erweitern enum, würde das Konstrukt bereits eine Warnung erzeugen.

Der Compiler merkt also, dass Sie alle Grundlagen abgedeckt haben, denkt aber anscheinend, dass Sie dies nicht getan haben, und das ist immer ein schlechtes Zeichen. Indem switchSie das Formular mit minimalem Aufwand in das erwartete Format ändern , zeigen Sie dem Compiler, dass Sie anscheinend genau das tun, was Sie tatsächlich tun, und Sie wissen es.

Clang ist verwirrt und hat eine Standardaussage, dass es eine sehr gute Übung gibt. Sie wird als defensive Programmierung bezeichnet und gilt als gute Programmierpraxis (1). Es wird häufig in unternehmenskritischen Systemen verwendet, möglicherweise jedoch nicht in der Desktop-Programmierung.

Der Zweck der defensiven Programmierung besteht darin, unerwartete Fehler aufzufangen, die theoretisch niemals auftreten würden. Ein solcher unerwarteter Fehler ist nicht notwendigerweise der Programmierer, der der Funktion eine falsche Eingabe oder sogar einen "bösen Hack" gibt. Es ist wahrscheinlicher, dass dies durch eine beschädigte Variable verursacht wurde: Pufferüberläufe, Stapelüberlauf, außer Kontrolle geratener Code und ähnliche Fehler, die nicht mit Ihrer Funktion zusammenhängen, könnten dies verursachen. Bei eingebetteten Systemen können sich Variablen möglicherweise aufgrund von EMI ändern, insbesondere wenn Sie externe RAM-Schaltkreise verwenden.

Was Sie in die Standardanweisung schreiben sollten ... Wenn Sie den Verdacht haben, dass das Programm am Ende durcheinander geraten ist, benötigen Sie eine Art Fehlerbehandlung. In vielen Fällen können Sie wahrscheinlich einfach eine leere Anweisung mit einem Kommentar hinzufügen: "Unerwartet, aber egal" usw., um zu zeigen, dass Sie über die unwahrscheinliche Situation nachgedacht haben.

(1) MISRA-C: 2004 15.3.

Besser noch:

typedef enum {
    MaskValueUno,
    MaskValueDos,

    MaskValue_count
} testingMask;

void myFunction(testingMask theMask) {
    assert(theMask >= 0 && theMask<MaskValue_count);
    switch theMask {
        case MaskValueUno: {}// deal with it
        case MaskValueDos: {}// deal with it
    }
};

Dies ist weniger fehleranfällig beim Hinzufügen von Elementen zur Aufzählung. Sie können den Test für> = 0 überspringen, wenn Sie Ihre Enum-Werte vorzeichenlos machen. Diese Methode funktioniert nur, wenn Ihre Aufzählungswerte keine Lücken aufweisen. Dies ist jedoch häufig der Fall.

Aber was ist, wenn ein Hack auftaucht und ein nicht initialisiertes Int in meine schöne Funktion wirft?

Dann bekommst du Undefiniertes Verhalten und dein defaultWille ist bedeutungslos. Sie können möglicherweise nichts tun, um dies zu verbessern.

Lass mich klarer sein. Sobald jemand eine nicht initialisierte intFunktion in Ihre Funktion übergibt , ist dies undefiniertes Verhalten. Ihre Funktion könnte das Problem des Anhaltens lösen, und es spielt keine Rolle. Es ist UB. Es gibt nichts, was Sie tun können, wenn UB einmal aufgerufen wurde.

Die Standardanweisung würde nicht unbedingt helfen. Wenn sich der Schalter über einer Aufzählung befindet, führt jeder Wert, der nicht in der Aufzählung definiert ist, undefiniertes Verhalten aus.

Nach allem, was Sie wissen, kann der Compiler diesen Switch (mit der Standardeinstellung) wie folgt kompilieren:

if (theMask == MaskValueUno)
  // Execute something MaskValueUno code
else // theMask == MaskValueDos
  // Execute MaskValueDos code

Sobald Sie undefiniertes Verhalten auslösen, gibt es kein Zurück mehr.

Ich bevorzuge es auch, default:in allen Fällen eine zu haben . Ich bin wie immer zu spät zur Party, aber ... ein paar andere Gedanken, die ich oben nicht gesehen habe:

• Die spezielle Warnung (oder der Fehler, wenn auch geworfen wird -Werror) kommt von -Wcovered-switch-default(von, -Weverythingaber nicht von -Wall). Wenn Ihre moralische Flexibilität es Ihnen erlaubt, bestimmte Warnungen auszuschalten (z. B. bestimmte Dinge aus -Walloder herauszuschneiden -Weverything), erwägen Sie, sie zu werfen -Wno-covered-switch-default(oder zu -Wno-error=covered-switch-defaultverwenden -Werror), und im Allgemeinen -Wno-...für andere Warnungen, die Sie als unangenehm empfinden.
• Für gcc(und allgemeineres Verhalten in clang), konsultiert gccManpage -Wswitch, -Wswitch-enum, -Wswitch-defaultfür (verschiedene) Verhalten in ähnlichen Situationen von Aufzählungstypen in switch - Anweisungen.

• Ich mag diese Warnung auch nicht im Konzept, und ich mag ihren Wortlaut nicht; Für mich deuten die Wörter aus der Warnung ("Standardbeschriftung ... deckt alle ... Werte ab") darauf hin, dass der default:Fall immer ausgeführt wird, wie z

  switch (foo) {
    case 1:
      do_something(); 
      //note the lack of break (etc.) here!
    default:
      do_default();
  }

  Auf dem ersten Lesung, ist das , was ich dachte , dass Sie in ausgeführt wurden - , dass Ihr default:Fall immer dann ausgeführt werden würde , weil es keine gibt break;oder return;oder ähnliches. Dieses Konzept ähnelt (meinem Ohr) anderen (wenn auch gelegentlich hilfreichen) Kommentaren im Nanny-Stil, aus denen es hervorgeht clang. Wenn foo == 1, werden beide Funktionen ausgeführt; Ihr Code oben hat dieses Verhalten. Das heißt, nicht ausbrechen, nur wenn Sie möglicherweise weiterhin Code aus nachfolgenden Fällen ausführen möchten! Dies scheint jedoch nicht Ihr Problem zu sein.

Auf die Gefahr, pedantisch zu sein, einige andere Gedanken zur Vollständigkeit:

• Ich denke jedoch, dass dieses Verhalten (mehr) mit aggressiven Typüberprüfungen in anderen Sprachen oder Compilern vereinbar ist. Wenn, wie Sie theoretisieren, einige reprobate nicht versuchen , eine weitergeben intoder etwas zu dieser Funktion, die ausdrücklich sind eigene Art beabsichtigt , zu konsumieren, sollten Sie Ihre Compiler Sie schützen gleich gut in dieser Situation mit einer aggressiven Warnung oder einen Fehler. ABER das tut es nicht! (Das heißt, es scheint, dass zumindest gccund clangnicht die enumTypüberprüfung, aber ich höre, dass dies der iccFall ist ). Da Sie nicht bekommen Typ -Sicherheit, könnten Sie erhalten Wert -safety wie oben erörtert. Andernfalls sollten Sie, wie in TFA vorgeschlagen, ein structoder etwas in Betracht ziehen , das Typensicherheit bietet.
• Eine andere Problemumgehung könnte darin bestehen, einen neuen "Wert" in Ihrem enumNamen zu erstellen MaskValueIllegalund diesen casein Ihrem Namen nicht zu unterstützen switch. Das würde gegessen von default:(zusätzlich zu jedem anderen verrückten Wert)

Es lebe die defensive Codierung!

Hier ist ein alternativer Vorschlag:
Das OP versucht, sich gegen den Fall zu schützen, dass jemand in einem Fall vorbeikommt, in intdem eine Aufzählung erwartet wird. Oder eher dort, wo jemand eine alte Bibliothek mit einem neueren Programm verknüpft hat, indem er einen neueren Header mit mehr Fällen verwendet.

Warum nicht den Schalter wechseln, um das intGehäuse zu handhaben ? Das Hinzufügen eines Cast vor dem Wert in der Option beseitigt die Warnung und gibt sogar einen Hinweis darauf, warum die Standardeinstellung existiert.

void myFunction(testingMask theMask) {
    int maskValue = int(theMask);
    switch(maskValue) {
        case MaskValueUno: {} // deal with it
        case MaskValueDos: {}// deal with it
        default: {} //deal with an unexpected or uninitialized value
    }
}

Ich finde das viel weniger verwerflich als das assert()Testen jedes der möglichen Werte oder sogar die Annahme, dass der Bereich der Aufzählungswerte geordnet ist, damit ein einfacherer Test funktioniert. Dies ist nur eine hässliche Methode, um genau und schön das zu tun, was default tut.