Perché le variabili non possono essere dichiarate in un'istruzione switch?

Mi sono sempre chiesto questo: perché non puoi dichiarare le variabili dopo un'etichetta del caso in un'istruzione switch? In C ++ puoi dichiarare le variabili praticamente ovunque (e dichiararle vicine al primo utilizzo è ovviamente una buona cosa) ma comunque non funzionerà:

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

Quanto sopra mi dà il seguente errore (MSC):

l'inizializzazione di "newVal" viene ignorata dall'etichetta "case"

Questa sembra essere una limitazione anche in altre lingue. Perché è un tale problema?

Casele dichiarazioni sono solo etichette . Ciò significa che il compilatore interpreterà questo come un salto direttamente all'etichetta. In C ++, il problema qui è di portata. Le parentesi graffe definiscono l'ambito come tutto all'interno switchdell'istruzione. Ciò significa che ti viene lasciato un ambito in cui un salto verrà eseguito ulteriormente nel codice saltando l'inizializzazione.

Il modo corretto di gestirlo è definire un ambito specifico per casequell'istruzione e definire la variabile al suo interno:

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

Questa domanda è stata originariamente contrassegnata come [C] e [C ++] allo stesso tempo. Il codice originale non è effettivamente valido sia in C che in C ++, ma per ragioni completamente diverse e non correlate.

• In C ++ questo codice non è valido perché l' case ANOTHER_VAL:etichetta passa nell'ambito della variabile newValbypassando la sua inizializzazione. I salti che aggirano l'inizializzazione di oggetti automatici sono illegali in C ++. Questo aspetto del problema viene risolto correttamente dalla maggior parte delle risposte.

• Tuttavia, nel linguaggio C bypassare l'inizializzazione delle variabili non è un errore. Saltare nell'ambito di una variabile sulla sua inizializzazione è legale in C. Significa semplicemente che la variabile viene lasciata non inizializzata. Il codice originale non viene compilato in C per un motivo completamente diverso. L'etichetta case VAL:nel codice originale è allegata alla dichiarazione di variabile newVal. Nel linguaggio C le dichiarazioni non sono dichiarazioni. Non possono essere etichettati. E questo è ciò che causa l'errore quando questo codice viene interpretato come codice C.

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

L'aggiunta di un {}blocco aggiuntivo risolve i problemi C ++ e C, anche se questi problemi sembrano essere molto diversi. Sul lato C ++ limita l'ambito di newVal, assicurandosi che case ANOTHER_VAL:non salti più in quell'ambito, il che elimina il problema C ++. Dal lato C questo extra {}introduce un'istruzione composta, rendendo così l' case VAL:etichetta da applicare a un'istruzione, che elimina il problema C.

• Nel caso C il problema può essere facilmente risolto senza il {}. Basta aggiungere un'istruzione vuota dopo l' case VAL:etichetta e il codice diventerà valido

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

  Si noti che anche se ora è valido dal punto di vista C, rimane invalido dal punto di vista C ++.

• Simmetricamente, nel caso C ++ il problema può essere facilmente risolto senza {}. Basta rimuovere l'inizializzatore dalla dichiarazione delle variabili e il codice diventerà valido

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

  Si noti che anche se ora è valido dal punto di vista C ++, rimane invalido dal punto di vista C.

Ok. Solo per chiarire questo strettamente non ha nulla a che fare con la dichiarazione. Si riferisce solo al "salto sull'inizializzazione" (ISO C ++ '03 6.7 / 3)

Molti dei post qui menzionati affermano che saltare la dichiarazione può comportare che la variabile "non venga dichiarata". Questo non è vero. Un oggetto POD può essere dichiarato senza un inizializzatore ma avrà un valore indeterminato. Per esempio:

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

Laddove l'oggetto sia un non-POD o aggregato, il compilatore aggiunge implicitamente un inizializzatore, e quindi non è possibile saltare una simile dichiarazione:

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

Questa limitazione non è limitata all'istruzione switch. È anche un errore usare 'goto' per saltare su un'inizializzazione:

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

Un po 'di curiosità è che questa è una differenza tra C ++ e C. In C, non è un errore saltare l'inizializzazione.

Come altri hanno già detto, la soluzione è aggiungere un blocco nidificato in modo che la durata della variabile sia limitata all'etichetta del singolo caso.

L'intera istruzione switch è nello stesso ambito. Per aggirare il problema, procedere come segue:

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

    case ANOTHER_VAL:
      ...
    break;
}

Nota le parentesi.

Dopo aver letto tutte le risposte e qualche altra ricerca, ottengo alcune cose.

Case statements are only 'labels'

In C, secondo le specifiche,

§6.8.1 Dichiarazioni etichettate:

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

In C non esiste alcuna clausola che consenta una "dichiarazione etichettata". Non fa parte della lingua.

Così

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

Questo non verrà compilato , vedere http://codepad.org/YiyLQTYw . GCC sta dando un errore:

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

Anche

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

anche questo non è compilando , vedi http://codepad.org/BXnRD3bu . Anche qui sto ottenendo lo stesso errore.

In C ++, secondo le specifiche,

è consentita la dichiarazione con etichetta, ma non è consentita l'inizializzazione con etichetta.

Vedi http://codepad.org/ZmQ0IyDG .

La soluzione a tale condizione è due

1. Utilizza il nuovo ambito usando {}

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

2. O utilizzare la dichiarazione fittizia con etichetta

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

3. Dichiarare la variabile prima di switch () e inizializzarla con valori diversi nell'istruzione case se soddisfa i requisiti

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

Altre cose con l'istruzione switch

Non scrivere mai istruzioni nello switch che non fanno parte di alcuna etichetta, perché non verranno mai eseguite:

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

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

    default:
        break;
}

Vedi http://codepad.org/PA1quYX3 .

Non puoi farlo, perché le caseetichette sono in realtà solo punti di ingresso nel blocco contenitore.

Ciò è chiaramente illustrato dal dispositivo di Duff . Ecco un po 'di codice da 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);
    }
}

Notare come le caseetichette ignorano totalmente i confini del blocco. Sì, questo è male. Questo è il motivo per cui il tuo esempio di codice non funziona. Saltare su caseun'etichetta è lo stesso che usare goto, quindi non puoi saltare una variabile locale con un costruttore.

Come diversi altri manifesti hanno indicato, è necessario inserire un blocco per conto proprio:

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

La maggior parte delle risposte finora sono errate sotto un aspetto: puoi dichiarare le variabili dopo l'istruzione case, ma non puoi inizializzarle:

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

Come accennato in precedenza, un buon modo per aggirare questo è usare le parentesi graffe per creare un ambito per il tuo caso.

Il mio trucco preferito dell'interruttore malefico è usare un if (0) per saltare un'etichetta di caso indesiderata.

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

Ma molto malvagio.

Prova questo:

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

È possibile dichiarare le variabili all'interno di un'istruzione switch se si avvia un nuovo blocco:

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

Il motivo è legato all'allocazione (e al recupero) dello spazio nello stack per l'archiviazione delle variabili locali.

Prendere in considerazione:

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

In assenza di dichiarazioni di interruzione, a volte newVal viene dichiarato due volte e non si sa se lo fa fino al runtime. La mia ipotesi è che il limite sia dovuto a questo tipo di confusione. Quale sarebbe lo scopo di newVal? La convenzione detterebbe che sarebbe l'intero blocco dell'interruttore (tra le parentesi graffe).

Non sono un programmatore C ++, ma in C:

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

Funziona bene. Dichiarare una variabile all'interno di un blocco interruttore va bene. Dichiarare dopo una custodia non lo è.

L'intera sezione dello switch è un singolo contesto di dichiarazione. Non è possibile dichiarare una variabile in un'istruzione case del genere. Prova questo invece:

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

Se il tuo codice dice "int newVal = 42", ti aspetteresti ragionevolmente che newVal non sia mai non inizializzato. Ma se vai su questa affermazione (che è quello che stai facendo), è esattamente quello che succede: newVal è nell'ambito ma non è stato assegnato.

Se questo è ciò che intendevi realmente accadere, allora la lingua richiede di renderlo esplicito dicendo "int newVal; newVal = 42;". Altrimenti puoi limitare l'ambito di newVal al singolo caso, che è più probabile quello che volevi.

Potrebbe chiarire le cose se si considera lo stesso esempio ma con "const int newVal = 42;"

Volevo solo enfatizzare il punto di slim . Un costrutto switch crea un ambito cittadino di prima classe. Quindi è possibile dichiarare (e inizializzare) una variabile in un'istruzione switch prima della prima etichetta del caso, senza una coppia di parentesi aggiuntiva:

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

Finora le risposte sono state per C ++.

Per C ++, non è possibile saltare un'inizializzazione. È possibile in C. Tuttavia, in C, una dichiarazione non è una dichiarazione e le etichette dei casi devono essere seguite da dichiarazioni.

Quindi, C valido (ma brutto), C ++ non valido

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

Al contrario, in C ++, una dichiarazione è un'istruzione, quindi quanto segue è C ++ valido, C non valido

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

Interessante che questo vada bene:

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

case 1:  
    break;
}

... ma questo non è:

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

case 1:  
    break;
}

Capisco che una correzione sia abbastanza semplice, ma non capisco ancora perché il primo esempio non dia fastidio al compilatore. Come accennato in precedenza (2 anni prima hehe), la dichiarazione non è ciò che causa l'errore, nonostante la logica. L'inizializzazione è il problema. Se la variabile viene inizializzata e dichiarata sulle diverse righe, viene compilata.

Ho scritto questa risposta originariamente per questa domanda . Tuttavia quando ho finito ho scoperto che la risposta è stata chiusa. Quindi l'ho pubblicato qui, forse qualcuno a cui piacciono i riferimenti allo standard lo troverà utile.

Codice originale in questione:

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

In realtà ci sono 2 domande:

1. Perché posso dichiarare una variabile dopo l' caseetichetta?

È perché nell'etichetta C ++ deve essere nella forma:

N3337 6.1 / 1

etichettato-dichiarazione:

...

• attributo-specificatore-seqopt case constant-expression :statement

...

E nella C++ dichiarazione dichiarazione è anche considerato come una dichiarazione (al contrario di C):

N3337 6/1:

dichiarazione :

...

Dichiarazione-statement

...

2. Perché posso saltare la dichiarazione delle variabili e quindi usarla?

Perché: N3337 6.7 / 3

È possibile trasferire in un blocco, ma non in modo da bypassare le dichiarazioni con l'inizializzazione . Un programma che salta (Il trasferimento dalla condizione di un'istruzione switch a un'etichetta case è considerato un salto in questo senso.)

da un punto in cui una variabile con durata di memorizzazione automatica non rientra nell'ambito di applicazione fino a un punto in cui si trova all'interno dell'ambito è scarsamente formata a meno che la variabile non 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 è dichiarato senza un inizializzatore (8.5).

Poiché kè di tipo scalare e non è inizializzato nel punto della dichiarazione, è possibile saltare la sua dichiarazione. Questo è semanticamente equivalente:

goto label;

int x;

label:
cout << x << endl;

Tuttavia ciò non sarebbe possibile se xfosse stato inizializzato nel punto di dichiarazione:

 goto label;

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

    label:
    cout << x << endl;

Le nuove variabili possono essere decalate solo nell'ambito del blocco. Devi scrivere qualcosa del genere:

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

Naturalmente, newVal ha solo uno scopo all'interno delle parentesi graffe ...

Saluti, Ralph

Un switchblocco non è uguale a una successione di if/else ifblocchi.Sono sorpreso che nessun'altra risposta lo spieghi chiaramente.

Considera questa switchaffermazione:

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

Potrebbe essere sorprendente, ma il compilatore non lo vedrà come un semplice if/else if. Produrrà il seguente codice:

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

Le caseistruzioni vengono convertite in etichette e quindi chiamate con goto. Le parentesi creano un nuovo ambito ed è facile capire ora perché non è possibile dichiarare due variabili con lo stesso nome all'interno di aswitch blocco.

Può sembrare strano, ma è necessario supportare il fallthrough (ovvero, non utilizzare breakper consentire l'esecuzione dell'esecuzione successiva case).

Credo che il problema a portata di mano sia che la dichiarazione è stata saltata, e tu hai provato a usare il var altrove, non sarebbe stato dichiarato.

newVal esiste nell'intero ambito dello switch ma viene inizializzato solo se viene colpito l'arto VAL. Se si crea un blocco attorno al codice in VAL, dovrebbe essere OK.

Lo standard C ++ ha: È possibile trasferire in un blocco, ma non in un modo che ignori le dichiarazioni con l'inizializzazione. Un programma che salta da un punto in cui una variabile locale con durata di memorizzazione automatica non rientra nel campo di applicazione a un punto in cui si trova all'interno del campo di applicazione è mal formato a meno che la variabile abbia il tipo POD (3.9) e sia dichiarata senza un inizializzatore (8.5).

Il codice per illustrare questa regola:

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

Il codice per mostrare l'effetto di inizializzazione:

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

Sembra che gli oggetti anonimi possano essere dichiarati o creati in un'istruzione case switch per il motivo per cui non possono essere referenziati e come tali non possono passare al caso successivo. Considera questo esempio compilato su GCC 4.5.3 e Visual Studio 2008 (potrebbe essere un problema di conformità anche per cui gli esperti devono valutare)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

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

    default:
        break;
    }
    return EXIT_SUCCESS;
}