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

Je me suis toujours demandé ceci - pourquoi ne pouvez-vous pas déclarer des variables après une étiquette de cas dans une instruction switch? En C ++, vous pouvez déclarer des variables à peu près n'importe où (et les déclarer proches de la première utilisation est évidemment une bonne chose) mais ce qui suit ne fonctionnera 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 le libellé «case»

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

Caseles instructions ne sont que des étiquettes . Cela signifie que le compilateur interprétera cela comme un saut directement vers l'étiquette. En C ++, le problème ici est celui de la portée. Vos accolades définissent la portée comme tout à l'intérieur duswitch instruction. 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 bonne façon de gérer cela est de définir une portée spécifique à cette caseinstruction et de définir votre variable à l'intérieur:

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

Cette question est a été étiqueté comme [C] et [C ++] en même temps. Le code d'origine est en effet invalide à la fois en C et C ++, mais pour des raisons totalement différentes et sans rapport.

• En C ++, ce code n'est pas valide car l' case ANOTHER_VAL:étiquette saute dans la portée de la variable en newValcontournant son initialisation. Les sauts qui contournent l'initialisation des objets automatiques sont illégaux en C ++. Ce côté du problème 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 sur son initialisation est légal en C. Cela signifie simplement que la variable n'est pas initialisée. Le code d'origine ne compile pas en C pour une raison complètement différente. L'étiquette case VAL:dans le code d'origine est attachée à la déclaration de variable newVal. En langage C, les déclarations ne sont pas des déclarations. Ils ne peuvent pas être étiquetés. 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 extra {} bloc résout à la fois les problèmes C ++ et C, même si ces problèmes sont très différents. Du côté C ++, il restreint la portée de newVal, en s'assurant que case ANOTHER_VAL:ne saute plus dans cette portée, ce qui élimine le problème C ++. Du côté C, ce supplément {}introduit une instruction composée, ce qui rend l' case VAL:étiquette à appliquer à une instruction, ce qui élimine le problème C.

• Dans le cas C, le problème peut être facilement résolu sans {} . Ajoutez simplement une instruction vide après l' case VAL:étiquette 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 s'il est désormais valide du point de vue C, il reste invalide du point de vue C ++.

• Symétriquement, dans le cas C ++, le problème peut être facilement résolu sans le {} . Il suffit de supprimer l'initialiseur de la déclaration de 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 s'il est désormais valide du point de vue C ++, il reste invalide du point de vue C.

D'accord. Juste pour clarifier cela, cela n'a strictement rien à voir avec la déclaration. Elle concerne uniquement le "saut par-dessus l'initialisation" (ISO C ++ '03 6.7 / 3)

Beaucoup de messages ici ont mentionné que le fait de sauter la déclaration peut entraîner la non-déclaration de la variable. Ce n'est pas vrai. Un objet POD peut être déclaré sans initialiseur mais il aura une valeur indéterminée. Par exemple:

switch (i)
{
   case 0:
     int j; // 'j' has indeterminate value
     j = 0; // 'j' 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 initialiseur, et il n'est donc pas possible de passer 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 n'est pas limitée à l'instruction switch. C'est aussi une erreur d'utiliser 'goto' pour sauter une initialisation:

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

Un petit anecdote est que c'est une différence entre C ++ et C. En C, ce n'est pas une erreur de sauter par-dessus 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 de cas individuel.

L'instruction switch entière est dans la même portée. Pour le contourner, procédez comme suit:

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

    case ANOTHER_VAL:
      ...
    break;
}

Notez les crochets.

Après avoir lu toutes les réponses et quelques recherches supplémentaires, je reçois quelques choses.

Case statements are only 'labels'

En C, selon la spécification,

§6.8.1 Déclarations étiquetées:

labeled-statement:
    identifier : statement
    case constant-expression : statement
    default : statement

En C, aucune clause ne permet une "déclaration étiquetée". Cela ne fait tout simplement pas partie de la langue.

Donc

case 1: int x=10;
        printf(" x is %d",x);
break;

Cela ne se compilera pas , voir http://codepad.org/YiyLQTYw . GCC donne une erreur:

label can only be a part of statement and declaration is not a statement

Même

  case 1: int x;
          x=10;
            printf(" x is %d",x);
    break;

ce n'est pas non plus la compilation , voir http://codepad.org/BXnRD3bu . Ici, je reçois également la même erreur.

En C ++, selon la spécification,

La déclaration étiquetée est autorisée mais l'initialisation étiquetée n'est pas autorisée.

Voir http://codepad.org/ZmQ0IyDG .

La solution à une telle condition est deux

1. Soit utiliser une nouvelle portée en utilisant {}

   case 1:
          {
              int x=10;
              printf(" x is %d", x);
          }
   break;

2. Ou utilisez une déclaration fictive avec une étiquette

   case 1: ;
              int x=10;
              printf(" x is %d",x);
   break;

3. Déclarez la variable avant switch () et initialisez-la avec différentes valeurs dans l'instruction case si elle répond à vos besoins

   main()
   {
       int x;   // Declare before
       switch(a)
       {
       case 1: x=10;
           break;
   
       case 2: x=20;
           break;
       }
   }

Encore plus de choses avec l'instruction switch

N'écrivez jamais dans le commutateur des instructions qui ne font partie d'aucune étiquette, car elles ne seront jamais exécutées:

switch(a)
{
    printf("This will never print"); // This will never executed

    case 1:
        printf(" 1");
        break;

    default:
        break;
}

Voir http://codepad.org/PA1quYX3 .

Vous ne pouvez pas faire cela, car les caseétiquettes ne sont en fait que des points d'entrée dans le bloc conteneur.

Ceci est plus clairement illustré par l'appareil de Duff . Voici un code 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 les caseétiquettes ignorent totalement les limites des blocs. Oui, c'est mal. Mais c'est pourquoi votre exemple de code ne fonctionne pas. Passer à une caseétiquette équivaut à utiliser goto, vous n'êtes donc pas autorisé à passer par-dessus une variable locale avec un constructeur.

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

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

Jusqu'à présent, la plupart des réponses sont fausses sur un point: vous pouvez déclarer des variables après l'instruction case, mais vous ne pouvez pas les initialiser:

case 1:
    int x; // Works
    int y = 0; // Error, initialization is skipped by case
    break;
case 2:
    ...

Comme mentionné précédemment, une bonne solution consiste à utiliser des accolades pour créer une portée pour votre cas.

Mon astuce maléfique préférée est d'utiliser un if (0) pour sauter une étiquette de cas indésirable.

switch(val)
{
case 0:
// Do something
if (0) {
case 1:
// Do something else
}
case 2:
// Do something in all cases
}

Mais très mal.

Essaye ça:

switch (val)
{
    case VAL:
    {
        int newVal = 42;
    }
    break;
}

Vous pouvez déclarer des variables dans une instruction switch si vous démarrez un nouveau bloc:

switch (thing)
{ 
  case A:
  {
    int i = 0;  // Completely legal
  }
  break;
}

La raison est liée à l'allocation (et la récupération) d'espace sur la pile pour le stockage des variables locales.

Considérer:

switch(val)
{
case VAL:
   int newVal = 42;
default:
   int newVal = 23;
}

En l'absence d'instructions break, newVal est parfois déclaré deux fois, et vous ne savez pas si c'est le cas jusqu'à l'exécution. Je suppose que la limitation est due à ce genre de confusion. Quelle serait la portée de newVal? La convention dicterait que ce serait l'ensemble du bloc de commutation (entre les accolades).

Je ne suis pas programmeur C ++, mais en C:

switch(val) {
    int x;
    case VAL:
        x=1;
}

Fonctionne bien. Déclarer une variable à l'intérieur d'un bloc de commutation est très bien. Déclarer après un garde de cas ne l'est pas.

La section entière du commutateur est un contexte de déclaration unique. Vous ne pouvez pas déclarer une variable dans une instruction case comme celle-ci. Essayez plutôt ceci:

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

Si votre code dit "int newVal = 42", vous vous attendez raisonnablement à ce que newVal ne soit jamais non initialisé. Mais si vous passez au-dessus de cette déclaration (ce que vous faites), c'est exactement ce qui se passe - newVal est dans le champ d'application mais n'a pas été attribué.

Si c'est ce que vous vouliez vraiment faire, le langage nécessite de le rendre explicite en disant "int newVal; newVal = 42;". Sinon, vous pouvez limiter la portée de newVal au cas unique, ce qui correspond plus probablement à ce que vous vouliez.

Cela peut clarifier les choses si vous considérez le même exemple mais avec "const int newVal = 42;"

Je voulais juste souligner mince de points . Une construction de commutateur crée une portée entière de premier ordre pour les citoyens. Il est donc possible de déclarer (et d'initialiser) une variable dans une instruction switch avant la première étiquette de cas, sans paire de crochets supplémentaire:

switch (val) {  
  /* This *will* work, even in C89 */
  int newVal = 42;  
case VAL:
  newVal = 1984; 
  break;
case ANOTHER_VAL:  
  newVal = 2001;
  break;
}

Jusqu'à présent, les réponses ont été pour C ++.

Pour C ++, vous ne pouvez pas sauter une initialisation. Vous pouvez le faire en C. Cependant, en C, une déclaration n'est pas une instruction, et les étiquettes de cas doivent être suivies d'instructions.

Donc, C valide (mais moche), C ++ invalide

switch (something)
{
  case 1:; // Ugly hack empty statement
    int i = 6;
    do_stuff_with_i(i);
    break;
  case 2:
    do_something();
    break;
  default:
    get_a_life();
}

Inversement, en C ++, une déclaration est une instruction, donc ce qui suit est C ++ valide, C non valide

switch (something)
{
  case 1:
    do_something();
    break;
  case 2:
    int i = 12;
    do_something_else();
}

Intéressant que ce soit bien:

switch (i)  
{  
case 0:  
    int j;  
    j = 7;  
    break;  

case 1:  
    break;
}

... mais ce n'est pas:

switch (i)  
{  
case 0:  
    int j = 7;  
    break;  

case 1:  
    break;
}

Je comprends qu'un correctif est assez simple, mais je ne comprends pas encore pourquoi le premier exemple ne dérange pas le compilateur. Comme évoqué précédemment (2 ans plus tôt hehe), la déclaration n'est pas la cause de l'erreur, même malgré la logique. L'initialisation est le problème. Si la variable est initialisée et déclarée sur les différentes lignes, elle se compile.

J'ai écrit cette réponse à l'origine pour cette question . Cependant, quand j'ai fini, j'ai trouvé que la réponse était fermée. Je l'ai donc posté ici, peut-être que quelqu'un qui aime les références à la norme le trouvera utile.

Code original en question:

int i;
i = 2;
switch(i)
{
    case 1: 
        int k;
        break;
    case 2:
        k = 1;
        cout<<k<<endl;
        break;
}

Il y a en fait 2 questions:

1. Pourquoi puis-je déclarer une variable après l' caseétiquette?

C'est parce que dans C ++, l'étiquette doit être en forme:

N3337 6.1 / 1

label-statement:

...

• attribut-spécificateur-seqopt case constant-expression :statement

...

Et dans la C++ déclaration, la déclaration est également considérée comme une déclaration (par opposition à C):

N3337 6/1:

déclaration :

...

déclaration-déclaration

...

2. Pourquoi puis-je sauter par-dessus la déclaration de variable et ensuite l'utiliser?

Parce que: N3337 6.7 / 3

Il est possible de transférer dans un bloc, mais pas d'une manière qui contourne les déclarations avec l'initialisation . Un programme qui saute (Le transfert de la condition d'une instruction switch à une étiquette de cas est considéré comme un saut à cet égard.)

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ée, sauf si la variable a un type scalaire , un type de classe avec un constructeur par défaut trivial et un destructeur trivial, une version qualifiée par cv de l'un de ces types ou d'un tableau de l'un des types précédents et est déclaré sans initialiseur (8.5).

Depuis kest de type scalaire , et n'est pas initialisé au moment de la déclaration, il est possible de sauter par-dessus. C'est sémantiquement équivalent:

goto label;

int x;

label:
cout << x << endl;

Cependant cela ne serait pas possible, si a xété initialisé au moment de la déclaration:

 goto label;

    int x = 58; //error, jumping over declaration with initialization

    label:
    cout << x << endl;

Les nouvelles variables peuvent être décalarisées uniquement à la portée du bloc. Vous devez écrire quelque chose comme ceci:

case VAL:  
  // This will work
  {
  int newVal = 42;  
  }
  break;

Bien sûr, newVal n'a de portée que dans les accolades ...

À la vôtre, Ralph

Un switchbloc n'est pas la même chose qu'une succession de if/else ifblocs. Je suis surpris qu'aucune autre réponse ne l'explique clairement.

Considérez cette switchdéclaration:

switch (value) {
    case 1:
        int a = 10;
        break;
    case 2:
        int a = 20;
        break;
}

Cela peut être surprenant, mais le compilateur ne le considérera pas comme un simple if/else if. Il produira le code suivant:

if (value == 1)
    goto label_1;
else if (value == 2)
    goto label_2;
else
    goto label_end;

{
label_1:
    int a = 10;
    goto label_end;
label_2:
    int a = 20; // Already declared !
    goto label_end;
}

label_end:
    // The code after the switch block

Les caseinstructions sont converties en étiquettes, puis appelées avec goto. Les crochets créent une nouvelle portée et il est facile de voir maintenant pourquoi vous ne pouvez pas déclarer deux variables avec le même nom dans unswitch bloc.

Cela peut sembler étrange, mais il est nécessaire de prendre en charge la fonction fallthrough (c'est-à-dire de ne pas utiliser breakpour laisser l'exécution continuer jusqu'à la suivante case).

Je crois que le problème est que la déclaration a été ignorée et que vous avez essayé d'utiliser le var ailleurs, elle ne serait pas déclarée.

newVal existe dans toute l'étendue du commutateur mais n'est initialisé que si le membre VAL est touché. Si vous créez un bloc autour du code dans VAL, cela devrait être OK.

C ++ Standard a: Il est possible de transférer dans un bloc, mais pas d'une manière qui contourne les déclarations avec initialisation. Un programme qui passe d'un point où une variable locale 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é sauf si la variable a le type POD (3.9) et est déclarée sans initialiseur (8.5).

Le code pour illustrer cette règle:

#include <iostream>

using namespace std;

class X {
  public:
    X() 
    {
     cout << "constructor" << endl;
    }
    ~X() 
    {
     cout << "destructor" << endl;
    }
};

template <class type>
void ill_formed()
{
  goto lx;
ly:
  type a;
lx:
  goto ly;
}

template <class type>
void ok()
{
ly:
  type a;
lx:
  goto ly;
}

void test_class()
{
  ok<X>();
  // compile error
  ill_formed<X>();
}

void test_scalar() 
{
  ok<int>();
  ill_formed<int>();
}

int main(int argc, const char *argv[]) 
{
  return 0;
}

Le code pour montrer l'effet d'initialisation:

#include <iostream>

using namespace std;

int test1()
{
  int i = 0;
  // There jumps fo "case 1" and "case 2"
  switch(i) {
    case 1:
      // Compile error because of the initializer
      int r = 1; 
      break;
    case 2:
      break;
  };
}

void test2()
{
  int i = 2;
  switch(i) {
    case 1:
      int r;
      r= 1; 
      break;
    case 2:
      cout << "r: " << r << endl;
      break;
  };
}

int main(int argc, const char *argv[]) 
{
  test1();
  test2();
  return 0;
}

Il semble que des objets anonymes peuvent être déclarés ou créés dans une instruction de cas de commutateur pour la raison qu'ils ne peuvent pas être référencés et en tant que tels ne peuvent pas passer au cas suivant. Considérez que cet exemple se compile sur GCC 4.5.3 et Visual Studio 2008 (cela pourrait être un problème de conformité, alors les experts doivent peser)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

    switch( i )
    {
    case 42:
        Foo();  // Apparently valid
        break;

    default:
        break;
    }
    return EXIT_SUCCESS;
}