【揭秘】为什么switch...case比if...else执行效率高

switch...case与if...else的根本区别

创新互联提供成都做网站、成都网站设计、网页设计，品牌网站建设，1元广告等致力于企业网站建设与公司网站制作，十载的网站开发和建站经验,助力企业信息化建设，成功案例突破成百上千,是您实现网站建设的好选择.

switch...case会生成一个跳转表来指示实际的case分支的地址，而这个跳转表的索引号与switch变量的值是相等的。从而，switch...case不用像if...else那样遍历条件分支直到命中条件，而只需访问对应索引号的表项从而到达定位分支的目的。

具体地说，switch...case会生成一份大小（表项数）为最大case常量＋1的跳表，程序首先判断switch变量是否大于最大case 常量，若大于，则跳到default分支处理；否则取得索引号为switch变量大小的跳表项的地址（即跳表的起始地址＋表项大小＊索引号），程序接着跳到此地址执行，到此完成了分支的跳转。

第一步，写一个demo程序：foo.c

 
 
 
    
  
  
  
  1. #include   
    2.   
  
  
  2. static int  
    3.   
  
  
  3. foo_ifelse(char c)  
    4.   
  
  
  4. {  
    5.   
  
  
  5.         if (c == '0' || c == '1') {  
    6.   
  
  
  6.                 c += 1;  
    7.   
  
  
  7.         } else if (c == 'a' || c == 'b') {  
    8.   
  
  
  8.                 c += 2;  
    9.   
  
  
  9.         } else if (c == 'A' || c == 'B') {  
    10.   
  
  
  10.                 c += 3;  
    11.   
  
  
  11.         } else {  
    12.   
  
  
  12.                 c += 4;  
    13.   
  
  
  13.         }  
    14.   
  
  
  14.         return (c);  
    15.   
  
  
  15. }  
    16.   
  
  
  16. static int  
    17.   
  
  
  17. foo_switch(char c)  
    18.   
  
  
  18. {  
    19.   
  
  
  19.         switch (c) {  
    20.   
  
  
  20.                 case '1':  
    21.   
  
  
  21.                 case '0': c += 1; break;  
    22.   
  
  
  22.                 case 'b':  
    23.   
  
  
  23.                 case 'a': c += 2; break;  
    24.   
  
  
  24.                 case 'B':  
    25.   
  
  
  25.                 case 'A': c += 3; break;  
    26.   
  
  
  26.                 default:  c += 4; break;  
    27.   
  
  
  27.         }    
    28.   
  
  
  28.         return (c); 
    29.   
  
  
  29. }  
    30.   
  
  
  30. int  
    31.   
  
  
  31. main(int argc, char **argv)  
    32.   
  
  
  32. {  
    33.   
  
  
  33.         int m1 = foo_ifelse('0');  
    34.   
  
  
  34.         int m2 = foo_ifelse('1');  
    35.   
  
  
  35.         int n1 = foo_switch('a'); 
    36.   
  
  
  36.         int n2 = foo_switch('b');  
    37.   
  
  
  37.         (void) printf("%c %c %c %c\n", m1, m2, n1, n2);  
    38.   
  
  
  38.         return (0);  
    39.   
  
  
  39. } 
    40.

第二步，在Ubuntu上使用gcc编译

$ gcc -g -o foo foo.c

第三步，使用gdb对二进制文件foo反汇编 (使用intel语法)

 
 
 
    
  
  
  
  1. o 反汇编foo_ifelse（） 
    2.   
  
  
  2. (gdb) set disassembly-flavor intel  
    3.   
  
  
  3. (gdb) disas /m foo_ifelse  
    4.   
  
  
  4. Dump of assembler code for function foo_ifelse:  
    5.   
  
  
  5. 4       {  
    6.   
  
  
  6.    0x0804841d <+0>:     push   ebp  
    7.   
  
  
  7.    0x0804841e <+1>:     mov    ebp,esp  
    8.   
  
  
  8.    0x08048420 <+3>:     sub    esp,0x4  
    9.   
  
  
  9.    0x08048423 <+6>:     mov    eax,DWORD PTR [ebp+0x8]  
    10.   
  
  
  10.    0x08048426 <+9>:     mov    BYTE PTR [ebp-0x4],al    
    11.   
  
  
  11. 5               if (c == '0' || c == '1') {  
    12.   
  
  
  12.    0x08048429 <+12>:    cmp    BYTE PTR [ebp-0x4],0x30  
    13.   
  
  
  13.    0x0804842d <+16>:    je     0x8048435   
    14.   
  
  
  14.    0x0804842f <+18>:    cmp    BYTE PTR [ebp-0x4],0x31  
    15.   
  
  
  15.    0x08048433 <+22>:    jne    0x8048441   
    16.   
  
  
  16. 6                       c += 1;  
    17.   
  
  
  17.    0x08048435 <+24>:    movzx  eax,BYTE PTR [ebp-0x4]  
    18.   
  
  
  18.    0x08048439 <+28>:    add    eax,0x1  
    19.   
  
  
  19.    0x0804843c <+31>:    mov    BYTE PTR [ebp-0x4],al  
    20.   
  
  
  20.    0x0804843f <+34>:    jmp    0x804847b   
    21.   
  
  
  21. 7               } else if (c == 'a' || c == 'b') {  
    22.   
  
  
  22.    0x08048441 <+36>:    cmp    BYTE PTR [ebp-0x4],0x61  
    23.   
  
  
  23.    0x08048445 <+40>:    je     0x804844d   
    24.   
  
  
  24.    0x08048447 <+42>:    cmp    BYTE PTR [ebp-0x4],0x62  
    25.   
  
  
  25.    0x0804844b <+46>:    jne    0x8048459   
    26.   
  
  
  26. 8                       c += 2;  
    27.   
  
  
  27.    0x0804844d <+48>:    movzx  eax,BYTE PTR [ebp-0x4]  
    28.   
  
  
  28.    0x08048451 <+52>:    add    eax,0x2  
    29.   
  
  
  29.    0x08048454 <+55>:    mov    BYTE PTR [ebp-0x4],al  
    30.   
  
  
  30.    0x08048457 <+58>:    jmp    0x804847b   
    31.   
  
  
  31. 9               } else if (c == 'A' || c == 'B') {  
    32.   
  
  
  32.    0x08048459 <+60>:    cmp    BYTE PTR [ebp-0x4],0x41  
    33.   
  
  
  33.    0x0804845d <+64>:    je     0x8048465   
    34.   
  
  
  34.    0x0804845f <+66>:    cmp    BYTE PTR [ebp-0x4],0x42  
    35.   
  
  
  35.    0x08048463 <+70>:    jne    0x8048471   
    36.   
  
  
  36. 10                      c += 3;  
    37.   
  
  
  37.    0x08048465 <+72>:    movzx  eax,BYTE PTR [ebp-0x4]  
    38.   
  
  
  38.    0x08048469 <+76>:    add    eax,0x3  
    39.   
  
  
  39.    0x0804846c <+79>:    mov    BYTE PTR [ebp-0x4],al  
    40.   
  
  
  40.    0x0804846f <+82>:    jmp    0x804847b   
    41.   
  
  
  41. 11              } else {  
    42.   
  
  
  42. 12                      c += 4;  
    43.   
  
  
  43.    0x08048471 <+84>:    movzx  eax,BYTE PTR [ebp-0x4]  
    44.   
  
  
  44.    0x08048475 <+88>:    add    eax,0x4  
    45.   
  
  
  45.    0x08048478 <+91>:    mov    BYTE PTR [ebp-0x4],al  
    46.   
  
  
  46. 13              }  
    47.   
  
  
  47. 14  
    48.   
  
  
  48. 15              return (c);  
    49.   
  
  
  49.    0x0804847b <+94>:    movsx  eax,BYTE PTR [ebp-0x4]  
    50.   
  
  
  50. 16      }  
    51.   
  
  
  51.    0x0804847f <+98>:    leave  
    52.   
  
  
  52.    0x08048480 <+99>:    ret  
    53.   
  
  
  53. End of assembler dump.  
    54.   
  
  
  54. (gdb)o 反汇编foo_ifelse（）  
    55.   
  
  
  55. (gdb) set disassembly-flavor intel  
    56.   
  
  
  56. (gdb) disas /m foo_ifelse  
    57.   
  
  
  57. Dump of assembler code for function foo_ifelse:  
    58.   
  
  
  58. 4       {  
    59.   
  
  
  59.    0x0804841d <+0>:     push   ebp  
    60.   
  
  
  60.    0x0804841e <+1>:     mov    ebp,esp  
    61.   
  
  
  61.    0x08048420 <+3>:     sub    esp,0x4  
    62.   
  
  
  62.    0x08048423 <+6>:     mov    eax,DWORD PTR [ebp+0x8]  
    63.   
  
  
  63.    0x08048426 <+9>:     mov    BYTE PTR [ebp-0x4],al  
    64.   
  
  
  64. 5               if (c == '0' || c == '1') {  
    65.   
  
  
  65.    0x08048429 <+12>:    cmp    BYTE PTR [ebp-0x4],0x30  
    66.   
  
  
  66.    0x0804842d <+16>:    je     0x8048435   
    67.   
  
  
  67.    0x0804842f <+18>:    cmp    BYTE PTR [ebp-0x4],0x31  
    68.   
  
  
  68.    0x08048433 <+22>:    jne    0x8048441   
    69.   
  
  
  69. 6                       c += 1;  
    70.   
  
  
  70.    0x08048435 <+24>:    movzx  eax,BYTE PTR [ebp-0x4]  
    71.   
  
  
  71.    0x08048439 <+28>:    add    eax,0x1  
    72.   
  
  
  72.    0x0804843c <+31>:    mov    BYTE PTR [ebp-0x4],al  
    73.   
  
  
  73.    0x0804843f <+34>:    jmp    0x804847b   
    74.   
  
  
  74. 7               } else if (c == 'a' || c == 'b') {  
    75.   
  
  
  75.    0x08048441 <+36>:    cmp    BYTE PTR [ebp-0x4],0x61  
    76.   
  
  
  76.    0x08048445 <+40>:    je     0x804844d   
    77.   
  
  
  77.    0x08048447 <+42>:    cmp    BYTE PTR [ebp-0x4],0x62  
    78.   
  
  
  78.    0x0804844b <+46>:    jne    0x8048459   
    79.   
  
  
  79. 8                       c += 2;  
    80.   
  
  
  80.    0x0804844d <+48>:    movzx  eax,BYTE PTR [ebp-0x4]  
    81.   
  
  
  81.    0x08048451 <+52>:    add    eax,0x2  
    82.   
  
  
  82.    0x08048454 <+55>:    mov    BYTE PTR [ebp-0x4],al  
    83.   
  
  
  83.    0x08048457 <+58>:    jmp    0x804847b   
    84.   
  
  
  84. 9               } else if (c == 'A' || c == 'B') {  
    85.   
  
  
  85.    0x08048459 <+60>:    cmp    BYTE PTR [ebp-0x4],0x41  
    86.   
  
  
  86.    0x0804845d <+64>:    je     0x8048465   
    87.   
  
  
  87.    0x0804845f <+66>:    cmp    BYTE PTR [ebp-0x4],0x42  
    88.   
  
  
  88.    0x08048463 <+70>:    jne    0x8048471  
    89.   
  
  
  89. 10                      c += 3;  
    90.   
  
  
  90.    0x08048465 <+72>:    movzx  eax,BYTE PTR [ebp-0x4]  
    91.   
  
  
  91.    0x08048469 <+76>:    add    eax,0x3  
    92.   
  
  
  92.    0x0804846c <+79>:    mov    BYTE PTR [ebp-0x4],al  
    93.   
  
  
  93.    0x0804846f <+82>:    jmp    0x804847b   
    94.   
  
  
  94. 11              } else {  
    95.   
  
  
  95. 12                      c += 4;  
    96.   
  
  
  96.    0x08048471 <+84>:    movzx  eax,BYTE PTR [ebp-0x4]  
    97.   
  
  
  97.    0x08048475 <+88>:    add    eax,0x4  
    98.   
  
  
  98.    0x08048478 <+91>:    mov    BYTE PTR [ebp-0x4],al  
    99.   
  
  
  99. 13              }  
    100.   
  
  
  100. 14  
    101.   
  
  
  101. 15              return (c);  
    102.   
  
  
  102.    0x0804847b <+94>:    movsx  eax,BYTE PTR [ebp-0x4]  
    103.   
  
  
  103. 16      }  
    104.   
  
  
  104.    0x0804847f <+98>:    leave  
    105.   
  
  
  105.    0x08048480 <+99>:    ret  
    106.   
  
  
  106. End of assembler dump.  
    107.   
  
  
  107. (gdb) 
    108.

o 反汇编foo_switch（）

 
 
 
    
  
  
  
  1. (gdb) set disassembly-flavor intel  
    2.   
  
  
  2. (gdb) disas /m foo_switch  
    3.   
  
  
  3. Dump of assembler code for function foo_switch:  
    4.   
  
  
  4. 20      {  
    5.   
  
  
  5.    0x08048481 <+0>:     push   ebp  
    6.   
  
  
  6.    0x08048482 <+1>:     mov    ebp,esp  
    7.   
  
  
  7.    0x08048484 <+3>:     sub    esp,0x4  
    8.   
  
  
  8.    0x08048487 <+6>:     mov    eax,DWORD PTR [ebp+0x8]  
    9.   
  
  
  9.    0x0804848a <+9>:     mov    BYTE PTR [ebp-0x4],al  
    10.   
  
  
  10. 21              switch (c) {  
    11.   
  
  
  11.    0x0804848d <+12>:    movsx  eax,BYTE PTR [ebp-0x4]  
    12.   
  
  
  12.    0x08048491 <+16>:    sub    eax,0x30  
    13.   
  
  
  13.    0x08048494 <+19>:    cmp    eax,0x32  
    14.   
  
  
  14.    0x08048497 <+22>:    ja     0x80484c6   
    15.   
  
  
  15.    0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]  
    16.   
  
  
  16.    0x080484a0 <+31>:    jmp    eax  
    17.   
  
  
  17. 22                      case '1':  
    18.   
  
  
  18. 23                      case '0': c += 1; break;  
    19.   
  
  
  19.    0x080484a2 <+33>:    movzx  eax,BYTE PTR [ebp-0x4]  
    20.   
  
  
  20.    0x080484a6 <+37>:    add    eax,0x1  
    21.   
  
  
  21.    0x080484a9 <+40>:    mov    BYTE PTR [ebp-0x4],al  
    22.   
  
  
  22.    0x080484ac <+43>:    jmp    0x80484d1   
    23.   
  
  
  23. 24                      case 'b':  
    24.   
  
  
  24. 25                      case 'a': c += 2; break;  
    25.   
  
  
  25.    0x080484ae <+45>:    movzx  eax,BYTE PTR [ebp-0x4]  
    26.   
  
  
  26.    0x080484b2 <+49>:    add    eax,0x2  
    27.   
  
  
  27.    0x080484b5 <+52>:    mov    BYTE PTR [ebp-0x4],al  
    28.   
  
  
  28.    0x080484b8 <+55>:    jmp    0x80484d1   
    29.   
  
  
  29. 26                      case 'B':  
    30.   
  
  
  30. 27                      case 'A': c += 3; break;  
    31.   
  
  
  31.    0x080484ba <+57>:    movzx  eax,BYTE PTR [ebp-0x4]  
    32.   
  
  
  32.    0x080484be <+61>:    add    eax,0x3  
    33.   
  
  
  33.    0x080484c1 <+64>:    mov    BYTE PTR [ebp-0x4],al  
    34.   
  
  
  34.    0x080484c4 <+67>:    jmp    0x80484d1   
    35.   
  
  
  35. 28                      default:  c += 4; break;  
    36.   
  
  
  36.    0x080484c6 <+69>:    movzx  eax,BYTE PTR [ebp-0x4]  
    37.   
  
  
  37.    0x080484ca <+73>:    add    eax,0x4  
    38.   
  
  
  38.    0x080484cd <+76>:    mov    BYTE PTR [ebp-0x4],al  
    39.   
  
  
  39.    0x080484d0 <+79>:    nop  
    40.   
  
  
  40. 29              } 
    41.   
  
  
  41. 30  
    42.   
  
  
  42. 31              return (c);  
    43.   
  
  
  43.    0x080484d1 <+80>:    movsx  eax,BYTE PTR [ebp-0x4]  
    44.   
  
  
  44. 32      }  
    45.   
  
  
  45.    0x080484d5 <+84>:    leave  
    46.   
  
  
  46.    0x080484d6 <+85>:    ret  
    47.   
  
  
  47. End of assembler dump.  
    48.   
  
  
  48. (gdb) 
    49.

分析：

  •  在foo_ifelse()中，采用的方法是按顺序比较，如满足条件，则执行对应的代码，否则跳转到下一个分支再进行比较；
  •  在foo_switch()中，下面的这段汇编代码比较有意思， 
 
 
 
    
  
  
  
  1. ..  
    2.   
  
  
  2. 21 switch (c) {  
    3.   
  
  
  3.    0x0804848d <+12>:    movsx  eax,BYTE PTR [ebp-0x4]  
    4.   
  
  
  4.    0x08048491 <+16>:    sub    eax,0x30  
    5.   
  
  
  5.    0x08048494 <+19>:    cmp    eax,0x32  
    6.   
  
  
  6.    0x08048497 <+22>:    ja     0x80484c6   
    7.   
  
  
  7.    0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]  
    8.   
  
  
  8.    0x080484a0 <+31>:    jmp    eax  
    9.   
  
  
  9. .. 
    10.

注意：

第17行 jmp eax

也就是说，当c的取值不同，是什么机制保证第17行能跳转到正确的位置开始执行呢？

第16行: eax = [eax * 4 + 0x80485f0]

搞清楚了从地址0x80485f0开始，对应的内存里面的内容也就回答了刚才的问题。

执行完第16行后，

  •  当c为'1'或'0'时， eax的值应该是0x080484a2；
  •  当c为'b'或'a'时， eax的值应该是0x080484ae；
  •  当c为'B'或'A'时， eax的值应该是0x080484ba；

通过gdb查看对应的内存，确实如此！

 
 
 
    
  
  
  
  1. >>> ord('1') - 0x30  
    2.   
  
  
  2. >>> ord('0') - 0x30  
    3.   
  
  
  3. (gdb) x /2wx  0*4+0x80485f0  
    4.   
  
  
  4. 0x80485f0:    0x080484a2    0x080484a2  
    5.   
  
  
  5. >>> ord('b') - 0x30  
    6.   
  
  
  6. >>> ord('a') - 0x30  
    7.   
  
  
  7. (gdb) x /2wx 49*4+0x80485f0  
    8.   
  
  
  8. 0x80486b4:    0x080484ae    0x080484ae             
    9.   
  
  
  9. >>> ord('B') - 0x30  
    10.   
  
  
  10. >>> ord('A') - 0x30  
    11.   
  
  
  11. (gdb) x /2wx 17*4+0x80485f0  
    12.   
  
  
  12. 0x8048634:    0x080484ba    0x080484ba 
    13.

那么，我们可以大胆的猜测，虽然c的取值不同但是跳转的IP确实是精准无误的，一定是编译阶段就被设定好了，果真如此吗？接下来分析一下对应的二进制文件foo,

第四步，使用objdump查看foo,

 
 
 
    
  
  
  
  1. $ objdump -D foo > /tmp/x  
    2.   
  
  
  2. $ vim /tmp/x  
    3.   
  
  
  3.  509 Disassembly of section .rodata:  
    4.   
  
  
  4.  ...  
    5.   
  
  
  5.  518  80485f0:       a2 84 04 08 a2          mov    %al,0xa2080484  
    6.   
  
  
  6.  519  80485f5:       84 04 08                test   %al,(%eax,%ecx,1)  
    7.   
  
  
  7.  ...  
    8.   
  
  
  8.  534  8048630:       c6 84 04 08 ba 84 04    movb   $0x8,0x484ba08(%esp,%eax,1)  
    9.   
  
  
  9.  535  8048637:       08  
    10.   
  
  
  10.  536  8048638:       ba 84 04 08 c6          mov    $0xc6080484,%edx  
    11.   
  
  
  11.  ...  
    12.   
  
  
  12.  566  80486b0:       c6 84 04 08 ae 84 04    movb   $0x8,0x484ae08(%esp,%eax,1)  
    13.   
  
  
  13.  567  80486b7:       08  
    14.   
  
  
  14.  568  80486b8:       ae                      scas   %es:(%edi),%al  
    15.   
  
  
  15.  569  80486b9:       84 04 08                test   %al,(%eax,%ecx,1)  
    16.   
  
  
  16.  ... 
    17.

在0x80485f0地址，存的8个字节正好是0x080484a2, 0x080484a2 (注意：按照小端的方式阅读)

在0x80486b4地址，存的8个字节正好是0x080484ae, 0x080484ae

在0x8048634地址，存的8个字节正好是0x080484ba,0x080484ba

果然不出所料，要跳转的IP的值正是在编译的时候存入了.rodata（只读数据区）。一旦foo开始运行，对应的内存地址就填写上了正确的待跳转地址，接下来只不过是根据c的取值计算出对应的IP存放的内存起始地址X，从X中取出待跳转的地址，直接跳转就好。

 
 
 
    
  
  
  
  1. 16    0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]  
    2.   
  
  
  2. 17    0x080484a0 <+31>:    jmp    eax 
    3.

到此为止，我们已经搞清楚了为什么switch...case...语句相对于if...else if...else...来说执行效率要高的根本原因。简言之，编译的时候创建了一个map存于.rodata区中，运行的时候直接根据输入(c的值）查表，找到对应的IP后直接跳转。（省去了cmp, jmp -> cmp, jmp -> cmp, jmp...这一冗长的计算过程。）

总结：

switch...case...执行效率高，属于典型的以空间换时间。也就是说，（套用算法的行话）以提高空间复杂度为代价降低了时间复杂度。

【责任编辑：庞桂玉 TEL：（010）68476606】

文章名称：【揭秘】为什么switch...case比if...else执行效率高
文章路径：http://www.shufengxianlan.com/qtweb/news1/191151.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计公司知识

分类信息网

乐山石膏隔墙　　 　柔性防护网　　 　成都做网站　　 　成都二枢电信服务器托管　　 　企业网站改版　　 　梓潼做网站　　 　成都网站推广　　 　网站制作　　 　成都响应式网站建设　　 　成都谷歌推广　　 　江安网站建设　　 　成都网站建设　　 　成都网站设计　　 　西部信息机房　　 　云服务器　　 　乐山服务器托管　　 　网站优化排名推广　　 　成都定制高级网站建设　　 　成都网站建设　　 　成都法律咨询