Переключение оператора Fallthrough ... должно ли это быть разрешено? [закрытый]

это обоюдоострый меч. Иногда очень полезно, часто опасно.

когда это хорошо? Если вы хотите, чтобы 10 случаев обрабатывались одинаково...

switch (c) {
  case 1:
  case 2:
            ... do some of the work ...
            /* FALLTHROUGH */
  case 17:
            ... do something ...
            break;
  case 5:
  case 43:
            ... do something else ...
            break;
}

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

Fallthrough действительно удобная вещь, в зависимости от того, что вы делаете. Рассмотрим этот аккуратный и понятный способ организации вариантов:

switch ($someoption) {
  case 'a':
  case 'b':
  case 'c':
    // do something
    break;
  case 'd':
  case 'e':
    // do something else
    break;
}

представьте, что вы делаете это с if / else. Это будет полный бардак.

вы слышали о устройство Даффа? Это отличный пример использования Switch fallthrough.

Это функция, которую можно использовать, и ее можно злоупотреблять, как и почти все языковые функции.

это может быть очень полезно несколько раз, но в целом, no-fallthrough-это желаемое поведение. Прохождение должно быть разрешено, но не подразумеваться.

пример, чтобы обновить старые версии некоторых данных:

switch (version) {
    case 1:
        // update some stuff
    case 2:
        // update more stuff
    case 3:
        // update even more stuff
    case 4:
        // and so on
}

Я хотел бы другой синтаксис для резервных копий в коммутаторах, что-то вроде, errr..

switch(myParam)
{
  case 0 or 1 or 2:
    // do something;
    break;
  case 3 or 4:
    // do something else;
    break;
}

Примечание: это уже было бы возможно с перечислениями, если вы объявите все случаи на вашем перечислении, используя флаги правильно? Звучит не так уж плохо, случаи могут (должны?) очень хорошо быть частью вашего перечисления уже.

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

int value = 10;
value.Switch()
  .Case(() => { /* do something; */ }, new {0, 1, 2})
  .Case(() => { /* do something else */ } new {3, 4})
  .Default(() => { /* do the default case; */ });

хотя это, вероятно, еще менее читаемо :P

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

однако, я думаю, что недостатки более чем оправдывают не использовать его, и, наконец, не позволять ему больше (C#). Среди проблем:

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

использовать переключатель/корпус проваливаемся:

switch (x)
{
case 1:
case 2:
case 3:
 do something
 break;
}

использование нового выключателя/чехол проваливаемся:

switch (x)
{
case 1:
    some code
case 2:
    some more code
case 3:
    even more code
    break;
}

Это можно переписать с помощью if / else конструкций без каких-либо потерь на мой взгляд.

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

мощный и опасный. Самая большая проблема с провалом заключается в том, что он не является явным. Например, если вы сталкиваетесь с часто редактируемым кодом, который имеет переключатель с провалами, как вы знаете, что это намеренно, а не ошибка?

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

switch($var) {
    case 'first':
        // fall-through
    case 'second':
        i++;
        break;
 }

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

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

использование провала, как в вашем первом примере, явно нормально, я бы не считал это настоящим провалом.

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

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

мысль падения должна использоваться только тогда, когда она используется в качестве таблицы перехода в блок кода. Если есть какая-либо часть кода с безусловным разрывом перед большим количеством случаев, все группы случаев должны заканчиваться таким образом. Все остальное - "зло".

в некоторых случаях использование fall-throughs является актом лени со стороны программиста - например, они могут использовать серию операторов||, но вместо этого используют серию "всеохватывающих" случаев переключения.

Это, как говорится, я нашел их, чтобы быть особенно полезным, когда я знаю, что В конце концов мне все равно понадобятся параметры (например, в ответе меню), но еще не реализованы все варианты. Аналогично, если вы делаете провал для обоих "a" и "A", я считаю, что существенно чище использовать провал переключателя, чем сложное утверждение if.

вероятно, это вопрос стиля и того, как думают программисты, но я обычно не люблю удалять компоненты языка во имя "безопасности" - вот почему я склоняюсь к C и его вариантам/потомкам больше, чем, скажем, Java. Мне нравится быть в состоянии обезьянничать с указателями и тому подобное, даже когда у меня нет "причины".