Почему мы должны использовать break в switch?

Кто решил (и на основе каких понятий), что switchконструкция (на многих языках) должна использоваться breakв каждом утверждении?

Почему мы должны написать что-то вроде этого:

switch(a)
{
    case 1:
        result = 'one';
        break;
    case 2:
        result = 'two';
        break;
    default:
        result = 'not determined';
        break;
}

(заметил это в PHP и JS; возможно, есть много других языков, использующих это)

Если switchесть альтернатива if, почему мы не можем использовать ту же конструкцию, что и для if? То есть:

switch(a)
{
    case 1:
    {
        result = 'one';
    }
    case 2:
    {
        result = 'two';
    }
    default:
    {
        result = 'not determined';
    }
}

Говорят, что breakпредотвращает выполнение блока, следующего за текущим. Но действительно ли кто-то сталкивался с ситуацией, когда возникла необходимость выполнения текущего и последующих блоков? Я не Для меня breakвсегда есть. В каждом блоке. В каждом коде.

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

Что касается того, почему C был разработан таким образом, он, вероятно, вытекает из концепции C как «переносной сборки». switchУтверждение в основном это абстракция таблицы отраслевой и таблица филиала также имеет неявное падение-через и требует дополнительной инструкции перехода , чтобы избежать этого.

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

Потому что switchэто не альтернатива if ... elseзаявлениям на этих языках.

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

Пример:

public Season SeasonFromMonth(Month month)
{
    Season season;
    switch (month)
    {
        case Month.December:
        case Month.January:
        case Month.February:
            season = Season.Winter;
            break;

        case Month.March:
        case Month.April:
        case Month.May:
            season = Season.Spring;
            break;

        case Month.June:
        case Month.July:
        case Month.August:
            season = Season.Summer;
            break;

        default:
            season = Season.Autumn;
            break;
    }

    return season;
}

Это было задано в связи с переполнением стека в контексте C: почему для оператора switch был нужен разрыв?

Подводя итог принятому ответу, это была, вероятно, ошибка. Большинство других языков, вероятно, просто следовали за C. Однако, некоторые языки, такие как C #, похоже, исправили это, допустив провал - но только когда программист явно говорит об этом (источник: ссылка выше, я сам не говорю на C #) ,

Я отвечу на примере. Если вы хотите указать количество дней в каждом месяце года, очевидно, что в некоторых месяцах 31, а в 30 - 1 28/29. Это будет выглядеть так,

switch(month) {
    case 4:
    case 6:
    case 9:
    case 11;
        days = 30;
        break;
    case 2:
        //Find out if is leap year( divisible by 4 and all that other stuff)
        days = 28 or 29;
        break;
    default:
        days = 31;
}

Это пример, когда несколько случаев имеют одинаковый эффект и все сгруппированы вместе. Очевидно, была причина выбора ключевого слова break, а не конструкции if ... else if .

Главное, на что следует обратить внимание, это то, что оператор switch во многих похожих случаях - это не if ... else if ... else if ... else для каждого из случаев, а скорее if (1, 2, 3) ... еще, если (4,5,6) еще ...

Существуют две ситуации, когда может произойти «провал» из одного дела в другое - пустой случай:

switch ( ... )
{
  case 1:
  case 2:
    do_something_for_1_and_2();
    break;
  ...
}

и непустой случай

switch ( ... )
{
  case 1:
    do_something_for_1();
    /* Deliberately fall through */
  case 2:
    do_something_for_1_and_2();
    break;
...
}

Несмотря на ссылку на устройство Даффа , законные экземпляры для второго случая очень редки и, как правило, запрещены стандартами кодирования и помечены во время статического анализа. И там, где это найдено, это чаще всего происходит из-за упущения а break.

Первое совершенно разумно и распространено.

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

Жаль, что панель ISO C выглядит более озабоченной добавлением новых (нежелательных) и плохо определенных функций в язык, а не исправлением неопределенных, неуказанных или определяемых реализацией функций, не говоря уже о нелогичности.

Не принуждение breakпозволяет сделать ряд вещей, которые в противном случае было бы трудно сделать. Другие отметили группирование случаев, для которых есть ряд нетривиальных случаев.

Одним из случаев, когда крайне важно, чтобы его breakне использовали , было устройство Даффа . Это используется для « развертывания » циклов, где это может ускорить операции, ограничивая количество требуемых сравнений. Я полагаю, что первоначальное использование допускало функциональность, которая раньше была слишком медленной с полностью свернутым циклом. В некоторых случаях он меняет размер кода на скорость.

Рекомендуется заменить breakсоответствующий комментарий, если в кейсе есть какой-либо код. В противном случае кто-то исправит недостающее breakи внесет ошибку.

В C, где, как представляется, источник, блок кода switchоператора не является специальной конструкцией. Это обычный блок кода, такой же, как блок под ifоператором.

switch ()
{
}

if ()
{
}

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

Как обычный блок кода, он не должен быть составным оператором. Метки тоже не обязательны. Это действительные switchутверждения в C:

switch (a)
    case 1: Foo();

switch (a)
    Foo();

switch (a)
{
    Foo();
}

Сам стандарт C дает это в качестве примера (6.8.4.2):

switch (expr) 
{ 
    int i = 4; 
    f(i); 
  case 0: 
    i=17; 
    /*falls through into default code */ 
  default: 
    printf("%d\n", i); 
} 

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

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

Это также объясняет устройство Даффа:

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

Почему провал? Потому что в нормальном потоке кода в нормальном блоке кода ожидается переход к следующему оператору , так же, как вы ожидаете его в ifблоке кода.

if (a == b)
{
    Foo();
    /* "Fall-through" to Bar expected here. */
    Bar();
}

switch (a)
{
    case 1: 
        Foo();
        /* Automatic break would violate expected code execution semantics. */
    case 2:
        Bar();
}

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

Интересный дополнительный вопрос из всего этого состоит в том, что следующие вложенные операторы печатают «Готово». или нет.

int a = 10;

switch (a)
{
    switch (a)
    {
        case 10: printf("Done.\n");
    }
}

Стандарт C заботится об этом (6.8.4.2.4):

Метка регистра или значения по умолчанию доступна только в пределах ближайшего оператора switch.

Несколько человек уже упомянули идею соответствия множественным условиям, что время от времени очень ценно. Однако способность соответствовать нескольким условиям не обязательно требует, чтобы вы выполняли одно и то же с каждым соответствующим условием. Учтите следующее:

switch (someCase)
{
    case 1:
    case 2:
        doSomething1And2();
        break;

    case 3:
        doSomething3();

    case 4:
        doSomething3And4();
        break;

    default:
        throw new Error("Invalid Case");
}

Есть два разных способа сопоставления множества условий. При выполнении условий 1 и 2 они просто переходят к одному и тому же фрагменту кода и делают одно и то же. С условиями 3 и 4, однако, хотя они оба заканчиваются вызовом doSomething3And4(), только 3 вызова doSomething3().

Чтобы ответить на два ваших вопроса.

Зачем C нужны перерывы?

Все сводится к корням Cs как «переносному ассемблеру». Где псевдо-код, как это было распространено:

    targets=(addr1,addr2,addr3);
    opt = 1  ## or 0 or 2
switch:
    br targets[opt]  ## go to addr2 
addr1:
    do 1stuff
    br switchend
addr2:
    do 2stuff
    br switchend
addr3
    do 3stuff
switchend:
    ......

Инструкция switch была разработана для обеспечения аналогичной функциональности на более высоком уровне.

У нас когда-нибудь есть выключатели без перерывов?

Да, это довольно часто, и есть несколько вариантов использования;

Во-первых, вы можете предпринять одно и то же действие в нескольких случаях. Мы делаем это, укладывая чехлы друг на друга:

case 6:
case 9:
    // six or nine code

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

case 9:
    crashed()
    newstate=10;
case 10:
    claim_damage();
    break;

Оператор Break - это оператор прыжка, который позволяет пользователю выйти из ближайшего включающего переключателя (для вашего случая), в то время как, do, for или foreach. это так же просто, как это.

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

Если вам нужен тот редкий случай, когда вы хотите перейти к следующему случаю - просто заявите это с помощью continueзаявления.

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