[已解决]关于结构体的默认初始化问题

孤不冷cing

看了大佬们的回复，感觉自己C的门还没摸到，任重而道远啊

1. $ cat test3.c
   
2. #include <stdio.h>
   
3. 
   
4. struct Imfor{
   
5.         char *name;
   
6. };
   
7. 
   
8. int main(void)
   
9. {
   
10.         struct Imfor imfor;
    
11. 
    
12.         if (imfor.name == NULL)
    
13.                 printf("imfor.name == NULL\n");
    
14. 
    
15.         return 0;
    
16. }
    
17. $ gcc test3.c -o test3 && ./test3
    
18. imfor.name == NULL
    

复制代码

1. $ cat test4.c
   
2. #include <stdio.h>
   
3. 
   
4. struct Imfor{
   
5.         char name[10];
   
6. };
   
7. 
   
8. int main(void)
   
9. {
   
10.         struct Imfor imfor;
    
11. 
    
12.         if (imfor.name == NULL)
    
13.         {
    
14.                 printf("imfor.name == NULL\n");
    
15.         }
    
16.         else if (imfor.name[0] == '\0')
    
17.         {
    
18.                 printf("imfor.name[0] == '\\0'\n");
    
19.         }
    
20. 
    
21.         return 0;
    
22. }
    
23. $ gcc test4.c -o test4 && ./test4
    
24. imfor.name[0] == '\0'
    

复制代码

在小甲鱼的C教程里说，未初始化的会自动初始化为'\0'，为什么字符指针是初始化为NULL啊
结构体中其他类型的变量又会初始化成什么呢

最佳答案

月排行榜 / 总排行榜

jackz007

2022-11-25 22:09:24

        分别用 gcc 和 VC9.0 编译下面的代码，研究一下反汇编代码，看看是否真的有变量的初始化

1. #include <stdio.h>
   
2. 
   
3. int main(void)
   
4. {
   
5.         struct node {
   
6.                 int i               ;
   
7.                 int * p             ;
   
8.         } dx                        ;
   
9.         printf("i = %d\n" , dx . i) ;
   
10.         printf("p = %p\n" , dx . p) ;
    
11. }

复制代码

       【tdm-gcc 5.1.0】：

1. 00401350  /$  55                         push    ebp                                   main() 入口
   
2. 00401351  |.  89E5                       mov     ebp, esp
   
3. 00401353  |.  83E4 F0                    and     esp, FFFFFFF0
   
4. 00401356  |.  83EC 20                    sub     esp, 20                               <--- 堆栈分配 0x20 字节供局部变量使用
   
5. 00401359  |.  E8 E2050000                call    00401940                                            
   
6. 0040135E  |.  8B4424 18                  mov     eax, dword ptr [esp+18]               <--- dx . i - 直接使用，未经任何初始化
   
7. 00401362  |.  894424 04                  mov     dword ptr [esp+4], eax                <--- dx . i 入栈，准备显示
   
8. 00401366  |.  C70424 24304000            mov     dword ptr [esp], 00403024             ; ||ASCII "i = %d"
   
9. 0040136D  |.  E8 3E080000                call    <jmp.&msvcrt.printf>                  ; |\printf()
   
10. 00401372  |.  8B4424 1C                  mov     eax, dword ptr [esp+1C]               <--- dx . p - 直接使用，未经任何初始化                           
    
11. 00401376  |.  894424 04                  mov     dword ptr [esp+4], eax                <--- dx . p 入栈，准备显示                             
    
12. 0040137A  |.  C70424 2C304000            mov     dword ptr [esp], 0040302C             ; |ASCII "p = %p"
    
13. 00401381  |.  E8 2A080000                call    <jmp.&msvcrt.printf>                  ; \printf()
    
14. 00401386  |.  B8 00000000                mov     eax, 0
    
15. 0040138B  |.  C9                         leave
    
16. 0040138C  \.  C3                         retn

复制代码

        【VC9.0】

1. 00401000  /$  55                         push    ebp                                   main() 入口
   
2. 00401001  |.  8BEC                       mov     ebp, esp
   
3. 00401003  |.  83EC 08                    sub     esp, 8                                <--- 堆栈分配 0x08 字节供局部变量使用
   
4. 00401006  |.  8B45 F8                    mov     eax, dword ptr [ebp-8]                dx . i - 直接使用，未经任何初始化
   
5. 00401009  |.  50                         push    eax                                   <--- dx . i 入栈，准备显示
   
6. 0040100A  |.  68 00C04000                push    0040C000                              ;  ASCII "i = %d"
   
7. 0040100F  |.  E8 1A000000                call    0040102E                              <--- printf()
   
8. 00401014  |.  83C4 08                    add     esp, 8
   
9. 00401017  |.  8B4D FC                    mov     ecx, dword ptr [ebp-4]                <--- dx . p - 直接使用，未经任何初始化
   
10. 0040101A  |.  51                         push    ecx                                   <--- dx . p 入栈，准备显示
    
11. 0040101B  |.  68 08C04000                push    0040C008                              ;  ASCII "p = %p"
    
12. 00401020  |.  E8 09000000                call    0040102E                              <--- printf()
    
13. 00401025  |.  83C4 08                    add     esp, 8
    
14. 00401028  |.  33C0                       xor     eax, eax
    
15. 0040102A  |.  8BE5                       mov     esp, ebp
    
16. 0040102C  |.  5D                         pop     ebp
    
17. 0040102D  \.  C3                         retn

复制代码

        最后结论就是，不要想太多，编译器绝对不会为你初始化任何一个变量

跳转到最佳答案楼层

jackz007

        分别用 gcc 和 VC9.0 编译下面的代码，研究一下反汇编代码，看看是否真的有变量的初始化

1. #include <stdio.h>
   
2. 
   
3. int main(void)
   
4. {
   
5.         struct node {
   
6.                 int i               ;
   
7.                 int * p             ;
   
8.         } dx                        ;
   
9.         printf("i = %d\n" , dx . i) ;
   
10.         printf("p = %p\n" , dx . p) ;
    
11. }

复制代码

       【tdm-gcc 5.1.0】：

1. 00401350  /$  55                         push    ebp                                   main() 入口
   
2. 00401351  |.  89E5                       mov     ebp, esp
   
3. 00401353  |.  83E4 F0                    and     esp, FFFFFFF0
   
4. 00401356  |.  83EC 20                    sub     esp, 20                               <--- 堆栈分配 0x20 字节供局部变量使用
   
5. 00401359  |.  E8 E2050000                call    00401940                                            
   
6. 0040135E  |.  8B4424 18                  mov     eax, dword ptr [esp+18]               <--- dx . i - 直接使用，未经任何初始化
   
7. 00401362  |.  894424 04                  mov     dword ptr [esp+4], eax                <--- dx . i 入栈，准备显示
   
8. 00401366  |.  C70424 24304000            mov     dword ptr [esp], 00403024             ; ||ASCII "i = %d"
   
9. 0040136D  |.  E8 3E080000                call    <jmp.&msvcrt.printf>                  ; |\printf()
   
10. 00401372  |.  8B4424 1C                  mov     eax, dword ptr [esp+1C]               <--- dx . p - 直接使用，未经任何初始化                           
    
11. 00401376  |.  894424 04                  mov     dword ptr [esp+4], eax                <--- dx . p 入栈，准备显示                             
    
12. 0040137A  |.  C70424 2C304000            mov     dword ptr [esp], 0040302C             ; |ASCII "p = %p"
    
13. 00401381  |.  E8 2A080000                call    <jmp.&msvcrt.printf>                  ; \printf()
    
14. 00401386  |.  B8 00000000                mov     eax, 0
    
15. 0040138B  |.  C9                         leave
    
16. 0040138C  \.  C3                         retn

复制代码

        【VC9.0】

1. 00401000  /$  55                         push    ebp                                   main() 入口
   
2. 00401001  |.  8BEC                       mov     ebp, esp
   
3. 00401003  |.  83EC 08                    sub     esp, 8                                <--- 堆栈分配 0x08 字节供局部变量使用
   
4. 00401006  |.  8B45 F8                    mov     eax, dword ptr [ebp-8]                dx . i - 直接使用，未经任何初始化
   
5. 00401009  |.  50                         push    eax                                   <--- dx . i 入栈，准备显示
   
6. 0040100A  |.  68 00C04000                push    0040C000                              ;  ASCII "i = %d"
   
7. 0040100F  |.  E8 1A000000                call    0040102E                              <--- printf()
   
8. 00401014  |.  83C4 08                    add     esp, 8
   
9. 00401017  |.  8B4D FC                    mov     ecx, dword ptr [ebp-4]                <--- dx . p - 直接使用，未经任何初始化
   
10. 0040101A  |.  51                         push    ecx                                   <--- dx . p 入栈，准备显示
    
11. 0040101B  |.  68 08C04000                push    0040C008                              ;  ASCII "p = %p"
    
12. 00401020  |.  E8 09000000                call    0040102E                              <--- printf()
    
13. 00401025  |.  83C4 08                    add     esp, 8
    
14. 00401028  |.  33C0                       xor     eax, eax
    
15. 0040102A  |.  8BE5                       mov     esp, ebp
    
16. 0040102C  |.  5D                         pop     ebp
    
17. 0040102D  \.  C3                         retn

复制代码

        最后结论就是，不要想太多，编译器绝对不会为你初始化任何一个变量

人造人

第1个代码如果你开了编译器警告的话，编译器会给你一个这样的警告
为什么编译器会给你这个警告呢？这个警告是什么意思？

1. main.c: In function ‘main’:
   
2. main.c:11:18: warning: ‘imfor.name’ is used uninitialized [-Wuninitialized]
   
3.    11 |         if (imfor.name == NULL)
   
4.       |             ~~~~~^~~~~
   
5. main.c:9:22: note: ‘imfor’ declared here
   
6.     9 |         struct Imfor imfor;
   
7.       |                      ^~~~~
   

复制代码

人造人

上面的代码中的警告和这个一样，你说这样的代码有什么问题呢？

1. sh-5.1$ cat main.c
   
2. #include <stdio.h>
   
3. 
   
4. int main(void) {
   
5.     int i;
   
6.     printf("%d\n", i);
   
7.     return 0;
   
8. }
   
9. sh-5.1$ gcc -g -Wall -o main main.c
   
10. main.c: In function ‘main’:
    
11. main.c:5:5: warning: ‘i’ is used uninitialized [-Wuninitialized]
    
12.     5 |     printf("%d\n", i);
    
13.       |     ^~~~~~~~~~~~~~~~~
    
14. main.c:4:9: note: ‘i’ was declared here
    
15.     4 |     int i;
    
16.       |         ^
    
17. sh-5.1$
    

复制代码

zhangjinxuan

你要记住，指针和数组不是同一东西，只是很像罢了

其实任何全局未初始化的全部都是 0，就是不同的类型，不同的表现方式罢了

例如，int, float, double, long 等数字变量没什么好说的，就是 0

而字符串（字符数组）所有元素都是 0，也就是 '\0'

不过指针就不一样了，他初始化都是NULL，为什么呢？我们来看看 NULL 的定义:

1. #define NULL ((void*)0)

复制代码

很明显， NULL 就是把 0 转换为了指针，就是不同的类型，不同的表现方式罢了

但，不要想着写 (int*)3 了，只有 0 才可以转换为指针类型，就表示 0x0 这一个空地址，因为空地址是一个系统不常用的地址，所以用来定义 NULL

人造人

1. 未初始化的会自动初始化为'\0'

复制代码

行了，这个教材可以不用看了，未定义的行为，意思是让编译器决定怎么整，编译器不初始化成0不行吗？
标准让编译器来处理未定义行为，编译器想做什么就做什么
遇到了未定义行为可以把内存地址0x1024中的值改写成512吗？可以，这没问题
遇到了未定义行为可以把内存地址0~0xffffffff中的值改写成0x1024吗？可以，这没问题
遇到了未定义行为可以让cpu直接瘫痪吗？可以，这没问题
遇到了未定义行为可以发射核弹吗？可以，这没问题，前提是你要安装了能发射核弹的硬件系统
知道了吗？未定义行为就是编译器可以想怎么做就怎么做
讨论这个没有意义，这你得问编译器的设计者，看看他有没有发射核弹的硬件系统

人造人

1.         if (imfor.name == NULL)

复制代码

第2个代码，name是一个数组，你拿他和NULL比较？
这个数组的名字可以是NULL吗？
你哪里见过这样的代码？

1. sh-5.1$ cat main.c
   
2. #include <stdio.h>
   
3. 
   
4. int main(void) {
   
5.     int array[10] = {0};
   
6.     if(array == NULL) printf("\n");
   
7.     return 0;
   
8. }
   
9. sh-5.1$ gcc -g -Wall -o main main.c
   
10. main.c: In function ‘main’:
    
11. main.c:5:14: warning: the comparison will always evaluate as ‘false’ for the address of ‘array’ will never be NULL [-Waddress]
    
12.     5 |     if(array == NULL) printf("\n");
    
13.       |              ^~
    
14. main.c:4:9: note: ‘array’ declared here
    
15.     4 |     int array[10] = {0};
    
16.       |         ^~~~~
    
17. sh-5.1$
    

复制代码

人造人

1. the comparison will always evaluate as ‘false’ for the address of ‘array’ will never be NULL

复制代码

1. 比较将始终评估为“false”，因为“数组”的地址永远不会为空

复制代码

人造人

结构体中其他类型的变量又会初始化成什么呢
也许不初始化，直接格式化你的硬盘，有什么问题吗？反正未定义的行为，允许编译器想做什么就做什么

人造人

zhangjinxuan 发表于 2022-11-25 22:33
你要记住，指针和数组不是同一东西，只是很像罢了

其实任何全局（或结构体）未初始化的全部都是 0，就是 ...

其实任何全局（或结构体）
这里的 ‘或’ 是什么意思？
意思是局部变量也默认初始化成0 ？

竹逸

弱弱的问一下，全局变量或指针自带初始化默认值吗？我咋没印象⊙﹏⊙∥，哎躺床上手机看，不然实机自己验证一下(ー_ー)!!

zhangjinxuan

人造人 发表于 2022-11-25 22:52
其实任何全局（或结构体）
这里的 ‘或’ 是什么意思？
意思是局部变量也默认初始化成0 ？

我好像被误导了，局部结构体似乎也不能初始化为0

zhangjinxuan

人造人 发表于 2022-11-25 22:37
行了，这个教材可以不用看了，未定义的行为，意思是让编译器决定怎么整，编译器不初始化成0不行吗？
...

我已经被搞蒙蔽了

zhangjinxuan

我已退出群聊

人造人

竹逸 发表于 2022-11-26 00:13
弱弱的问一下，全局变量或指针自带初始化默认值吗？我咋没印象⊙﹏⊙∥，哎躺床上手机看，不然实机自己验证 ...

只要是全局的，不管什么类型，默认值都是0
还有static变量（局部的，全局的都行），不管什么类型，默认值都是0

竹逸

人造人 发表于 2022-11-26 10:08
只要是全局的，不管什么类型，默认值都是0
还有static变量（局部的，全局的都行），不管什么类型，默认 ...

我看了自己的笔记，确实没发现说全局自带默认值的，怪不得我没印象(ー_ー)!!

但总结里有一条静态局部变量不赋初值时默认为0(字符型默认是空字符\0)

孤不冷cing

zhangjinxuan 发表于 2022-11-25 22:33
你要记住，指针和数组不是同一东西，只是很像罢了

其实任何全局未初始化的全部都是 0，就是不同的类型， ...

涨知识了

孤不冷cing

人造人 发表于 2022-11-25 22:40
第2个代码，name是一个数组，你拿他和NULL比较？
这个数组的名字可以是NULL吗？
你哪里见过这样的代码 ...

我把指针和数组给搅一起了，以前光想着他们的相似处，完全没注意他们的区别
而且我把NULL是空指针也给忘了

孤不冷cing

人造人 发表于 2022-11-26 10:08
只要是全局的，不管什么类型，默认值都是0
还有static变量（局部的，全局的都行），不管什么类型，默认 ...

编译器不初始化变量，那这个默认值是什么时候赋的呀

人造人

孤不冷cing 发表于 2022-11-26 19:12
编译器不初始化变量，那这个默认值是什么时候赋的呀

操作系统在加载你的程序的时候也许做一次初始化，应该是初始化成0，但是执行到你的main函数以后，堆栈中的数据已经很有可能不是0了，是什么？不知道
这就要看库函数的代码怎么使用的堆栈，当然不止库函数的代码，还有操作系统的代码，所以根本没办法预测这些值是什么

简单来说就是堆栈里面的是一些随机值，编译器如果没有初始化变量的话，那就使用这些随机值