在C语言中，条件判断语句是程序的重要组成部分，也是系统业务逻辑的控制手段，教科书告诉我们switch...case...语句比if...else if...else执行效率要高，但这到底是为什么呢？本文尝试从汇编的角度予以分析并揭晓其中的奥秘。

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

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

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

第一步，写一个demo程序：foo.c#include <stdio.h>

static int
- `5 |, X4 G) W7 B+ Vfoo_ifelse(char c)
{
- w* g& d6 ^: j- R9 f4 z& ^        if (c == '0' || c == '1') {
4 U$ r' l* }9 l, V& k; ~; D1 E                c += 1;
6 Q7 B+ L- w: j& G/ s$ P4 w- }        } else if (c == 'a' || c == 'b') {
                c += 2;
" ~& r& a4 n) G% s2 Y, M& C5 ~* ?  x        } else if (c == 'A' || c == 'B') {
- ~/ G" q: S$ A" h" V* L  K                c += 3;
! Y$ N$ {8 E& U( R; [9 r* q        } else {
                c += 4;
        }
4 b) V6 ?( t( p: V
        return (c);
$ D( `* \$ G) X! x}
! ~/ `5 e3 r6 n; F- n7 c# Y
1 P9 B7 o* T+ M* k: Qstatic int
foo_switch(char c)
{
; p- U4 D, N  t: s, S4 x; D* [        switch (c) {
0 }! t: D+ o& Q9 \; N                case '1':
, h3 l: k4 T1 ?( ^9 N* P                case '0': c += 1; break;
. b9 D5 Y' K' v9 `* Y                case 'b':
                case 'a': c += 2; break;
/ F) z  F+ {3 b0 \+ [                case 'B':
                case 'A': c += 3; break;
9 E: k8 \5 A) M& `& X1 R                default:  c += 4; break;
0 q- F" D+ T4 F6 P  s# w; ~# a2 w, R0 L. f        }

        return (c);
- S, m; t, s: p% ^# g}

int
main(int argc, char **argv)
{
        int m1 = foo_ifelse('0');
        int m2 = foo_ifelse('1');
) D: m5 `$ r3 v6 u; ]        int n1 = foo_switch('a');
2 [- U' [! W7 i; E! A6 ~        int n2 = foo_switch('b');
        (void) printf("%c %c %c %c\n", m1, m2, n1, n2);
/ Z1 s& L! |7 q. B% V        return (0);
2 a  m* y. c% j6 [4 M4 s7 {2 ]}
. c! t7 D  P2 q- Y% s1 ?6 K, `第二步，在Ubuntu上使用gcc编译

$ gcc -g -o foo foo.c

第三步，使用gdb对二进制文件foo反汇编 (使用intel语法)o 反汇编foo_ifelse（）
(gdb) set disassembly-flavor intel
(gdb) disas /m foo_ifelse
( h1 V" T6 u' y3 ~" d+ ?Dump of assembler code for function foo_ifelse:
4       {
   0x0804841d <+0>:     push   ebp
3 i- \2 b; {: D' y   0x0804841e <+1>:     mov    ebp,esp
. N9 f- r! @: ^0 B, k" a; D* t& T   0x08048420 <+3>:     sub    esp,0x4
   0x08048423 <+6>:     mov    eax,DWORD PTR [ebp+0x8]
   0x08048426 <+9>:     mov    BYTE PTR [ebp-0x4],al

' v& f* c# T4 X5               if (c == '0' || c == '1') {
   0x08048429 <+12>:    cmp    BYTE PTR [ebp-0x4],0x30
) F+ {7 n4 D0 S   0x0804842d <+16>:    je     0x8048435 <foo_ifelse+24>
8 p% l9 k( H$ V$ y, D   0x0804842f <+18>:    cmp    BYTE PTR [ebp-0x4],0x31
   0x08048433 <+22>:    jne    0x8048441 <foo_ifelse+36>
' e6 m$ t# c: `, b
6                       c += 1;
$ k/ Y$ i' Y1 T   0x08048435 <+24>:    movzx  eax,BYTE PTR [ebp-0x4]
   0x08048439 <+28>:    add    eax,0x1
9 F  S0 P/ c9 k0 j5 c& `  W2 }; j* \   0x0804843c <+31>:    mov    BYTE PTR [ebp-0x4],al
9 Z0 C% _6 M5 e* u& p0 j, T   0x0804843f <+34>:    jmp    0x804847b <foo_ifelse+94>

+ x. z  X0 a; T7               } else if (c == 'a' || c == 'b') {
   0x08048441 <+36>:    cmp    BYTE PTR [ebp-0x4],0x61
( A% M5 V" @" G4 Y* ~   0x08048445 <+40>:    je     0x804844d <foo_ifelse+48>
   0x08048447 <+42>:    cmp    BYTE PTR [ebp-0x4],0x62
   0x0804844b <+46>:    jne    0x8048459 <foo_ifelse+60>
* A# z9 c- e" O+ k, {% h9 W
: A1 v" s5 d7 M$ F& T/ t8                       c += 2;
   0x0804844d <+48>:    movzx  eax,BYTE PTR [ebp-0x4]
' |! W6 w4 i' ]4 m) s6 L   0x08048451 <+52>:    add    eax,0x2
; F1 K+ G& E2 D0 U6 s0 p   0x08048454 <+55>:    mov    BYTE PTR [ebp-0x4],al
   0x08048457 <+58>:    jmp    0x804847b <foo_ifelse+94>

9               } else if (c == 'A' || c == 'B') {
   0x08048459 <+60>:    cmp    BYTE PTR [ebp-0x4],0x41
   0x0804845d <+64>:    je     0x8048465 <foo_ifelse+72>
   0x0804845f <+66>:    cmp    BYTE PTR [ebp-0x4],0x42
! m! D1 X+ {. ^   0x08048463 <+70>:    jne    0x8048471 <foo_ifelse+84>
9 A, Z0 C; T; t% S/ |
10                      c += 3;
: d8 A6 P5 w- i   0x08048465 <+72>:    movzx  eax,BYTE PTR [ebp-0x4]
& P5 l; |2 `8 {3 _   0x08048469 <+76>:    add    eax,0x3
; @+ ~8 H( ?: k( p4 `   0x0804846c <+79>:    mov    BYTE PTR [ebp-0x4],al
" B  `- s5 E" m( k   0x0804846f <+82>:    jmp    0x804847b <foo_ifelse+94>
2 ?( a" G- \( m8 a( J
  r% W7 d9 J0 Y8 T11              } else {
; e& ?0 u+ V$ i- d0 k12                      c += 4;
   0x08048471 <+84>:    movzx  eax,BYTE PTR [ebp-0x4]
   0x08048475 <+88>:    add    eax,0x4
) F+ ?4 |' n; G( O, ?8 F   0x08048478 <+91>:    mov    BYTE PTR [ebp-0x4],al
% n) p5 d* r' `7 D
13              }
14
6 Q$ Y! Q- t7 s4 U8 A# L15              return (c);
   0x0804847b <+94>:    movsx  eax,BYTE PTR [ebp-0x4]

' ?4 f3 q) w- r16      }
7 }- N" s/ @( s# O6 t   0x0804847f <+98>:    leave
( U8 I  F" |, e4 G   0x08048480 <+99>:    ret

End of assembler dump.
(gdb)o 反汇编foo_ifelse（）
# u7 w6 X) _- P, L: S; F3 \6 B(gdb) set disassembly-flavor intel
; |' I# r2 o3 x; J, A, o. |(gdb) disas /m foo_ifelse
- x" ?% J1 a) K. z) }Dump of assembler code for function foo_ifelse:
4       {
   0x0804841d <+0>:     push   ebp
   0x0804841e <+1>:     mov    ebp,esp
   0x08048420 <+3>:     sub    esp,0x4
   0x08048423 <+6>:     mov    eax,DWORD PTR [ebp+0x8]
   0x08048426 <+9>:     mov    BYTE PTR [ebp-0x4],al

5               if (c == '0' || c == '1') {
' w, k: W* Q# g( }1 Q' y6 L   0x08048429 <+12>:    cmp    BYTE PTR [ebp-0x4],0x30
   0x0804842d <+16>:    je     0x8048435 <foo_ifelse+24>
   0x0804842f <+18>:    cmp    BYTE PTR [ebp-0x4],0x31
   0x08048433 <+22>:    jne    0x8048441 <foo_ifelse+36>

: E' U* `" t5 y# ?  |, P6                       c += 1;
   0x08048435 <+24>:    movzx  eax,BYTE PTR [ebp-0x4]
& ]) I8 E2 h3 z& h/ d8 M   0x08048439 <+28>:    add    eax,0x1
# O" e- ~" |; J) @   0x0804843c <+31>:    mov    BYTE PTR [ebp-0x4],al
   0x0804843f <+34>:    jmp    0x804847b <foo_ifelse+94>

3 p* t$ y4 V. l  [' W$ b" A7               } else if (c == 'a' || c == 'b') {
   0x08048441 <+36>:    cmp    BYTE PTR [ebp-0x4],0x61
$ g* n) y* x$ n   0x08048445 <+40>:    je     0x804844d <foo_ifelse+48>
+ L- z" O( }: r. j8 Q   0x08048447 <+42>:    cmp    BYTE PTR [ebp-0x4],0x62
1 n; g. A' ?% ], @& G0 \+ ^   0x0804844b <+46>:    jne    0x8048459 <foo_ifelse+60>
8 ~0 G: w, k7 V) T$ a
8                       c += 2;
   0x0804844d <+48>:    movzx  eax,BYTE PTR [ebp-0x4]
  [6 x" U6 x4 V! A  i  I7 ]   0x08048451 <+52>:    add    eax,0x2
   0x08048454 <+55>:    mov    BYTE PTR [ebp-0x4],al
   0x08048457 <+58>:    jmp    0x804847b <foo_ifelse+94>
/ T; Z1 u: o/ I& t! A6 J  T
8 F  z4 t4 _# G# p9               } else if (c == 'A' || c == 'B') {
   0x08048459 <+60>:    cmp    BYTE PTR [ebp-0x4],0x41
   0x0804845d <+64>:    je     0x8048465 <foo_ifelse+72>
( C& j( l( o; {9 R# e- g8 ~   0x0804845f <+66>:    cmp    BYTE PTR [ebp-0x4],0x42
0 M) c- B* y% l! m- J8 J1 f+ k   0x08048463 <+70>:    jne    0x8048471 <foo_ifelse+84>

10                      c += 3;
   0x08048465 <+72>:    movzx  eax,BYTE PTR [ebp-0x4]
   0x08048469 <+76>:    add    eax,0x3
   0x0804846c <+79>:    mov    BYTE PTR [ebp-0x4],al
   0x0804846f <+82>:    jmp    0x804847b <foo_ifelse+94>

11              } else {
12                      c += 4;
( h1 ]' R, z5 j  Z0 k2 g/ Y   0x08048471 <+84>:    movzx  eax,BYTE PTR [ebp-0x4]
) @; \: N1 T! g   0x08048475 <+88>:    add    eax,0x4
   0x08048478 <+91>:    mov    BYTE PTR [ebp-0x4],al

13              }
3 v# M' S$ u0 x  u8 E2 X3 }# N) e14
# v* X0 c+ _" N, P' ?15              return (c);
2 \/ h: {; b5 G; F9 B   0x0804847b <+94>:    movsx  eax,BYTE PTR [ebp-0x4]
* w9 x8 M1 B' e
16      }
/ C  a/ p7 c* c   0x0804847f <+98>:    leave
   0x08048480 <+99>:    ret
, }! m1 i: I. O$ g
End of assembler dump.
(gdb)

o 反汇编foo_switch（）

(gdb) set disassembly-flavor intel
(gdb) disas /m foo_switch
Dump of assembler code for function foo_switch:
20      {
   0x08048481 <+0>:     push   ebp
   0x08048482 <+1>:     mov    ebp,esp
  B9 N+ V; x( Z" R   0x08048484 <+3>:     sub    esp,0x4
2 }# e2 V4 f8 k5 I# Z   0x08048487 <+6>:     mov    eax,DWORD PTR [ebp+0x8]
2 G+ O+ O4 E0 |) `" y   0x0804848a <+9>:     mov    BYTE PTR [ebp-0x4],al
( {$ v+ M; ~/ G# @' `
21              switch (c) {
   0x0804848d <+12>:    movsx  eax,BYTE PTR [ebp-0x4]
+ e$ j. |" D; a+ X   0x08048491 <+16>:    sub    eax,0x30
' H/ _; \- A$ q/ ?  [0 f. `( ?   0x08048494 <+19>:    cmp    eax,0x32
8 [( \# ]- o: q4 q4 z9 X3 m% k   0x08048497 <+22>:    ja     0x80484c6 <foo_switch+69>
8 t, m/ S+ w, v1 J6 @) a& v   0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]
) j8 \$ x5 K' @3 Q+ \   0x080484a0 <+31>:    jmp    eax
( z$ V0 H% \( G7 r
& s/ y. @# j- n. I$ q22                      case '1':
23                      case '0': c += 1; break;
   0x080484a2 <+33>:    movzx  eax,BYTE PTR [ebp-0x4]
' t9 M( d. k2 k  q. r) H7 G   0x080484a6 <+37>:    add    eax,0x1
   0x080484a9 <+40>:    mov    BYTE PTR [ebp-0x4],al
   0x080484ac <+43>:    jmp    0x80484d1 <foo_switch+80>

5 P7 D  Y/ E* k4 L24                      case 'b':
25                      case 'a': c += 2; break;
   0x080484ae <+45>:    movzx  eax,BYTE PTR [ebp-0x4]
   0x080484b2 <+49>:    add    eax,0x2
   0x080484b5 <+52>:    mov    BYTE PTR [ebp-0x4],al
   0x080484b8 <+55>:    jmp    0x80484d1 <foo_switch+80>
$ ?8 c4 m4 d8 ~; s' k
26                      case 'B':
27                      case 'A': c += 3; break;
   0x080484ba <+57>:    movzx  eax,BYTE PTR [ebp-0x4]
   0x080484be <+61>:    add    eax,0x3
   0x080484c1 <+64>:    mov    BYTE PTR [ebp-0x4],al
   0x080484c4 <+67>:    jmp    0x80484d1 <foo_switch+80>

2 b  S) o  x" P/ c( N+ B28                      default:  c += 4; break;
5 W8 C/ m+ {3 H$ `- }   0x080484c6 <+69>:    movzx  eax,BYTE PTR [ebp-0x4]
. a* [/ V; L" ^5 e" k   0x080484ca <+73>:    add    eax,0x4
   0x080484cd <+76>:    mov    BYTE PTR [ebp-0x4],al
   0x080484d0 <+79>:    nop

29              }
. b) u7 p0 x$ o3 g% `30
$ }2 [: B$ ^* W  Y, z31              return (c);
+ ^6 b+ b0 S# X   0x080484d1 <+80>:    movsx  eax,BYTE PTR [ebp-0x4]
& w9 q; B% ?1 \! w" G& V! v5 V0 {
' u' _# L7 k1 l' {32      }
   0x080484d5 <+84>:    leave
   0x080484d6 <+85>:    ret
' o3 F  o- U6 Q
; z9 N3 Y4 h3 G. JEnd of assembler dump.
(gdb)
分析：

• 在foo_ifelse()中，采用的方法是按顺序比较，如满足条件，则执行对应的代码，否则跳转到下一个分支再进行比较；
• 在foo_switch()中，下面的这段汇编代码比较有意思，
  
  % G! L, h: l. p' ?2 A

..
7 z, A4 p, N# s: ?- ^" F21 switch (c) {
' \  u! r. J( R% C$ u0 y* J: k   0x0804848d <+12>:    movsx  eax,BYTE PTR [ebp-0x4]
/ F3 k7 c' [. r: q% |8 q: {+ S   0x08048491 <+16>:    sub    eax,0x30
+ S4 d6 f: ]) Q& \6 n0 y0 n   0x08048494 <+19>:    cmp    eax,0x32
   0x08048497 <+22>:    ja     0x80484c6 <foo_switch+69>
   0x08048499 <+24>:    mov    eax,DWORD PTR [eax*4+0x80485f0]
) D( Y9 E6 Q9 p9 g   0x080484a0 <+31>:    jmp    eax
% m8 \+ |0 K1 t0 m0 S: w0 t3 Z..

注意：

第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
; [, Y: ]# d% Y3 Q8 D; G; M>>> ord('0') - 0x30
(gdb) x /2wx  0*4+0x80485f0
0x80485f0:    0x080484a2    0x080484a2
+ F  c. v3 h' n+ L# {
>>> ord('b') - 0x30
8 H8 p. k; g% q1 M, k, k0 [>>> ord('a') - 0x30
(gdb) x /2wx 49*4+0x80485f0
0x80486b4:    0x080484ae    0x080484ae
. z+ w% d  O2 l2 b& {               
>>> ord('B') - 0x30
# e5 \+ b# d1 u- U+ `>>> ord('A') - 0x30
(gdb) x /2wx 17*4+0x80485f0
7 q4 N8 H0 Q; `- N# N+ P4 G6 x8 R  V0x8048634:    0x080484ba    0x080484ba
4 ]( ]; x/ V5 J' M+ C* i

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

第四步，使用objdump查看foo,$ objdump -D foo > /tmp/x

# L% v+ u7 _! \; `; n- m3 {$ vim /tmp/x
2 S  [6 m) T- l" G/ M$ c 509 Disassembly of section .rodata:
...
  t9 n* g4 A- i 518  80485f0:       a2 84 04 08 a2          mov    %al,0xa2080484
2 {& N/ e' |, {" V/ E 519  80485f5:       84 04 08                test   %al,(%eax,%ecx,1)
+ g. L, m8 |$ R* U1 ` ...
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)
: {* |8 N  d* l9 u2 k0 ~% M3 h 567  80486b7:       08
568  80486b8:       ae                      scas   %es%edi),%al
569  80486b9:       84 04 08                test   %al,(%eax,%ecx,1)
...
: E! ]6 e& }1 f  \0 n, ?$ A8 ?5 T+ Q

在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...执行效率高，属于典型的以空间换时间。也就是说，（套用算法的行话）以提高空间复杂度为代价降低了时间复杂度。

赞一个