Sintaxe válida, mas sem valor, no caso de switch?

Por meio de um pequeno erro de digitação, encontrei acidentalmente esse construto:

int main(void) {
    char foo = 'c';

    switch(foo)
    {
        printf("Cant Touch This\n");   // This line is Unreachable

        case 'a': printf("A\n"); break;
        case 'b': printf("B\n"); break;
        case 'c': printf("C\n"); break;
        case 'd': printf("D\n"); break;
    }

    return 0;
}

Parece que a printfparte superior da switchdeclaração é válida, mas também completamente inacessível.

Eu obtive uma compilação limpa, sem sequer um aviso sobre código inacessível, mas isso parece inútil.

Um compilador deve sinalizar isso como código inacessível?
Isso serve a algum propósito?

Talvez não seja o mais útil, mas não completamente inútil. Você pode usá-lo para declarar uma variável local disponível no switchescopo.

switch (foo)
{
    int i;
case 0:
    i = 0;
    //....
case 1:
    i = 1;
    //....
}

O padrão ( N1579 6.8.4.2/7) tem o seguinte exemplo:

EXEMPLO No fragmento de programa artificial

switch (expr)
{
    int i = 4;
    f(i);
case 0:
    i = 17;
    /* falls through into default code */
default:
    printf("%d\n", i);
}

o objeto cujo identificador iexiste com duração de armazenamento automático (dentro do bloco), mas nunca é inicializado e, portanto, se a expressão de controle tiver um valor diferente de zero, a chamada para a printffunção acessará um valor indeterminado. Da mesma forma, a chamada para a função fnão pode ser alcançada.

PS BTW, a amostra não é um código C ++ válido. Nesse caso ( N4140 6.7/3ênfase minha):

Um programa que salta ⁹⁰ de um ponto em que uma variável com duração de armazenamento automático não está no escopo para um ponto em que está no escopo está mal formada , a menos que a variável tenha tipo escalar , tipo de classe com um construtor padrão trivial e um destruidor trivial, uma versão qualificada para cv de um desses tipos ou uma matriz de um dos tipos anteriores e é declarada sem um inicializador (8.5).

---

^{90) A transferência da condição de uma switchdeclaração para um rótulo de caso é considerada um salto a esse respeito.}

Portanto, substituir int i = 4;por int i;torna um C ++ válido.

Isso serve a algum propósito?

Sim. Se, em vez de uma declaração, você colocar uma declaração antes do primeiro rótulo, isso pode fazer todo o sentido:

switch (a) {
  int i;
case 0:
  i = f(); g(); h(i);
  break;
case 1:
  i = g(); f(); h(i);
  break;
}

As regras para declarações e declarações são compartilhadas para blocos em geral, portanto, é a mesma regra que permite que isso também permita declarações lá.

Também vale a pena mencionar que, se a primeira instrução for uma construção de loop, os rótulos de caso poderão aparecer no corpo do loop:

switch (i) {
  for (;;) {
    f();
  case 1:
    g();
  case 2:
    if (h()) break;
  }
}

Por favor, não escreva um código como este se houver uma maneira mais legível de escrevê-lo, mas é perfeitamente válido e a f()chamada é acessível.

Existe um uso famoso desse dispositivo chamado Duff's Device .

int n = (count+3)/4;
switch (count % 4) {
  do {
    case 0: *to = *from++;
    case 3: *to = *from++;
    case 2: *to = *from++;
    case 1: *to = *from++;
  } while (--n > 0);
}

Aqui, copiamos um buffer apontado por por frompara um buffer apontado por to. Copiamos countinstâncias de dados.

A do{}while()instrução começa antes do primeiro caserótulo e os caserótulos são incorporados no do{}while().

Isso reduz o número de ramificações condicionais no final do do{}while()loop encontrado por aproximadamente um fator de 4 (neste exemplo; a constante pode ser ajustada para qualquer valor que você desejar).

Agora, às vezes, os otimizadores podem fazer isso por você (especialmente se estão otimizando instruções de streaming / vetorizadas), mas sem a otimização guiada por perfil, eles não sabem se você espera que o loop seja grande ou não.

Em geral, as declarações de variáveis ​​podem ocorrer lá e ser usadas em todos os casos, mas ficam fora do escopo após o término da opção. (observe que qualquer inicialização será ignorada)

Além disso, o fluxo de controle que não é específico do comutador pode levá-lo àquela seção do bloco do comutador, conforme ilustrado acima, ou com a goto.

Supondo que você esteja usando o gcc no Linux, isso seria um aviso se você estivesse usando a versão 4.4 ou anterior.

A opção -Wunreachable-code foi removida no gcc 4.4 em diante.

Não apenas para declaração de variáveis, mas também para salto avançado. Você pode utilizá-lo bem se, e somente se, não for propenso ao código de espaguete.

int main()
{
    int i = 1;
    switch(i)
    {
        nocase:
        printf("no case\n");

        case 0: printf("0\n"); break;
        case 1: printf("1\n"); goto nocase;
    }
    return 0;
}

Impressões

1
no case
0 /* Notice how "0" prints even though i = 1 */

Deve-se notar que a caixa de comutação é uma das cláusulas de fluxo de controle mais rápidas. Portanto, deve ser muito flexível para o programador, o que às vezes envolve casos como este.

Deve-se observar que praticamente não há restrições estruturais no código da switchinstrução ou em onde os case *:rótulos são colocados nesse código *. Isso possibilita truques de programação como o dispositivo de duff , uma implementação possível da seguinte forma:

int n = ...;
int iterations = n/8;
switch(n%8) {
    while(iterations--) {
        sum += *ptr++;
        case 7: sum += *ptr++;
        case 6: sum += *ptr++;
        case 5: sum += *ptr++;
        case 4: sum += *ptr++;
        case 3: sum += *ptr++;
        case 2: sum += *ptr++;
        case 1: sum += *ptr++;
        case 0: ;
    }
}

Veja bem, o código entre o switch(n%8) {e o case 7:rótulo é definitivamente acessível ...

* _{Como supercat apontou felizmente em um comentário : Desde C99, nem um gotonem um rótulo (seja um case *:rótulo ou não) podem aparecer no escopo de uma declaração que contenha uma declaração VLA. Portanto, não é correto dizer que não há restrições estruturais na colocação das case *:etiquetas. No entanto, o dispositivo da duff é anterior ao padrão C99 e, de qualquer maneira, não depende dos VLAs. No entanto, senti-me compelido a inserir um "virtualmente" na minha primeira frase devido a isso.}

Você tem sua resposta relacionada com o exigido gccopção -Wswitch-unreachable para gerar o aviso, esta resposta é para a reflexão sobre a usabilidade / worthyness parte.

Citando diretamente o C11capítulo §6.8.4.2, ( grifo meu )

switch (expr)
{
int i = 4;
f(i);
case 0:
i = 17;
/* falls through into default code */
default:
printf("%d\n", i);
}

o objeto cujo identificador iexiste com duração de armazenamento automático (dentro do bloco), mas nunca é inicializado ; portanto, se a expressão de controle tiver um valor diferente de zero, a chamada para a printf função acessará um valor indeterminado. Da mesma forma, a chamada para a função fnão pode ser alcançada.

O que é muito auto-explicativo. Você pode usar isso para definir uma variável com escopo local que está disponível apenas dentro do switchescopo da instrução.

É possível implementar um "loop e meio" com ele, embora possa não ser a melhor maneira de fazê-lo:

char password[100];
switch(0) do
{
  printf("Invalid password, try again.\n");
default:
  read_password(password, sizeof(password));
} while (!is_valid_password(password));