Пропадание оператора switch… должно ли это быть разрешено? [закрыто]

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

Является ли это чем-то, что язык программирования должен явно запрещать (как это делает C #, хотя и предоставляет обходной путь), или это особенность любого языка, которая достаточно мощна, чтобы оставить ее в руках программиста?

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

    switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something
            break;
        case 2:
        case 3:
        case 4:
            // Do something
            break;
   }

Однако меня беспокоит что-то вроде этого.

   switch(m_loadAnimSubCt){
        case 0:
        case 1:
            // Do something, but fall through to the other cases
            // after doing it.

        case 2:
        case 3:
        case 4:
            // Do something else.
            break;
   }

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

Это может зависеть от того, что вы считаете неудачным. Я в порядке с такими вещами:

switch (value)
{
  case 0:
    result = ZERO_DIGIT;
    break;

  case 1:
  case 3:
  case 5:
  case 7:
  case 9:
     result = ODD_DIGIT;
     break;

  case 2:
  case 4:
  case 6:
  case 8:
     result = EVEN_DIGIT;
     break;
}

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

И обратите внимание, что я использую определение «зла» из часто задаваемых вопросов C ++.

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

Когда это хорошо? Если вы хотите, чтобы все 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 * /, чтобы указать, что это было вашим намерением.

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

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

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

switch ($someoption) {
  case 'a':
  case 'b':
  case 'c':
    // Do something
    break;

  case 'd':
  case 'e':
    // Do something else
    break;
}

Представьте, что вы делаете это с помощью if / else. Был бы беспорядок.

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

Пример для обновления старых версий некоторых данных:

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, я извлекаю его в отдельную общую функцию, которая может быть вызвана в любой ветке.

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

При этом я обнаружил, что они особенно полезны, когда я знаю, что в конечном итоге мне все равно понадобятся параметры (например, в ответе меню), но я еще не реализовал все варианты. Точно так же, если вы делаете провал как для «a», так и для «A», я считаю, что гораздо проще использовать переключатель «провал», чем составной оператор if.

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

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

Все остальное - «зло».