Переход от одного случая к случаю по умолчанию в операторе switch

Question

switch(ch){
          case 'a':
                 //do something, condition does not match so go to default case
                 //don't break in here, and don't allow fall through to other cases.
          case 'b':
                 //..
          case 'c':
                 //..
          case '_':
                 //...
          default:
                 //
                 break;
}

В операторе switch, подобном приведенному выше, я ввожу регистр 'a', я нарушаю его только в том случае, если внутри него возникает условие, иначе я хочу перейти к регистру по умолчанию. Есть ли другой способ сделать это, кроме ярлыков или gotos?

Answer 1

goto Для победы

switch (ch) {
    case 'a':
        if (1) goto LINE96532;
        break;
    case 'b':
        if (1) goto LINE96532;
        break;
LINE96532:
    default:
        //
        break;
}

Answer 2

Просто измените порядок дел, чтобы этот случай был последним:

switch(ch){
          case 'b':
                 //..
          case 'c':
                 //..
          case '_':
                 //...
          case 'a':
                 //do something, condition does not match so go to default case
                 if (condition)
                     break;
                 //don't break in here, and don't allow fall through to other cases.
          default:
                 //
                 break;
}

Answer 3

Если условие не зависит от случаев, зачем помещать его внутрь?

if (!condition){
  // do default
}else{
  switch(ch){
    case 'a':
      // do a
      break;
    ...
  }
}

Answer 4

Рефакторинг вашего кода:

int test_char(char ch)
{
  switch(ch) {
    case 'a': if (condition) return 0; break;
    case 'b': // ...
    default: return -1;
  }

  return 1;
}

... 
// defaults processing switch
switch(test_char(ch)) {
  case 0: break; // condition met
  case 1: // default processing
  default: // case not handled by test_char
}

Это также добавляет преимущество гибкости при тестировании нескольких классов обработки по умолчанию. Скажем, у вас есть группа символов [c, d, e, f], которые разделяют некоторую общую логику. Просто верните 2 из test_char() для этих случаев (возможно, после тестирования некоторых условий) и добавьте обработчик case 2: в оператор переключения обработки по умолчанию.

Answer 5

Я не уверен, что это лучший ответ, но здесь он идет:

Если вы абсолютно не хотите использовать метки и хотите сохранить дела в их текущем порядке, то вы можете продолжить после случая "а", а затем проверить, чтобы увидеть, если (ch!= 'A') в начале каждого В последующем случае оператор выполняется только в том случае, если условие истинно:

switch(ch){
    case 'a':
        // do something
    case 'b':
    if(ch != 'a') {
        //do something
    }
    //repeat for each subsequent case
    default:
        //do something
    break;
}

Это, вероятно, не самый эффективный способ решения вашей проблемы, но он должен выполнять то, что вы хотите.

Answer 6

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

typedef enum boolean
{
    FALSE = 0, TRUE = 1
} bool;

void pstuff(char input)
{
    bool _skip = FALSE; 
    switch(input)
    {
        case 'a':
            printf("Case a.");
            _skip = TRUE; 
        case 'b': 
            if(!_skip)
            {
                printf("Case b.");
                _skip = TRUE;
            }
        case 'c':       
            if(!_skip)
            {
                printf("Case c.");
                _skip = TRUE; 
            }
        //...
        default: 
            printf("Done!\n"); //Always gets printed.

    }   
}

Answer 7

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

int default_true = 0;
switch (case_value)
{
    case 'a': /* if the condition is true, set the default_true flag */

    case 'b': /* if the condition is true, set the default_true flag */

    //...

    default: default_flag = 1; // set the default_true flag to true
}

if (default_flag)
{
    //place your "default" code here rather than inside the switch statement
    //this prevents code reduplication
}

Answer 8

Вот что я сделал:

char ucResult = 1;
switch(ch){
      case 'a':
          if(ucResult){
             // do something
             if(error) ucResult = 0;
          }
      case 'b':
          if(ucResult){
             // do something
             if(error) ucResult = 0;
          }
      case 'c':
          if(ucResult){
             // do something
             if(error) ucResult = 0;
          }
      case '_':
          if(ucResult){
             // do something
             if(error) ucResult = 0;
          }
      default:
             //
             break;
}

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

Answer 9

Что ж, сообщение действительно старое, но чтобы ответить всем: вы можете просто написать 'goto default;' и вы сразу перейдете к случаю по умолчанию без каких-либо проблем.

Пример:

        switch (value)
        {
            case value1:
               // do something;
                break;
            case value2:
               // do something
                break;
           .
           .
           .
           .
            case value20:
               // do something
                **goto default;**
           .
           .
            case valueN:
                // do something
                break;

            default:
                // do something
                break;
        }

Answer 10

прыгать по умолчанию

• использовать пустой регистр букв чуть выше значения по умолчанию (с очевидным именем)
• использование goto case "case-labelname" прыгать, а затем упасть до дефолта..

пример

    switch (VAR)
{
    case "a":
        // dO STUFF !
    if(COND)
            goto case "DFLT";
        // dO STUFF !
        break;
    case "B":
        // dO STUFF !
        break;
    case "C":
        // dO STUFF !
    IF(COND)
            goto case "DFLT";
        break;
    case "DFLT":
    default:

       // dO DEFAULT
        break;
}