Pourquoi les variables ne peuvent-elles pas être déclarées dans une instruction switch ?

Question

Je me suis toujours posé la question suivante : pourquoi ne peut-on pas déclarer des variables après une étiquette case dans une instruction switch ? En C++, vous pouvez déclarer des variables à peu près n'importe où (et les déclarer à proximité de leur première utilisation est évidemment une bonne chose), mais ce qui suit ne fonctionne toujours pas :

switch (val)  
{  
case VAL:  
  // This won't work
  int newVal = 42;  
  break;
case ANOTHER_VAL:  
  ...
  break;
}  

Ce qui précède me donne l'erreur suivante (MSC) :

L'initialisation de 'newVal' est ignorée par l'étiquette 'case'.

Cela semble être une limitation dans d'autres langues également. Pourquoi est-ce un tel problème ?

Answer 1

Case les déclarations sont seulement étiquettes . Cela signifie que le compilateur l'interprétera comme un saut directement à l'étiquette. En C++, le problème ici est celui de la portée. Vos accolades définissent la portée comme étant tout ce qui se trouve à l'intérieur de l'élément switch déclaration. Cela signifie que vous vous retrouvez avec une portée où un saut sera effectué plus loin dans le code en sautant l'initialisation.

La manière correcte de gérer cette situation est de définir une portée spécifique à cet élément case et définissez votre variable dans celle-ci :

switch (val)
{   
case VAL:  
{
  // This will work
  int newVal = 42;  
  break;
}
case ANOTHER_VAL:  
...
break;
}

Answer 2

Cette question a été initialement étiquetée comme c y c++ en même temps. Le code original est en effet invalide à la fois en C et en C++, mais pour des raisons complètement différentes et non liées.

• En C++, ce code n'est pas valable parce que l'élément case ANOTHER_VAL: saute dans la portée de la variable newVal en contournant son initialisation. Les sauts qui contournent l'initialisation d'objets automatiques sont illégaux en C++. Cet aspect de la question est correctement traité par la plupart des réponses.

• Cependant, en langage C, le contournement de l'initialisation des variables n'est pas une erreur. Sauter dans la portée d'une variable par-dessus son initialisation est légal en C. Cela signifie simplement que la variable est laissée non initialisée. Le code original ne compile pas en C pour une raison complètement différente. Étiquette case VAL: dans le code original est attaché à la déclaration de la variable newVal . En langage C, les déclarations ne sont pas des instructions. Elles ne peuvent pas être étiquetées. Et c'est ce qui provoque l'erreur lorsque ce code est interprété comme du code C.

    switch (val)  
    {  
    case VAL:             /* <- C error is here */
      int newVal = 42;  
      break;
    case ANOTHER_VAL:     /* <- C++ error is here */
      ...
      break;
    }

  Ajout d'un supplément {} Ce bloc résout les problèmes du C++ et du C, même si ces problèmes sont très différents. Du côté du C++, il restreint la portée de la fonction newVal en s'assurant que case ANOTHER_VAL: ne saute plus dans cette portée, ce qui élimine le problème du C++. Du côté du C, cet élément supplémentaire {} introduit une déclaration composée, rendant ainsi le case VAL: à appliquer à une déclaration, ce qui élimine le problème du C.

• Dans le cas de C, le problème peut être facilement résolu sans le {} . Il suffit d'ajouter une déclaration vide après le case VAL: et le code deviendra valide

    switch (val)  
    {  
    case VAL:;            /* Now it works in C! */
      int newVal = 42;  
      break;
    case ANOTHER_VAL:  
      ...
      break;
    }

  Notez que même si elle est maintenant valide du point de vue du C, elle reste invalide du point de vue du C++.

• Symétriquement, dans le cas du C++, le problème peut être résolu facilement sans le {} . Il suffit de supprimer l'initialisateur de la déclaration de la variable et le code deviendra valide.

    switch (val)  
    {  
    case VAL: 
      int newVal;
      newVal = 42;  
      break;
    case ANOTHER_VAL:     /* Now it works in C++! */
      ...
      break;
    }

  Notez que même si elle est maintenant valide du point de vue du C++, elle reste invalide du point de vue du C.

Answer 3

Ok. Juste pour clarifier, cela n'a strictement rien à voir avec la déclaration. Il s'agit uniquement de "sauter par-dessus l'initialisation" (ISO C++ '03 6.7/3).

De nombreux messages ici ont mentionné que le fait de sauter par-dessus la déclaration peut avoir pour conséquence que la variable "n'est pas déclarée". Ceci n'est pas vrai. Un objet POD peut être déclaré sans initialisateur mais il aura une valeur indéterminée. Par exemple :

switch (i)
{
   case 0:
     int j; // 'j' has indeterminate value
     j = 0; // 'j' set (not initialized) to 0, but this statement
            // is jumped when 'i == 1'
     break;
   case 1:
     ++j;   // 'j' is in scope here - but it has an indeterminate value
     break;
}

Lorsque l'objet est un non-POD ou un agrégat, le compilateur ajoute implicitement un initialisateur, et il n'est donc pas possible de sauter par-dessus une telle déclaration :

class A {
public:
  A ();
};

switch (i)  // Error - jumping over initialization of 'A'
{
   case 0:
     A j;   // Compiler implicitly calls default constructor
     break;
   case 1:
     break;
}

Cette limitation ne se limite pas à l'énoncé du commutateur. L'utilisation de 'goto' pour sauter par-dessus une initialisation est également une erreur :

goto LABEL;    // Error jumping over initialization
int j = 0; 
LABEL:
  ;

Il s'agit d'une différence entre le C++ et le C. En C, ce n'est pas une erreur de sauter l'initialisation.

Comme d'autres l'ont mentionné, la solution consiste à ajouter un bloc imbriqué afin que la durée de vie de la variable soit limitée à l'étiquette du cas individuel.

Answer 4

L'ensemble de la déclaration de commutation est dans la même portée. Pour le contourner, faites ceci :

switch (val)
{
    case VAL:
    {
        // This **will** work
        int newVal = 42;
    }
    break;

    case ANOTHER_VAL:
      ...
    break;
}

Note les crochets.

Answer 5

Vous ne pouvez pas faire ça, parce que case Les étiquettes ne sont en fait que des points d'entrée dans le bloc contenant.

L'illustration la plus claire en est donnée par Dispositif de Duff . Voici un code tiré de Wikipedia :

strcpy(char *to, char *from, size_t 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);
    }
}

Remarquez comment le case Les étiquettes ignorent totalement les limites du bloc. Oui, c'est diabolique. Mais c'est pourquoi votre exemple de code ne fonctionne pas. Sauter à un case est identique à l'utilisation de l'étiquette goto Vous n'êtes donc pas autorisé à sauter par-dessus une variable locale avec un constructeur.

Comme l'ont indiqué plusieurs autres posters, vous devez mettre en place votre propre bloc :

switch (...) {
    case FOO: {
        MyObject x(...);
        ...
        break; 
    }
    ...
 }