Kuriositäten der Schalteraussage

Einführung

Die Grammatik für die switch-Anweisung in C lautet einfach:

        switch ( expression ) statement

C++ hat den Schalter von C geerbt und die Möglichkeit hinzugefügt, eine optionale init-Anweisung hinzuzufügen, aber das steht nicht im Mittelpunkt dieses Artikels.

Beachten Sie, was nicht da ist: Es gibt keine Erwähnung von Groß- und Kleinschreibung oder Standard. Diese werden an anderer Stelle in der Grammatik angegeben. Dies bedeutet, dass die Richtigkeit einer Switch-Anweisung semantisch und nicht syntaktisch erzwungen wird. Die Konsequenzen daraus sind die Aussage:

1. Kann jede Aussage sein.
2. Wird genau so behandelt wie jede andere Aussage.
3. Kann auch null oder mehr Fallbezeichnungen und höchstens eine Standardbezeichnung enthalten.

Durchfallen

Eines der umstrittenen Merkmale von C ist, dass innerhalb einer switch-Anweisung Fälle zum nächsten Fall „durchfallen“ (falls vorhanden). Wenn beispielsweise der Wert „a“ für die Variable c angegeben ist, Code wie:

switch ( c ) {
    case 'a':
        printf( "apple\n" );
    case 'b':
        printf( "banana\n" );
}

gibt Apfel und Banane aus, da die Ausführung nach der Zuordnung von „a“ und dem Drucken von Apfel einfach in den Fall „b“ „durchfällt“. Dies ist ein seltsames Ergebnis der obigen Konsequenz Nr. 2, da aufeinanderfolgende Anweisungen außerhalb eines Schalters natürlich von einer zur nächsten „durchfallen“. Innerhalb eines Wechsels zwischen Fällen ist dies meistens nicht das, was Sie wollen, also können Sie eine Pause verwenden (oder fortfahren, wenn Sie sich in einer Schleife, Return oder Goto befinden).

Bei den meisten Compilern können Sie eine Warnung anfordern, wenn Code in einen nächsten Fall übergeht. Ab C23 oder C++17 können Sie das Attribut [[fallthrough]] einschließen, um dem Compiler mitzuteilen, dass ein Fallthrough beabsichtigt ist, und Sie nicht zu warnen:

switch ( how_good ) {
    case VERY_GOOD:
        printf( "very " );
        [[fallthrough]];
    case GOOD:
        printf( "good\n" );
        break;
}

Das vielleicht berühmteste Beispiel dafür, wo Durchfallen nützlich ist, ist Duffs Gerät. Sie können dort die Details dazu lesen, aber das Endergebnis ist der Code wie (in modernem C umgeschrieben):

void send( short *to, short const *from, size_t count ) {
    size_t n = (count + 7) / 8;
    switch ( count % 8 ) {
        case 0: do { *to = *from++;
        case 7:      *to = *from++;
        case 6:      *to = *from++;
        case 5:      *to = *from++;
        case 4:      *to = *from++;
        case 3:      *to = *from++;
        case 2:      *to = *from++;
        case 1:      *to = *from++;
                } while ( --n > 0 );
    }
}

ist aufgrund der Konsequenz Nr. 3 vollkommen legal, nämlich der Tatsache, dass sich die do-Schleife innerhalb eines Schalters befindet und es jeder Anweisung ermöglicht, eine Fallbezeichnung zu haben.

Einzelne Aussage

Mit switch ist die Anweisung immer eine zusammengesetzte Anweisung, also eine Folge von Anweisungen, die in {} eingeschlossen sind, sie kann aber alternativ auch eine einzelne Aussage:

bool check_n_args( int n_args ) {
    switch ( n_args )              // no { here
        case 0:
        case 1:
        case 2:
            return true;
                                   // no } here
    fprintf( stderr, "error: args must be 0-2\n" );
    return false;
}

Da es nur die einzige Anweisung „return true“ gibt, sind die {} nicht notwendig, genauso wie sie nach einem if, do, else, for oder while auch nicht notwendig wären.

Abgesehen davon, dass das Obige eine alternative Schreibweise ist:

    if ( n_args >= 0 && n_args (Abgesehen davon, dass der Ausdruck nur einmal ausgewertet wird) gibt es keinen legitimen Grund, jemals eine einzelne Anweisung mit einem Schalter zu verwenden, daher würde ich dies niemals empfehlen.  Es ist nur ein seltsames Ergebnis der oben genannten Konsequenz Nr. 1.<p>

</p>
  
  
  Standardmäßig nicht zuletzt
<h2>

</h2>Wenn ein Schalter einen Standardwert hat, ist dieser immer der letzte, kann sich aber tatsächlich an einer beliebigen Stelle innerhalb des Schalters befinden:<p>
<br>

</p>



<pre class="brush:php;toolbar:false">    switch ( n_args ) {
        default:
            fprintf( stderr, "error: args must be 0-2\n" );
            return false;
        case 0:
            // ...

Aus Sicht der Leistung spielt die Lage des Verzugs (bzw. die Reihenfolge der Fälle) keine Rolle. Der einzige technische Grund dafür, dass die Standardausführung nicht zuletzt erfolgt, besteht darin, dass die Ausführung in den nächsten Fall übergehen soll. Jeder andere Grund wäre rein stilistischer Natur, z. B. Sie möchten zuerst den allgemeinen Fall und dann die Sonderfälle behandeln.

Aussagen vor dem ersten Fall

Es ist auch möglich, Aussagen

vor dem ersten Fall zu machen, zum Beispiel:

switch ( n_args ) {
        printf( "never executed\n" );
    case 0:
        // ...

Solche Aussagen werden

nie ausgeführt. Die meisten Compiler werden davor warnen. Soweit ich weiß, gibt es keinen Grund, jemals vor dem ersten Fall Aussagen zu machen.

Es ist jedoch von geringem Nutzen, vor dem ersten Fall

Erklärungen zu haben, zum Beispiel:

switch ( n_args ) {
        int i;
    case 0:
        i = f();
        // ...
        break;
    case 1:
        i = g();
        // ...
        break;
}

Dies ist von geringem Nutzen, wenn eine Variable nur in einem oder mehreren Fällen im Rahmen des Schalters verwendet wird. Beachten Sie, dass Sie solche Variablen

nicht initialisieren sollten wie:

switch ( n_args ) {
        int i = 0;  // WRONG: do _not_ initialize!
    // ...

weil, obwohl die Variable

deklariert ist, ihr Initialisierungscode nie ausgeführt wird (genau wie printf() in einem vorherigen Beispiel nie ausgeführt wurde), also auch der Code trügerisch. Stattdessen müssen Sie solche Variablen in jedem Fall initialisieren, der sie verwendet.

Auch wenn einfache Deklarationen (ohne Initialisierung) kein ausführbarer Code sind, werden einige Compiler (meiner Meinung nach) immer noch davor warnen. Daher sind solche Erklärungen nicht sinnvoll.

Wenn Sie Deklarationen wirklich nur im Rahmen eines Schalters wünschen, können Sie sie entweder im ersten Fall oder nur in den Fällen platzieren, die sie verwenden. Vor C23 sind Deklarationen unmittelbar nach einem Etikett jedoch nicht zulässig:

switch ( n_args ) {
    case 0:
        int i;       // error (pre-C23)
        // ...

Um diese Einschränkung zu umgehen, können Sie {} für einen Fall hinzufügen:

    case 0: {
        int i;       // OK now (all C versions)
        // ...
    }

A break-able Block

If you have a long block of code that you want to jump to the end of, there are a few ways to do it:

1. A sequence of if-else statements; or;
2. A sequence of if-goto statements; or;
3. A do { ... } while (0) statement with breaks.

Each has its trade-offs. Another way would be:

#define BLOCK  switch (0) default:

void f() {
    BLOCK {
        // ...
        if ( condition_1 )
            break;
        // ... lots more code ...
    }

    // "break" above jumps here

Hence, it’s most similar to do { ... } while (0), but without having to put the while (0) at the end.

Conclusion

The apparent simplicity of the switch statement in C (and C++) is deceptive in that it allows several odd ways to write code using them, some useful, some not. The most useful is Duff’s device for loop unrolling.

Das obige ist der detaillierte Inhalt vonKuriositäten der Schalteraussage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!