• c中函数参数传递


    c中函数参数传递

    1 输入参数传递数组或地址

    测试代码:

    复制代码
     1 #include <stdio.h>
     2 
     3 void foo(char *a)
     4 {
     5     fprintf(stdout, "%x %x %x\n", &a, a, a[0]);
     6 }
     7 
     8 int main ( int argc, char *argv[] )
     9 {
    10     char a[20] = {'a', 'b', 'c'};
    11 
    12     fprintf(stdout, "%x %x %x\n", &a, a, a[0]);
    13     foo(a);
    14     return 0;
    15 }               /* ----------  end of function main  ---------- */
    复制代码

    运行结果:

    bfc5f31c bfc5f31c 61
    bfc5f2f0 bfc5f31c 61

      运行结果的第二列和第三列都比较好理解,a仅仅是个地址,在main中并没有专门为a开辟一个空间来存放a这个地址,也可以说a就是一个地址的别名,它和指针不一样,指针是一个变量,只是这个变量里面存放的是地址而已,所以在main函数中对a取地址其实是没什么意义的,因为它本来就是个地址,所以编译器仅仅是把a输出。但当以a为参数调用foo函数时,一边我们都认为把一个地址传给了foo,foo里的a和main中的a是一样的。其实不然,foo里的a是一个指针变量,main中调用foo时,其实就是把main中a的值赋值给了foo中的a变量。所以本质上来讲,传地址和传值是没区别的,其实都是传值,区别在于这个值是不是个地址而已。不过c++的引用就不一样了,它是真正的对传递的参数取个别名,所以和传地址是不一样的。

      我们可以反汇编来看看上面的程序实际运行是怎么样的,先看main函数:

    复制代码
    08048422 <main>:
     8048422:       55                      push   %ebp
     8048423:       89 e5                   mov    %esp,%ebp
     8048425:       83 e4 f0                and    $0xfffffff0,%esp
     8048428:       83 ec 40                sub    $0x40,%esp
     804842b:       c7 44 24 2c 00 00 00    movl   $0x0,0x2c(%esp)
     8048432:       00
     8048433:       c7 44 24 30 00 00 00    movl   $0x0,0x30(%esp)
     804843a:       00
     804843b:       c7 44 24 34 00 00 00    movl   $0x0,0x34(%esp)
     8048442:       00
     8048443:       c7 44 24 38 00 00 00    movl   $0x0,0x38(%esp)
     804844a:       00
     804844b:       c7 44 24 3c 00 00 00    movl   $0x0,0x3c(%esp)
     8048452:       00
     8048453:       c6 44 24 2c 61          movb   $0x61,0x2c(%esp)
     8048458:       c6 44 24 2d 62          movb   $0x62,0x2d(%esp)
     804845d:       c6 44 24 2e 63          movb   $0x63,0x2e(%esp)
     8048462:       0f b6 44 24 2c          movzbl 0x2c(%esp),%eax
     8048467:       0f be c8                movsbl %al,%ecx
     804846a:       ba 84 85 04 08          mov    $0x8048584,%edx
     804846f:       a1 c0 97 04 08          mov    0x80497c0,%eax
     8048474:       89 4c 24 10             mov    %ecx,0x10(%esp)
     8048478:       8d 4c 24 2c             lea    0x2c(%esp),%ecx
     804847c:       89 4c 24 0c             mov    %ecx,0xc(%esp)
     8048480:       8d 4c 24 2c             lea    0x2c(%esp),%ecx
     8048484:       89 4c 24 08             mov    %ecx,0x8(%esp)
     8048488:       89 54 24 04             mov    %edx,0x4(%esp)
     804848c:       89 04 24                mov    %eax,(%esp)
     804848f:       e8 8c fe ff ff          call   8048320 <fprintf@plt>
     8048494:       8d 44 24 2c             lea    0x2c(%esp),%eax
     8048498:       89 04 24                mov    %eax,(%esp)
     804849b:       e8 44 ff ff ff          call   80483e4 <foo>
     80484a0:       b8 00 00 00 00          mov    $0x0,%eax
     80484a5:       c9                      leave
     80484a6:       c3                      ret
    复制代码

      函数中一些惯例语句我们直接跳过,我在http://www.cnblogs.com/chengxuyuancc/archive/2013/05/28/3104769.html中已经分析过了,我们直接看其它部分。首先编译器为数组char  a[20]在栈中分配空间,从804842b到804844b可以看出编译器为数组分配的空间是0x2c(%esp)~0x3c(%esp),这段代码主要是对数组清零。8048453~804848c主要是为调用函数fprintf,将参数压入栈中,从代码可以看出参数是从右向左依次压入栈的。8048494~8048498获取a的值并将a的值放入栈顶。

    foo函数的反汇编代码:

    复制代码
    080483e4 <foo>:
     80483e4:       55                      push   %ebp
     80483e5:       89 e5                   mov    %esp,%ebp
     80483e7:       53                      push   %ebx
     80483e8:       83 ec 24                sub    $0x24,%esp
     80483eb:       8b 45 08                mov    0x8(%ebp),%eax
     80483ee:       0f b6 00                movzbl (%eax),%eax
     80483f1:       0f be d8                movsbl %al,%ebx
     80483f4:       8b 4d 08                mov    0x8(%ebp),%ecx
     80483f7:       ba 84 85 04 08          mov    $0x8048584,%edx
     80483fc:       a1 c0 97 04 08          mov    0x80497c0,%eax
     8048401:       89 5c 24 10             mov    %ebx,0x10(%esp)
     8048405:       89 4c 24 0c             mov    %ecx,0xc(%esp)
     8048409:       8d 4d 08                lea    0x8(%ebp),%ecx
     804840c:       89 4c 24 08             mov    %ecx,0x8(%esp)
     8048410:       89 54 24 04             mov    %edx,0x4(%esp)
     8048414:       89 04 24                mov    %eax,(%esp)
     8048417:       e8 04 ff ff ff          call   8048320 <fprintf@plt>
     804841c:       83 c4 24                add    $0x24,%esp
     804841f:       5b                      pop    %ebx
     8048420:       5d                      pop    %ebp
     8048421:       c3                      ret
    复制代码

      在80483f4行中0x8(%ebp)指向的就是函数foo中的参数a的存储空间,正如前面所说的,foo中的a是一个指针变量,里面存放的是main中传过来的数组的地址。8048409则是获得a的地址值。

      从汇编代码中我们可以直观的看到main中的a实际是一个地址的别名,它不占用存储空间,而它以参数传递给foo时,foo的接收参数a是有存储空间的

     2 输入参数传递结构体

    测试代码:

    复制代码
     1 #include <stdio.h>
     2 
     3 typedef struct test_p
     4 {
     5     char a[20];
     6 }test_p;
     7 
     8 void foo(test_p a)
     9 {
    10     a.a[0] = 2;
    11     printf("%d\n", a.a[0]);
    12 }
    13 
    14 int main ( int argc, char *argv[] )
    15 {
    16     test_p a;
    17 
    18     a.a[0] = 1;
    19     foo(a);
    20     printf("%d\n", a.a[0]);
    21     return 0;
    22 }               /* ----------  end of function main
    复制代码

    运行结果:

    2
    1

      这个结果是很容易理解的,由于上面属于传值调用,也就是直接把main中的test_p结构体a拷贝一份赋值给foo中的test_p结构体a,从反汇编的代码中也可以看出实际也是这样的。

     3 输出参数传递结构体

      如果函数有返回值,一般传出参数放在寄存器eax中,从第一个例子中main函数的反汇编代码可以看出,main在返回之前将0赋值给了eax寄存器作为函数返回值。但如果返回值比较大,eax装不了怎么办?我们可以看看下面输出参数为结构体的情况。

    测试代码:

    复制代码
     1 #include <stdio.h>
     2 
     3 typedef struct test_p
     4 {
     5     char a[20];
     6 }test_p;
     7 
     8 test_p foo()
     9 {
    10     test_p a;
    11     a.a[0] = 1;
    12     return a;
    13 }
    14 
    15 int main ( int argc, char *argv[] )
    16 {
    17     test_p a;
    18 
    19     a = foo();
    20     return 0;
    21 }               /* ----------  end of function main  ---------- */
    复制代码

    反汇编代码:

    复制代码
    08048394 <foo>:
     8048394:       55                      push   %ebp
     8048395:       89 e5                   mov    %esp,%ebp
     8048397:       83 ec 20                sub    $0x20,%esp
     804839a:       c6 45 ec 01             movb   $0x1,-0x14(%ebp)
     804839e:       8b 45 08                mov    0x8(%ebp),%eax
     80483a1:       8b 55 ec                mov    -0x14(%ebp),%edx
     80483a4:       89 10                   mov    %edx,(%eax)
     80483a6:       8b 55 f0                mov    -0x10(%ebp),%edx
     80483a9:       89 50 04                mov    %edx,0x4(%eax)
     80483ac:       8b 55 f4                mov    -0xc(%ebp),%edx
     80483af:       89 50 08                mov    %edx,0x8(%eax)
     80483b2:       8b 55 f8                mov    -0x8(%ebp),%edx
     80483b5:       89 50 0c                mov    %edx,0xc(%eax)
     80483b8:       8b 55 fc                mov    -0x4(%ebp),%edx
     80483bb:       89 50 10                mov    %edx,0x10(%eax)
     80483be:       8b 45 08                mov    0x8(%ebp),%eax
     80483c1:       c9                      leave
     80483c2:       c2 04 00                ret    $0x4
    
    080483c5 <main>:
     80483c5:       55                      push   %ebp
     80483c6:       89 e5                   mov    %esp,%ebp
     80483c8:       83 ec 24                sub    $0x24,%esp
     80483cb:       8d 45 ec                lea    -0x14(%ebp),%eax
     80483ce:       89 04 24                mov    %eax,(%esp)
     80483d1:       e8 be ff ff ff          call   8048394 <foo>
     80483d6:       83 ec 04                sub    $0x4,%esp
     80483d9:       b8 00 00 00 00          mov    $0x0,%eax
     80483de:       c9                      leave
     80483df:       c3                      ret
    复制代码

      从反汇编的main函数中可以看出,在调用foo之前给foo传递了结构体变量a的地址。在foo函数在804839e~80483bb代码中将自己本地结构体变量的值赋给foo传递过来的变量,并将foo传递过来的变量的地址赋值给寄存器eax。也就是说main中的语句a = foo()其实就相当于语句foo(&a)。这样就很好的解决了返回参数过大的问题。

      上面讲的三种参数传递的情况算是c中较复杂的情况了,其它的情况都是同样的道理。从反汇编的代码中可以看出编译器为我们写的c代码做了很多优化的工作,就如上面的第三种情况,开始我认为foo函数在返回的时候应该另外开辟一段临时空间用以存放变量a的值,由于foo函数返回后变量a的空间就被释放了,在回到main函数后再将临时空间中存放的值赋值给a,不过编译器却巧妙的将a变量的地址传给foo函数,这样就节省了空间和时间。

     
     
    分类: c汇编

  • 相关阅读:
    linux服务器上无root权限如何安装nodejs?
    Jupyter按tab键无法补全,而且报错TypeError: __init__() got an unexpected keyword argument 'column'的解决办法
    通过损失函数优化提高训练速度、准确性和数据利用率
    华为诺亚AutoML框架-Vega:(2) 代码结构
    华为诺亚实验室AutoML框架-Vega:(1) 介绍
    AutoML: A survey of the state-of-the-art综述期刊论文免费下载
    安装Docker 图形界面管理工具 -- Portainer
    Dockfile 编写示例(将 jar 制作成容器)
    Docker 常用命令集
    云服务器CentOS安装Docker
  • 原文地址:https://www.cnblogs.com/Leo_wl/p/3109414.html
Copyright © 2020-2023  润新知