Bizarreries de la déclaration de commutation

Introduction

La grammaire de l'instruction switch en C est simplement :

        switch ( expression ) statement

C++ a hérité du commutateur C et a ajouté la possibilité d'ajouter une init-statement facultative, mais ce n'est pas au cœur de cet article.

Remarquez ce qui pas ici : il n'y a aucune mention de cas ou de défaut. Ceux-ci sont spécifiés ailleurs dans la grammaire. Cela signifie que l'exactitude d'une instruction switch est appliquée sémantiquement plutôt que syntaxiquement. Les conséquences de ceci sont cette déclaration :

1. Peut être n'importe quelle déclaration.
2. Est traité exactement de la même manière que toute autre déclaration.
3. Peut également contenir zéro ou plusieurs étiquettes de cas et au plus une étiquette par défaut.

Automne

L'une des caractéristiques controversées de C est que, dans une instruction switch, les cas « passent » au cas suivant (le cas échéant). Par exemple, étant donné une valeur de « a » pour la variable c, un code tel que :

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

imprimera pomme et banane car après avoir fait correspondre « a » et imprimé pomme, l'exécution « tombe » simplement dans le cas « b ». Il s'agit d'un résultat étrange de la conséquence n°2 ci-dessus puisque, en dehors d'un changement, les instructions consécutives « passent » naturellement de l'une à l'autre. À l'intérieur d'un changement de cas, ce n'est pas ce que vous voulez la plupart du temps, vous pouvez donc utiliser un break (ou continuer si vous êtes dans une boucle, un retour ou un goto).

La plupart des compilateurs vous permettront de demander à être averti lorsque le code passe à un cas suivant. Depuis C23 ou C++17, vous pouvez inclure l'attribut [[fallthrough]] pour indiquer au compilateur qu'un échec est intentionnel et ne pas vous avertir :

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

L’exemple le plus célèbre de l’utilité du fall-through est peut-être le dispositif de Duff. Vous pouvez en lire les détails ici, mais l'essentiel est ce code tel que (réécrit en C moderne) :

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

est parfaitement légal en raison de la conséquence n°3, c'est-à-dire le fait que la boucle do se trouve à l'intérieur d'un commutateur permet à toute instruction d'avoir une étiquette de cas.

Déclaration unique

Avec switch, la instruction est invariablement une instruction composée, c'est-à-dire une séquence d'instructions entourée de {}, mais elle peut alternativement être une simple déclaration :

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

Puisqu'il n'y a qu'une seule instruction return true, les {} ne sont pas nécessaires tout comme ils ne le seraient pas après un if, do, else, for ou while non plus.

Mis à part le fait que ce qui précède est une autre façon d'écrire :

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

(sauf que l'expression n'est évaluée qu'une seule fois), il n'y a aucune raison légitime d'utiliser une seule instruction avec un commutateur, donc je ne recommanderais jamais de le faire. C’est juste un résultat étrange de la conséquence n°1 ci-dessus.

par défaut Pas le dernier

Lorsqu'un commutateur a une valeur par défaut, celle-ci est invariablement la dernière, mais elle peut en fait se trouver n'importe où dans le commutateur :

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

En termes de performance, la position du défaut (ni même l'ordre des cas) n'a pas d'importance. La seule raison technique pour ne pas avoir de défaut en dernier serait si vous vouliez que l'exécution passe au cas suivant. Toute autre raison serait purement stylistique, par exemple, vous souhaitez d'abord traiter le cas commun suivi des cas particuliers.

Déclarations avant la première affaire

Il est également possible d'avoir des déclarations avant le premier cas, par exemple :

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

De telles déclarations ne sont jamais exécutées. La plupart des compilateurs vous avertiront à ce sujet. Pour autant que je sache, il n’y a aucune raison d’avoir des déclarations avant le premier cas.

Cependant, il est légèrement utile d'avoir des déclarations avant le premier cas, par exemple :

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

Ceci est légèrement utile lorsqu'une variable est utilisée uniquement dans le cadre du changement par un ou plusieurs cas. Notez que vous ne devez pas initialiser des variables telles que :

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

car, même si la variable est déclarée, son code d'initialisation n'est jamais exécuté (tout comme le printf() dans un exemple précédent n'est jamais exécuté), donc le code est trompeur. Au lieu de cela, vous devez initialiser ces variables dans chaque cas qui les utilise.

Même si les déclarations simples (sans initialisation) ne sont pas du code exécutable, certains compilateurs en avertiront toujours (à tort, à mon humble avis). Par conséquent, de telles déclarations ne sont pas utiles.

Si vous voulez vraiment des déclarations uniquement dans le cadre d'un switch, vous pouvez soit les mettre dans le premier cas, soit uniquement dans le(s) cas qui les utilisent. Cependant, avant C23, les déclarations immédiatement après une étiquette ne sont pas autorisées :

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

Pour contourner cette restriction, vous pouvez ajouter {} pour un cas :

    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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!