Dlaczego zmiennych nie można zadeklarować w instrukcji switch?

Zawsze się nad tym zastanawiałem - dlaczego nie możesz zadeklarować zmiennych po etykiecie sprawy w instrukcji switch? W C ++ możesz deklarować zmienne niemal wszędzie (a deklarowanie ich przy pierwszym użyciu jest oczywiście dobrą rzeczą), ale następujące działania nadal nie będą działać:

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

Powyższe daje mi następujący błąd (MSC):

inicjalizacja „newVal” jest pomijana przez etykietę „case”

Wydaje się, że jest to ograniczenie także w innych językach. Dlaczego to taki problem?

Caseinstrukcje są tylko etykietami . Oznacza to, że kompilator zinterpretuje to jako skok bezpośrednio do etykiety. W C ++ problemem jest tutaj zakres. Twoje nawiasy klamrowe definiują zakres jako wszystko w switchinstrukcji. Oznacza to, że masz zakres, w którym skok zostanie wykonany dalej w kodzie pomijając inicjalizację.

Prawidłowym sposobem radzenia sobie z tym jest zdefiniowanie zakresu specyficznego dla tej caseinstrukcji i zdefiniowanie w niej zmiennej:

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

To pytanie jest pierwotnie oznaczone jako [c] i [C ++] w tym samym czasie. Oryginalny kod jest rzeczywiście niepoprawny zarówno w C, jak i C ++, ale z zupełnie innych niezwiązanych powodów.

• W C ++ ten kod jest nieprawidłowy, ponieważ case ANOTHER_VAL:etykieta przeskakuje w zakres zmiennej, newValpomijając jej inicjalizację. Skoki, które omijają inicjalizację automatycznych obiektów, są nielegalne w C ++. Ta strona problemu jest poprawnie rozwiązana przez większość odpowiedzi.

• Jednak w języku C pominięcie inicjalizacji zmiennej nie jest błędem. Przeskakiwanie do zakresu zmiennej podczas jej inicjalizacji jest legalne w C. Oznacza to po prostu, że zmienna pozostaje niezainicjowana. Oryginalny kod nie kompiluje się w C z zupełnie innego powodu. Etykieta case VAL:w oryginalnym kodzie jest dołączona do deklaracji zmiennej newVal. W języku C deklaracje nie są instrukcjami. Nie można ich oznakować. I to powoduje błąd, gdy ten kod jest interpretowany jako kod C.

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

Dodanie dodatkowego {}bloku rozwiązuje zarówno problemy z C ++, jak i C, nawet jeśli problemy te są bardzo różne. Po stronie C ++ ogranicza zakres newVal, upewniając się, że case ANOTHER_VAL:nie przeskakuje już do tego zakresu, co eliminuje problem z C ++. Po stronie C, która dodatkowo {}wprowadza instrukcję złożoną, dzięki czemu case VAL:etykieta ma zastosowanie do instrukcji, co eliminuje problem C.

• W przypadku C problem można łatwo rozwiązać bez {}. Wystarczy dodać pustą instrukcję po case VAL:etykiecie, a kod stanie się prawidłowy

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

  Zauważ, że pomimo tego, że jest teraz poprawny z punktu widzenia C, pozostaje nieważny z punktu widzenia C ++.

• Symetrycznie, w przypadku C ++ problem można łatwo rozwiązać bez {}. Wystarczy usunąć inicjalizator z deklaracji zmiennej, a kod stanie się prawidłowy

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

  Zauważ, że pomimo tego, że jest teraz poprawny z punktu widzenia C ++, pozostaje niepoprawny z punktu widzenia C.

Ok. Wyjaśnienie tego ściśle nie ma nic wspólnego z deklaracją. Odnosi się tylko do „przeskakiwania inicjalizacji” (ISO C ++ '03 6.7 / 3)

Wiele postów tutaj wspomniało, że przeskakiwanie deklaracji może spowodować, że zmienna „nie zostanie zadeklarowana”. To nie jest prawda. Obiekt POD można zadeklarować bez inicjatora, ale będzie on miał nieokreśloną wartość. Na przykład:

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

Jeśli obiekt nie jest POD lub agreguje, kompilator domyślnie dodaje inicjator, więc nie można przeskoczyć takiej deklaracji:

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

To ograniczenie nie ogranicza się do instrukcji switch. Błędem jest także użycie „goto” do przeskoczenia inicjalizacji:

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

Ciekawostką jest to, że jest to różnica między C ++ i C. W C przeskakiwanie inicjalizacji nie jest błędem.

Jak wspomnieli inni, rozwiązaniem jest dodanie zagnieżdżonego bloku, aby czas życia zmiennej był ograniczony do indywidualnej etykiety przypadku.

Cała instrukcja switch ma ten sam zakres. Aby obejść ten problem, wykonaj następujące czynności:

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

    case ANOTHER_VAL:
      ...
    break;
}

Zwróć uwagę na nawiasy.

Po przeczytaniu wszystkich odpowiedzi i kilku dalszych badań otrzymuję kilka rzeczy.

Case statements are only 'labels'

W C, zgodnie ze specyfikacją,

§6.8.1 Stwierdzenia oznaczone:

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

W C nie ma żadnej klauzuli, która dopuszcza „deklarację z etykietą”. To po prostu nie jest częścią języka.

Więc

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

To się nie skompiluje , patrz http://codepad.org/YiyLQTYw . GCC podaje błąd:

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

Parzysty

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

to również nie jest kompilowane , patrz http://codepad.org/BXnRD3bu . Tutaj również pojawia się ten sam błąd.

W C ++, zgodnie ze specyfikacją,

etykieta-deklaracja jest dozwolona, ​​ale etykieta -inicjalizacja nie jest dozwolona.

Zobacz http://codepad.org/ZmQ0IyDG .

Rozwiązaniem takiego stanu są dwa

1. Użyj nowego zakresu za pomocą {}

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

2. Lub użyj fałszywego oświadczenia z etykietą

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

3. Zadeklaruj zmienną przed switch () i zainicjuj ją z różnymi wartościami w instrukcji case, jeśli spełnia twoje wymagania

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

Więcej rzeczy z instrukcją switch

Nigdy nie pisz w przełączniku żadnych instrukcji, które nie są częścią żadnej etykiety, ponieważ nigdy nie zostaną wykonane:

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

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

    default:
        break;
}

Zobacz http://codepad.org/PA1quYX3 .

Nie możesz tego zrobić, ponieważ caseetykiety są w rzeczywistości tylko punktami wejścia do bloku zawierającego.

Najwyraźniej ilustruje to urządzenie Duffa . Oto kod z Wikipedii:

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

Zauważ, że caseetykiety całkowicie ignorują granice bloków. Tak, to jest złe. Ale dlatego twój przykład kodu nie działa. Przeskakiwanie do caseetykiety jest takie samo jak używanie goto, więc nie można przeskakiwać nad zmienną lokalną za pomocą konstruktora.

Jak wskazało kilka innych plakatów, musisz umieścić własny blok:

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

Większość odpowiedzi do tej pory są źle pod jednym względem: Państwo może zadeklarować zmienne po instrukcji case, ale nie można ich zainicjować:

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

Jak wspomniano wcześniej, dobrym sposobem na obejście tego jest użycie nawiasów klamrowych do utworzenia zakresu dla twojej skrzynki.

Moją ulubioną sztuczką polegającą na zamianie zła jest użycie if (0), aby pominąć niechcianą etykietę skrzynki.

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

Ale bardzo złe.

Spróbuj tego:

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

Możesz zadeklarować zmienne w instrukcji switch, jeśli uruchomisz nowy blok:

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

Powodem jest przydzielanie (i odzyskiwanie) miejsca na stosie do przechowywania zmiennych lokalnych.

Rozważać:

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

W przypadku braku instrukcji break czasami newVal zostaje zadeklarowany dwukrotnie i nie wiesz, czy to robi, dopóki nie zostanie uruchomione. Domyślam się, że ograniczenie wynika z tego rodzaju zamieszania. Jaki byłby zakres newVal? Konwencja dyktuje, że byłby to cały blok przełączników (między nawiasami klamrowymi).

Nie jestem programistą C ++, ale w C:

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

Działa w porządku. Zadeklarowanie zmiennej w bloku przełącznika jest w porządku. Deklaracja po tym, jak strażnik nie jest.

Cała sekcja przełącznika jest kontekstem pojedynczej deklaracji. Nie można zadeklarować zmiennej w takiej instrukcji case. Spróbuj zamiast tego:

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

Jeśli Twój kod mówi „int newVal = 42”, można oczekiwać, że newVal nigdy nie zostanie niezainicjowany. Ale jeśli masz problem z tym stwierdzeniem (co robisz), właśnie tak się dzieje - newVal jest objęty zakresem, ale nie został przypisany.

Jeśli tak naprawdę chciałeś się wydarzyć, to język musi wyraźnie to powiedzieć, mówiąc „int newVal; newVal = 42;”. W przeciwnym razie możesz ograniczyć zakres newVal do pojedynczej skrzynki, co jest bardziej prawdopodobne, co chciałeś.

Może to wyjaśnić, jeśli weźmiesz pod uwagę ten sam przykład, ale z „const int newVal = 42;”

Chciałem tylko podkreślić, szczupły „s punkt . Konstrukcja przełącznika tworzy cały zakres pierwszorzędnego obywatela. Można więc zadeklarować (i zainicjować) zmienną w instrukcji switch przed etykietą pierwszego przypadku, bez dodatkowej pary nawiasów:

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

Do tej pory odpowiedzi były na C ++.

W przypadku C ++ nie można przeskoczyć inicjalizacji. Możesz w C. Jednak w C deklaracja nie jest instrukcją, a po etykietach przypadków muszą znajdować się instrukcje.

Tak więc poprawne (ale brzydkie) C, nieprawidłowe C ++

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

I odwrotnie, w C ++ deklaracja jest instrukcją, więc następujące jest poprawne C ++, nieprawidłowe C

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

Ciekawe, że to dobrze:

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

case 1:  
    break;
}

... ale to nie jest:

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

case 1:  
    break;
}

Rozumiem, że poprawka jest dość prosta, ale nie rozumiem jeszcze, dlaczego pierwszy przykład nie przeszkadza kompilatorowi. Jak wspomniano wcześniej (2 lata wcześniej hehe), deklaracja nie jest przyczyną błędu, nawet pomimo logiki. Problemem jest inicjalizacja. Jeśli zmienna zostanie zainicjowana i zadeklarowana w różnych wierszach, zostanie skompilowana.

Napisałem tę odpowiedź orginally na to pytanie . Jednak kiedy skończyłem, okazało się, że odpowiedź została zamknięta. Więc zamieściłem go tutaj, może ktoś, kto lubi odniesienia do standardu, uzna to za pomocne.

Kod oryginalny, o którym mowa:

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

Tak naprawdę są 2 pytania:

1. Dlaczego mogę zadeklarować zmienną po caseetykiecie?

To dlatego, że w C ++ etykieta musi być w formie:

N3337 6.1 / 1

etykieta-oświadczenie:

...

• atrybut-specyfikator-seqopt case constant-expression :statement

...

A w C++ deklaracji oświadczenie jest również uważane za oświadczenie (w przeciwieństwie do C):

N3337 6/1:

oświadczenie :

...

oświadczenie-oświadczenie

...

2. Dlaczego mogę przeskoczyć deklarację zmiennej, a następnie jej użyć?

Ponieważ: N3337 6,7 / 3

Możliwe jest przeniesienie do bloku, ale nie w sposób, który omija deklaracje podczas inicjalizacji . Program, który przeskakuje ( przeniesienie z warunku instrukcji switch na etykietę sprawy jest pod tym względem uważane za skok ).

od punktu, w którym zmienna z automatycznym czasem przechowywania nie jest objęta zakresem, do punktu, w którym mieści się w zakresie, jest źle sformułowana, chyba że zmienna ma typ skalarny, typ klasy z trywialnym domyślnym konstruktorem i trywialny destruktor, wersję zakwalifikowaną do CV jednego z tych typów lub tablicy jednego z poprzednich typów i jest zadeklarowany bez inicjatora (8.5).

Ponieważ kjest typu skalarnego i nie jest inicjowany w punkcie deklaracji, możliwe jest przeskakiwanie jego deklaracji. Jest to semantycznie równoważne:

goto label;

int x;

label:
cout << x << endl;

Nie byłoby to jednak możliwe, gdyby xzostało zainicjowane w punkcie deklaracji:

 goto label;

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

    label:
    cout << x << endl;

Nowe zmienne mogą być odkodowane tylko w zakresie bloków. Musisz napisać coś takiego:

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

Oczywiście newVal ma zakres tylko w nawiasach klamrowych ...

Pozdrawiam, Ralph

switchBlok nie jest taka sama jak kolejnych if/else ifbloków. Dziwi mnie, że żadna inna odpowiedź nie wyjaśnia tego wyraźnie.

Rozważ to switchoświadczenie:

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

Może to być zaskakujące, ale kompilator nie uzna tego za proste if/else if. Wygeneruje następujący kod:

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

Te casestwierdzenia są konwertowane na etykiety, a następnie wywołana goto. Nawiasy tworzą nowy zakres i łatwo jest teraz zrozumieć, dlaczego nie można zadeklarować dwóch zmiennych o tej samej nazwie w switchbloku.

Może to wyglądać dziwnie, ale konieczne jest wsparcie przewrotu (to znaczy nie używanie, breakaby pozwolić na wykonanie następnego case).

Wydaje mi się, że problemem jest to, że oświadczenie zostało pominięte, a ty próbowałeś użyć var ​​gdzie indziej, nie zostałby zadeklarowany.

newVal istnieje w całym zakresie przełącznika, ale jest inicjowany tylko po uderzeniu w kończynę VAL. Jeśli utworzysz blok wokół kodu w VAL, powinno być OK.

Standard C ++ ma: Możliwe jest przeniesienie do bloku, ale nie w sposób, który omija deklaracje podczas inicjalizacji. Program, który skacze z miejsca, w którym zmienna lokalna z automatycznym czasem przechowywania nie wchodzi w zakres, do punktu, w którym jest objęty zakresem, jest źle sformułowany, chyba że zmienna ma typ POD (3.9) i jest zadeklarowana bez inicjatora (8.5).

Kod ilustrujący tę regułę:

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

Kod pokazujący efekt inicjalizacji:

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

Wygląda na to, że anonimowe obiekty mogą być deklarowane lub tworzone w instrukcji case switch, ponieważ nie można do nich odwoływać się i jako takie nie mogą przejść do następnej sprawy. Rozważ ten przykład kompiluje się w GCC 4.5.3 i Visual Studio 2008 (może to być problem ze zgodnością, więc eksperci powinni się zastanowić)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

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

    default:
        break;
    }
    return EXIT_SUCCESS;
}