Por que a instrução switch foi projetada para precisar de uma pausa?

Dada uma simples instrução switch

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

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

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

A ausência de uma declaração de interrupção no caso 2, implica que a execução continuará dentro do código do caso 3. Isso não é um acidente; foi projetado dessa maneira. Por que essas decisões foram tomadas? Que benefício isso oferece versus ter uma semântica de quebra automática para os blocos? Qual foi a justificativa?

Muitas respostas parecem focar na capacidade de cair como o motivo para exigir a breakdeclaração.

Acredito que foi simplesmente um erro, devido em grande parte porque quando C foi projetado, não havia quase tanta experiência com a forma como essas construções seriam usadas.

Peter Van der Linden defende seu livro "Expert C Programming":

Analisamos as fontes do compilador Sun C para ver com que frequência a falha padrão foi usada. O front end do compilador Sun ANSI C possui 244 instruções de opção, cada uma com uma média de sete casos. A queda ocorre em apenas 3% de todos esses casos.

Em outras palavras, o comportamento normal da troca está errado 97% das vezes. Não é apenas em um compilador - pelo contrário, onde o fall through foi usado nessa análise foi geralmente para situações que ocorrem com mais frequência em um compilador do que em outro software, por exemplo, ao compilar operadores que podem ter um ou dois operandos :

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

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

A queda de casos é tão amplamente reconhecida como um defeito que até existe uma convenção de comentário especial, mostrada acima, que diz ao fiapo "este é realmente um daqueles 3% de casos em que a queda foi desejada".

Eu acho que foi uma boa ideia para o C # exigir uma instrução de salto explícita no final de cada bloco de caso (enquanto ainda permite que vários rótulos de caso sejam empilhados - desde que haja apenas um único bloco de instruções). No C #, você ainda pode fazer com que um caso caia para outro - você só precisa tornar explícita a queda saltando para o próximo caso usando a goto.

É uma pena que o Java não tenha aproveitado a oportunidade para romper com a semântica C.

De várias maneiras, c é apenas uma interface limpa para idiomas de montagem padrão. Ao escrever o controle de fluxo acionado por tabela de salto, o programador tem a opção de cair ou saltar da "estrutura de controle", e um salto exige uma instrução explícita.

Então, c faz a mesma coisa ...

Para implementar o dispositivo de Duff, obviamente:

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

Se os casos foram projetados para serem quebrados implicitamente, você não pode ter sucesso.

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

Se o switch foi projetado para ocorrer implicitamente após cada caso, você não teria escolha. A estrutura da caixa do switch foi projetada da maneira que deve ser mais flexível.

As instruções de caso em uma instrução switch são simplesmente rótulos.

Quando você ativa um valor, a instrução switch efetivamente vai para o rótulo com o valor correspondente.

Isso significa que a interrupção é necessária para evitar a passagem para o código no próximo rótulo.

Quanto ao motivo pelo qual foi implementado dessa maneira - a natureza de falha de uma instrução switch pode ser útil em alguns cenários. Por exemplo:

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;

Para permitir coisas como:

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 */
}

Pense na casepalavra - chave como um gotorótulo e ela será muito mais natural.

Elimina a duplicação de código quando vários casos precisam executar o mesmo código (ou o mesmo código em sequência).

Como no nível da linguagem assembly, não importa se você quebra entre eles ou não existe zero de sobrecarga para os casos de qualquer maneira, por que não permitir isso, pois eles oferecem vantagens significativas em certos casos.

Por acaso, me deparei com um caso de atribuição de valores em vetores a estruturas: tinha que ser feito de tal maneira que se o vetor de dados fosse menor que o número de membros de dados na estrutura, o restante dos membros permaneceria em seu valor padrão. Nesse caso, omitir breakfoi bastante útil.

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

Como muitos aqui especificaram, é para permitir que um único bloco de código funcione para vários casos. Isso deveria ser uma ocorrência mais comum para as instruções do switch do que o "bloco de código por caso" especificado no seu exemplo.

Se você tiver um bloco de código por caso sem falhas, talvez considere usar um bloco if-elseif-else, pois isso pareceria mais apropriado.