我今天为招聘新员工出的C语言考题

doubleelec

GCC怎么处理没研究过
但要完成这个任务,从原理上讲应该不是难事吧,即
"已知若干变量的size, 在一个地址空间上以4字节为单位排列这些变量"
当然真正的处理过程要复杂的多,"优化"是编译过程中的一个难题.
要想知道细节,就得问研究编译的牛人了.

quhw

呵呵，这种东西很玄妙的阿。
以前写过一个程序，开始是在x86上面运行的，后来放到alpha就会出来warning，不是编译的warning，是运行时，好象是说内存访问什么的，记不请出了。后来查出来是内存访问的问题，好像alpha不能按字节访问，必须对齐才行，没有考证过，反正把程序改了就好了。总之指针这种东西平台依赖性太强了，真是要小心啊。

lucifer

对齐当然是编译器控制的了。可以在命令行上用参数控制，也可以在程序中用#pragma pack(n)控制。不过要n比结构中最大的size的成员小才管用，否则还是按照最大size成员的大小对齐
btw,面试出这种问题，除非公司就是专门做系统级开发的，否则很无聊。而且要出也要把条件明确了。本身就是编译器和平台相关的，不说清楚没法回答啊。这个还算好了，刚看水木上有人被问
[PHP]
#include <iostream>
using namespace std ;

class Test
{
public:
        Test( int i, char ch ) : a(i), _ch(ch) {}
private:
        int a ;
        char _ch ;
};

int main()
{
        Test ft(376,'A') ;
        void* out = &ft ;
        char result = *((char*)out+1) ;
        cout << (int)result << endl ;
        return 0 ;
}

[/PHP]
result是多少，这个连字节序都要考虑了，真是无比同情这个可怜的人啊

lanche

呵，那么多人对这个感兴趣。我有个建议，面试时可以搞些脑筋急转弯，看看谁先残。

chice

最初由 zywwzy 发表
佩服。
出这道题的本意就是要应试的人了解指针和缓冲区的问题。
因为作为公司的笔试题，严谨性要求不是特别高。但需要每个做题目的人都能看得懂这段问题代码。
其实这段代码可能你写过，我写过，结果可能不是你预期的，也不是我预期的。大家在不经意间留下的这些隐患需要我们有雪亮的眼睛去观察，去发现。
今天来应试的几个“高级程序员”都毫不犹豫地24，32，48，让我颇感失望。
^_^，以后这道题目要增加限制，前提是不打开任何优化选项的条件下或者直接改成主观题，让应试者根据条件阐述原因。

说句心里话，这种考试似乎进入了误区。编程人员的责任是编写优良的代码，
而不是去当hacker。

个人感觉只要能回答出结果不一定是24 32 48的就应该给满分。

(另外，不同的编译器变量在栈里面的顺序也不一定，而且编译器并不对
变量顺序做承诺。所以不排除结果是 24 32 48的可能。)

doubleelec

同意
程序员首先应该避免编出结果"未定义"的代码
而不是关心这样的代码会出现什么结果

ivanfan

感慨，好多强人，大家又都这么认真热烈的讨论，
我也要拼命加油了！！
干巴代！！

herberteuler

我还有些问题要同大家探讨。

如果把最初的程序改成下面这样：

1. #include <stdio.h>
3. static int var1;
4. static char var2;
5. static int var3;
7. int main(void)
8. {
9.         char str_val1[]="24\n";
10.         char str_val2[]="32\n";
11.         char str_val3[]="48\n";
13.         sscanf(str_val1,"%d",&var1);
14.         sscanf(str_val2,"%d",&var2);
15.         sscanf(str_val3,"%d",&var3);
16.         printf("var1=%d,var2=%d,var3=%d\n",var1,var2,var3);
17.         return 0;
18. }

复制代码

编译执行的结果就是 (至少我这里是这样)

1. var1=24,var2=32,var3=48

复制代码

Linux 内核中用户空间的格式如下：

1. start_code = 0x0        ------> +--------------------+
2.                                 |        代码         |
3. end_code, start_data    ------> +--------------------+
4.                                 |        数据         |  由装载的
5. end_data, start_brk     ------> +--------------------+
6.                                 |        BSS         |  文件定义
7. end_brk                 ------> +--------------------+
8.                                           .
9.                                           .
10.                                           .
11. start_code = 0x40000000 ------> +--------------------+
12.                                 |        代码         |
13. end_code, start_data    ------> +--------------------+
14.                                 |        数据         |  共享 C 库
15. end_data, start_bss     ------> +--------------------+
16.                                 |        BSS         |   (重复)
17. end_bss                 ------> +--------------------+
18.                                           .
19.                                           .
20.                                           .
21. start_stack             ------> +--------------------+
22.                                 | 指向环境和参数的指针  |
23. end_stack, start_arg    ------> +--------------------+
24.                                 |        参数         |
25. end_arg, start_env      ------> +--------------------+
26.                                 |        环境         |
27. end_env = 0xC0000000    ------> +--------------------+

复制代码

下面这个程序可以说明上面修改后的程序的虚拟地址空间：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <errno.h>
6. #include <ctype.h>
8. static int val1;
9. static char val2;
10. static int val3;
12. void dumpaddr(FILE *fp, char *desc, void *addr);
13. void mkprnt(char *buf);
15. int main(int argc, char *argv[], char *envp[])
16. {
17.         FILE *p;
18.         int i;
19.         if ((p = popen("sort -n -k3 | "
20.                 "gawk '{ printf "%-32s   %s\\n", $1, $2 }'", "w"))
21.                 == NULL) {
22.                 fprintf(stderr, "%s: cannot open pipe in dump(): %s\n",
23.                         argv[0], strerror(errno));
24.                 exit(-2);
25.         }
26.         for (i = 0; argv[i]; i++) {
27.                 char buf[32];
28.                 strcpy(buf, "arg:");
29.                 strncpy(buf+4, argv[i], sizeof(buf)-6);
30.                 buf[sizeof(buf) - 1] = '\0';
31.                 mkprnt(buf);
32.                 dumpaddr(p, buf, argv[i]);
33.         }
34.         for (i = 0; envp[i]; i++) {
35.                 char buf[32];
36.                 buf[0] = '&';
37.                 strncpy(buf+1, envp[i], sizeof(buf)-2);
38.                 buf[sizeof(buf) - 1] = '\0';
39.                 mkprnt(buf);
40.                 dumpaddr(p, buf, envp[i]);
41.         }
42.         dumpaddr(p, "main", main);
43.         dumpaddr(p, "stderr", stderr);
44.         dumpaddr(p, "stdout", stdout);
46.         char str_val1[]="24\n";
47.         char str_val2[]="32\n";
48.         char str_val3[]="48\n";
49.         int mval1;
50.         char mval2;
51.         int mval3;
53.         dumpaddr(p, "str_val1", str_val1);
54.         dumpaddr(p, "str_val2", str_val2);
55.         dumpaddr(p, "str_val3", str_val3);
56.         dumpaddr(p, "val1", &val1);
57.         dumpaddr(p, "val2", &val2);
58.         dumpaddr(p, "val3", &val3);
59.         dumpaddr(p, "i", &i);
60.         dumpaddr(p, "p", &p);
61.         dumpaddr(p, "mval1", &mval1);
62.         dumpaddr(p, "mval2", &mval2);
63.         dumpaddr(p, "mval3", &mval3);
65.         pclose(p);
66.         return 0;
67. }
69. /* dumpaddr: write messege desc and addr into stream p */
70. void dumpaddr(FILE *fp, char *desc, void *addr)
71. {
72.         fprintf(fp, "%-32s   0x%08X\t%-32lu\n",
73.                 desc, (long) addr, (unsigned long) addr);
74. }
76. /* mkprnt: make buf printable */
77. void mkprnt(char *buf)
78. {
79.         while (*buf)
80.                 if (!isprint(*buf++))
81.                         *buf = '@';
82. }

复制代码

在我这里运行 ./y abcdef (y 是我输出的可执行文件) 的结果是：

1. main                               0x080485C4
2. [color=red]val1                               0x08049C50
3. val2                               0x08049C54
4. val3                               0x08049C58[/color]
5. stdout                             0x40150F80
6. stderr                             0x401510E0
7. [color=blue]mval3                              0xBFFFF8D8
8. mval2                              0xBFFFF8DF
9. mval1                              0xBFFFF8E0[/color]
10. str_val3                           0xBFFFF8E4
11. str_val2                           0xBFFFF8E8
12. str_val1                           0xBFFFF8EC
13. i                                  0xBFFFF918
14. p                                  0xBFFFF91C
15. arg:./y                            0xBFFFFA87
16. arg:abcdef                         0xBFFFFA8B
17. &KDE_MULTIHEAD=false               0xBFFFFA92
18. &TERM=xterm                        0xBFFFFAA6
19. &SHELL=/bin/bash                   0xBFFFFAB1
20. &XDM_MANAGED=/var/run/xdmctl/xd    0xBFFFFAC1
21. &GTK2_RC_FILES=/etc/gtk-2.0/gtk    0xBFFFFB08
22. &GTK_RC_FILES=/etc/gtk/gtkrc:/h    0xBFFFFB68
23. &GS_LIB=/home/herbert/.fonts       0xBFFFFBBF
24. &WINDOWID=48234501                 0xBFFFFBDB
25. &KDE_FULL_SESSION=true             0xBFFFFBED
26. &USER=herbert                      0xBFFFFC03
27. &LS_COLORS=no=00:fi=00:di=01;34    0xBFFFFC10
28. &LD_LIBRARY_PATH=/usr/lib/wine     0xBFFFFE45
29. &XCURSOR_SIZE=                     0xBFFFFE63
30. &SESSION_MANAGER=local/natsu:/t    0xBFFFFE71
31. &XPSERVERLIST=:64                  0xBFFFFEA1
32. &KONSOLE_DCOP=DCOPRef(konsole-3    0xBFFFFEB3
33. &DESKTOP_SESSION=default           0xBFFFFEDE
34. &PATH=/usr/local/bin:/usr/bin:/    0xBFFFFEF6
35. &KONSOLE_DCOP_SESSION=DCOPRef(k    0xBFFFFF32
36. &PWD=/home/herbert                 0xBFFFFF67
37. &XMODIFIERS=@im=fcitx              0xBFFFFF79
38. &LANG=zh_CN                        0xBFFFFF8E
39. &SHLVL=2                           0xBFFFFF99
40. &HOME=/home/herbert                0xBFFFFFA1
41. &XCURSOR_THEME=default             0xBFFFFFB4
42. &LOGNAME=herbert                   0xBFFFFFCA
43. &DISPLAY=:0.0                      0xBFFFFFDA
44. &COLORTERM=                        0xBFFFFFE7
45. &_=./y                             0xBFFFFFF2

复制代码

可以看到大致上同前面大家讨论的相同。注意执行结果的红色和蓝色部分。此外，我发现 mval3 的“地址范围”与 mval2 的“地址范围”并不相连，因此堆栈上有“空洞”。不过仍然有几个问题：
请看执行结果的红色部分。为什么甚至对于 char 这样的类型，仍然要为它分配 4 个字节的空间？是否因为 doubleelec 所说的“对于大于8位的数,如果不按32位对齐,读取时就可能访问两次内存”？

kj501

这个程序：

1. 
   
2. #include <stdio.h>
   
3. 
   
4. static int var1;
   
5. static char var2;
   
6. static int var3;
   
7. 
   
8. int main(void)
   
9. {
   
10.         char str_val1[]="24\n";
    
11.         char str_val2[]="32\n";
    
12.         char str_val3[]="48\n";
    
13. 
    
14.         sscanf(str_val1,"%d",&var1);
    
15.         sscanf(str_val2,"%d",&var2);
    
16.         sscanf(str_val3,"%d",&var3);
    
17.         printf("var1=%d,var2=%d,var3=%d\n",var1,var2,var3);
    
18.         return 0;
    
19. }
    

复制代码

是看不到预期效果的。你定义的变量是静态变量，静态变量在运行时是放在.data段的，不是放在栈上的。我看了程序编译后的可执行文件的段头表(执行objdump -h)，结果如下：

1. 
   
2. [kj501@s2023 c]$ objdump -h a.out
   
3. 
   
4. a.out:     file format elf32-i386
   
5. 
   
6. Sections:
   
7. Idx Name          Size      VMA       LMA       File off  Algn
   
8.   0 .interp       00000013  08048114  08048114  00000114  2**0
   
9.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
   
10.   1 .note.ABI-tag 00000020  08048128  08048128  00000128  2**2
    
11.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
12.   2 .hash         0000002c  08048148  08048148  00000148  2**2
    
13.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
14.   3 .dynsym       00000060  08048174  08048174  00000174  2**2
    
15.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
16.   4 .dynstr       00000053  080481d4  080481d4  000001d4  2**0
    
17.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
18.   5 .gnu.version  0000000c  08048228  08048228  00000228  2**1
    
19.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
20.   6 .gnu.version_r 00000020  08048234  08048234  00000234  2**2
    
21.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
22.   7 .rel.dyn      00000008  08048254  08048254  00000254  2**2
    
23.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
24.   8 .rel.plt      00000018  0804825c  0804825c  0000025c  2**2
    
25.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
26.   9 .init         00000017  08048274  08048274  00000274  2**2
    
27.                   CONTENTS, ALLOC, LOAD, READONLY, CODE
    
28. 10 .plt          00000040  0804828c  0804828c  0000028c  2**2
    
29.                   CONTENTS, ALLOC, LOAD, READONLY, CODE
    
30. 11 .text         00000234  080482d0  080482d0  000002d0  2**4
    
31.                   CONTENTS, ALLOC, LOAD, READONLY, CODE
    
32. 12 .fini         0000001a  08048504  08048504  00000504  2**2
    
33.                   CONTENTS, ALLOC, LOAD, READONLY, CODE
    
34. 13 .rodata       00000030  08048520  08048520  00000520  2**2
    
35.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
36. 14 .eh_frame     00000004  08048550  08048550  00000550  2**2
    
37.                   CONTENTS, ALLOC, LOAD, READONLY, DATA
    
38. 15 .data         0000000c  08049554  08049554  00000554  2**2
    
39.                   CONTENTS, ALLOC, LOAD, DATA
    
40. 16 .dynamic      000000c8  08049560  08049560  00000560  2**2
    
41.                   CONTENTS, ALLOC, LOAD, DATA
    
42. 17 .ctors        00000008  08049628  08049628  00000628  2**2
    
43.                   CONTENTS, ALLOC, LOAD, DATA
    
44. 18 .dtors        00000008  08049630  08049630  00000630  2**2
    
45.                   CONTENTS, ALLOC, LOAD, DATA
    
46. 19 .jcr          00000004  08049638  08049638  00000638  2**2
    
47.                   CONTENTS, ALLOC, LOAD, DATA
    
48. 20 .got          0000001c  0804963c  0804963c  0000063c  2**2
    
49.                   CONTENTS, ALLOC, LOAD, DATA
    
50. 21 .bss          00000010  08049658  08049658  00000658  2**2
    
51.                   ALLOC
    
52. 22 .comment      00000132  00000000  00000000  00000658  2**0
    
53.                   CONTENTS, READONLY
    
54. 23 .debug_aranges 00000078  00000000  00000000  00000790  2**3
    
55.                   CONTENTS, READONLY, DEBUGGING
    
56. 24 .debug_pubnames 00000025  00000000  00000000  00000808  2**0
    
57.                   CONTENTS, READONLY, DEBUGGING
    
58. 25 .debug_info   00000a0e  00000000  00000000  0000082d  2**0
    
59.                   CONTENTS, READONLY, DEBUGGING
    
60. 26 .debug_abbrev 00000138  00000000  00000000  0000123b  2**0
    
61.                   CONTENTS, READONLY, DEBUGGING
    
62. 27 .debug_line   00000258  00000000  00000000  00001373  2**0
    
63.                   CONTENTS, READONLY, DEBUGGING
    
64. 28 .debug_str    000006a3  00000000  00000000  000015cb  2**0
    
65.                   CONTENTS, READONLY, DEBUGGING
    
66. [kj501@s2023 c]$
    

复制代码

可见.data段是按照2的2次方也就是4字节对齐的。除非你填入8个字节的长整数，你才能看到数据被覆盖的效果。

kj501

对于char类型，按4个字节对齐确实能减少处理器访问内存的次数。