Почему переменные не могут быть объявлены в операторе switch?

Я всегда задавался вопросом: почему вы не можете объявлять переменные после метки регистра в операторе switch? В C ++ вы можете объявлять переменные практически везде (и объявление их близко к первому использованию, очевидно, хорошо), но следующее по-прежнему не будет работать:

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

Вышесказанное дает мне следующую ошибку (MSC):

инициализация 'newVal' пропускается по метке 'case'

Это кажется ограничением и в других языках. Почему это такая проблема?

Caseзаявления являются только метками . Это означает, что компилятор интерпретирует это как переход непосредственно к метке. В C ++ проблема здесь одна из области видимости. Ваши фигурные скобки определяют объем как все внутриswitch утверждения. Это означает, что вы остаетесь с областью, в которой будет выполняться переход к коду, пропускающему инициализацию.

Правильный способ справиться с этим - определить область действия, специфичную для этого caseоператора, и определить в нем переменную:

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

Этот вопрос будет первоначально был помечен как [C] и [C ++] в то же время. Исходный код действительно недействителен как на C, так и на C ++, но по совершенно другим не связанным причинам.

• В C ++ этот код недопустим, потому что case ANOTHER_VAL:метка попадает в область действия переменной, newValминуя ее инициализацию. Переходы, которые обходят инициализацию автоматических объектов, недопустимы в C ++. Эта сторона вопроса правильно решается большинством ответов.

• Однако в языке C обход инициализации переменной не является ошибкой. Прыжок в область действия переменной при ее инициализации допустим в C. Это просто означает, что переменная остается неинициализированной. Оригинальный код не компилируется в C по совершенно другой причине. Метка case VAL:в исходном коде прилагается к объявлению переменной newVal. В языке C декларации не являются заявлениями. Они не могут быть помечены. И это то, что вызывает ошибку, когда этот код интерпретируется как C-код.

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

Добавление дополнительного {}блока устраняет проблемы как C ++, так и C, даже если эти проблемы очень разные. На стороне C ++ это ограничивает область действия newVal, обеспечивая, чтобы case ANOTHER_VAL:больше не переходил в эту область, что устраняет проблему C ++. На стороне C, что дополнительно {}вводит составной оператор, тем самым делая case VAL:метку для применения к оператору, что устраняет проблему C.

• В случае C проблема может быть легко решена без {}. Просто добавьте пустое утверждение после case VAL:метки, и код станет действительным

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

  Обратите внимание, что, хотя теперь он действителен с точки зрения C, он остается недействительным с точки зрения C ++.

• Симметрично, в случае C ++ проблема может быть легко решена без {}. Просто удалите инициализатор из объявления переменной, и код станет действительным

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

  Обратите внимание, что даже если он теперь действителен с точки зрения C ++, он остается недействительным с точки зрения C.

Хорошо. Просто уточнить это строго не имеет ничего общего с декларацией. Это относится только к «перепрыгиванию через инициализацию» (ISO C ++ '03 6.7 / 3)

Во многих постах здесь упоминается, что перепрыгивание через объявление может привести к тому, что переменная «не будет объявлена». Это неправда. Объект POD может быть объявлен без инициализатора, но он будет иметь неопределенное значение. Например:

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

Если объект не POD или агрегат, компилятор неявно добавляет инициализатор, и поэтому невозможно перепрыгнуть через такое объявление:

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

Это ограничение не ограничивается оператором switch. Также является ошибкой использовать 'goto', чтобы перепрыгнуть через инициализацию:

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

Немного мелочей в том, что это разница между C ++ и C. В C не является ошибкой перепрыгивать через инициализацию.

Как уже упоминалось, решение состоит в том, чтобы добавить вложенный блок, чтобы время жизни переменной ограничивалось индивидуальной меткой регистра.

Весь оператор switch находится в той же области. Чтобы обойти это, сделайте это:

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

    case ANOTHER_VAL:
      ...
    break;
}

Обратите внимание на скобки.

После прочтения всех ответов и дополнительных исследований я получаю несколько вещей.

Case statements are only 'labels'

В С, согласно спецификации,

§6.8.1 Помеченные заявления:

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

В C нет ни одного предложения, которое допускает «помеченное объявление». Это просто не часть языка.

Так

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

Это не скомпилируется , см. Http://codepad.org/YiyLQTYw . GCC выдает ошибку:

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

Даже

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

это также не компилируется , см. http://codepad.org/BXnRD3bu . Здесь я также получаю ту же ошибку.

В C ++, согласно спецификации,

помечено-объявление разрешено, но помечено -инициализация не допускается.

Смотрите http://codepad.org/ZmQ0IyDG .

Решение такого условия два

1. Либо используйте новую область видимости, используя {}

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

2. Или используйте пустышку с меткой

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

3. Объявите переменную перед switch () и инициализируйте ее различными значениями в выражении case, если она удовлетворяет вашему требованию

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

Еще несколько вещей с оператором switch

Никогда не записывайте в коммутатор какие-либо операторы, которые не являются частью какой-либо метки, потому что они никогда не будут выполнены

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

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

    default:
        break;
}

Смотрите http://codepad.org/PA1quYX3 .

Вы не можете сделать это, потому что case метки на самом деле являются просто точками входа в содержащий блок.

Это наиболее ясно иллюстрируется устройством Даффа . Вот некоторый код из Википедии:

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

Обратите внимание, как caseметки полностью игнорируют границы блоков. Да, это зло. Но именно поэтому ваш пример кода не работает. Переход к caseметке аналогичен использованию goto, поэтому вам не разрешено перепрыгивать через локальную переменную с помощью конструктора.

Как указали несколько других постеров, вы должны поместить в свой блок:

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

Большинство ответов пока неверны в одном отношении: вы можете объявлять переменные после оператора case, но не можете их инициализировать:

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

Как упоминалось ранее, хорошим способом решения этой проблемы является использование фигурных скобок для создания области для вашего случая.

Мой любимый трюк со злым переключателем - использовать if (0) для пропуска нежелательной метки регистра.

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

Но очень злой.

Попробуй это:

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

Вы можете объявить переменные в операторе switch, если вы начинаете новый блок:

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

Причина в том, чтобы выделить (и восстановить) пространство в стеке для хранения локальной переменной (переменных).

Рассматривать:

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

В отсутствие операторов прерывания иногда newVal объявляется дважды, и вы не знаете, будет ли он до времени выполнения. Я думаю, что ограничение связано с такой путаницей. Каков будет объем newVal? Конвенция будет предписывать, что это будет весь блок переключателей (между скобками).

Я не программист C ++, но в C:

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

Работает отлично. Объявление переменной внутри блока переключателей - это нормально. Декларировать после дела охранника нет.

Весь раздел коммутатора представляет собой единый контекст объявления. Вы не можете объявить переменную в таком случае. Попробуйте это вместо:

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

Если в вашем коде написано «int newVal = 42», то разумно ожидать, что newVal никогда не инициализируется. Но если вы перейдете к этому утверждению (что вы и делаете), то именно это и произойдет - newVal находится в области видимости, но не был назначен.

Если это именно то, что вы действительно хотели сделать, тогда язык должен сделать это явным, сказав "int newVal; newVal = 42;". В противном случае вы можете ограничить область действия newVal одним случаем, что более вероятно, чем вы хотели.

Это может прояснить ситуацию, если вы рассмотрите тот же пример, но с "const int newVal = 42;"

Я просто хотел бы подчеркнуть тонкий «s точку . Конструкция переключателя создает целую область первоклассного гражданина. Таким образом, можно объявить (и инициализировать) переменную в операторе switch перед меткой первого регистра, без дополнительной пары скобок:

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

До сих пор ответы были для C ++.

Для C ++ вы не можете перепрыгнуть через инициализацию. Вы можете сделать это в C. Однако в C декларация не является оператором, и после меток должны следовать операторы.

Итак, допустимый (но некрасивый) C, неверный 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();
}

И наоборот, в C ++ объявление является оператором, поэтому следующее допустимо C ++, недопустимо C

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

Интересно, что это нормально

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

case 1:  
    break;
}

... но это не так:

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

case 1:  
    break;
}

Я понял, что исправить это достаточно просто, но я пока не понимаю, почему первый пример не беспокоит компилятор. Как было упомянуто ранее (на 2 года раньше хе-хе), декларация не является причиной ошибки, даже несмотря на логику. Инициализация - это проблема. Если переменная инициализирована и объявлена ​​в разных строках, она компилируется.

Я написал этот ответ изначально для этого вопроса . Однако когда я закончил, я обнаружил, что ответ закрыт. Так что я разместил это здесь, может быть, кто-то, кто любит ссылки на стандартные, найдет это полезным.

Оригинальный код в вопросе:

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

На самом деле есть 2 вопроса:

1. Почему я могу объявить переменную после caseметки?

Это потому, что в C ++ метка должна быть в форме:

N3337 6.1 / 1

меченый-заявление:

...

• атрибут-спецификатор-seqopt case constant-expression :statement

...

И в C++ заявлении заявление также рассматривается как утверждение (в отличие от C):

N3337 6/1:

утверждение :

...

заявление-заявление

...

2. Почему я могу перепрыгнуть через объявление переменной и затем использовать его?

Потому что: N3337 6,7 / 3

Можно передать в блок, но не так, чтобы обойти объявления с инициализацией . Программа, которая переходит ( переход от условия оператора switch к метке регистра считается скачком в этом отношении.)

от точки, где переменная с автоматическим продолжением хранения не находится в области видимости, до точки, где она находится в области видимости, плохо сформирована, если переменная не имеет скалярного типа , типа класса с тривиальным конструктором по умолчанию и тривиальным деструктором, версия с квалификацией cv одного из этих типов или массив одного из предыдущих типов и объявляется без инициализатора (8.5).

Поскольку он kимеет скалярный тип и не инициализируется в точке объявления, перепрыгивание через него возможно. Это семантически эквивалентно:

goto label;

int x;

label:
cout << x << endl;

Однако это было бы невозможно, если бы оно xбыло инициализировано в точке объявления:

 goto label;

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

    label:
    cout << x << endl;

Новые переменные могут быть декалифицированы только в области видимости блока. Вам нужно написать что-то вроде этого:

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

Конечно, newVal имеет только область в фигурных скобках ...

Ура, Ральф

switchБлок не является такой же , как последовательность if/else ifблоков.Я удивлен, что никакой другой ответ не объясняет это ясно.

Рассмотрим это switchутверждение:

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

Это может быть удивительно, но компилятор не увидит в этом ничего простого if/else if. Он выдаст следующий код:

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

Операторы caseпреобразуются в метки, а затем вызываются с помощью goto. Скобки создают новую область видимости, и теперь легко понять, почему вы не можете объявить две переменные с одинаковым именем в пределахswitch блоке.

Это может выглядеть странно, но необходимо поддерживать падение (то есть не использовать, breakчтобы выполнение продолжалось до следующего case).

Я считаю, что проблема заключается в том, что это заявление было пропущено, и вы пытались использовать var в другом месте, оно не будет объявлено.

newVal существует во всей области действия коммутатора, но инициализируется только в случае удара по лимбу VAL. Если вы создаете блок вокруг кода в VAL, все должно быть в порядке.

Стандарт C ++ имеет: Возможна передача в блок, но не таким образом, чтобы обойти объявления с инициализацией. Программа, которая переходит от точки, в которой локальная переменная с автоматическим хранением находится вне области действия, до точки, в которой она находится в области действия, имеет неправильную форму, если переменная не имеет тип POD (3.9) и не объявлена ​​без инициализатора (8.5).

Код для иллюстрации этого правила:

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

Код для отображения эффекта инициализатора:

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

Похоже, что анонимные объекты могут быть объявлены или созданы в операторе switch switch по той причине, что на них нельзя ссылаться и как таковые они не могут перейти к следующему случаю. Рассмотрим этот пример, который компилируется в GCC 4.5.3 и Visual Studio 2008 (может быть проблема с соответствием, так что эксперты, пожалуйста, оцените)

#include <cstdlib>

struct Foo{};

int main()
{
    int i = 42;

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

    default:
        break;
    }
    return EXIT_SUCCESS;
}