切换案例编程实践答案

【问题标题】：switch case programming practice切换案例编程实践
【发布时间】：2009-08-06 20:32:54
【问题描述】：

enum SQLErrorCode{
      OK = 0,
      PARTIAL_OK = 1,
      SOMEWHAT_OK = 2,
      NOT_OK = 3,
};

代码 1：

int error = getErrorCode();
if((error == SQLErrorCode.PARTIAL_OK) ||
  (error == SQLErrorCode.SOMEWHAT_OK) ||
  (error == SQLErrorCode.NOT_OK) ||
  (error < 0))
   callFunction1();
else
    callFunction2();

代码 2：

switch(error){
       case SQLErrorCode.PARTIAL_OK: 
                                    callFunction1();
                                    break;
        case SQLErrorCode.SOMEWHAT_OK:
                                    callFunction1();
                                    break;
        case SQLErrorCode.NOT_OK: 
                                    callFunction1();
                                    break;
        default:
                                    callFunction2();
                                    break;
}

我应该更喜欢哪种方法。就性能而言，应该没有太大的区别。如何处理 switch case 中的错误

编辑：乔尔的解决方案：

switch(error) {
     case SQLErrorCode.PARTIAL_OK: 
     case SQLErrorCode.SOMEWHAT_OK:
     case SQLErrorCode.NOT_OK: 
         callFunction1();
         break;
     case SQLErrorCode.OK:
         callFunction2();
         break;
     default:     // error < 0 is handled
         callFunction1();
         break;
}

Q. 错误

【问题讨论】：

你在说C吗？不是 C#？ SQLErrorCode. 前缀不合法 C.
这是标记为 C，但 C 不允许 enumtype.enumval。你的意思是用 C# 标记它吗？
大部分 switch 示例都在改变原代码的含义。它们的含义更像是：“if( .... || (error NOT_OK) )”。如果这确实是您想要的，那么只需：if (error != 0)。
我已经修改了我的答案以供您编辑。新的应该处理所有的情况。基本概念：使用特定案例语句处理已知案例以及默认情况下的所有其他内容。

标签： c# c++ c if-statement switch-statement

【解决方案1】：

没有表达对哪个最好的偏好，这里有另一种可能性：

switch(error){
    case SQLErrorCode.PARTIAL_OK: 
    case SQLErrorCode.SOMEWHAT_OK:
    case SQLErrorCode.NOT_OK: 
                                callFunction1();
                                break;
    default:
                                callFunction2();
                                break;
}

【讨论】：

比原来的开关功能好多了。
糟糕！我错过了：|我的错！
嘿，我们都可以搞砸一次......但下一次......你已经完成了:)
这是我的偏好。相关问题：stackoverflow.com/questions/188461/…
好的，这个很“优雅”，但我不会使用这种方法。为什么，你可能会问？当您突然想用另一个函数处理 SOMEWHAT_OK 时，这可能非常危险。在这里很容易打破整个逻辑。我没有拒绝这个答案，但大卫的评论与我的想法一致。

【解决方案2】：

对于这么少的情况并不重要，但 switch 实际上对于整数来说更快：它可以并且通常是作为跳转表而不是系列来实现的的有条件的检查。

作为比较，不同案例的数量增加到 10 个：

enum SQLErrorCode{
    CODE0 = 0,
    CODE1 = 1,
    CODE2 = 2,
    CODE3 = 3,
    CODE4 = 4,
    CODE5 = 5,
    CODE6 = 6,
    CODE7 = 7,
    CODE8 = 8,
    CODE9 = 9
};

enum SQLErrorCode getErrorCode();

void run()
{
    int error = getErrorCode();
#ifdef CASE1
    if((error == CODE0) ||       
       (error == CODE1) ||
       (error == CODE2) ||
       (error == CODE3) ||
       (error == CODE4) ||
       (error == CODE5) ||
       (error == CODE6) ||
       (error == CODE7) ||
       (error == CODE8) ||
       (error == CODE9) ||
       (error < 0))
        callFunction1();
    else
        callFunction2();
#endif
#ifdef CASE2
    switch(error)
    {
        case CODE0:
            callFunction1();
            break;
    case CODE1:
        callFunction1();
        break;
    case CODE2:
        callFunction1();
        break;
    case CODE3:
        callFunction1();
        break;
    case CODE4:
        callFunction1();
        break;
    case CODE5:
        callFunction1();
        break;
    case CODE6:
        callFunction1();
        break;
    case CODE7:
        callFunction1();
        break;
    case CODE8:
        callFunction1();
        break;
    case CODE9:
        callFunction1();
        break;
    default:
        callFunction2();
        break;
}
#endif

}

现在看看在使用 GCC 在 Linux 上构建时，第一种情况与第二种情况生成的程序集。

如果您查看程序集，您会发现一个显着差异（对于较大的语句）：||s 的系列（或 if/else，如果您这样做）是一系列分支一次一个。 switch 变成了一张大桌子：它占用了更多的代码，但可能意味着它可以一次处理。

（顺便说一句，我们在这里讨论的是 C 对吗？不是 C#？你的代码不会编译：在 C 中，枚举器不使用枚举名称作为前缀。所以它是 PARTIAL_OK 没有 SQLErrorCode. )

代码 1：cc -DCASE1 -s switch.s switch.c

        .file   "1241256.c"
        .text
.globl run
        .type   run, @function
run:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        call    getErrorCode
        movl    %eax, -4(%ebp)
        cmpl    $0, -4(%ebp)
        je      .L2
        cmpl    $1, -4(%ebp)
        je      .L2
        cmpl    $2, -4(%ebp)
        je      .L2
        cmpl    $3, -4(%ebp)
        je      .L2
        cmpl    $4, -4(%ebp)
        je      .L2
        cmpl    $5, -4(%ebp)
        je      .L2
        cmpl    $6, -4(%ebp)
        je      .L2
        cmpl    $7, -4(%ebp)
        je      .L2
        cmpl    $8, -4(%ebp)
        je      .L2
        cmpl    $9, -4(%ebp)
        je      .L2
        cmpl    $0, -4(%ebp)
        jns     .L13
.L2:
        call    callFunction1
        jmp     .L15
.L13:
        call    callFunction2
.L15:
        leave
        ret
        .size   run, .-run
        .ident  "GCC: (GNU) 4.2.4 (Ubuntu 4.2.4-1ubuntu4)"
        .section        .note.GNU-stack,"",@progbits

代码 2：cc -DCASE2 -s switch.s switch.c

        .text
.globl run
        .type   run, @function
run:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        call    getErrorCode
        movl    %eax, -4(%ebp)
        cmpl    $9, -4(%ebp)
        ja      .L2
        movl    -4(%ebp), %eax
        sall    $2, %eax
        movl    .L13(%eax), %eax
        jmp     *%eax
        .section        .rodata
        .align 4
        .align 4
.L13:
        .long   .L3
        .long   .L4
        .long   .L5
        .long   .L6
        .long   .L7
        .long   .L8
        .long   .L9
        .long   .L10
        .long   .L11
        .long   .L12
        .text
.L3:
        call    callFunction1
        jmp     .L15
.L4:
        call    callFunction1
        jmp     .L15
.L5:
        call    callFunction1
        jmp     .L15
.L6:
        call    callFunction1
        jmp     .L15
.L7:
        call    callFunction1
        jmp     .L15
.L8:
        call    callFunction1
        jmp     .L15
.L9:
        call    callFunction1
        jmp     .L15
.L10:
        call    callFunction1
        jmp     .L15
.L11:
        call    callFunction1
        jmp     .L15
.L12:
        call    callFunction1
        jmp     .L15
.L2:
        call    callFunction2
.L15:
        leave
        ret
        .size   run, .-run
        .ident  "GCC: (GNU) 4.2.4 (Ubuntu 4.2.4-1ubuntu4)"
        .section        .note.GNU-stack,"",@progbits

【讨论】：

这正是我想要的！
是的，这是默认的（显示的命令行是我使用的）。

【解决方案3】：

为什么不...

switch(error) {
    case SQLErrorCode.PARTIAL_OK: 
    case SQLErrorCode.SOMEWHAT_OK:
    case SQLErrorCode.NOT_OK: 
         callFunction1();
         break;
    case SQLErrorCode.OK:
         callFunction2();
         break;
    default:
         if (error < 0)
              callFunction1();
         else
              callFunction2();
         break;
}

比你的 switch 更容易写，比你的 if 更容易阅读。然而它仍然处理错误

编辑：

Richard 提出了一个很好的观点。我已经编辑处理已知范围之外的正负错误。

【讨论】：

我投了这个票，虽然我自己更喜欢 break 与单词 case 对齐。
当 'error' 是一个正值而不是枚举中列出的值之一时会发生什么？例如10？在原始代码中，将调用“callFunction2”，但是在您的代码中调用“callFunction1”。这种行为可能不是“错误的”，但是它与原始代码不同。

【解决方案4】：

假设 getErrorCode() 返回您的枚举值之一或小于 0 的值，怎么样

int error = getErrorCode();
if (error == SQLErrorCode.OK)
  callFunction2(); // Good path
else
  callFunction1(); // Error / not good enough path

显然，如果您的代码需要在error > 3 上使用callFunction2()，那么这是行不通的。

【讨论】：

我正要提出同样的建议。

【解决方案5】：

您还可以编写一个函数来确定什么是 OK 错误或不是 OK 错误代码：

bool isOK(int code)
{
  return code == SQLErrorCode.OK;
}

你的代码可能变成：

if (isOk(getErrorCode()))
{
  callFunction2;
}
else
{
  callFunction1;
}

【讨论】：

+1：这是唯一一个似乎已经掌握了 switch 语句对于说“！= OK”是矫枉过正的答案。

【解决方案6】：

我有一段时间没碰C了，但它不是掉线了吗？所以你可以这样写第二个夹头......

switch(error){
   case SQLErrorCode.PARTIAL_OK: 
    case SQLErrorCode.SOMEWHAT_OK:
    case SQLErrorCode.NOT_OK: 
                                callFunction1();
                                break;
    default:
                                callFunction2();
                                break;

}

【讨论】：

【解决方案7】：

当你有多种方法来获得相同的效果时，你就会造成混乱。因为在 switch 版本中，SqlErrorCode.PARTIAL_OK 和 SqlErrorCode.SOMEWHAT_OK 有不同的情况，这意味着它们有不同的处理。需要进行一些研究才能看到正在发生的事情（并且它与您的 if 语句处理不完全兼容，这可能意味着它让您感到困惑）。

在这种情况下，我会使用 if 语句，因为这个想法是使用一个或另一个函数。

【讨论】：

你在这里很真实。我很困惑我应该更喜欢哪一个。