Pourquoi la déclaration de l'interrupteur a-t-elle été conçue pour nécessiter une pause ?

Question

Étant donné une simple instruction de commutation

switch (int)
{
    case 1 :
    {
        printf("1\n");
        break;
    }

    case 2 : 
    {
        printf("2\n");
    }

    case 3 : 
    {
        printf("3\n");
    }
}

L'absence d'instruction break dans le cas 2, implique que l'exécution se poursuivra dans le code du cas 3. Ce n'est pas un accident, cela a été conçu de cette façon. Pourquoi cette décision a-t-elle été prise ? Quel avantage cela procure-t-il par rapport à l'utilisation d'une sémantique de rupture automatique pour les blocs ? Quel était le raisonnement ?

Answer 1

De nombreuses réponses semblent se concentrer sur la capacité de tomber à travers comme le raison pour avoir exigé le break déclaration.

Je pense qu'il s'agissait simplement d'une erreur, due en grande partie au fait que, lorsque C a été conçu, l'expérience de l'utilisation de ces constructions était loin d'être aussi grande.

Peter Van der Linden en parle dans son livre "Expert C Programming" :

Nous avons analysé les sources du compilateur C de Sun pour voir combien de fois la chute par défaut par défaut était utilisé. Le compilateur Sun ANSI C de Sun comporte 244 instructions switch chacune d'entre elles comporte une moyenne de sept cas. Le passage à travers se produit dans seulement 3% de tous ces cas.

En d'autres termes, l'interrupteur normal est mauvais 97% du temps. Ce n'est pas seulement dans un compilateur, au contraire. Au contraire, lorsque le fall through a été utilisé dans cette analyse, c'était souvent pour des situations qui se produisent plus fréquemment dans un compilateur que dans d'autres logiciels, par exemple, lors de la compilation d'opérateurs qui peuvent avoir soit un ou deux opérandes :

switch (operator->num_of_operands) {
    case 2: process_operand( operator->operand_2);
              /* FALLTHRU */

    case 1: process_operand( operator->operand_1);
    break;
}

La chute de l'affaire est si largement répandue reconnu comme un défaut qu'il y a même une convention de commentaire spéciale, montrée ci-dessus, qui dit à lint "ceci est vraiment l'un de ces 3% de cas où la chute est souhaitée".

Je pense que c'était une bonne idée pour le C# d'exiger une déclaration de saut explicite à la fin de chaque bloc de cas (tout en permettant toujours d'empiler plusieurs étiquettes de cas - tant qu'il n'y a qu'un seul bloc de déclarations). En C#, il est toujours possible de faire passer un cas à un autre - il suffit de rendre le passage explicite en sautant au cas suivant à l'aide d'une instruction de saut de type goto .

Il est dommage que Java n'ait pas profité de l'occasion pour s'affranchir de la sémantique du C.

Answer 2

A bien des égards, c est juste une interface propre aux idiomes standards d'assemblage. Lors de l'écriture d'un contrôle de flux piloté par une table de saut, le programmeur a le choix entre passer à travers ou sauter hors de la "structure de contrôle", et un saut hors requiert une instruction explicite.

Donc, C fait la même chose...

Answer 3

Pour mettre en place le dispositif de Duff, évidemment :

dsend(to, from, count)
char *to, *from;
int count;
{
    int 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);
    }
}

Answer 4

Si les affaires étaient conçues pour se briser implicitement, il n'y aurait pas de solution de repli.

case 0:
case 1:
case 2:
    // all do the same thing.
    break;
case 3:
case 4:
    // do something different.
    break;
default:
    // something else entirely.

Si l'interrupteur était conçu pour se déclencher implicitement après chaque cas, vous n'auriez pas le choix. La structure switch-case a été conçue comme elle l'est pour être plus flexible.

Answer 5

Les instructions de type "case" dans une instruction "switch" sont simplement des étiquettes.

Lorsque vous activez une valeur, l'instruction switch fait essentiellement un goto à l'étiquette avec la valeur correspondante.

Cela signifie que la rupture est nécessaire pour éviter le passage au code sous l'étiquette suivante.

Quant à la raison pourquoi il a été mis en œuvre de cette façon - la nature de la chute d'une déclaration de commutation peut être utile dans certains scénarios. Par exemple :

case optionA:
    // optionA needs to do its own thing, and also B's thing.
    // Fall-through to optionB afterwards.
    // Its behaviour is a superset of B's.
case optionB:
    // optionB needs to do its own thing
    // Its behaviour is a subset of A's.
    break;
case optionC:
    // optionC is quite independent so it does its own thing.
    break;