Почему мы не можем определить переменную дважды в коммутаторе?

Ответ 1

если инструкции break не используются, тогда мы знаем, что будут выполняться следующие случаи. Поэтому, если вам разрешено объявлять в обоих случаях, что вызовет конфликт. Например

switch(x) {

case 1:
   int a = 1;  // i have removed the break;
case 2:
   int a = 2; // now what will happen here :)
   break;
}

Ответ 2

Поскольку область ограничена { и }, и у вас есть переменная a дважды.

Вы можете избежать этой ошибки компиляции:

switch(x) {
    case 1: {
        int a = 1;
        break;
    }
    case 2: {
       int a = 2;
       break;
    }
}

Обратите внимание, что в вашем примере компилятор не удался, потому что если вы удалите первый оператор break, то, что называется fall-through может случиться:

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

В этом случае утверждения, которые будут выполняться (из-за провала), следующие:

• int a = 1;
• int a = 1;
• break;

И как вы можете видеть, переменная a дублируется, поэтому компиляция завершается неудачно в вашем примере.

Ответ 3

Здесь ничего не связано с switch. Вы просто не можете объявить одну и ту же переменную дважды в той же области.

Это незаконно:

int a = 1;
int a = 2;

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

Ответ 4

Оператор switch представляет собой блок кода. Оператор switch evalutates это выражение, затем выполняет все инструкции, которые следуют за совпадением метки case.

В этом случае он оценивает x, и это сравнивается с каждой константой, пока не будет найдено совпадение.

Но на самом деле это похоже на высказывание:

for(int i = 0; i < 4; i++) {
    int i = 1;
}

это также не сработает, потому что i уже определен.

Ответ 5

Объем переменных в каждом аргументе case соответствует всему оператору switch.

Однако, если вы хотите использовать одну и ту же переменную, вы можете определить свой собственный блок внутри каждого оператора case, используя фигурные скобки {и}.

Ответ 6

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

Если вы должны были объявить a вне коммутатора, а затем вызвать его в коммутаторе, он должен работать.

int a;

switch(x) {
case 1:
   a = 1;
   break;
case 2:
   b = 2;
   break;
}

В качестве альтернативы, в каждом случае коммутатора вы можете манипулировать своим новым int и затем делать что-то с ним следующим образом:

switch(x) {
case 1:
   int a = 1;
//do something with your new int here that affects a parameter outside the switch
   break;
case 2:
   int b = 1;
//do something with your new int here that affects a parameter outside the switch
   break;
}

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

Ответ 7

Пойдите с этими фактами: - > Вы не можете объявить одну и ту же локальную переменную дважды в одной области. - > case не создает свою собственную область. - > switch, да создает свою собственную область. - > Доказательство. Если вы не делаете break случай, все случаи будут выполняться, если они не удовлетворяют условию. (в отличие от else if).