c语言函数形参的地址关系

cao627

1. include <stdio.h>
   
2. 
   
3. void test1(int a,int b, int c)
   
4. {
   
5.         int * p;
   
6.         p = &a;
   
7.         printf("%d\n", *p);
   
8.         p--;
   
9.         printf("%d\n", *p);
   
10.         p--;
    
11.         printf("%d\n", *p);
    
12. }
    
13. 
    
14. void test2(const char * s, ...)
    
15. {
    
16.         int * p;
    
17.         p = (int *)&s;
    
18.         p++;
    
19.         printf("%d\n", *p);
    
20.         p++;
    
21.         printf("%d\n", *p);
    
22. }
    
23. 
    
24. int main()
    
25. {
    
26. 
    
27.         test1(100,200,300);
    
28.         test2("hello world",100,200);
    
29.         return 0;
    
30. }
    
31. 
    

复制代码

看到一个视频教程，里面用test2实现了：打印第二个参数和第三个参数的值，依据是形参的地址在内存里紧挨着的，但在我的环境里无法实现这一点。

问题：
1.在test2中定义的是指向正整型指针p，对p++，p的步进是4，而传给test2的实参"hello world" 长度大于4个字节，p++后指向的应该还是在"hello.world"  这串字符存储的空间内，怎么能指到参数100的存储空间，视频教程里确实做到了。

2.在我的环境里test1的参数的地址关系是从左往右递减的，即如上代码是用p--实现依次打印第一，第二，第三个参数。而在视频教程中是用p++。这跟编译器不同的关系吗？

Dannysd

1. #include<stdio.h>
   
2. 
   
3. void test1(int a,int b, int c)
   
4. {
   
5.         int * p;
   
6.         p = &a;
   
7.         printf("%d\n", *p);
   
8.         p++;
   
9.         printf("%d\n", *p);
   
10.         p++;
    
11.         printf("%d\n", *p);
    
12. }
    
13. 
    
14. void test2(const char * s, ...)
    
15. {
    
16.         int * p;
    
17.         p = (int *)&s;
    
18.         p++;
    
19.         printf("%d\n", *p);
    
20.         p++;
    
21.         printf("%d\n", *p);
    
22. }
    
23. 
    
24. int main()
    
25. {
    
26.         test1(100,200,300);
    
27. 
    
28.         test2("hello world",100,200);
    
29. 
    
30.         return 0;
    
31. }

复制代码

1. ./a.out
   
2. 100
   
3. 200
   
4. 300
   
5. 100
   
6. 200

复制代码

Dannysd

test2反汇编

1. 080483f9 <test2>:
   
2. 80483f9:       55                      push   %ebp
   
3. 80483fa:       89 e5                   mov    %esp,%ebp
   
4. 80483fc:       83 ec 18                sub    $0x18,%esp
   
5. 80483ff:       8d 45 08                lea    0x8(%ebp),%eax
   
6. 8048402:       89 45 fc                mov    %eax,0xfffffffc(%ebp)
   
7. 8048405:       83 45 fc 04             addl   $0x4,0xfffffffc(%ebp)
   
8. 8048409:       8b 45 fc                mov    0xfffffffc(%ebp),%eax
   
9. 804840c:       8b 00                   mov    (%eax),%eax
   
10. 804840e:       89 44 24 04             mov    %eax,0x4(%esp)
    
11. 8048412:       c7 04 24 60 85 04 08    movl   $0x8048560,(%esp)
    
12. 8048419:       e8 9a fe ff ff          call   80482b8 <printf@plt>
    
13. 804841e:       83 45 fc 04             addl   $0x4,0xfffffffc(%ebp)
    
14. 8048422:       8b 45 fc                mov    0xfffffffc(%ebp),%eax
    
15. 8048425:       8b 00                   mov    (%eax),%eax
    
16. 8048427:       89 44 24 04             mov    %eax,0x4(%esp)
    
17. 804842b:       c7 04 24 60 85 04 08    movl   $0x8048560,(%esp)
    
18. 8048432:       e8 81 fe ff ff          call   80482b8 <printf@plt>
    
19. 8048437:       c9                      leave  
    
20. 8048438:       c3                      ret   
    

复制代码

1. 8048405:       83 45 fc 04             addl   $0x4,0xfffffffc(%ebp)

复制代码

这句对应的是p++，其实是在栈上向移动到了下一个地址

cao627

对于test1这样的形式，在我的环境中要用指针递减的方式才能依次打印各个参数。
对于test2这样的形式，在我的环境中无论用指针递增还是递减都不能打印字符串长量后的各个参数。

我的环境是
ubuntu 14.04  64位
gcc 4.8.2

cao627

@Dannysd
请你在test2中打印一下p取到字符串常量首地址的地址，然后再打印一下p++后的地址。看看两地址的差。

hellioncu

研究这个意义不大，不具有可移植性

Dannysd

我是32位环境，gcc version 4.1.2 Centos
可变参数这个没弄懂。。。。
test1

1. Breakpoint 1, test1 (a=100, b=200, c=300) at c.c:13
   
2. 13              p = &a;
   
3. (gdb) n
   
4. 14              printf("%d\n", *p);
   
5. (gdb) p a
   
6. $8 = 100
   
7. (gdb) p *p
   
8. $9 = 100
   
9. (gdb) p &a
   
10. $10 = (int *) 0xbfffc310
    
11. (gdb) p/x p
    
12. $11 = 0xbfffc310
    
13. (gdb) n
    
14. 100
    
15. 15              p++;
    
16. (gdb) p *p
    
17. $12 = 100
    
18. (gdb) p/x p
    
19. $13 = 0xbfffc310
    
20. (gdb) n
    
21. 16              printf("%d\n", *p);
    
22. (gdb) p *p
    
23. $14 = 200
    
24. (gdb) p/x p
    
25. $15 = 0xbfffc314
    
26. (gdb) n
    
27. 200
    
28. 17              p++;
    
29. (gdb) p *p
    
30. $16 = 200
    
31. (gdb) p/x p
    
32. $17 = 0xbfffc314
    
33. (gdb) n
    
34. 18              printf("%d\n", *p);
    
35. (gdb) p *p
    
36. $18 = 300
    
37. (gdb) p/x p
    
38. $19 = 0xbfffc318
    
39. (gdb) n
    
40. 300
    
41. 19      }

复制代码

============================
test2

1. Breakpoint 1, test2 (s=0x8048564 "hello world") at c.c:24
   
2. 24              p = (int *)&s;
   
3. (gdb) p *p
   
4. $1 = 200
   
5. (gdb) p/x p
   
6. $2 = 0xbfffe588
   
7. (gdb) n
   
8. 25              p++;
   
9. (gdb) p *p
   
10. $3 = 134514020
    
11. (gdb) p/x p
    
12. $4 = 0xbfffe580
    
13. (gdb) n
    
14. 26              printf("%d\n", *p);
    
15. (gdb) p *p
    
16. $5 = 100
    
17. (gdb) p/x p
    
18. $6 = 0xbfffe584
    
19. (gdb) n
    
20. 100
    
21. 27              p++;
    
22. (gdb) p *p
    
23. $7 = 100
    
24. (gdb) p/x p
    
25. $8 = 0xbfffe584
    
26. (gdb) n
    
27. 28              printf("%d\n", *p);
    
28. (gdb) p *p
    
29. $9 = 200
    
30. (gdb) p/x p
    
31. $10 = 0xbfffe588
    
32. (gdb) n
    
33. 200
    
34. 29      }
    
35. (gdb) p *p
    
36. $11 = 200
    
37. (gdb) p/x p
    
38. $12 = 0xbfffe588
    
39. (gdb) n
    
40. main () at c.c:37
    
41. 37              return 0;
    
42. (gdb) n
    
43. 38      }
    
44. (gdb) n
    
45. 0x00c44ebc in __libc_start_main () from /lib/libc.so.6
    
46. (gdb) n
    
47. Single stepping until exit from function __libc_start_main,
    
48. which has no line number information.
    
49. 
    
50. Program exited normally.

复制代码

cao627

1.在test2中定义的是指向正整型指针p，对p++，p的步进是4，而传给test2的实参"hello world" 长度大于4个字节，p++后指向的应该还是在"hello.world"  这串字符存储的空间内，怎么能指到参数100的存储空间，视频教程里确实做到了。

("hello world",100,200) 在内存栈中开辟的是   存放helllo world字符串的首地址的空间,4字节空间,4字节空间
p首先取得是存放helllo world字符串的首地址的空间的地址。
对p++后就取到了存放helllo world字符串的首地址的空间后面的4字节空间


对于32位系统，地址的长度是4字节，上面的存放helllo world字符串的首地址的空间就是4字节。p是定义的是指向int型的，p++的步进是4, 所以*(p++) 取得存放helllo world字符串的首地址的4字节空间的后面一个4字节的空间的内容。

但是对于64位系统，地址的长度是8字节，上面的存放helllo world字符串的首地址的空间就是8字节。p是定义的是指向int型的，p++的步进是4，所以*(P++)不能取到存放helllo world字符串的首地址的8字节空间后面一个4字节空间的内容。

这可能就是我的系统（64位）上形参地址是从左往又依次递减的缘故？
这样：存放helllo world字符串的首地址的8字节空间的地址高于紧挨它的形参括号中它右边4字节空间的地址，设形参括号中它右边4字节空间的地址是A，由于这块空间的大小为4字节，所以存放helllo world字符串的首地址的8字节空间的地址就是A+4。这样p取到存放helllo world字符串的首地址的8字节空间的地址，*(p--)就正好取到形参括号中它右边4字节空间内容。

Dannysd

回复 8# cao627


    默认的是cdecl，从右至左压参入栈

   要不加上 __attribute__((cdecl))这个再试试？

zhaohongjian000

取决于ABI规范，函数调用约定属于ABI规范的一部分。简单的说，现在还在用内存传参数的，只有32位的x86了。
x86-64、arm这种都有完整的文档，怎么传参数查看文档即可。

x86-64的附个链接：http://www.x86-64.org/documentation/abi.pdf