Sintassi valida, ma senza valore in caso di commutazione?

Attraverso un piccolo errore di battitura, ho trovato per caso questo costrutto:

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

Sembra che la printfparte superiore switchdell'istruzione sia valida, ma anche completamente irraggiungibile.

Ho ottenuto una compilazione pulita, senza nemmeno un avvertimento sul codice irraggiungibile, ma questo sembra inutile.

Un compilatore dovrebbe contrassegnarlo come codice irraggiungibile?
Questo serve a qualche scopo?

Forse non il più utile, ma non del tutto inutile. È possibile utilizzarlo per dichiarare una variabile locale disponibile nell'ambito switch.

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

Lo standard ( N1579 6.8.4.2/7) ha il seguente esempio:

ESEMPIO Nel frammento del programma artificiale

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

l'oggetto il cui identificatore iesiste con durata di memorizzazione automatica (all'interno del blocco) ma non viene mai inizializzato, e quindi se l'espressione di controllo ha un valore diverso da zero, la chiamata alla printffunzione accederà a un valore indeterminato. Allo stesso modo, fnon è possibile raggiungere la chiamata alla funzione .

PS BTW, l'esempio non è un codice C ++ valido. In quel caso ( N4140 6.7/3, enfatizzare il mio):

Un programma che salta ⁹⁰ da un punto in cui una variabile con durata di memorizzazione automatica non rientra nell'ambito in un punto in cui è nell'ambito è mal formato a meno che la variabile abbia un tipo scalare , un tipo di classe con un costruttore predefinito banale e un distruttore banale, una versione qualificata per cv di uno di questi tipi o una matrice di uno dei tipi precedenti ed è dichiarata senza un inizializzatore (8.5).

---

^{90) Il passaggio dalla condizione di una switchdichiarazione a un'etichetta del caso è considerato un salto in questo senso.}

Quindi la sostituzione int i = 4;con lo int i;rende un C ++ valido.

Questo serve a qualche scopo?

Sì. Se invece di una dichiarazione, metti una dichiarazione prima della prima etichetta, questo può avere perfettamente senso:

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

Le regole per le dichiarazioni e le istruzioni sono condivise per i blocchi in generale, quindi è la stessa regola che consente ciò che consente anche le istruzioni lì.

Vale anche la pena ricordare che se la prima istruzione è un costrutto loop, le etichette dei casi potrebbero apparire nel corpo del loop:

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

Si prega di non scrivere codice in questo modo se esiste un modo più leggibile per scriverlo, ma è perfettamente valido e la f()chiamata è raggiungibile.

C'è un uso famoso di questo chiamato 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);
}

Qui copiamo un buffer puntato da fromun buffer puntato da to. Copiamo countistanze di dati.

L' do{}while()istruzione inizia prima della prima caseetichetta e le caseetichette sono incorporate all'interno di do{}while().

Ciò riduce il numero di rami condizionali alla fine del do{}while()loop incontrati all'incirca da un fattore 4 (in questo esempio; la costante può essere regolata su qualsiasi valore desiderato).

Ora, gli ottimizzatori a volte possono fare questo per te (specialmente se stanno ottimizzando le istruzioni di streaming / vettorializzate), ma senza l'ottimizzazione guidata dal profilo non possono sapere se ti aspetti che il ciclo sia grande o meno.

In generale, in questi casi possono verificarsi dichiarazioni di variabili che possono essere utilizzate in ogni caso, ma al di fuori dell'interruttore non rientrano nell'ambito di applicazione. (nota che qualsiasi inizializzazione verrà saltata)

Inoltre, il flusso di controllo che non è specifico dell'interruttore può portarti in quella sezione del blocco interruttore, come illustrato sopra, o con un goto.

Supponendo che tu stia usando gcc su Linux, ti darebbe un avviso se stai usando la versione 4.4 o precedente.

L'opzione -Wunreachable-code è stata rimossa da gcc 4.4 in poi.

Non solo per la dichiarazione variabile ma anche per il salto avanzato. Puoi utilizzarlo bene se e solo se non sei incline al codice spaghetti.

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

stampe

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

Va notato che il caso di commutazione è una delle clausole di flusso di controllo più veloci. Quindi deve essere molto flessibile per il programmatore, che a volte comporta casi come questo.

Va notato che non ci sono praticamente restrizioni strutturali sul codice all'interno switchdell'istruzione o su dove le case *:etichette sono inserite all'interno di questo codice *. Ciò rende possibili trucchi di programmazione come il dispositivo di Duff , una possibile implementazione della quale appare così:

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

Vedi, il codice tra la switch(n%8) {e l' case 7:etichetta è sicuramente raggiungibile ...

* _{Come ha sottolineato fortunatamente il supercat in un commento : dal C99, né una gotoné un'etichetta (che sia case *:un'etichetta o meno) può apparire nell'ambito di una dichiarazione che contiene una dichiarazione VLA. Quindi non è corretto dire che non ci sono nessun limitazioni strutturali sul posizionamento delle case *:etichette. Tuttavia, il dispositivo di Duff è precedente allo standard C99 e non dipende comunque dai VLA. Tuttavia, mi sono sentito obbligato a inserire un "virtualmente" nella mia prima frase a causa di ciò.}

Hai ottenuto la tua risposta correlata all'opzione richiestagcc -Wswitch-unreachable per generare l'avviso, questa risposta è quella di elaborare la parte di usabilità / dignità .

Citando direttamente C11, capitolo §6.8.4.2, ( sottolineatura mia )

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

l'oggetto il cui identificatore iesiste con durata di memorizzazione automatica (all'interno del blocco) ma non viene mai inizializzato e quindi se l'espressione di controllo ha un valore diverso da zero, la chiamata alla printf funzione accederà a un valore indeterminato. Allo stesso modo, fnon è possibile raggiungere la chiamata alla funzione .

Il che è molto esplicativo. È possibile utilizzarlo per definire una variabile con ambito locale disponibile solo nell'ambito switchdell'istruzione.

È possibile implementare un "loop e mezzo" con esso, anche se potrebbe non essere il modo migliore per farlo:

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