全局变量与局部变量初始化问题

头文件：

[cpp]  view plain copy print ?

1. #ifndef FRIEND_H  
2. #define FRIEND_H  
3. struct X;  
4.   
5. struct Y{  
6.     void f(X*);  
7. };  
8. struct X{  
9. private :  
10.     int i;  
11. public :  
12.     void initialize();  
13.     friend void g(X *x ,int);  
14.     friend void Y::f(X*);  
15.     friend struct Z;  
16.     friend void h();  
17. };  
18.   
19. struct Z{  
20. private :  
21.     int j;  
22. public :  
23.     void initialize();  
24.     int g(X*);  
25.   
26. };  
27. #endif  

 

cpp文件：

[cpp]  view plain copy print ?

1. #include "friend.h"  
2. void X::initialize(){  
3.     i = 0;  
4. }  
5.   
6. void g(X* x,int i){  
7.     x->i = i;  
8. }  
9.   
10. void Y::f(X* x){  
11.     x->i = 47;  
12. }  
13.   
14. void Z::initialize(){  
15.     j = 99;  
16. }  
17.   
18. int Z::g(X* x){  
19.     x->i += j;  
20.     return x->i;  
21. }  
22.   
23. void h(){  
24.     X x;  
25.     x.i = 100;  
26. }  

第一种情况：

main函数（定义全局结构体变量）：

[cpp]  view plain copy print ?

1. #include "friend.h"  
2. #include <iostream>  
3. using namespace std;  
4. X x;  
5. Z z;  
6. int main() {  
7.     cout << z.g(&x);  
8.     return 0;  
9. }  

在这种情况下，输出结果为0。因为x和z为全局结构体变量，x和z中的成员变量被自动初始化为默认值（int初始化为0），所以得到的结果为0。

 

第二种情况：

main函数（定义局部结构体变量，并且不调用initialize函数）：

[cpp]  view plain copy print ?

1. #include "friend.h"  
2. #include <iostream>  
3. using namespace std;  
4. int main() {  
5.     X x;  
6.     Z z;  
7.     cout << z.g(&x);  
8.     return 0;  
9. }  

在这种情况下，输出结果为一个随机值。因为x和z为局部结构体变量，x和z中的成员变量不会被自动初始化，而我们也没有手动对其成员变量初始化，其成员变量是一个随机值，所以的得到的结果为一个随机值。这种情况相当危险，甚至导致程序出错。

 

第三种情况：

main函数（定义局部结构体变量，并且调用initialize函数）：

[cpp]  view plain copy print ?

1. #include "friend.h"  
2. #include <iostream>  
3. using namespace std;  
4. int main() {  
5.     X x;  
6.     Z z;  
7.     x.initialize();  
8.     z.initialize();  
9.     cout << z.g(&x);  
10.     return 0;  
11. }  

在这种情况下，输出结果为99。因为x和z为局部结构体变量，x和z中的成员变量不会被自动初始化，而我们手动对其成员变量初始化，其成员变量被初始化为指定值(x的成员变量i初始化为0，y的成员变量j初始化为99)，所以的得到的结果为99。

 

 

综上所述，当我们定义变量时，如果定义为全局变量，系统会自动把变量初始化为默认值(内置类型初始化为系统默认值，自定义类型调用相应的初始化函数进行初始化)，而定义为局部变量时，系统不会自动初始化变量，我们必须手动对变量进行初始化(无论是内置类型还是自定义类型)，否则得到的结果可能和我们预期的不一致，甚至导致程序出错。

原文地址：http://blog.csdn.net/ygc87/article/details/6862198