[导读]本文展示了14个C语言的迷题以及答案，代码应该是足够清楚的，而且有相当的一些例子可能是我们日常工作可能会见得到的。通过这些迷题，希望你能更了解C语言。如果你不看答案，不知道是否有把握回答各个谜题？让我们来试试。
( Z' ~8 V- Y8 Z1 T+ L

* p) X9 w" u0 b. i
本文展示了14个C语言的迷题以及答案，代码应该是足够清楚的，而且有相当的一些例子可能是我们日常工作可能会见得到的。通过这些迷题，希望你能更了解C语言。
+ N/ C! z- J* D3 x* ~7 }如果你不看答案，不知道是否有把握回答各个谜题？让我们来试试。

1

下面的程序并不见得会输出"hello-std-out"，你知道为什么吗？

1. #include
   
2. 
   
3.      
   
4. #include
   
5. 
   ' j! [, H4 M8 w" V  Q2 J# t
6.      
   
7. int main()
   
8. 
   : [: ~! p! i8 J" R* `( \" e; ?
9.      
   . G) m) d9 M8 H" h( X
10. {
    * X* \" p* D$ i6 z
11. 
    # r8 I# b8 k- u5 |3 n8 z4 [2 E
12.      
    
13. while(1)
    , o5 o4 g4 M  y3 E; Z/ P$ s  ?
14. 
    
15.      
    ! x4 a. w6 A/ y
16. {
    
17. 
    
18.      
    
19. fprintf(stdout,"hello-std-out");
    % u/ q& f( H4 P2 c6 q4 b
20. 
    5 t6 Q( [6 A* b4 C0 c# S
21.      
    
22. fprintf(stderr,"hello-std-err");
    : ]8 M% U1 |* d) N
23. 
    " u6 v$ {& S# i& V; e' ~
24.      
    ) W2 h. w* r0 T! H7 S# B
25. sleep(1);
    
26. 
    
27.      
    
28. }
    
29. 
    ( Z7 }7 ]* r3 p: q; g; y4 D9 _
30.      
    
31. return 0;
    
32. 
    
33.      
    & j8 O7 Y( T( i) L" O$ z
34. }
    

复制代码

0 C) x+ [9 C+ }参考答案stdout和stderr是不同设备描述符。stdout是块设备，stderr则不是。对于块设备，只有当下面几种情况下才会被输入：遇到回车；缓冲区满；flush被调用。而stderr则不会。
9 R/ u' i* E1 o4 z, c2 q
2
* n  @0 I# f% L" I* y0 Y
下面的程序看起来是正常的，使用了一个逗号表达式来做初始化。可惜这段程序是有问题的。你知道为什么吗？

1. #include
   ( |# @2 F+ Y% D# T
2. 
   2 b5 s9 a3 d3 p3 C
3.      
   
4. int main()
   
5. 
   
6.      
   9 ?3 G/ U( R9 X8 J, h2 [3 L7 M7 W
7. {
   
8. 
   " j  x5 d; m3 `7 F# G
9.      
   ( D1 |6 O1 N8 Q; F* f
10. int a = 1,2;
    
11. 
    
12.      
    
13. printf("a : %d\n",a);
    
14. 
    : [4 W; [% K% |/ J/ ]0 |  J$ j
15.      
    % K$ U5 ^* O& A+ a1 n
16. return 0;
    
17. 
    
18.      
    
19. }

复制代码

, i6 f7 _5 R* S! Q
, H1 S: P  R. i6 D参考答案这个程序会得到编译出错（语法出错）。逗号表达式是没错，可是在初始化和变量声明时，逗号并不是逗号表达式的意义。这点要区分，要修改上面这个程序，你需要加上括号："int a = (1,2);"。
5 q3 ?6 @$ l8 b- Y0 z9 x3 g! l
3

下面的程序会有什么样的输出呢？

1. #include
   
2. 
   
3.      
   ( e+ i$ P; G7 J( `( ^
4. int main()
   9 \- H3 y2 V% ^% m
5. 
   
6.      
   ( f4 w+ ?! ^% E6 k/ ]: n0 J
7. {
   
8. 
   # e& u1 g4 V) _+ k- E3 r2 w
9.      
   
10. int i=43;
    + i' J) w5 T4 v4 d! i6 f7 t
11. 
    & C, c* A# E4 K  a7 p( ^8 F# _
12.      
    : V' p% `% d( s/ d4 v
13. printf("%d\n",printf("%d",printf("%d",i)));
    
14. 
    
15.      
    
16. return 0;
    : \- o5 h% {; ~, u0 c  s
17. 
    
18.      
      T2 r3 F3 w  ~, a" U# B4 @  [" d
19. }

复制代码

; p* b! ^3 Q0 n- e, c参考答案程序会输出4321，你知道为什么吗？要知道为什么，你需要知道printf的返回值是什么。printf返回值是输出的字符个数。

9 h3 o1 G- P0 |/ [2 G4
, a+ A8 g! [& S
8 a2 r* m- ?$ O3 @, _下面的程序会输出什么？

1. #include
   
2. 
   " X) ]5 m, W, Q2 S; Z/ l5 X4 q
3.      
   8 o& e+ [0 V6 ]) `( k2 d: [
4. int main()
   
5. 
   * u- x8 [/ W2 q
6.      
   + [0 G. T, [3 ^0 G) M8 w5 J& h
7. {
   5 O& r9 ]' U( i+ [2 L3 X5 b
8. 
   & P6 \$ u3 B4 i# O$ B( d- n2 X- E
9.      
   4 w! f- |: a' g5 c5 @& Y6 Y
10. float a = 12.5;
    3 h9 |9 _  d9 L+ K& h4 z
11. 
    
12.      
    ' n( t( q& ^' v! j
13. printf("%d\n", a);
    $ V. l% ]" e6 G7 |, J
14. 
    7 J( L+ ~% z# y! i7 Q8 b2 }* a
15.      
    
16. printf("%d\n", (int)a);
    
17. 
    
18.      
    : B  X7 m8 t/ z8 h0 N1 l
19. printf("%d\n", *(int *)&a);
    3 K* w' J! k& ?3 O1 p! A0 c9 c. [
20. 
    
21.      
    
22. return 0;
    - p  Q  `1 J* t) s9 u# @
23. 
    , ^2 ^2 F/ G# y  e
24.      
    % Q. C8 a1 ]5 F% F. z6 l: T; i
25. }

复制代码

参考答案该项程序输出："0 12 1095237632"。
0 h9 D' |/ Z% y5 O: k原因是：浮点数是4个字节，12.5f转成二进制是：01000001010010000000000000000000，十六进制是：0x41480000，十进制是：1095237632。所以，第二和第三个输出相信大家也知道是为什么了。
' a1 d" C( l) N! u9 [  G而对于第一个，为什么会输出0，我们需要了解一下float和double的内存布局，如下：
• float: 1位符号位(s)、8位指数(e)，23位尾数(m,共32位)。• double: 1位符号位(s)、11位指数(e)，52位尾数(m,共64位)。
7 q1 {- M9 q' ~然后，我们还需要了解一下printf由于类型不匹配，所以，会把float直接转成double，注意，12.5的float和double的内存二进制完全不一样。别忘了在x86芯片下使用是的反字节序，高位字节和低位字位要反过来。所以：• float版：0x41480000 (在内存中是：00 00 48 41)。
; J9 m5 \1 ?5 C/ D3 _4 v2 s  K7 ^• double版：0x4029000000000000 (在内存中是：00 00 00 00 00 00 29 40)。
& l* _3 I/ n. ~* ?' X# Q5 l/ y
而我们的%d要求是一个4字节的int，对于double的内存布局，我们可以看到前四个字节是00，所以输出自然是0了。这个示例向我们说明printf并不是类型安全的，这就是为什么C++要引如cout的原因了。

$ U, f' a) m7 Y; I" |# T
5
: ]2 R' a, F, N, S$ k6 U! |+ F
下面，我们再来看一个交叉编译的事情，下面的两个文件可以编译通过吗？如果可以通过，结果是什么？

1. //file1.cint arr[80];
   
2. 
   
3.      
   6 J( Q; o: Q, C5 ~: x! ~" P8 Z
4. //file2.cextern int *arr;
   
5. 
   
6.      
   3 o5 n# T+ ^/ ]. _' l+ t
7. int main()
   ( ]$ L7 n4 ^1 ]2 L; |, o$ E
8. 
   1 f+ O  ]6 S( S( i+ z
9.      
     q; z, g; f( I- W: A
10. {
    ; T6 f2 f# a6 d: s1 G; r0 o
11. 
    
12.      
    8 ]- o4 C# O1 w) ~
13. arr[1] = 100;
    / o8 l- j0 W# @4 t# v
14. 
    / s5 a9 a3 W; j7 J- U  i
15.      
    
16. printf("%d\n", arr[1]);
    
17. 
    
18.      
    
19. return 0;
    7 n8 A9 B, L! {4 G4 a
20. 
    + r$ ^- [; s3 s, q% c2 Q/ q3 ?
21.      
    ' h' O) K( y3 n3 c+ O7 Q3 i0 n
22. }

复制代码

   
参考答案该程序可以编译通过，但运行时会出错。为什么呢？原因是，在另一个文件中用 extern int *arr来外部声明一个数组并不能得到实际的期望值，因为他们的类型并不匹配。所以导致指针实际并没有指向那个数组。
注意：一个指向数组的指针，并不等于一个数组。
7 b2 U( d6 J; t* }2 w修改："extern int arr[]"。
2 V3 i- l* u7 C
4 F& J  A) H1 B$ g6
3 D/ [. f7 `/ E9 [
7 N1 J. t6 |- i+ G) @$ c; ?; p3 `请说出下面的程序输出是多少？并解释为什么？（注意，该程序并不会输出"b is 20"）

1. #include
   1 t# T3 a. ^0 \) T( Z3 y9 |0 ^8 L
2. 
   
3.      
     }$ y! A- ?8 G. E7 j6 i& ~
4. int main()
   
5. 
   
6.      
   ( V! Y. X, g$ w; r
7. {
   . c1 H7 v8 r+ @6 ?  s5 k2 Q
8. 
   
9.      
   9 c- o4 I! A1 @( _' m! J
10. int a=1;
    " x$ h9 o0 a' e6 B% ]  n
11. 
    
12.      
    7 \1 u/ L+ M8 {9 y, c
13. switch(a)
    
14. 
    
15.      
    5 p( [& {8 h* O* n( S6 M
16. {
    . p1 K5 K8 G- ^. q% g; [4 }9 J4 X
17. 
    
18.      
    ! ~& q# R" H& C" c1 q( i$ \
19. int b=20;
    
20. 
    
21.      
    7 e  a/ m/ Z' p/ b1 I* g9 Y% l
22. case 1:
      N* p1 _9 L, F* U1 n5 q
23. 
      P8 H8 \" K. ^- b# V
24.      
    
25. printf("b is %d\n",b);
    8 L4 L1 S- n4 h3 t
26. 
    
27.      
    + `2 m. ?! R+ t, s3 m
28. break;
    ! Y3 [0 ?& [! F1 H* T! f0 M" O
29. 
    5 G# p* o, j; A) Z
30.      
    # q9 w3 D! p  w  T, q
31. default:
    
32. 
    ( m2 [9 E* ~- Y8 J( i  o
33.      
    . x. a- ^8 }: u0 T9 [" k6 G
34. printf("b is %d\n",b);
    : j, l8 r7 a* K2 _3 y( Q
35. 
    
36.      
    
37. break;
    
38. 
    ; o# j6 I- Y4 P2 h% v2 m# }
39.      
    
40. }
    
41. 
    : u- M# @) @' c  L
42.      
    ! E% [1 ?7 V! \) S7 D$ z2 S" W
43. return 0;
    
44. 
    ; z/ j% w, q% @/ n
45.      
    5 z( Q: V6 ~0 f- ?
46. }

复制代码

3 I3 f, j. T( B! @/ o
参考答案该程序在编译时，可能会出现一条warning: unreachable code at beginning of switch statement。我们以为进入switch后，变量b会被初始化，其实并不然，因为switch-case语句会把变量b的初始化直接就跳过了。所以，程序会输出一个随机的内存值。
. O0 Z( O! R! X5 A8 Z
6 Y& z+ f$ P& W5 p0 {, _- ]; a* f# ^7
1 A9 H4 b" S  U& h; C( a5 L" h$ N
. n4 C) q# z; b6 E" I请问下面的程序会有什么潜在的危险？

1. #include
   7 W# {' F  u* s1 O2 R
2. 
   2 k6 {% q* N6 d1 p# x
3.      
   
4. int main()
   , n$ I* z& X5 n' _
5. 
   
6.      
   1 f. j8 c4 T) t
7. {
   
8. 
   7 g5 b5 k9 V2 E7 Y/ P
9.      
   ; e/ c: Y/ j- z+ P6 J; x
10. char str[80];
    2 x: d( U) b. V, i
11. 
    
12.      
    - P1 `. Y: U7 P/ m
13. printf("Enter the string:");
    & P; F/ O# @% }2 x0 I
14. 
    $ H5 Y, |1 c* K
15.      
    
16. scanf("%s",str);
    - ?0 v3 y) i& n* v
17. 
    1 B# S# T8 s! F1 N% w6 q- i
18.      
    3 T) Y6 `8 T/ o1 O( p
19. printf("You entered:%s\n",str);
    6 _. a. ]( z+ H% y& h% Q' J$ i* V2 W
20. 
    
21.      
    & r" ~2 ~# g" i; E( {; ^& I. i7 I- [
22. return 0;
    
23. 
    
24.      
    , ~$ n# e5 ~/ ^, J% C/ u, P
25. }

复制代码

: c: U. J; ]3 Z: ~3 A参考答案本题很简单了。这个程序的潜在问题是，如果用户输入了超过80个长度的字符，那么就会有数组越界的问题了，你的程序很有可能会crash了。
# t1 x7 U* P2 x! k
8
" ^+ j+ j' v3 ?' i( A$ z! Z
请问下面的程序输出什么？

1. #include
   
2. 
   0 o, o# f, I- N) W  _
3.      
   # j/ \4 S% c5 @) L! F
4. int main()
   / B& x9 E" b  P4 E& d
5. 
   
6.      
   8 t( }. }: z( x$ A) s, }
7. {
   
8. 
   
9.      
   
10. int i;
    / c8 l! X4 d$ q; F
11. 
    
12.      
    + h- A# K, h  ^# U/ R8 C# K
13. i = 10;
    5 `1 y- I& g7 t
14. 
    3 t* z% I8 f7 e
15.      
    
16. printf("i : %d\n",i);
    # L' V+ t. R4 j) T
17. 
    
18.      
    * }, K( m5 b1 r1 [, V
19. printf("sizeof(i++) is: %d\n",sizeof(i++));
    / i) E4 x5 a# _& b0 O0 [, l* c
20. 
    9 q' B+ y; W* D2 ^
21.      
    
22. printf("i : %d\n",i);
    ) G  {+ p6 o- P7 ^) S8 E
23. 
    
24.      
    3 {2 F1 C0 m6 g% V0 o
25. return 0;
    ( L. c( }% {# A
26. 
    0 }6 K4 D  ^# u9 b/ ]& E+ K  K; f
27.      
    : L7 e* ~+ R/ }& h  K  }9 r7 M
28. }

复制代码

参考答案如果你觉得输出分别是：10，4，11。那么你就错了。
错在了第三个，第一个是10没有什么问题，第二个是4，也没有什么问题，因为是32位机上一个int有4个字节。但是第三个为什么输出的不是11呢？居然还是10？原因是，sizeof不是一个函数，是一个操作符，其求i++的类型的size，这是一件可以在程序运行前（编译时）完全的事情，所以，sizeof(i++)直接就被4给取代了，在运行时也就不会有了i++这个表达式。

" r9 S) E+ d6 V$ F9
6 `+ @8 K- y- b! y- G
% P) E- f8 ]! S" @" f# E) \- {请问下面的程序的输出值是什么？

1. #include
     Y2 S( x$ m5 z! d4 a: U# _
2. 
   3 q  s' v: d. u5 T
3.      
   
4. #include
   
5. 
   
6.      
   
7. 
   
8. 
   
9.      
   ; T  V( w- a1 g! T+ H* d, m/ a* y
10. #define SIZEOF(arr) (sizeof(arr)/sizeof(arr[0]))
    
11. 
    ( [6 j0 C- w  b
12.      
    . J5 @9 y. \) i
13. #define PrintInt(expr) printf("%s:%d\n",#expr,(expr))
    6 |" H1 }. ^# ]
14. 
    8 B& \: I0 N! p" @
15.      
    8 G$ _" q- U. z$ p
16. 
    1 Z$ U$ P$ y) r! `) Q' B" d' Y
17. 
    
18.      
    
19. int main()
    
20. 
    
21.      
    . j' F9 U3 d9 v: Y# F- f& g
22. {
    
23. 
    7 q  o- o3 S$ ], K4 f
24.      
    & g5 Z* g! \4 ?3 A1 ]
25. /* The powers of 10 */
    0 s% W& K0 K2 w' {) q  b
26. 
    ' H( k, {) E% `: h6 q
27.      
    * Q9 |9 d  N! N4 r$ }
28. int pot[] = {
    0 t( [! V+ B  @0 v
29. 
    
30.      
    9 Y$ U) @0 m( M) Y: ?
31. 0001,
    
32. 
    
33.      
    1 m- I, o6 G; h) K* k. l
34. 0010,
    
35. 
    $ p9 f5 |; O  [8 h. J! Z
36.      
    * W  [7 `9 R; j  ?
37. 0100,
    
38. 
    
39.      
    ' i8 j/ I8 s/ C0 l  ?! y
40. 1000
    
41. 
    
42.      
    
43.       };
    
44. 
    / g# o5 j, ~. h  T& f7 L8 D
45.      
      @8 |# Y' u- n8 T% K
46. 
    
47. 
    
48.      
    
49. int i;
    
50. 
    
51.      
    
52. for(i=0;i
    
53. 
    
54.      
    
55. return 0;
    
56. 
    ( K! L3 _: y6 ?" W0 C) B& @
57.      
    
58. }
    

复制代码

' Y! a* \: A4 x: E8 s1 U7 _参考答案如果你对于PrintInt这个宏有问题的话，可以去看一看资料。不过，本例的问题不在这里，本例的输出会是：1，8，64，1000。其实很简单了，在C/C++中，以0开头的数字都是八进制的。
  j3 G5 ?! [3 ^) e8 F$ r# q
10
/ {  q' q5 O+ U2 u" D
7 M1 Q+ [' P4 q- b* k请问下面的程序输出是什么？（绝对不是10）

1. #include
   
2. 
   ) O, B9 W5 ~& a
3.      
   $ G! U6 h, J5 X" a7 @
4. #define PrintInt(expr) printf("%s : %dn",#expr,(expr))
   
5. 
   ! Q" L2 F4 c! y( }0 b2 k  a, @
6.      
   8 ^6 G* i7 L' X$ s
7. int main()
   # T; K+ a0 }$ O
8. 
   
9.      
   1 c6 D7 R* Q4 v
10. {
    ; K  x) G- P  s9 [1 F6 \( s
11. 
    
12.      
    
13. int y = 100;
    ) b) O; {- R3 U$ o
14. 
    2 e2 X0 [) ^4 x# f8 w
15.      
    
16. int *p;
    
17. 
    & C7 @' J; J: x) _( \/ j
18.      
    
19. p = malloc(sizeof(int));
    
20. 
    
21.      
    " N8 d/ G2 c, k
22. *p = 10;
    $ ~5 Q+ D! F1 e0 r. o/ ]
23. 
    & R9 M2 z1 A  _1 s1 [6 Y* U7 Z
24.      
    
25. y = y/*p; /*dividing y by *p */;
    6 O: o+ W1 ^& H; m
26. 
    , q# [2 O) r. O* o
27.      
    
28. PrintInt(y);
    
29. 
    0 w, w. g6 V4 _/ P4 L+ p
30.      
    
31. return 0;
    - j$ S7 x( u) X/ x
32. 
    ' \! f# Z1 e- }$ V( n3 Y
33.      
    % y7 a; s/ Q. J9 u5 o" a0 G
34. }

复制代码

8 V! x. n+ }' w. u/ ^, ?参考答案本题输出的是100。为什么呢？问题就出在"y = y/*p;"上了，我们本来想的是"y / (*p)"，然而，我们没有加入空格和括号，结果"y/*p"中的"/*"被解释成了注释的开始。于是，这也是整个恶梦的开始。

11
: V+ G7 [$ ^% S& V% L  `# w  J7 v
6 z+ w; {- Q% S) b2 b5 O" m6 w下面的输出是什么？

1. #include
   
2. 
   # T4 z, r# G5 ^# h) n
3.      
   
4. int main()
   ' |$ ~0 v7 c. J/ ~: J
5. 
   0 J( P' }, B* v- j) r$ ^5 D
6.      
   
7. {
   
8. 
   
9.      
   
10. int i = 6;
    
11. 
    8 _7 g% |: C0 F  x) h) ?
12.      
    
13. if( ((++i < 7) && ( i++/6)) || (++i <= 9));
    # h  e: b4 r/ k+ j
14. 
    / r* i; x, e$ b7 @0 M: C/ x
15.      
    " ~* {- A. \) `$ `! e% x/ b$ ^' P
16. printf("%d\n",i);
    
17. 
    / U1 t: {( {6 j* z/ X8 G4 }, P9 ^
18.      
    
19. return 0;
    4 j, ~, O/ O1 x
20. 
    
21.      
    . a6 _6 q: T( S; c
22. }

复制代码

   
* M: S$ m6 m6 a3 M9 Y参考答案本题并不简单的是考前缀++或反缀++，本题主要考的是&&和||的短路求值的问题。
所谓短路求值：对于（条件1 && 条件2），如果“条件1”是false，那“条件2”的表达式会被忽略了。对于（条件1 || 条件2），如果“条件1”为true，而“条件2”的表达式则被忽略了。
所以，我相信你会知道本题的答案是什么了。
4 c# K5 @& \3 O. e- j" |, L
12

下面的C程序是合法的吗？如果是，那么输出是什么？

1. #includeint main(){int a=3, b = 5;printf(&a["Ya!Hello! how is this? %s\n"], &b["junk/super"]);printf(&a["WHAT%c%c%c %c%c %c !\n"], 1["this"],2["beauty"],0["tool"],0["is"],3["sensitive"],4["CCCCCC"]);return 0;}
   $ D8 B) y2 A( g

复制代码

) j! d* E5 G; l0 n
# ~' T5 z) y8 E" O. X6 i5 l1 L参考答案本例是合法的，输出为："Hello! how is this? super That is C !"
本例主要展示了一种另类的用法。下面的两种用法是相同的：• "hello"[2]• 2["hello"]
如果你知道：a 其实就是 *(a+i)也就是 *(i+a)，所以如果写成 i[a] 应该也不难理解了。

13
1 E/ r4 \' o8 h, k. P  E; h$ V
1 l% S6 {7 ]3 G0 x0 @0 m7 K: K请问下面的程序输出什么？（假设：输入"Hello, World"）

1. #include
   
2. 
   
3.      
   
4. int main()
   3 s/ }9 K( ^; V+ ]% }3 P
5. 
   
6.      
   
7. {
   
8. 
   % x( r! z* o  R0 Z8 [) M
9.      
   " B5 O3 A& d6 b+ d" h
10. char dummy[80];
    7 c5 P) d+ D7 x* F' z) r
11. 
    8 N8 M) |0 M- [' M
12.      
    4 `) m+ P9 Z9 z+ N% `5 l5 G
13. printf("Enter a string:\n");
    $ Q! x- p4 _2 X
14. 
    
15.      
    : k4 y- R! D% @6 [
16. scanf("%[^r]",dummy);
    & v- g: }( E6 d
17. 
    ( u: D+ T( w0 e: m% q
18.      
    
19. printf("%s\n",dummy);
    
20. 
    ! r; j1 |7 I% ]# q0 E) f
21.      
    - G( r6 p, m: f& e$ n. {$ f
22. return 0;
    * J' t$ G# T) D2 c: P9 b6 u; n/ W
23. 
      B- d8 b  {. J2 j1 T$ h
24.      
    ; U$ f# t" [( Y% @; d
25. }

复制代码

参考答案本例的输出是"Hello, Wo"。scanf中的"%[^r]"是从中作梗的东西，意思是遇到字符r就结束了。

7 m/ G  d0 s! n+ C  q14
$ c+ d8 ~$ z" S0 z6 ~4 p
: s. r. r' E7 K8 q$ C/ K下面的程序试图使用"位操作"来完成"乘5"的操作，不过这个程序中有个BUG，你知道是什么吗？

1. #include
   
2. 
   
3.      
   
4. #define PrintInt(expr) printf("%s : %d\n",#expr,(expr))
   , p5 ]4 i( p% N* b
5. 
   ' }! n' ~6 }) B; w
6.      
   8 _% y/ d8 s# t; i' O/ c
7. int FiveTimes(int a)
   
8. 
   
9.      
   # X2 Y/ l' m/ Z7 m
10. {
    
11. 
    
12.      
    & v; V1 ?% q4 x9 e/ t  j
13. int t;
    ! U! V6 o; o$ N& W" }1 V8 Y. Y+ i
14. 
    , e, k: |# a9 r+ I1 O$ G
15.      
    ) Y, M: {3 }% s" l3 L8 z
16. t = a<<2 + a;
    6 j$ Q, d  a  N6 ]
17. 
    
18.      
    
19. return t;
    
20. 
    
21.      
    ( F2 f& Y- h0 R, p
22. }
    
23. 
    ) T# `' H6 S5 a+ |+ K  P. }
24.      
    
25. int main()
    
26. 
    / M3 _8 k1 C7 C4 h
27.      
    
28. {
    - X8 Z: o7 a4 H. g! }
29. 
    - ^! N1 ]8 U$ ^
30.      
    2 j& z  F4 Q/ h' o% T5 [
31. int a = 1, b = 2,c = 3;
    
32. 
    
33.      
    : M3 N" l$ R" ?. t" ?2 a
34. PrintInt(FiveTimes(a));
    0 c" \' B/ X% _4 l/ e
35. 
    
36.      
    
37. PrintInt(FiveTimes(b));
    
38. 
    
39.      
      X4 m4 Z( s: H2 A6 X5 U
40. PrintInt(FiveTimes(c));
    
41. 
    
42.      
    # C1 t; q% W+ Q' H
43. return 0;
    ; y( t; o, ^' ]: u5 k# b9 e
44. 
    ' K9 o9 W+ p" m, p
45.      <span style="color: rgb(51, 51, 51); font-family: monospace; font-size: 15px; white-space: pre-wrap; background-color: rgb(255, 255, 255);">}</span>

复制代码

  

% G: W& e+ p+ y0 i  ?; h6 E% O
% I: [" E& }3 M! Q# Y8 r2 @0 O参考答案本题的问题在于函数FiveTimes中的表达式"t = a<<2 + a;"。对于a<<2这个位操作，优先级要比加法要低，所以这个表达式就成了"t = a << (2+a)"，于是我们就得不到我们想要的值。
该程序修正如下：

1. int FiveTimes(int a)
   - s! P9 A' p9 R6 |& a4 U
2. 
   : y1 o/ X8 V# g& }
3.          
   
4. {
   
5. 
   7 _" Q8 f) B& T, P& u
6.          
   7 A3 q4 n) V3 q9 ?9 R9 Q5 ~( m* C
7.       int t;
   
8. 
   2 ?9 B3 z/ E8 X$ b
9.          
   
10.       t = (a<<2) + a;
    / |4 `4 W) D3 _( [
11. 
    # |  x  M1 P& F$ w
12.          
    " Q  P2 Q* B3 G, j; T8 @" p
13.       return t;
    2 G* M0 ^# H/ t5 I5 J
14. 
      R, r0 J1 _1 a! k* ^( v
15.          
    3 g' R0 ?9 l1 z; R
16. }

复制代码

感谢