在 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 语句中，我输入 case 'a'，只有当其中的条件发生时才中断，否则我想跳转到默认情况。除了标签或 goto 之外，还有其他方法吗？

Answer 1

好吧，帖子真的很旧，但要回答大家： 你可以简单地写'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 2

我希望我的解决方案能回答您的问题。只需让案例一直跟进（从匹配案例开始），但使用条件来禁止后续案例运行。

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 3

这就是我所做的：

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 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] 共享一些共同的逻辑。对于这些情况（可能在测试了某些条件之后），只需从 test_char() 返回 2，并将 case 2: 处理程序添加到默认处理 switch 语句中。

Answer 5

如果您必须首先使用 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 6

如果条件不依赖于案例，为什么要放在里面？

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

Answer 7

我不确定这是否是最佳答案，但这里是：

如果您绝对不想使用标签，并且希望将案例保持在当前顺序，那么您可以在案例 'a' 之后继续，然后检查 if(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 8

goto为了胜利

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

Answer 9

只需重新排序这些案例，以便该案例是最后一个：

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