C语言中，未初始化的局部变量到底是多少？

答案往往是：

• 与编译器有关。
• 可能但不保证初始化为0。
• 未确定。
  
  1 h; S! k1 S! h

总之，全部都是些一本正经的形而上答案，这很令人讨厌。

但凡一些人给你滔滔不绝地扯编译器，C库，处理器体系结构却给不出一个实际场景复现问题的时候，这人大概率在扯淡。

其实，这个问题本身就是错误的问法，说全了能讲10万字，我们只要能在特定场景下确定其特定行为就OK了，当然，这就需要设计一个比较OK的实验。

在演示一个实际代码行为之前，先给出一个知识，CPU不认识变量，更无法识别变量的名字，CPU只会从特定的内存位置取值或者将值存到特定的内存位置，因此当问一个变量的值是多少的时候，必须要知道这个变量对应的值被保存在什么地方。

来看下面的代码：

1. 
   * b5 }3 }+ M" W4 ]
2. #include <stdio.h>
   + A! S! M1 }- q5 X
3. 
   : \! b9 H. A, v2 Q1 {
4. void func1()
   # v* V8 i' \$ @. T  L; e
5. {
   0 u7 a5 m8 G$ }- \* O: P
6.   int a;
   / ?2 r' U9 X  p, r+ R9 P. ^) T
7.   printf("func1:%d\n", a);
   
8.   a = 12345;
   
9. }
   
10. 
    * f! j) e$ `0 R: U
11. void func2()
    
12. {
    * K/ g8 ~8 ?/ q/ U/ y+ w
13.   int b;
    8 T$ \0 F2 r+ X" j' g
14.   printf("func2:%d\n", b);
    - K" e) P+ G( X& ]
15. }
    . }; o) x$ U3 u: ^# @# ~  L
16. 
    & l! ?: n! {$ D. M: D* n
17. void func4()
    
18. {
    
19.   int d;
    ( \* J0 R, p) t; q+ S: E- ^
20.   printf("func3:%d\n", d);
    
21. }
    
22. 
    7 r0 x5 N, {- `0 Y: P* v& _
23. void func3()
    
24. {
    
25.   int c;
    
26.   printf("func3:%d\n", c);
    
27.   c = 54321;
    ( l% w# K% z8 W, |  ?! d: B6 t
28.   func4();
    
29. }
    
30. 
    / U" _& ]) N" O; C2 O; }7 \
31. void test_call()
    ' N  X( B* f& j, O2 M
32. {
    % b, c5 f8 r5 e" Y
33.   func3();
    
34. }
    4 }+ X" Z  l, N& k  L5 N' u7 C( Q
35. 
    ' F# m$ J6 ?) P6 Y" {! D' g8 J' V6 n2 z
36. int main(int argc, char **argv)
    & A4 _6 S! h$ u0 j
37. {
    - ~0 d  z/ J8 B+ W# H
38.   func1();
    , P6 \% ~, c  h; ^: ]) O
39.   func2();
    7 h+ a8 @. |$ P3 ~
40. 
    
41.   test_call();
    
42. }

复制代码

我们有func1～func4一共4个函数，其内部均有一个未初始化的局部变量，它们的值到底是多少呢？

对于这种局部变量，它们的值取决于：

• 变量在栈中的位置。
• 变量对应的栈位置在 之前 有没有被store过。
  
  # `- G' F1 P% t9 }  |& C

可以看到，上述第一点标记了一个内存位置，第二点则是代码的行为，也就是说，只要有代码去store对应的位置， 且后续的代码没有reset该位置的值的话，该位置就会保留着原先被store后的值。

验证非常简单，试一下就知道了：

1. 
   . L% Q. C& |3 x. y  z# E' \
2. [root@localhost test]# ./a.out
   
3. func1:0
   ( T: j# D% Q7 Q$ F/ q% x
4. func2:12345
   + f  P4 G8 _+ q% s0 u- K
5. func3:0
   ( b; c  s8 [4 l! s$ n# J  [6 m' E
6. func3:0

复制代码

• 按照函数调用栈帧的变化，func1的局部变量a和func2的局部变量b显然是位于同一个位置的，在func1被调用时，这是一块新的内存(可能在进入main之前有栈帧到达过这个位置)，a的值取决于调入内存该位置的页面对应偏移的初始值，这取决于操作系统：
• 
    |6 h% |1 ^1 f# c2 N8 F

• 操作系统在分配给程序页面时可能会将页面clear为零页。
  
  # ~/ V) l, o: r5 J, \) ^

栈的分配不会涉及C库，这里显然并不涉及C库的行为，但类似malloc分配的内存则涉及C库了。

打印结果，a的值为0，我们认为操作系统返回给了应用程序零页。接下来在func1中将其赋值12345之后函数返回，接下来调用func2的时候，在之前func1已经退出的栈帧位置重建栈帧，对应位置依然还是12345。

我没有看到func1的ret操作后面有stack清0的代码指令。效率考虑，也不该有这样的指令。

再看test_call函数，很明显，func3和func4调用使用的并不是同一个栈帧，因此即便是在func3中对c赋值了54321，也不会影响在其栈帧之上的func4的栈帧对应位置的值d。因此c和d的初始值均保持为0。

那么，初始化一个局部变量和不初始化一个局部变量，在指令层面上，区别在哪里呢？

很简单，亲眼看一下就知道，先看未初始化局部变量的func1：

1. 
   & ]; c1 M1 }2 K6 T6 \" |
2. // int a;
   
3. 00000000004005ad <func1>:
   * Z) E8 u% k" C3 {9 }) [6 a
4.   4005ad:   55                      push   %rbp
   , A8 h4 B& c& S- n9 D% ~2 R/ e
5.   4005ae:   48 89 e5                mov    %rsp,%rbp
   5 {/ T3 I) u- b( ^0 r& p$ o
6.   4005b1:   48 83 ec 10             sub    $0x10,%rsp
   
7.   4005b5:   8b 45 fc                mov    -0x4(%rbp),%eax
   5 S7 c4 a  Y" S+ v$ a
8.   4005b8:   89 c6                   mov    %eax,%esi
   " P3 u2 q: q4 t& q7 m
9.   4005ba:   bf 90 07 40 00          mov    $0x400790,%edi
   * Q8 t1 B: u; z2 s7 N0 |
10.   4005bf:   b8 00 00 00 00          mov    $0x0,%eax
    2 F' o. C+ @3 W* N8 S0 B, o
11.   4005c4:   e8 b7 fe ff ff          callq  400480 <printf@plt>
    
12.   4005c9:   c7 45 fc 39 30 00 00    movl   $0x3039,-0x4(%rbp)
    
13.   4005d0:   c9                      leaveq
    5 \' [  h7 X5 R8 N
14.   4005d1:   c3                      retq

复制代码

# m* P$ r" L. p' e6 s) P7 s! k+ x7 U

• 再看初始化局部变量a为2222的版本：
• 1. 
     - }" s# z4 ^! @# Y% L
  2. // int a = 2222;
     
  3. 00000000004005ad <func1>:
     ! j6 a* g9 q5 z$ j* Z9 G1 C  o
  4.   4005ad:   55                      push   %rbp
     
  5.   4005ae:   48 89 e5                mov    %rsp,%rbp
     5 `9 l' A% B/ J2 B
  6.   4005b1:   48 83 ec 10             sub    $0x10,%rsp
     
  7.   4005b5:   c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)
     
  8.   4005bc:   8b 45 fc                mov    -0x4(%rbp),%eax
     
  9.   4005bf:   89 c6                   mov    %eax,%esi
     & q$ y, u6 U) \
  10.   4005c1:   bf 90 07 40 00          mov    $0x400790,%edi
      
  11.   4005c6:   b8 00 00 00 00          mov    $0x0,%eax
      
  12.   4005cb:   e8 b0 fe ff ff          callq  400480 <printf@plt>
      8 B  I+ _2 S( b  I/ t) d
  13.   4005d0:   c7 45 fc 39 30 00 00    movl   $0x3039,-0x4(%rbp)
      
  14.   4005d7:   c9                      leaveq
      7 a, k3 ?1 E- t; J8 h* |( b
  15.   4005d8:   c3                      retq

  复制代码
• 仅仅差了一条指令：
• 1. 
     
  2. 4005b5:   c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)

  复制代码
  
  * ~9 e5 X7 U# g. y7 h

初始化的操作是依靠实实在在的指令完成的。

总结一句， 函数返回在pop出当前栈帧的时候，并不会清理它遗留在栈帧里的数据，下个函数调用再次重用到该栈帧的内存时，未初始化的局部变量将会被遗留数据影响，从而变得不确定！

所以，记得初始化你的局部变量。

, O6 k- A+ C( K7 j3 u% l