爲何switch...case語句比if...else執行效率高

在C語言中，教科書告訴咱們switch...case...語句比if...else if...else執行效率要高，但這究竟是爲何呢？本文嘗試從彙編的角度予以分析並揭曉其中的奧祕。

第一步，寫一個demo程序：foo.c

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

 

第二步，在Ubuntu上使用gcc編譯

$ gcc -g -o foo foo.c

 

第三步，使用gdb對二進制文件foo反彙編 (使用intel語法)

o 反彙編foo_ifelse（）

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

o 反彙編foo_switch（）

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

分析：
（1）在foo_ifelse()中，採用的方法是按順序比較，如知足條件，則執行對應的代碼，不然跳轉到下一個分支再進行比較；

（2）在foo_switch()中，下面的這段彙編代碼比較有意思，

..
11 21              switch (c) {
12    0x0804848d <+12>:    movsx  eax,BYTE PTR [ebp-0x4]
13    0x08048491 <+16>:    sub    eax,0x30
14    0x08048494 <+19>:    cmp    eax,0x32
15    0x08048497 <+22>:    ja     0x80484c6 <foo_switch+69>
16    0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]
17    0x080484a0 <+31>:    jmp    eax
..

注意： 第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查看對應的內存，確實如此！

>>> ord('1') - 0x30
1
>>> ord('0') - 0x30
0
(gdb) x /2wx  0*4+0x80485f0
0x80485f0:    0x080484a2    0x080484a2

>>> ord('b') - 0x30
50
>>> ord('a') - 0x30
49
(gdb) x /2wx 49*4+0x80485f0
0x80486b4:    0x080484ae    0x080484ae
                
>>> ord('B') - 0x30
18
>>> ord('A') - 0x30
17
(gdb) x /2wx 17*4+0x80485f0
0x8048634:    0x080484ba    0x080484ba

那麼，咱們能夠大膽的猜想，雖然c的取值不一樣可是跳轉的IP確實是精準無誤的，必定是編譯階段就被設定好了，果然如此嗎？ 接下來分析一下對應的二進制文件foo,

 

第四步，使用objdump查看foo,

$ objdump -D foo > /tmp/x

$ vim /tmp/x
 509 Disassembly of section .rodata:
 ...
 518  80485f0:       a2 84 04 08 a2          mov    %al,0xa2080484
 519  80485f5:       84 04 08                test   %al,(%eax,%ecx,1)
 ...
 534  8048630:       c6 84 04 08 ba 84 04    movb   $0x8,0x484ba08(%esp,%eax,1)
 535  8048637:       08
 536  8048638:       ba 84 04 08 c6          mov    $0xc6080484,%edx
 ...
 566  80486b0:       c6 84 04 08 ae 84 04    movb   $0x8,0x484ae08(%esp,%eax,1)
 567  80486b7:       08
 568  80486b8:       ae                      scas   %es:(%edi),%al
 569  80486b9:       84 04 08                test   %al,(%eax,%ecx,1)
 ...

在0x80485f0地址，存的8個字節正好是0x080484a2, 0x080484a2 (注意：按照小端的方式閱讀)

在0x80486b4地址，存的8個字節正好是0x080484ae, 0x080484ae

在0x8048634地址，存的8個字節正好是0x080484ba,0x080484ba

果真不出所料，要跳轉的IP的值正是在編譯的時候存入了.rodata（只讀數據區）。一旦foo開始運行，對應的內存地址就填寫上了正確的待跳轉地址，接下來只不過是根據c的取值計算出對應的IP存放的內存起始地址X，從X中取出待跳轉的地址，直接跳轉就好。

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

到此爲止，咱們已經搞清楚了爲何switch...case...語句相對於if...else if...else...來講執行效率要高的根本緣由。簡言之，編譯的時候建立了一個map存於.rodata區中，運行的時候直接根據輸入(c的值）查表，找到對應的IP後直接跳轉。 （省去了cmp, jmp -> cmp, jmp -> cmp, jmp...這一冗長的計算過程。）

 

總結： switch...case...執行效率高，屬於典型的以空間換時間。也就是說，（套用算法的行話）以提升空間複雜度爲代價下降了時間複雜度。