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

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

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

    case ANOTHER_VAL:
      ...
    break;
}

Примечание скобки.

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

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

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

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

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

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

Вы не можете этого сделать, потому что метки 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; 
    }
    ...
 }

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

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

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

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

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

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

Учитывать:

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

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

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

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

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

Новые переменные можно объявлять только в области видимости блока. Вам нужно написать примерно так:

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

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

Привет, Ральф

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

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

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

Если объект не является 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 перепрыгивать через инициализацию не является ошибкой.

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

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

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

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

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

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

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

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

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 объявление не является оператором, и за метками case должны следовать операторы.

Итак, допустимый (но уродливый) 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 года назад хе-хе), декларация не является причиной ошибки, даже несмотря на логику. Инициализация - это проблема. Если переменная инициализирована и объявлена ​​в разных строках, она компилируется.

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

Case statements are only 'labels'

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

§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.

Стандарт 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 case по той причине, что на них нельзя ссылаться и как таковые не могут перейти в следующий case. Рассмотрим этот пример, компилируемый на 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;
}

Этот вопрос является изначально был помечен как [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.

Блок 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).

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

Исходный код, о котором идет речь:

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

labeled-statement:

...

• attribute-specifier-seqoptcaseconstant-expression : statement

...

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

N3337 6/1:

statement:

...

declaration-statement

...

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

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

It is possible to transfer into a block, but not in a way that bypasses declarations with initialization. A program that jumps (The transfer from the condition of a switch statement to a case label is considered a jump in this respect.)

from a point where a variable with automatic storage duration is not in scope to a point where it is in scope is ill-formedunless the variable has scalar type, class type with a trivial default constructor and a trivial destructor, a cv-qualified version of one of these types, or an array of one of the preceding types and is declared without an initializer (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;