精华内容
下载资源
问答
  • 在函数中以数组作为形参

    千次阅读 2018-09-18 14:54:15
    数组的两特殊性质对我们定义和使用作用数组上的函数有影响,这两性质分别是: 不允许拷贝数组; 使用数组时通常会将其转换成指针。 因为不能拷贝数组,所以我们无法以值传递的方式使用数组参数。 因为...

    说明:

    数组的两个特殊性质对我们定义和使用作用在数组上的函数有影响,这两个性质分别是:

    • 不允许拷贝数组;
    • 使用数组时通常会将其转换成指针。

    因为不能拷贝数组,所以我们无法以值传递的方式使用数组参数。
    因为数组会被转换成指针,所以当我们为函数传递一个数组时,实际上传递的是指向数组首元素的指针

    尽管不能以值传递的形式传递数组,但是我们可以把形参写成类似数组的形式:

    //尽管形式不同,但这三个print函数是等价的
    //每个函数都有一个const int*类型的形参
    void print(const int*);
    void print(const int[]);
    void print(const int[10])//这里的维度表示我们期望数组含有多少元素,实际不一定

    当编译器处理对print函数的调用时,只检查传入的参数是否是const int*类型

    int i = 2;
    int j[2] = {1,2};
    print(&i);  //正确,&i的类型是int*
    print(j);   //正确,j被转换成int*并指向j[0]

    如果我们传给print函数的是一个数组,则实参自动地转换成指向首元素的指针,数组的大小对函数的调用没有影响。

    案例说明:

    下面以一个例子来说明数组作为形参被传递时,传递的是指向数组首元素的指针

    #include<iostream>
    using namespace std;
    
    int arraylength(int a[])
    {
        int len = sizeof(a) / sizeof(a[0]);
        cout << "len_of_arraylength: " << len << endl;
        return 0;
    }
    int main()
    {
        int a[13] = { 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
        int len = sizeof(a) / sizeof(a[0]);
        cout << "len_of_main: " << len << endl;
        arraylength(a);
        return 0;
    }

    这里写图片描述

    由于数组实际上是以指针的形式传递给函数的,因此一开始函数并不知道数组的确切尺寸,调用者应该为此提供额外的一些信息。管理指针形参有三种常用的技术:

    显示传递一个表示数组大小的形参

    专门定义一个表示数组大小的形参

    #include<iostream>
    using namespace std;
    //const int a[]等价于const int *a
    //len表示数组的大小,将它显示地传给函数用于控制对a元素的访问
    void print(const int a[],int len)               //显示传递一个表示数组大小的形参
    {
        for (int i = 0; i < len;i++)
            cout <<"a["<<i<<"]="<< a[i]<< endl;
    }
    int main()
    {
        int a[6] = { 5, 16, 39, 45, 51, 98};
        int len = sizeof(a) / sizeof(a[0]);
        print(a,len);
        return 0;
    }

    使用标记指定数组长度

    使用标准库函数begin和end

    C++11标准引入两个名为begin和end的函数,begin函数返回指向数组首元素的指针,end函数返回指向数组尾元素下一位置的指针,这两个函数定义在iterator头文件中。

    示例代码如下:

    #include<iostream>
    using namespace std;
    void print(const int *abeg, const int *aend)
    {
        while (abeg < aend)
        {
            cout << *abeg<< " ";
            abeg++;
        }
        cout << endl;
    }
    
    int main()
    {
        int a[6] = { 5, 16, 39, 45, 51, 98 };
        int *abeg = begin(a);
        int *aend = end(a);
        print(abeg,aend);
        return 0;
    }

    这里写图片描述

    参考博文:https://www.cnblogs.com/larryking/p/5734417.html

    展开全文
  • 在函数中以数组作为形参的方法

    千次阅读 2016-07-28 15:02:36
    本文介绍了三种在函数中以数组作为形参时的处理方法,重点介绍C++11标准是如何管理数组大小的。 数组的两特殊性质对我们定义和使用作用数组上的函数有影响,这两性质分别是: 不允许拷贝数组以及使用数组时...

    本文介绍了三种在函数中以数组作为形参时的处理方法,重点介绍C++11标准是如何管理数组大小的。

    数组的两个特殊性质对我们定义和使用作用在数组上的函数有影响,这两个性质分别是:
    不允许拷贝数组以及使用数组时通常会将其转换成指针。因为不能拷贝数组,所以我们无法以值传递的方式使用数组参数。因为数组会被转换成指针,所以当我们为函数传递一个数组时,实际上传递的是指向数组首元素的指针。

    尽管不能以值传递的形式传递数组,但是我们可以把形参写成类似数组的形式:

    //尽管形式不同,但这三个print函数是等价的
    //每个函数都有一个const int*类型的形参
    void print(const int*);
    void print(const int[]);
    void print(const int[10])//这里的维度表示我们期望数组含有多少元素,实际不一定
    

    当编译器处理对print函数的调用时,只检查传入的参数是否是const int*类型:

    int i = 2;
    int j[2] = {1,2};
    print(&i);  //正确,&i的类型是int*
    print(j);   //正确,j被转换成int*并指向j[0]
    

    如果我们传给print函数的是一个数组,则实参自动地转换成指向首元素的指针,数组的大小对函数的调用没有影响。

    由于数组实际上是以指针的形式传递给函数的,因此一开始函数并不知道数组的确切尺寸,调用者应该为此提供额外的一些信息。管理指针形参有三种常用的技术:

    使用标记指定数组长度

    这种方法要求数组本身包含一个结束标记,使用这种方法的典型示例是C风格字符串。C风格字符串存储在字符数组中,并且在最后一个字符后面跟着一个空字符。函数在处理C风格字符串时遇到空字符就停止:

    void print(const char *cp)
    {
        if(cp){     //若cp不是空指针
            while(*cp){     //只要指针所指字符不是空字符
                cout<<*cp++;    //输出当前字符并将指针前移
            }
        }
    }

    这个方法适用于那些有明显结束标记且该标记不会与普通数据混淆的情况。

    显示传递一个表示数组大小的形参

    这种方法是专门定义一个表示数组大小的形参,在C程序和过去的C++程序中常常使用这种方法。

    //const int ia[]等价于const int *ia
    //size表示数组的大小,将它显示地传给函数用于控制对ia元素的访问
    void print(const int ia[],size_t size)
    {
        for(size_t i = 0; i != size; ++i){
            cout<<ia[i]<<" ";
        }
    }
    

    这种方法通过形参size的值确定要输出多少个元素,调用print函数时必须传入这个表示数组大小的值:

    int j[] = {1,2,3};
    
    print(j,3);

    使用标准库函数begin和end

    C++11标准引入两个名为begin和end的函数,begin函数返回指向数组首元素的指针,end函数返回指向数组尾元素下一位置的指针,这两个函数定义在iterator头文件中。
    示例代码如下:

    #include<iostream>
    using namespace std;
    int main()
    {
        int arr[] = {1,2,3,4,5,6,7,8,9,-1,5,3,4};
    
        int *pbeg = begin(arr);     //指向arr首元素的指针
        int *pend = end(arr);       //指向arr尾元素的指针
    
        //寻找第一个负值元素,如果已经检查完全部元素则结束循环
        while(pbeg != pend && *pbeg >= 0){
            ++pbeg;
        }
        cout<<*pbeg<<endl;  //输出第一个负数的值
    }

    对于本文的print函数,可以写成如下形式:

    void print(const int *beg, const int *end)
    {
        //输出beg到end之间(不含end)的所有元素
        while(beg != end)
            cout<<*beg++<<" ";
    }

    为了调用这两个函数,我们需要传入两个指针:一个指向要输出的首元素,另一个指向尾元素的下一个位置。使用方法如下:

    int a[] = {1,2,3};
    
    print(begin(j),end(j));
    展开全文
  • Python函数:实参与形参

    千次阅读 2019-03-26 11:51:18
    学习C语言函数的时候,遇到的问题主要有形参实参的区别、参数的传递和改变、变量的作用域。同样Python,关于对函数的理解和使用也存在这些问题。下面来逐一讲解。 一.函数形参和实参的区别  相信过编程...

    在上一篇文章中提到了Python中函数的定义和使用,在这篇文章里我们来讨论下关于函数的一些更深的话题。在学习C语言函数的时候,遇到的问题主要有形参实参的区别、参数的传递和改变、变量的作用域。同样在Python中,关于对函数的理解和使用也存在这些问题。下面来逐一讲解。

    一.函数形参和实参的区别

      相信有过编程语言经验的朋友对形参和实参这两个东西并不陌生。形参全称是形式参数,在用def关键字定义函数时函数名后面括号里的变量称作为形式参数实参全称为实际参数,在调用函数时提供的值或者变量称作为实际参数。举个例子:

    复制代码

    复制代码

    #这里的a和b就是形参
    def add(a,b):
        return a+b
    
    #这里的1和2是实参
    add(1,2)
    x=2
    y=3
    #这里的x和y是实参
    add(x,y)

    复制代码

    复制代码

    二.参数的传递和改变

      在大多数高级语言当中,对参数的传递方式这个问题的理解一直是个难点和重点,因为它理解起来并不是那么直观明了,但是不理解的话在编写程序的时候又极其容易出错。下面我们来探讨一下Python中的函数参数的传递问题。

      首先在讨论这个问题之前,我们需要明确一点就是在Python中一切皆对象,变量中存放的是对象的引用。这个确实有点难以理解,“一切皆对象”?对,在Python中确实是这样,包括我们之前经常用到的字符串常量,整型常量都是对象。不信的话可以验证一下:

    print id(5)
    print id('python')
    x=2
    print id(x)
    y='hello'
    print id(y)

     

      这段代码的运行结果是:

      

      先解释一下函数id( )的作用。下面这段话是官方文档对id()函数的解释:

      

      显而易见,id(object)函数是返回对象object在其生命周期内位于内存中的地址,id函数的参数类型是一个对象,因此对于这个语句

    id(2)没有报错,就可以知道2在这里是一个对象。下面再看几个例子:

    x=2
    print id(2)
    print id(x)
    y='hello'
    print id('hello')
    print id(y)

      其运行结果为:

      

      从结果可以看出,id(x)和id(2)的值是一样的,id(y)和id('hello')的值也是一样的。

      在Python中一切皆对象,像2,'hello'这样的值都是对象,只不过5是一个整型对象,而'hello'是一个字符串对象。上面的x=2,在Python中实际的处理过程是这样的:先申请一段内存分配给一个整型对象来存储整型值2,然后让变量x去指向这个对象,实际上就是指向这段内存(这里有点和C语言中的指针类似)。而id(2)和id(x)的结果一样,说明id函数在作用于变量时,其返回的是变量指向的对象的地址。因为变量也是对象,所以在这里可以将x看成是对象2的一个引用。

      下面再看几个例子:

    复制代码

    复制代码

    x=2
    print id(x)
    y=2
    print id(y)
    s='hello'
    print id(s)
    t=s
    print id(t)

    复制代码

    复制代码

      其运行结果为:

      

      从运行结果可以看到id(x)和id(y)的结果是相同的,id(s)和id(t)的结果也是相同的。这说明x和y指向的是同一对象,而t和s也是指向的同一对象。x=2这句让变量x指向了int类型的对象2,而y=2这句执行时,并不重新为2分配空间,而是让y直接指向了已经存在的int类型的对象2.这个很好理解,因为本身只是想给y赋一个值2,而在内存中已经存在了这样一个int类型对象2,所以就直接让y指向了已经存在的对象。这样一来不仅能达到目的,还能节约内存空间。t=s这句变量互相赋值,也相当于是让t指向了已经存在的字符串类型的对象'hello'(这个原理和C语言中指针的互相赋值有点类似)。

      看这幅图就理解了:

      

      下面再看几个例子:

    复制代码

    复制代码

    x=2
    print id(2)
    print id(x)
    x=3
    print id(3)
    print id(x)
    L=[1,2,3]
    M=L
    print id(L)
    print id(M)
    print id(L[2])
    L[0]=2
    print id(L)
    print M

    复制代码

    复制代码

      运行结果为:

      

      下面来分析一下这个结果,两次的id(x)的值不同,这个可能让人有点难以理解。注意,在Python中,单一元素的对象是不允许更改的,比如整型数据、字符串、浮点数等。x=3这句的执行过程并不是先获取x原来指向的对象的地址,再把内存中的值更改为3,而是新申请一段内存来存储对象3,再让x去指向对象3,所以两次id(x)的值不同。然而为何改变了L中的某个子元素的值后,id(L)的值没有发生改变?在Python中,复杂元素的对象是允许更改的,比如列表、字典、元组等。Python中变量存储的是对象的引用,对于列表,其id()值返回的是列表第一个子元素L[0]的存储地址。就像上面的例子,L=[1,2,3],这里的L有三个子元素L[0],L[1],L[2],L[0]、L[1]、L[2]分别指向对象1、2、3,id(L)值和对象3的存储地址相同,看下面这个图就明白了:

      

      因为L和M指向的是同一对象,所以在更改了L中子元素的值后,M也相应改变了,但是id(L)值并没有改变,因为这句L[0]=2只是让L[0]重新指向了对象2,而L[0]本身的存储地址并没有发生改变,所以id(L)的值没有改变( id(L)的值实际等于L[0]本身的存储地址)。

     

      下面就来讨论一下函数的参数传递和改变这个问题。

      在Python中参数传递采用的是值传递,这个和C语言有点类似。先看几个例子:

    复制代码

    复制代码

    def modify1(m,K):
        m=2
        K=[4,5,6]
        return 
        
    def modify2(m,K):
        m=2
        K[0]=0
        return
    
    n=100
    L=[1,2,3]
    modify1(n,L)
    print n
    print L
    modify2(n,L)
    print n
    print L
        

    复制代码

    复制代码

      程序运行结果为:

      

      从结果可以看出,执行modify1( )之后,n和L都没有发生任何改变;执行modify2( )后,n还是没有改变,L发生了改变。因为在Python中参数传递采用的是值传递方式,在执行函数modify1时,先获取n和L的id( )值,然后为形参m和K分配空间,让m和K分别指向对象100和对象[1,2,3]。m=2这句让m重新指向对象2,而K=[4,5,6]这句让K重新指向对象[4,5,6]。这种改变并不会影响到实参n和L,所以在执行modify1之后,n和L没有发生任何改变;在执行函数modify2时,同理,让m和K分别指向对象2和对象[1,2,3],然而K[0]=0让K[0]重新指向了对象0(注意这里K和L指向的是同一段内存),所以对K指向的内存数据进行的任何改变也会影响到L,因此在执行modify2后,L发生了改变。

    三.变量的作用域

      在Python中,也存在作用域这个问题。在Python中,会为每个层次生成一个符号表,里层能调用外层中的变量,而外层不能调用里层中的变量,并且当外层和里层有同名变量时,外层变量会被里层变量屏蔽掉。举个例子:

    复制代码

    复制代码

    def function():
        x=2
        count=2
        while count>0:
            x=3
            print x
            count=count-1
    
    function()        
        

    复制代码

    复制代码

      在函数function中,while循环外面和while循环里面都有变量x,此时,while循环外面的变量x会被屏蔽掉。注意在函数内部定义的变量作用域都仅限于函数内部,在函数外部是不能够调用的,一般称这种变量为局部变量。

      还有一种变量叫做全局变量,它是在函数外部定义的,作用域是整个文件。全局变量可以直接在函数里面应用,但是如果要在函数内部改变全局变量,必须使用global关键字进行声明。

    复制代码

    复制代码

    x=2
    
    def fun1():
        print x
        
    def fun2():
        global x
        x=3
        print x
    
    fun1()
    fun2()
    print x

    复制代码

    复制代码

      关于函数的形参和实参、参数的传递以及变量的作用域问题这里就讨论这么多了,关于函数参数的类型问题会在《Python中的函数(三)》中继续讲解。

    展开全文
  • 深入理解js中函数中形参与实参

    千次阅读 2017-05-14 11:37:15
    前面的话  javascript函数的参数与... javascript函数定义并未指定函数形参的类型,函数调用也未对传入的实参值做任何类型检查。实际上,javascript函数调用甚至不检查传入形参的个数function add(x){ return

    前面的话
      javascript函数的参数与大多数其他语言的函数的参数有所不同。函数不介意传递进来多少个参数,也不在乎传进来的参数是什么数据类型,甚至可以不传参数。
    arguments
      javascript中的函数定义并未指定函数形参的类型,函数调用也未对传入的实参值做任何类型检查。实际上,javascript函数调用甚至不检查传入形参的个数

    function add(x){
    return x+1;
    }
    console.log(add(1));//2
    console.log(add('1'));//'11'
    console.log(add());//NaN
    console.log(add(1,2));//2

    同名形参
      在非严格模式下,函数中可以出现同名形参,且只能访问最后出现的该名称的形参。

    function add(x,x,x){
    return x;
    }
    console.log(add(1,2,3));//3

      而在严格模式下,出现同名形参会抛出语法错误

    function add(x,x,x){
    'use strict';
    return x;
    }
    console.log(add(1,2,3));//SyntaxError: Duplicate parameter name not allowed in this context

    参数个数
      当实参比函数声明指定的形参个数要少,剩下的形参都将设置为undefined值

    function add(x,y){
    console.log(x,y);//1 undefined
    }
    add(1);

      常常使用逻辑或运算符给省略的参数设置一个合理的默认值

    function add(x,y){
    y = y || 2;
    console.log(x,y);//1 2
    }
    add(1);

      [注意]实际上,使用y || 2是不严谨的,显式地设置假值(undefined、null、false、0、-0、”、NaN)也会得到相同的结果。所以应该根据实际场景进行合理设置。更多设置默认参数的方法:ES5和ES6中对函数设置默认参数的方法总结
      
      当实参比形参个数要多时,剩下的实参没有办法直接获得,需要使用即将提到的arguments对象
      javascript中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组,而不关心数组中包含哪些参数。在函数体内可以通过arguments对象来访问这个参数数组,从而获取传递给函数的每一个参数。arguments对象并不是Array的实例,它是一个类数组对象,可以使用方括号语法访问它的每一个元素

    function add(x){
    console.log(arguments[0],arguments[1],arguments[2])//1 2 3
    return x+1;
    }
    console.log(add(1,2,3));//2

      arguments对象的length属性显示实参的个数,函数的length属性显示形参的个数

    function add(x,y){
    console.log(arguments.length)//3
    return x+1;
    }
    add(1,2,3);
    console.log(add.length);//2

      形参只是提供便利,但不是必需的

    function add(){
    return arguments[0] + arguments[1];
    }
    console.log(add(1,2));//3

    对象参数
      当一个函数包含超过3个形参时,要记住调用函数中实参的正确顺序实在让人头疼

    function arraycopy(/*array*/from,/*index*/form_start,
    /*array*/to,/*index*/to_start,/*integer*/length){
    //todo
    }

    通过名/值对的形式来传入参数,这样参数的顺序就无关紧要了。定义函数的时候,传入的实参都写入一个单独的对象之中,在调用的时候传入一个对象,对象中的名/值对是真正需要的实参数据

    function easycopy(args){
    arraycopy(args.from,args.form_start || 0,args.to,args.to_start || 0, args.length);
    }
    var a = [1,2,3,4],b =[];
    easycopy({form:a,to:b,length:4});

    同步
      当形参与实参的个数相同时,arguments对象的值和对应形参的值保持同步

    function test(num1,num2){
    console.log(num1,arguments[0]);//1 1
    arguments[0] = 2;
    console.log(num1,arguments[0]);//2 2
    num1 = 10;
    console.log(num1,arguments[0]);//10 10
    }
    test(1);

      [注意]虽然命名参数和对应arguments对象的值相同,但并不是说读取两个值会访问相同的内存空间。它们的内存空间是独立的,但值是同步的
      但在严格模式下,arguments对象的值和形参的值是独立的

    function test(num1,num2){
    'use strict';
    console.log(num1,arguments[0]);//1 1
    arguments[0] = 2;
    console.log(num1,arguments[0]);//1 2
    num1 = 10;
    console.log(num1,arguments[0]);//10 2
    }
    test(1);

      当形参并没有对应的实参时,arguments对象的值与形参的值并不对应

    function test(num1,num2){
    console.log(num1,arguments[0]);//undefined,undefined
    num1 = 10;
    arguments[0] = 5;
    console.log(num1,arguments[0]);//10,5
    }
    test(); 

    内部属性
    【callee】
      arguments对象有一个名为callee的属性,该属性是一个指针,指向拥有这个arguments对象的函数
      下面是经典的阶乘函数

    function factorial(num){
    if(num <=1){
    return 1;
    }else{
    return num* factorial(num-1);
    }
    } 
    console.log(factorial(5));//120

      但是,上面这个函数的执行与函数名紧紧耦合在了一起,可以使用arguments.callee可以消除函数解耦

    function factorial(num){
    if(num <=1){
    return 1;
    }else{
    return num* arguments.callee(num-1);
    }
    } 
    console.log(factorial(5));//120

      但在严格模式下,访问这个属性会抛出TypeError错误

    function factorial(num){
    'use strict';
    if(num <=1){
    return 1;
    }else{
    return num* arguments.callee(num-1);
    }
    } 
    //TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them
    console.log(factorial(5));

      这时,可以使用具名的函数表达式

    var factorial = function fn(num){
    if(num <=1){
    return 1;
    }else{
    return num*fn(num-1);
    }
    }; 
    console.log(factorial(5));//120

    【caller】
      实际上有两个caller属性
    【1】函数的caller
      函数的caller属性保存着调用当前函数的函数的引用,如果是在全局作用域中调用当前函数,它的值是null

    function outer(){
    inner();
    }
    function inner(){
    console.log(inner.caller);//outer(){inner();}
    }
    outer(); 
    function inner(){
    console.log(inner.caller);//null
    }
    inner();

      在严格模式下,访问这个属性会抛出TypeError错误

    function inner(){
    'use strict';
    //TypeError: 'caller' and 'arguments' are restricted function properties and cannot be accessed in this context
    console.log(inner.caller);
    }
    inner();

    【2】arguments对象的caller
      该属性始终是undefined,定义这个属性是为了分清arguments.caller和函数的caller属性

    function inner(x){
    console.log(arguments.caller);//undefined
    }
    inner(1);

      同样地,在严格模式下,访问这个属性会抛出TypeError错误

    function inner(x){
    'use strict';
    //TypeError: 'caller' and 'arguments' are restricted function properties and cannot be accessed in this context
    console.log(arguments.caller);
    }
    inner(1);

    函数重载
      javascript函数不能像传统意义上那样实现重载。而在其他语言中,可以为一个函数编写两个定义,只要这两个定义的签名(接受的参数的类型和数量)不同即可
      javascript函数没有签名,因为其参数是由包含0或多个值的数组来表示的。而没有函数签名,真正的重载是不可能做到的

    //后面的声明覆盖了前面的声明
    function addSomeNumber(num){
    return num + 100;
    }
    function addSomeNumber(num){
    return num + 200;
    }
    var result = addSomeNumber(100);//300

      只能通过检查传入函数中参数的类型和数量并作出不同的反应,来模仿方法的重载

    function doAdd(){
    if(arguments.length == 1){
    alert(arguments[0] + 10);
    }else if(arguments.length == 2){
    alert(arguments[0] + arguments[1]);
    }
    }
    doAdd(10);//20
    doAdd(30,20);//50

    参数传递
      javascript中所有函数的参数都是按值传递的。也就是说,把函数外部的值复制到函数内部的参数,就和把值从一个变量复制到另一个变量一样
    【1】基本类型值
      在向参数传递基本类型的值时,被传递的值会被复制给一个局部变量(命名参数或arguments对象的一个元素)

    function addTen(num){
    num += 10;
    return num;
    }
    var count = 20;
    var result = addTen(count);
    console.log(count);//20,没有变化
    console.log(result);//30

    【2】引用类型值
      在向参数传递引用类型的值时,会把这个值在内存中的地址复制给一个局部变量,因此这个局部变量的变化会反映在函数的外部

    function setName(obj){
    obj.name = 'test';
    }
    var person = new Object();
    setName(person);
    console.log(person.name);//'test'

      当在函数内部重写引用类型的形参时,这个变量引用的就是一个局部对象了。而这个局部对象会在函数执行完毕后立即被销毁

    function setName(obj){
    obj.name = 'test';
    console.log(person.name);//'test'
    obj = new Object();
    obj.name = 'white';
    console.log(person.name);//'test'
    }
    var person = new Object();
    console.log(person.name);//undefined
    setName(person); 
    console.log(person.name);//'test'
    展开全文
  • Python3函数传参和函数形参定义方式

    千次阅读 2018-01-20 11:00:10
    1、函数调用时的参数传递方式:(调用函数)  传递方式以下四种:    位置传参    序列传参    关键字传参  字典关键字传参 (1)位置传参:  实际参数(实参)的对应关系与形式参数(形参)对应...
  • Python函数中形参实参讲解

    千次阅读 2019-09-12 15:53:51
    1、形参和实参的区别 形参就是形式上的参数,可以理解为数学的X,没有实际的...调用函数时,必须函数调用每个实参都关联到函数定义的一个形参。关联方式是基于实参的顺序,这被称作位置实参 def getinfo(n...
  • 函数形参的理解

    2020-11-01 18:50:05
    典型函数定义包括四部分:返回类型,函数的名字,形参列表和函数体。格式如下 int max(int a,int b) {函数体} 函数的作用 我看来,函数的一般作用是对一定的输入产生一定的输出,当然可以没有输入;至于...
  • 函数形参和实参

    2020-04-22 21:39:11
    在函数getinfo() 的定义,变量name和age 是一个形参 ——函数完成其工作所需的一项信息。代码getinfo(‘westos’,11),值’westos’和11 是一个实参 。 实参是调用函数时传递给函数的信息。 调用函数时,将要...
  • 例题:给定程序函数fun的功能是:在形参s所指字符串每个非数字字符之后插入一个“*”号。 例如,形参s所指的字符串为:albc45sdtg56f,则执行结果为:a*1b*c*45s*d*t*g*56f*。 请勿改动主函数main与其他函数...
  • 数组作为函数形参

    2019-05-13 21:50:13
    翻看以前学习资料时,发现如果用数组作为形参,其大小[即sizeof(形参名)]与指针大小一样——大小为 4。网上找到一篇写的很好,所以转载过来作为笔记。
  • 1,函数:我们定义好一事情,等想用的时候直接拿出来就行了,代码不用每次都写,节省无用功,(就好比把一次性做好的红烧肉放到冰箱里,什么时候想吃,就拿出来吃就好了,不用再费时费力去做了) 函数的官方定义:对代码块...
  • 一篇文章带你搞定 Python sort 方法与 sorted 函数

    千次阅读 多人点赞 2019-08-16 09:58:50
    Python 列表内置的 list.sort() 方法可以直接修改列表 还有一 sorted() 内置函数,它会从一可迭代对象构建一新的排序列表 文章目录一、基本排序二、关键函数三、Operator 函数五、升序和降序六、补充:...
  • C语言函数

    千次阅读 多人点赞 2019-11-13 20:02:10
    c语言函数 ...库(Library)是编程的一基本概念,可以认为它是一系列函数的集合,磁盘上往往是一文件夹。C语言自带的库称为标准库(Standard Library),其他公司或个人开发的库称为第三方库(Th...
  • pythonmain函数函数形参arg

    千次阅读 2019-08-27 14:43:10
    main函数的作用 if __name__ = '__main__' 可以保证模块导入时不会...C/Java,main是程序执行的起点,Python,也类似的运行机制,但方式却截然不同:Python使用缩进对齐组织代码的执行,所有没有缩进的...
  • 函数的实参和形参、作为值的函数

    千次阅读 2019-01-01 22:41:13
    JavaScript函数定义并未指定函数形参的类型,函数调用也未对传入的实参值做任何类型检查。实际上,JavaScript函数调用甚至不检查传入形参的个数。 可选形参 当调用函数的时候传入的实参比函数声明时指定的...
  • 如果以一衍生类指针指向一基础类对象,必须先做强制转型动作(explicit cast),这种做法很危险,也不符合语法习惯,程序设计上也会给程序员带来困扰。(一般不会这么去定义) 如果基础类和衍生类定义了相同...
  • 定义函数时,小括号的参数,是用来接收参数用的,称为"形参"。此外形参是可以任意修改的。 必选参数 必须要传递的参数 默认参数 如果没有传递参数,使用默认值;如果传递了参数,则使用传递的参数 可变...
  • 本篇文章讲解讨论了实参与形参的定义及辨识,同时讲解了引用调用和值调用的分析以及结论
  • 函数形参与返回

    千次阅读 2017-08-16 17:14:49
    函数中形参与实参的传递实质: 函数在调用时,会把实参变量的值复制给形参变量,即实参与形参是两不同的变量。形参的变量在函数返回后释放内存 ①改变形参指针的值: 实参和形参的值都为内存地址,指向同一...
  • Python多变形参函数的使用详解

    万次阅读 2018-08-11 11:25:46
    Python当如输入的参数数不能确定时,会定义不定形参函数,即多变形参函数。这样定义的函数可以调用函数时决定函数参数的个数,更加灵活好用。 1.不定参数:不确定调用函数时输入几参数,所以使用不定参数...
  • 函数调用实参和形参变化问题

    千次阅读 2015-01-26 19:52:48
    很多初学者搞不明白子函数中什么时候可以改变实参值,什么时候不会改变。...而子函数中用来接收变量的参数就称形参。如下: #include void fun(int p,int q) { int temp; temp = p; p = q; q = temp; return ;
  • 单片机编程中在C语言里嵌入汇编比较常见,只需要在嵌入前后写入:#pragma asm MOV A,#0x00#pragma endasm两声明即可,在它们中间就可以使用汇编代码,因为汇编是机器码,执行速度快,在对程序运行速度要求高的...
  • 写出一个函数后,就可以一直调用。 定义函数函数的基本组成: 1.1 向函数传递参数 向函数中传递任意参数,这样打印出的结果就可以根据自己的选择,做出改变。即是下一节讲到的形参 1 #向函数传递信息 2 ...
  • 1.函数的定义 ... (1)函数的分类 a. 系统函数(库函数):库函数是由头文件声明的,用户不需要自己声明,因此程序开头需要用#include指令所包含头文件 ... 函数参数的函数。 (2)函...
  • C的函数声明和形参

    2015-07-06 15:34:26
    1.函数定义前要声明,一般都是头文件声明。调用前要声明,否则编译报错。 2.被调函数返回类型为整形或者char型,系统会自理。 3.被调函数定义主函数之前。 4.定义所有函数之前,先对调用函数做了声明...
  • 指针数组的重要应用是作为main函数形参以往的程序,main函数的第一行一般形式为: int main()或 int main(void) 括号中为空或为“void”,表示main函数没有参数,调用main函数时不必给出参数。 这...
  • 构造函数后引用函数的话实际的参数必须和构造函数时的形参数据类型一致,为此笔者做了一实验,代码如下: 笔者首先构造了一求绝对值的函数zabs(),然后将整型变量b传入函数,计算其绝对值,程序执行结果...
  • 这是最常见的定义方式,一个函数可以定义任意个参数,每个参数间用逗号分割,用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等 的值(实际参数),而且顺序必须相同,也就是说这种调用...
  • 今天看鸡啄米的C++系列教程的时候学到了三有趣的东西:引用调用、内联函数和带默认形参值的函数。 首先是引用调用: 引用调用据百度百科说是C++特有的概念。C++函数调用三种方式:值调用、引用调用和地址...
  • 函数中实参到形参的传递

    千次阅读 2012-06-11 16:41:05
    函数并没有访问调用函数所传递的实参本身,所以不会改变实参的值。 void swap(int x, int y) { int tmp; tmp = x; x = y; y = tmp; } int main() { int a = 1,b = 2; cout<<"a = "<<a<<"\t"<<"

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,738
精华内容 46,695
关键字:

在函数中每个形参必须有