printf为什么会这样？

思一克

还有，malloc返回的不是局部变量的指针！

playmud

原帖由 "yuxh" 发表：
个为什么就是 2, 3？
和地址有关。

相当于:
int temp2=Func(2);
int temp1=Func(1);
    printf("%d, %d\n", temp1, temp2);

开始那个相当于:
static char * temp1=Func(1)=Func(2);

    printf("%s, %s\n", temp1, temp1);

思一克

to aero，
C都是从右向左压站的。和COMPILER无关
yuxh的例子也同样如此。

playmud

[quote]原帖由 "思一克"]还有，malloc返回的不是局部变量的指针！[/quote 发表：

哦?那返回的是什么?

思一克

malloc（）返回的是在堆中的全局变量的指针。

aero

我是说的参数计算顺序，又没说入栈顺序。yuxh的例子，明显是从左到右计算的参数。

话又说回来，的确一般的compiler都是从右至左入栈，但这个是标准规定的吗？我不清楚。

思一克

to aero,
计算次序==入站次序。
yuxh的例子也不例外。
关键是用不用公用的存储区域。

playmud

啥时候成了全局变量了?

converse

无可置疑，先调用的func（2），然后调用的func（1），见汇编代码,一切都清楚了：

1. 
   
2. Disassembly of section .text:
   
3. 
   
4. 00000000 <.text>;:
   
5.    0:        6e                           outsb  %ds:(%esi),(%dx)
   
6.    1:        75 6d                        jne    70 <_main+0x36>;
   
7.    3:        62 65 72                     bound  %esp,0x72(%ebp)
   
8.    6:        20 25 64 00 55 89            and    %ah,0x89550064
   
9. 
   
10. 0000000a <_Func>;:
    
11.    a:        55                           push   %ebp
    
12.    b:        89 e5                        mov    %esp,%ebp
    
13.    d:        83 ec 18                     sub    $0x18,%esp
    
14.   10:        8b 45 08                     mov    0x8(%ebp),%eax
    
15.   13:        89 44 24 08                  mov    %eax,0x8(%esp)
    
16.   17:        c7 44 24 04 00 00 00         movl   $0x0,0x4(%esp)
    
17.   1e:        00
    
18.   1f:        c7 04 24 00 00 00 00         movl   $0x0,(%esp)
    
19.   26:        e8 00 00 00 00               call   2b <_Func+0x21>;
    
20.   2b:        b8 00 00 00 00               mov    $0x0,%eax
    
21.   30:        c9                           leave  
    
22.   31:        c3                           ret   
    
23.   32:        25 73 2c 20 25               and    $0x25202c73,%eax
    
24.   37:        73 0a                        jae    43 <_main+0x9>;
    
25.         ...
    
26. 
    
27. 0000003a <_main>;:
    
28.   3a:        55                           push   %ebp
    
29.   3b:        89 e5                        mov    %esp,%ebp
    
30.   3d:        53                           push   %ebx
    
31.   3e:        83 ec 14                     sub    $0x14,%esp
    
32.   41:        83 e4 f0                     and    $0xfffffff0,%esp
    
33.   44:        b8 00 00 00 00               mov    $0x0,%eax
    
34.   49:        89 45 f8                     mov    %eax,0xfffffff8(%ebp)
    
35.   4c:        8b 45 f8                     mov    0xfffffff8(%ebp),%eax
    
36.   4f:        e8 00 00 00 00               call   54 <_main+0x1a>;
    
37.   54:        e8 00 00 00 00               call   59 <_main+0x1f>;
    
38.   59:        c7 04 24 02 00 00 00         movl   $0x2,(%esp);2入栈
    
39.   60:        e8 a5 ff ff ff               call   a <_Func>;
    
40.   65:        89 c3                        mov    %eax,%ebx
    
41.   67:        c7 04 24 01 00 00 00         movl   $0x1,(%esp);1入栈
    
42.   6e:        e8 97 ff ff ff               call   a <_Func>;
    
43.   73:        89 5c 24 08                  mov    %ebx,0x8(%esp)
    
44.   77:        89 44 24 04                  mov    %eax,0x4(%esp)
    
45.   7b:        c7 04 24 32 00 00 00         movl   $0x32,(%esp)
    
46.   82:        e8 00 00 00 00               call   87 <_main+0x4d>;
    
47.   87:        8b 5d fc                     mov    0xfffffffc(%ebp),%ebx
    
48.   8a:        c9                           leave  
    
49.   8b:        c3                           ret   
    
50.   8c:        90                           nop   
    
51.   8d:        90                           nop   
    
52.   8e:        90                           nop   
    
53.   8f:        90                           nop   
    

复制代码

aero

^_^，是了。看走眼了。是从右向左计算的。呵呵。