Por que os idiomas não usam explicações explícitas nas instruções do switch?

Eu estava lendo Por que temos para uso breakem switch? , e me levou a pensar por que o fall-through implícito é permitido em algumas linguagens (como PHP e JavaScript), enquanto não há suporte (AFAIK) para o fall-through explícito.

Não é como se uma nova palavra-chave precisasse ser criada, como continueseria perfeitamente apropriada e resolveria quaisquer problemas de ambiguidade, para saber se o autor pretendia que um caso ocorresse.

O formulário atualmente suportado é:

switch (s) {
    case 1:
        ...
        break;
    case 2:
        ... //ambiguous, was break forgotten?
    case 3:
        ...
        break;
    default:
        ...
        break;
}

Considerando que faria sentido para ele ser escrito como:

switch (s) {
    case 1:
        ...
        break;
    case 2:
        ...
        continue; //unambiguous, the author was explicit
    case 3:
        ...
        break;
    default:
        ...
        break;
}

Para os fins desta pergunta, vamos ignorar a questão de saber se os fall-throughs são ou não um bom estilo de codificação.

Existem idiomas que permitam falhas e o tornassem explícito?

Existem razões históricas que `switch`permitam falhas implícitas em vez de explícitas?

switch-statement

— zzzzBov
fonte

O C # requer que você seja explícito goto case, portanto a premissa da sua pergunta está um pouco errada.

— Pd

@pdr, perguntei muito explicitamente se havia algum idioma que já suportava fall-through, eu não conhecia goto caseem c #.

— precisa saber é o seguinte

Sim, desculpe, senti falta de duas partes na sua pergunta. Infelizmente, como está, estou votando para fechar, porque está muito próximo de uma pergunta de pesquisa. Haverá muitas respostas certas.

— Pd28

O C # também permite que vários rótulos compartilhem a mesma lista de instruções, o que remove algumas das situações que exigem falhas. Quanto ao resto, tem goto case, como pdr menciona.

— 28712 Brian

Respostas:

É principalmente histórico, a maioria dos idiomas copiou o que C fez.

A razão pela qual C fez dessa maneira é que os criadores de C pretendiam que as instruções de switch fossem fáceis de otimizar em uma tabela de salto. Essa também é a razão pela qual C limita as instruções da chave a valores integrais.

Em uma tabela de salto, o programa calculará para qual posição saltar com base na expressão. O programa pulará para esse ponto e continuará executando a partir desse ponto. Se você quiser pular o restante da tabela, precisará incluir um salto para o final da tabela. C usa breakinstruções explícitas para que haja uma correspondência direta com essa construção.

— Dirk Holsopple
fonte

Como uma pequena observação, em seu livro "Expert C Programming", Peter van der Linden menciona que, enquanto trabalhava para a Sun em seu compilador C, cerca de ~ 97% dos casos de comutação continham breake apenas menos de 3% eram falhos. . Ele então usou isso como um exemplo de que o comportamento de fall-through padrão é contra-intuitivo e seria melhor reverter (use uma palavra-chave para indicar fall-through explícito). Ah, e o livro também é ótimo em explicar outras esquisitices do C, algumas das quais são encontradas em C ++ e até em C # e Java também! Está tudo enraizado em B e BCPL. :)

— zxcdw

Existem linguagens de programação nas quais a queda é explícita, como c # ( msdn.microsoft.com/en-us/library/06tc147t(v=vs.71).aspx ). Por outro lado, a quebra também é explícita em c #.

— Linkerro 28/08/12

@zxcdw: Pena que não há como um passarinho voltar no tempo e sugerir que qualquer rótulo marcado case, exceto o primeiro, deva ser prefixado automaticamente break, mas os marcados +case(ou algum outro designador) não devem. Isso teria sido fácil para um compilador manipular e permitir as vantagens semânticas da organização atual, ao mesmo tempo em que eliminava muitas linhas de código.

— Supercat 14/07

Go permite explicação explícita usando a fallthroughpalavra - chave (break está implícito, mas pode ser explícito):

switch val {
case 1: // breaks
case 2:
    fallthrough
case 3:
    goto 
case 4, 5, 6: // equivalent to defining individual cases with explicit fallthough
    break // unnecessary
default:
}

Aqui está o trecho relevante do início eficaz e as especificações de idioma .

Eu não acho que você pode usar gotopara ir a um caso específico, mas você pode fazer uma etiqueta dentro do caso e usar um gotonormal.

Como bônus, o Go permite usar expressões binárias, seqüências de caracteres ou tipos em uma opção como instruções de caso.

— beatgammit
fonte

Por que os idiomas não usam explicações explícitas nas instruções do switch?

Existem idiomas que permitam falhas e o tornassem explícito?

Existem razões históricas que switchpermitam falhas implícitas em vez de explícitas?

Existem razões históricas que `switch`permitam falhas implícitas em vez de explícitas?