精华内容
下载资源
问答
  • Linux X86架构参数传递规则

    千次阅读 2018-12-27 16:18:01
    突然好奇x86架构下函数参数怎么传递的,之前只是听别人说过通过寄存器,但是怎么传,什么顺序都没有仔细研究过,也没有实际测试过,因此就想着用实践来检验一下咯。 传参顺序 在32位和64位机器上,寄存器名称不同,...

    背景

    突然好奇x86架构下函数参数怎么传递的,之前只是听别人说过通过寄存器,但是怎么传,什么顺序都没有仔细研究过,也没有实际测试过,因此就想着用实践来检验一下咯。

    传参顺序

    在32位和64位机器上,寄存器名称不同,64位机器为rxx,32位机器为exx。传参顺序如下,
    在这里插入图片描述
    64位系统有16个寄存器,32位系统只有8个。e开头的寄存器命名依然可以直接运用于相应寄存器的低32位。而剩下的寄存器名则是从r8 - r15,其低位分别用d,w,b指定长度。

    测试程序

    我们通过简单的程序编译后,使用gdb反汇编看下参数传入是否和上面描述的相符合。

    先看看32位程序是怎么传递参数的,

    #include <stdio.h>
    
    static int test32(int arg1, int arg2, int arg3, int arg4,int arg5,
                    int arg6, int arg7, int arg8)
    {
            return 0;
    }
    
    int main(void)
    {
            test32(1, 2, 3, 4, 5, 6, 7, 8);
    
            return 0;
    }
    

    将函数入参设置成8个,使用gdb反汇编观察参数具体传递情况。

    [root@CentOS-7-2 /home/register]# gcc -g -m32 test.c -o test
    [root@CentOS-7-2 /home/register]# gdb --quiet
    (gdb) file test
    Reading symbols from /home/register/test...done.
    (gdb) disassemble /m main
    Dump of assembler code for function main:
    10	{
       0x080483fa <+0>:	push   %ebp
       0x080483fb <+1>:	mov    %esp,%ebp
       0x080483fd <+3>:	sub    $0x20,%esp
    
    11		test32(1, 2, 3, 4, 5, 6, 7, 8);
       0x08048400 <+6>:	movl   $0x8,0x1c(%esp)
       0x08048408 <+14>:	movl   $0x7,0x18(%esp)
       0x08048410 <+22>:	movl   $0x6,0x14(%esp)
       0x08048418 <+30>:	movl   $0x5,0x10(%esp)
       0x08048420 <+38>:	movl   $0x4,0xc(%esp)
       0x08048428 <+46>:	movl   $0x3,0x8(%esp)
       0x08048430 <+54>:	movl   $0x2,0x4(%esp)
       0x08048438 <+62>:	movl   $0x1,(%esp)
       0x0804843f <+69>:	call   0x80483f0 <test32>
    
    12	
    13		return 0;
       0x08048444 <+74>:	mov    $0x0,%eax
    
    14	}
       0x08048449 <+79>:	leave  
       0x0804844a <+80>:	ret    
    
    End of assembler dump.
    

    由上可见,32位系统中并没有通过寄存器传参,而是直接将参数入栈,而且是按照参数顺序从右向左依次入栈。

    现在再来看下64为系统,

    #include <stdio.h>
    
    static int test64(long int arg1, long int arg2, long int arg3, long int arg4,
                    long int arg5, long int arg6, long int arg7, long int arg8)
    {
            return 0;
    }
    
    int main(void)
    {
            test64(11111111111L, 22222222222L, 33333333333L, 44444444444L,
                    55555555555L, 66666666666L, 77777777777L, 88888888888L);
    
            return 0;
    }
    

    这里入参使用long int类型,是因为如果使用int型,编译器会默认使用32位寄存器,即exx寄存器,不直观。

    [root@CentOS-7-2 /home/register]# gcc -g -m64 test.c -o test
    [root@CentOS-7-2 /home/register]# gdb --quiet
    (gdb) file test
    Reading symbols from /home/register/test...done.
    (gdb) disassemble /m main
    Dump of assembler code for function main:
    10	{
       0x0000000000400513 <+0>:	push   %rbp
       0x0000000000400514 <+1>:	mov    %rsp,%rbp
       0x0000000000400517 <+4>:	sub    $0x10,%rsp
    
    11		test64(11111111111L, 22222222222L, 33333333333L, 44444444444L,
       0x000000000040051b <+8>:	movabs $0x14b230ce38,%rax
       0x0000000000400525 <+18>:	mov    %rax,0x8(%rsp)
       0x000000000040052a <+23>:	movabs $0x121beab471,%rax
       0x0000000000400534 <+33>:	mov    %rax,(%rsp)
       0x0000000000400538 <+37>:	movabs $0xf85a49aaa,%r9
       0x0000000000400542 <+47>:	movabs $0xcef5e80e3,%r8
       0x000000000040054c <+57>:	movabs $0xa5918671c,%rcx
       0x0000000000400556 <+67>:	movabs $0x7c2d24d55,%rdx
       0x0000000000400560 <+77>:	movabs $0x52c8c338e,%rsi
       0x000000000040056a <+87>:	movabs $0x2964619c7,%rdi
       0x0000000000400574 <+97>:	callq  0x4004f0 <test64>
    
    12	                55555555555L, 66666666666L, 77777777777L, 88888888888L);
    13	
    14		return 0;
       0x0000000000400579 <+102>:	mov    $0x0,%eax
    
    15	}
       0x000000000040057e <+107>:	leaveq 
       0x000000000040057f <+108>:	retq   
    
    End of assembler dump.
    

    为了更直观,我们把64位的入参转换为16进制,

    十进制16进制
    111111111110x2964619c7
    222222222220x52c8c338e
    333333333330x7c2d24d55

    从这我们就能看出,参数传递确实是按照rdi、rsi、rdx、rcx、r8、r9的顺序存放第一个参数到第六个参数。对于超出6个参数的入参还是和32位机器一样放入栈中。

    相比于参数入栈,通过寄存器传递参数肯定更为高效。

    展开全文
  • 函数调用时参数传递规则

    千次阅读 2018-03-09 09:44:58
    ARM函数调用时参数传递规则 之前在学习如何在C语言中嵌入汇编时有了解到C语言之前的参数调用是使用寄存器 R0传递第一个参数, R1传递到第二个.. 一直到R3传递第四个参数. 但是 实际上有时可能传递的参数非常多,...

    ARM函数调用时参数传递规则
    之前在学习如何在C语言中嵌入汇编时有了解到C语言之前的参数调用是使用寄存器

    R0传递第一个参数,

    R1传递到第二个..

    一直到R3传递第四个参数.

    但是 实际上有时可能传递的参数非常多,超过8个,或是参数中有浮点数之类,参数也会超过4个寄存器,对于超出的部份并不使用R4,而是使用堆栈的方式.

    对于ARM体系来说,不同语言撰写的函数之间相互调用(mix calls)遵循的是 ATPCS(ARM-Thumb Procedure Call Standard),ATPCS主要是定义了函数呼叫时参数的传递规则以及如何从函数返回,关于ATPCS的详细内容可以查看ADS1.2 Online Books ——Developer Guide的2.1节。这篇文档要讲的是 汇编代码中对C函数调用时如何进行参数的传递以及如何从C函数正确返回

    不同于x86的参数传递规则,ATPCS建议函数的形参不超过4个,如果形参个数少于或等于4,则形参由R0,R1,R2,R3四个寄存器进行传递;若形参个数大于4,大于4的部分必须通过堆栈进行传递。

    x86_64函数调用时参数传递规则

    x86_64体系架构中函数调用时整数和指针参数按照从左到右的顺序依次保存在寄存器rdi,rsi,rdx,rcx,r8和r9中,浮点型参数保存在寄存器xmm0,xmm1……中。若有更多的参数则按照从右到左的顺序依次压入堆栈。

    当使用GDB工具调试C代码时,若使用break function设置断点时,若使用break function_name则断点设置在进入function以及保存完寄存器后的汇编语句上,而使用break *function_name则断点设置在刚刚进入函数的位置上(并没有保存栈帧到堆栈)。

    x86下的C函数调用惯例

    网址:http://blog.csdn.net/phunxm/article/details/8985321

    展开全文
  • 参数传递规则

    2013-08-10 19:08:10
    C语言的函数参数和返回值传递方式:值传递和地址传递(即指针传递); C++语言的函数参数和返回值传递方式:值传递,地址传递和引用传递规则1:不论函数是原型还是定义,都要明确写出参数的类型和名字,如果...

    C语言的函数参数和返回值传递方式:值传递和地址传递(即指针传递);

    C++语言的函数参数和返回值传递方式:值传递,地址传递和引用传递。


    规则1:不论函数是原型还是定义,都要明确写出参数的类型和名字,如果函数没有参数,使用void而不要空着;


    规则2:参数命名要恰当,输入参数和输出参数的顺序要合理。


    规则3:如果参数死后指针,且仅做输入用,则应该在类型前加const,以防止该指针指向的内存单元在函数体内无意中被修改。


    返回值有两种途径:使用return语句和使用输出参数。

    规则1:不要省略返回值的类型,如果函数没有返回值,应声明为void类型。

    规则2:函数名字与返回值类型在语义上不可冲突。

    规则3:不要讲正常值与错误标志混在一起返回。建议正常值用输出参数获得,而错误标志用return语句返回。

    提示:如果函数的返回值是一个对象,有些场合下可以用“返回引用”替换“返回对象值”,这样可以提高效率,而且还可以支持链式表达。但有些场合下只能用“返回对象值”。

    示例:

    (1)定义一个对象,如下:


    (2)返回引用:


    如果上面赋值函数采用“返回对象值”的方式,虽然功能仍然正确,但由于return语句要把*this拷贝到保存返回值的外部存储单元中,增加了不必要的开销,降低了赋值函数的效率。

    (3)返回对象:



    对于上相加函数,使用了“返回对象值”的方式返回String对象,这把局部对象temp及其真正地字符串值拷贝一份给调用环境接受者。如果改用“返回引用”,那么函数返回值是一个指向局部对象temp的“引用”(即地址),而temp在函数结束时自动销毁,将导致返回的“引用”无效。


    注意:不要把返回指针的函数用做左值。



    展开全文
  • 文章,作者通过实验列出了在x64下gcc的参数传递规则: 我试验了多个参数的情况,发现一般规则为,   当参数少于 7 个时,   参数从左到右放入寄存器 : rdi, rsi, rdx, rcx, r8, r9 。当参数为  7  ...

    在本文中以一段汇编代码为例介绍一下在x86和x64汇编语言中调用C 函数的过程。样例代码在ubuntu12.04 i386 环境下调试通过。此外本文还介绍了在将这段样例代码移植到X64环境下应该注意的问题。 

    样例代码的作用是计算两个整数的除法,并通过C语言的printf函数打印计算结果。

    .section .data
    dividend:
            .quad 8335
    divisor:
            .int 25
    quotient:
            .int 0
    remainder:
            .int 0
    output:
           .asciz "The quotient is %d, and the remainder is %d\n"
    .section .text
    .globl _start
    _start:
            movl dividend, %eax
            movl dividend+4, %edx
            divl divisor
            movl %eax, quotient
            movl %edx, remainder
            pushl remainder
            pushl quotient
            pushl $output
            call printf
            add $12, %esp
            pushl $0
           call exit 

    编译过程如下:

    lil@lil-kvm:~/assembly$as -o divtest.o divtest.s

    lil@lil-kvm:~/assembly$ld --dynamic-linker /lib/ld-Linux.so.2 -lc -o divtest divtest.o

    其中-lc 选项表示需要连接libc.so库,--dynamic-linker /lib/ld-linux.so.2 也必须指定,否则即使连接未报错,也会在运行时出现bash: ./divtest: No such file or directory 错误。

    编译后运行

    lil@lil-kvm:~/assembly$./divtest 
    The quotient is 333, and the remainder is 10

     然后将汇编代码在ubuntu 12.04 AMD64环境下编译

    liliang@lil:~/assembly$as -o divtest_i64.o divtest_i64.s 
    divtest_i64.s:Assembler messages:
    divtest_i64.s:20:Error: invalid instruction suffix for `push'
    divtest_i64.s:21:Error: invalid instruction suffix for `push'
    divtest_i64.s:22:Error: invalid instruction suffix for `push'
    divtest_i64.s:25:Error: invalid instruction suffix for `push'

    修改汇编代码中的相关指令后的代码如下:

    .section .data
    dividend:
           .quad 8335
    divisor:
           .int 25
    quotient:
           .int 0
    remainder:
           .int 0
    output:
           .asciz  "The quotient is %d, and the remainder is %d\n"
    .section .text
    .globl _start
    _start:
           movl dividend, %eax
           movl dividend + 4, %edx
           divl divisor
           movl %eax, quotient
           movl %edx, remainder
           push remainder
           push quotient
           push $output
           call printf
           add $24, %esp
           push $0
           call exit

    进行编译连接,注意此时的参数--dynamic-linker/lib64/ld-linux-x86-64.so.2

    liliang@lil:~/assembly$as-o divtest_i64.o divtest_i64.s 

    liliang@lil:~/assembly$ld --dynamic-linker/lib64/ld-linux-x86-64.so.2 -lc -odivtest_i64divtest_i64.o

    liliang@lil:~/assembly$ ./divtest_i64 
    Segmentation fault (core dumped)

     后又尝试着修改了几处指定,均未能解决问题,通过gdb调试几次将问题锁定在了call printf, 每次当执行printf时就会爆出异常,开始怀疑也许跟printf的参数有关。

    于是用C写了下面的测试程序ctest.c:

    #include <stdio.h>

    int main(int argc,char* argv[])
    {
       int divident = 333;
       int remainder = 10;
       printf("dievident=%d, remainder=%d\n", divident, remainder);
    }

     将程序编译成目标文件,并进行反汇编。

    liliang@lil:~/assembly$gcc -c ctest.c
    liliang@lil:~/assembly$objdump -d ctest.o

    ctest.o:    file format elf64-x86-64

    Disassembly of section .text:

    0000000000000000<main>:
      0:   55                      push   %rbp
      1:    48 89e5                mov    %rsp,%rbp
      4:    48 83 ec20             sub    $0x20,%rsp
      8:    89 7dec                mov    %edi,-0x14(%rbp)
      b:    48 89 75e0             mov    %rsi,-0x20(%rbp)
      f:    c7 45 f8 4d 01 00 00     movl  $0x14d,-0x8(%rbp)
     16:    c7 45 fc 0a 00 00 00     movl  $0xa,-0x4(%rbp)
     1d:    b8 00 00 00 00          mov    $0x0,%eax
     22:    8b 55fc                mov    -0x4(%rbp),%edx
     25:    8b 4df8                mov    -0x8(%rbp),%ecx
     28:    89 ce                   mov    %ecx,%esi
     2a:    48 89c7                mov    %rax,%rdi
     2d:    b8 00 00 00 00          mov    $0x0,%eax
     32:    e8 00 00 00 00          callq  37 <main+0x37>
     37:   c9                      leaveq 
     38:    c3                      retq

     通过反汇编出来的代码发现在x64的汇编下,调用printf所用的参数传递方式与x86下面有很大的不同,x86下面是通过堆栈来传递,而在x64下是用寄存器来传递。于是照葫芦画瓢将汇编代码改成了下面的样子:

    .section .data

    dividend:
            .quad 8335
    divisor:
            .int 25
    quotient:
            .int 0
    remainder:
            .int 0
    output:
           .asciz  "The quotient is %d, and the remainder is %d\n"
    .section .text
    .globl _start
    _start:
            movl dividend, %eax
            movl dividend+4, %edx
            divl divisor
            movl %eax, quotient
            movl %edx, remainder
            movl remainder,%edx
            movl quotient, %esi
            mov $output, %rdi
            callq printf
            mov $0, %rdi
            callq exit

     重新汇编,连接,运行

    liliang@lil:~/assembly$as -o divtest_i64.o divtest_i64.s

    liliang@lil:~/assembly$ld --dynamic-linker /lib64/ld-linux-x86-64.so.2  -lc  -o divtest_i64 -lc divtest_i64.o 

    liliang@lil:~/assembly$./divtest_i64 
    The quotient is 333, and the remainder is 10

    终得预期结果。

    结论:在x64环境下,gcc所用的参数传递方式跟在x86下不同,前者用的是寄存器,后者用的是堆栈。

    事后百度出来一篇win_hate文章,作者通过实验列出了在x64下gcc的参数传递规则:

    我试验了多个参数的情况,发现一般规则为, 当参数少于7个时, 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9。当参数为 7 个以上时,  6 个与前面一样, 但后面的依次从 "右向左放入栈中。

    (1) 参数个数少于7:
    f (a, b, c, d, e, f);
    a->%rdi, b->%rsi, c->%rdx, d->%rcx, e->%r8, f->%r9

    g (a, b)
    a->%rdi, b->%rsi

    有趣的是实际上将参数放入寄存器的语句是从右到左处理参数表的这点与32位的时候一致.

    展开全文
  • arm函数调用参数传递规则

    千次阅读 2016-05-06 00:29:17
    解释 r0:参数1,返回时作为返回值1用,通用寄存器1 r1:参数2,返回值,通用寄存器2 r2:参数3,通用寄存器 r3:参数4,通用寄存器 r4 ~ r8:变量寄存器1,2,3,4,5 ...arm的调用规则遵循 ATPCS(ARM-Thu
  • linux参数传递规则

    千次阅读 2011-03-03 01:26:00
    一般规则为, 当参数少于7个时, 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9。当参数为 7 个以上时, 前 6 个与前面一样, 但后面的依次从 "右向左" 放入栈中。 例如: CODE (1) ...
  • string类参数传递规则

    2018-04-26 23:46:40
    字符串参数传递规则:字符串作为参数传递,不符合引用数据类型的规则。即对传进来的值做修改后,不会影响原来的值。(正常情况下,引用数据类型在传递参数时,传的是地址,即形参实参指向同一地址,形参变化会导致实参...
  • arm汇编函数调用参数传递规则

    千次阅读 2017-03-07 21:17:35
    1. 子程序通过寄存器R0~R3来传递参数. 这时寄存器可以记作: A0~A3 , 被调用的子程序在返回前无需恢复寄存器R0~R3的内容.  2. 在子程序中,使用R4~R11来保存局部变量,这时寄存器R4~R11可以记作: V1~V8 .如果在子程序...
  • ARM参数传递规则

    千次阅读 2013-12-24 17:31:48
    1. r0,r1,r2,r3,在调用函数时,用来存放前4个函数参数和返回值,r4-r11,r14,在调用函数时必须保存这些寄存器到堆栈当中。如果函数的参数多于4个,则多余参数存放在堆栈当中,即sp,sp+4,sp+8,…依次类推。   2....
  • 函数参数传递规则(一)

    千次阅读 2013-11-21 00:12:19
    1、函数参数传递规则  函数接口的两个要素是参数和返回值,c中传递方式:值传递和地址传递(即指针传递);c++中:值传递,地址传递和引用传递。  规则一:不论是函数的原型还是定义,都要明确写出每个参数的...
  • 在本文中以一段汇编代码为例... a->%rdi, b->%rsi, c->%rdx, d->%rcx, e->%r8, f->%r9 h->8(%esp) g->(%esp) call H 了解i386 和 x86_64 架构下的参数传递规则差异,对于我们利用vmcore 来分析程序问题非常的有帮助。
  • ARM函数调用时参数传递规则

    千次阅读 2013-10-12 20:14:23
    ARM函数调用时参数传递规则 之前在学习如何在C语言中嵌入汇编时有了解到C语言之前的参数调用是使用寄存器R0传递第一个参数,R1传递到第二个..一直到R3传递第四个参数.但是 实际上有时可能传递的参数非常多,超过8...
  • x86参数传递规则

    千次阅读 2014-03-21 20:52:57
    2.每个函数拥有固定数量的参数,这意味着被调用函数可以在一个地方对参数进行清理,即在被调用函数内部进行堆栈参数的清理,而不是分散在每一次调用该函数的代码中。 3.以下是调用过程: 1)将参数从右到左压入堆栈...
  • int 0x80系统调用的参数传递规则

    千次阅读 2014-03-20 21:26:40
    系统调用的参数传递规则: 传递给系统调用的参数则必须按照参数顺序依次存放到寄存器ebx,ecx,edx,esi,edi中,当系统调用完成之后,返回值存放在eax中; A.当系统调用所需参数的个数不超过5个的时候,执行"int$0x80"指令时...
  • Python中的函数参数传递仍然采用的是引用方式。 考虑如下代码: def func(x): x = 1 y = 2 func(y) 此时y的值仍然是2,这是由于当调用函数func()时,形参x与实参y引用了相同的对象2,在函数体中,x被重新...
  • ARM中函数参数传递规则

    千次阅读 2009-12-27 13:36:00
    ARM中函数参数传递规则: ARM中函数参数传递规则和X86不同。ARM规则是:当参数在4个以内时使用r0-r3寄存器分别传递1-4号参数。当参数个数超过4时,前4个参数保存在r0-r3寄存器中;后面的参数反向压入堆栈。即最后一...
  • 信号和槽之间参数传递是有要求的,以下几种情况,信号和槽能够正常连接 1、信号和槽参数类型、数量完全一致 2、信号的参数表比槽的参数表数量多,但是,从信号的参数表第一个参数开始,能够与槽的参数表完全对应,...
  • 0x80系统调用的参数传递规则

    千次阅读 2014-06-27 09:05:52
    系统调用的参数传递规则: 传递给系统调用的参数则必须按照参数顺序依次存放到寄存器ebx,ecx,edx,esi,edi中,当系统调用完成之后,返回值存放在eax中; A.当系统调用所需参数的个数不超过5个的时候,执行"int$0x80"指令...
  • python的函数调用参数传递规则: 由于python是动态语言,变量赋值实际上是把值绑定到名字上,内在并没有地址、指针什么的概念,(虽然可以验证两个变量是不是同一个地址的值)所以对变量的传递仍就是传值...
  • 常用ARM汇编指令及ATPCS规则

    千次阅读 2018-11-18 10:59:45
    基本的ATPCS规则包括寄存器使用规则、数据栈使用规则、参数传递规则。 1.寄存器使用规则 ARM处理器中有r0~r15共16个寄存器,它们的用途有一些约定的习惯,并依具这些用途定义了别名,如下表所示: ATPCS中...
  • Java 只有一种参数参数传递规则: 基于值的传递! */ import java.util.Arrays; public class Demo02 { public static void main(String[] args) { Koo koo = new Koo(); int a = 5; ko
  • ATPCS规则

    千次阅读 多人点赞 2019-10-28 21:08:11
    1.寄存器使用规则  ARM处理器中有rO-r15共16个寄存器,它们的用途有一些约定的习惯,并依据这些用途定义了别名,如表所示。 寄存器 别名 使用规则 r15 pc ...
  • 参数传递是什么?参数传递的是什么?

    千次阅读 热门讨论 2020-05-14 11:49:53
    参数传递传的是什么? 传值(ByVal) 传地址(ByRef,默认) 过程是什么? 执行一段相同的程序代码 有哪些过程? Sub Function 子程序 函数 Call语句调用 ...
  • 1.python中的位置传递:先用形式参数定义,然后在调用时对应位置使用实参(具体的数值)调用 def sum(a, b):  return a + b sum(5, 6)
  • 汇编和C语言的参数传递

    千次阅读 2014-03-11 15:22:45
    启动汇编文件里面有下面这一段语句: ldr r0, =0x30000000 mov r1, #4096 mov r2, #2048 @3. 复制长度= 2048(bytes),对于本实验的...bl nand_read其中这个nand_read函数定义在一个c文件里面,且带3个参数: void na
  • 子程序之间通过寄存器r0~r3来传递参数,当参数个数多于4个时,使用堆栈来传递参数。 在子程序中,使用寄存器r4~r11保存局部变量。 寄存器r13用作堆栈指针,记作SP。寄存器r14称为链接寄存器,记作LR。该寄存器...
  • python中参数传递的方法

    千次阅读 2020-08-13 14:21:15
    Python中函数传递参数的形式主要有以下五种,分别为位置传递,关键字传递,默认值传递,不定参数传递(包裹传递)和解包裹传递。 1.位置传递实例: def fun(a,b,c)  return a+b+c print(f(1,2,3)) 2.关键字...
  • Makefile规则(依赖文件、传递参数)

    千次阅读 2019-05-05 13:51:54
    Makefile的原则是倒序着写, 如test.c 编到test.bin: test.bin(目标) : test(依赖) ...makefile里给子目录的makefile传递参数: export CROSS_COMPILE := arm-eabi- export TOPDIR := $(CURDIR)
  • Shell - 传递参数到Shell 脚本

    千次阅读 2019-10-26 10:41:41
    文章目录Shell - 传递参数到Shell 脚本1、参数传递规则2、参数引用规则3、执行文件参数4、获得传递的参数个数5、其它特殊组合 Shell - 传递参数到Shell 脚本 1、参数传递规则 以空格分隔开 ./xxx.sh 1 2 3 2、参数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 381,516
精华内容 152,606
关键字:

参数传递规则