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;
}

    if ( n_args >= 0 && n_args <= 2 )
        return true;

    switch ( n_args ) {
        default:
            fprintf( stderr, "error: args must be 0-2\n" );
            return false;
        case 0:
            // ...

vor dem ersten Fall zu machen, zum Beispiel:

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

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

Erklärungen zu haben, zum Beispiel:

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

nicht initialisieren sollten wie:

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

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.

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

    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!