Syntaxe valide mais sans valeur dans le boîtier de commutation?

À travers une petite faute de frappe, j'ai accidentellement trouvé cette construction:

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

Il semble que le printfhaut de la switchdéclaration soit valide, mais aussi complètement inaccessible.

J'ai obtenu une compilation propre, sans même un avertissement sur le code inaccessible, mais cela semble inutile.

Un compilateur doit-il signaler cela comme du code inaccessible?
Est-ce que cela sert à quelque chose que ce soit?

Peut-être pas le plus utile, mais pas complètement inutile. Vous pouvez l'utiliser pour déclarer une variable locale disponible dans la switchportée.

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

Le standard ( N1579 6.8.4.2/7) a l'exemple suivant:

EXEMPLE Dans le fragment de programme artificiel

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

l'objet dont l'identifiant iexiste avec une durée de stockage automatique (dans le bloc) mais n'est jamais initialisé, et donc si l'expression de contrôle a une valeur non nulle, l'appel à la printffonction accède à une valeur indéterminée. De même, l'appel à la fonction fne peut pas être atteint.

PS BTW, l'exemple n'est pas du code C ++ valide. Dans ce cas ( N4140 6.7/3, c'est moi qui souligne):

Un programme qui passe de ⁹⁰ d'un point où une variable avec une durée de stockage automatique n'est pas dans la portée à un point où elle est dans la portée est mal formé à moins que la variable ait un type scalaire , un type de classe avec un constructeur par défaut trivial et un destructeur trivial, une version qualifiée cv de l'un de ces types, ou un tableau de l'un des types précédents et est déclarée sans initialiseur (8.5).

---

^{90) Le passage de la condition d'une switchdéclaration à une étiquette de cas est considéré comme un saut à cet égard.}

Donc, le remplacer int i = 4;par en int i;fait un C ++ valide.

Est-ce que cela sert à quelque chose que ce soit?

Oui. Si au lieu d'une déclaration, vous mettez une déclaration avant la première étiquette, cela peut être parfaitement logique:

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

Les règles pour les déclarations et les instructions sont partagées pour les blocs en général, c'est donc la même règle qui autorise celle qui autorise également les instructions.

Il convient également de mentionner que si la première instruction est une construction de boucle, des étiquettes de casse peuvent apparaître dans le corps de la boucle:

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

Veuillez ne pas écrire de code comme celui-ci s'il existe un moyen plus lisible de l'écrire, mais il est parfaitement valide et l' f()appel est accessible.

Il y a une utilisation célèbre de cet appareil appelé 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);
}

Ici, nous copions un tampon pointé par par fromun tampon pointé par to. Nous copions des countinstances de données.

L' do{}while()instruction commence avant la première caseétiquette et les caseétiquettes sont incorporées dans le do{}while().

Cela réduit le nombre de branches conditionnelles à la fin de la do{}while()boucle rencontrées d'environ un facteur 4 (dans cet exemple; la constante peut être ajustée à la valeur souhaitée).

Maintenant, les optimiseurs peuvent parfois le faire pour vous (surtout s'ils optimisent le streaming / les instructions vectorisées), mais sans optimisation guidée par le profil, ils ne peuvent pas savoir si vous vous attendez à ce que la boucle soit grande ou non.

En général, les déclarations de variables peuvent s'y produire et être utilisées dans tous les cas, mais être hors de portée une fois le commutateur terminé. (notez que toute initialisation sera ignorée)

De plus, un flux de contrôle qui n'est pas spécifique au commutateur peut vous amener dans cette section du bloc de commutateur, comme illustré ci-dessus, ou avec un goto.

En supposant que vous utilisez gcc sous Linux, cela vous aurait donné un avertissement si vous utilisez 4.4 ou une version antérieure.

L'option -Wunreachable-code a été supprimée dans gcc 4.4 .

Non seulement pour la déclaration de variables, mais aussi pour le saut avancé. Vous pouvez bien l'utiliser si et seulement si vous n'êtes pas sujet au code de 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;
}

Impressions

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

Il convient de noter que le commutateur-cas est l'une des clauses de flux de contrôle les plus rapides. Il doit donc être très flexible pour le programmeur, ce qui implique parfois des cas comme celui-ci.

Il convient de noter qu'il n'y a pratiquement aucune restriction structurelle sur le code dans l' switchénoncé ou sur l'emplacement des case *:étiquettes dans ce code *. Cela rend possible des astuces de programmation comme le périphérique de duff , dont une implémentation possible ressemble à ceci:

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

Vous voyez, le code entre le switch(n%8) {et lecase 7: étiquette est définitivement accessible ...

* _{Comme Supercat l'a heureusement souligné dans un commentaire : depuis C99, ni un gotoni une étiquette (que ce soit une case *:étiquette ou non) ne peut apparaître dans le cadre d'une déclaration contenant une déclaration VLA. Il n'est donc pas correct de dire qu'il n'y a pas de restrictions structurelles sur le placement des case *:étiquettes. Cependant, l'appareil de duff est antérieur à la norme C99, et il ne dépend pas de toute façon de VLA. Néanmoins, je me suis senti obligé d'insérer un "virtuellement" dans ma première phrase à cause de cela.}

Vous avez obtenu votre réponse concernant l' option requisegcc -Wswitch-unreachable pour générer l'avertissement, cette réponse consiste à élaborer sur la partie convivialité / valeur .

Citant directement C11, chapitre §6.8.4.2, (c'est moi qui souligne )

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

l'objet dont l'identifiant iexiste avec une durée de stockage automatique (dans le bloc) mais n'est jamais initialisé , et donc si l'expression de contrôle a une valeur non nulle, l'appel à la printf fonction accède à une valeur indéterminée. De même, l'appel à la fonction fne peut pas être atteint.

Ce qui est très explicite. Vous pouvez l'utiliser pour définir une variable de portée locale qui n'est disponible que dans la switchportée de l' instruction.

Il est possible d'implémenter une "boucle et demie" avec, bien que ce ne soit pas la meilleure façon de le faire:

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