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

Ответ 1

goto Для Win

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

Ответ 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;
}

Ответ 3

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

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

Ответ 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: обработчик к оператору switch по умолчанию.

Ответ 5

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

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

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

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

Ответ 6

Если вы сначала должны иметь инструкции 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
}

Ответ 7

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

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

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

Ответ 8

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

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.

    }   
}

Ответ 9

Ну, пост действительно старый, но ответить всем: Вы можете просто написать "Перейти к умолчанию;" и вы без проблем перейдете к стандартному случаю.

Пример:

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

Ответ 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;
}