Pourquoi l'instruction switch a-t-elle été conçue pour nécessiter une pause?

Étant donné une simple instruction switch

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

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

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

L'absence d'une instruction break dans le cas 2, implique que l'exécution se poursuivra à l'intérieur du code pour le cas 3. Ce n'est pas un accident; il a été conçu de cette façon. Pourquoi ces décisions ont-elles été prises? Quel avantage cela apporte-t-il par rapport à une sémantique de rupture automatique pour les blocs? Quelle était la justification?

De nombreuses réponses semblent se concentrer sur la capacité à échouer comme raison d'exiger la breakdéclaration.

Je pense que c'était simplement une erreur, en grande partie parce que lorsque C a été conçu, il n'y avait pas autant d'expérience avec la façon dont ces constructions seraient utilisées.

Peter Van der Linden en fait la démonstration dans son livre "Expert C Programming":

Nous avons analysé les sources du compilateur Sun C pour voir à quelle fréquence la chute par défaut était utilisée. Le serveur frontal du compilateur Sun ANSI C comporte 244 instructions de commutation, chacune contenant en moyenne sept cas. La chute se produit dans seulement 3% de tous ces cas.

En d'autres termes, le comportement normal du commutateur est erroné 97% du temps. Ce n'est pas seulement dans un compilateur - au contraire, là où la chute a été utilisée 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 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 cas est si largement reconnue comme un défaut qu'il y a même une convention spéciale de commentaire, illustrée ci-dessus, qui dit à la charpie "c'est vraiment l'un de ces 3% des cas où la chute était souhaitée."

Je pense que c'était une bonne idée pour C # d'exiger une instruction de saut explicite à la fin de chaque bloc de cas (tout en permettant l'empilement de plusieurs étiquettes de cas - tant qu'il n'y a qu'un seul bloc d'instructions). En C #, vous pouvez toujours faire passer un cas à un autre - il vous suffit de rendre explicite la chute en passant au cas suivant en utilisant un goto.

C'est dommage que Java n'ait pas profité de l'occasion pour rompre avec la sémantique C.

À bien des égards, c est juste une interface claire pour les idiomes d'assemblage standard. Lors de l'écriture d'un contrôle de flux piloté par une table de saut, le programmeur a le choix de passer ou de sauter hors de la "structure de contrôle", et un saut en sortie nécessite une instruction explicite.

Alors, c fait la même chose ...

Pour implémenter 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);
    }
}

Si les cas étaient conçus pour se rompre implicitement, vous ne pourriez pas avoir de retombée.

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 le commutateur était conçu pour éclater implicitement après chaque cas, vous n'auriez pas le choix. La structure du boîtier de commutation a été conçue de manière à être plus flexible.

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

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

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

Quant à la raison pour laquelle elle a été implémentée de cette manière - la nature fall-through d'une instruction switch 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;

Pour autoriser des choses comme:

switch(foo) {
case 1:
    /* stuff for case 1 only */
    if (0) {
case 2:
    /* stuff for case 2 only */
    }
    /* stuff for cases 1 and 2 */
case 3:
    /* stuff for cases 1, 2, and 3 */
}

Considérez le casemot - clé comme une gotoétiquette et cela vient beaucoup plus naturellement.

Il élimine la duplication de code lorsque plusieurs cas doivent exécuter le même code (ou le même code en séquence).

Étant donné qu'au niveau du langage d'assemblage, peu importe si vous coupez entre chacun d'eux ou non, il n'y a de toute façon aucune surcharge pour les cas de chute, alors pourquoi ne pas les autoriser car ils offrent des avantages significatifs dans certains cas.

Je suis tombé sur un cas d'assignation de valeurs dans des vecteurs à des structures: cela devait être fait de telle manière que si le vecteur de données était plus court que le nombre de membres de données dans la structure, le reste des membres resterait dans leur valeur par défaut. Dans ce cas, l'omission breakétait très utile.

switch (nShorts)
{
case 4: frame.leadV1    = shortArray[3];
case 3: frame.leadIII   = shortArray[2];
case 2: frame.leadII    = shortArray[1];
case 1: frame.leadI     = shortArray[0]; break;
default: TS_ASSERT(false);
}

Comme beaucoup l'ont spécifié ici, il s'agit de permettre à un seul bloc de code de fonctionner pour plusieurs cas. Ce devrait être une occurrence plus courante pour vos instructions switch que le "bloc de code par cas" que vous spécifiez dans votre exemple.

Si vous avez un bloc de code par cas sans échec, vous devriez peut-être envisager d'utiliser un bloc if-elseif-else, car cela semblerait plus approprié.