精华内容
下载资源
问答
  • 参数传递有3种方式:值传递地址传递引用传递tips:被调用函数的形参只有函数被调用时才会临时分配存储单元,一旦调用结束占用内存便会被释放值传递和地址传递传递的都是实参一个拷贝C语言中实参和形参之间...

    参数传递,是在程序运行过程中,实际参数就会将参数值传递给相应的形式参数,然后在函数中实现对数据处理和返回的过程。参数传递有3种方式:

    值传递

    地址传递

    引用传递

    tips:

    被调用函数的形参只有函数被调用时才会临时分配存储单元,一旦调用结束占用的内存便会被释放

    值传递和地址传递,传递的都是实参的一个拷贝

    C语言中实参和形参之间的数据传递是单向的“值传递”,单向传递,只能由实参传给形参,反之不行

    输出格式并没有选择%p而是选择了%d,因为十进制的数看起来更直观

    1 值传递

    如果只是传递值的话:

    #include

    //值传递:传值

    void swap( int x, int y);

    int main()

    {

    int a=2,b=3;

    printf("before:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    swap(a,b);

    printf("after:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    return 0;

    }

    void swap(int x,int y)

    {

    int tmp;

    tmp=x;

    x=y;

    y=tmp;

    printf("inside:形参为x,y\nx=%d,地址为%d\ny=%d,地址为%d\n\n",x,&x,y,&y);

    }

    执行结果:从形参x和y的地址来看,传递的是实参a和b的拷贝。对拷贝的修改不会改变实参的值。。

    d32c30831f3cddeec27b1842f158f812.png

    如果值传递,传递的是地址呢?

    #include

    //值传递:传地址

    void swap( int *x, int *y);

    int main()

    {

    int a=2,b=3;

    printf("before:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    swap(&a,&b);

    printf("after:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    return 0;

    }

    void swap(int *x,int *y)

    {

    int *tmp= NULL;

    tmp=x;

    x=y;

    y=tmp;

    printf("inside:形参为*x,*y\n*x=%d,x=%d,地址为%d\n*y=%d,y=%d,地址为%d\n\n",*x,x,&x,*y,y,&y);

    }

    执行结果:形参是a和b的地址,但通过a和b的地址(即x和y)访问到的是a和b的拷贝。直接交换a和b的地址失败。

    0139eaf0c3c2f334423fd119940e9932.png

    2地址传递

    #include

    //地址传递

    void swap( int *x, int *y);

    int main()

    {

    int a=2,b=3;

    printf("before:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    swap(&a,&b);

    printf("after:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    return 0;

    }

    void swap(int *x,int *y)

    {

    int tmp;

    tmp=*x;

    *x=*y;

    *y=tmp;

    printf("inside:形参为*x,*y\n*x=%d,x=%d,地址为%d\n*y=%d,y=%d,地址为%d\n\n",*x,x,&x,*y,y,&y);

    }

    执行结果为: 形参是a和b的地址,但通过a和b的地址(即x和y)访问到的是a和b的拷贝。虽然不能直接交换a和b的地址,但是可以修改a和b的地址(即x和y)指向的值。也就是说,不能直接修改指针,但是可以修改指针指向的值。所以这一次a和b的值交换了。

    cb2eb290d2719fed5fca127f9358cbd8.png

    3 引用传递

    #include

    //引用传递

    void swap( int &x, int &y);

    int main()

    {

    int a=2,b=3;

    printf("before:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    swap(a,b);

    printf("after:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);

    return 0;

    }

    void swap(int &x,int &y)

    {

    int tmp;

    tmp=x;

    x=y;

    y=tmp;

    printf("inside:形参为&x,&y\nx=%d,地址为%d\ny=%d,地址为%d\n\n",x,&x,y,&y);

    }

    void swap( int &x, int &y); //表示传递进去的是实参,而不是拷贝。

    执行结果为: 传递的是实参,而不是实参的拷贝。对实参的修改,将会成功的改变其中的值。

    418c97554e59406a0c6f5f9eb86f0613.png

    补充

    int x=1;

    int *y=&x; //用于指针传递,y有自己独立的内存地址,存储的内容是x的地址,*y是x的值

    int &z=x; //用于引用传递,可以理解为z就是x,x就是z,只不过名字不一样

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  •  1、值传递:形参是实参的拷贝,改变函数形参的值并不会影响外部实参的值,这是最常用的一种传参方法,也是最简单的一种传参方法,只需要传递参数,返回值那是return考虑的;  2、指针传递:指针传递参数从本质上...
    
      1. C++从概念上来说一下这几种函数传参方式及区别:
      
     1、值传递:形参是实参的拷贝,改变函数形参的值并不会影响外部实参的值,这是最常用的一种传参方法,也是最简单的一种传参方法,只需要传递参数,返回值那是return考虑的;
      
     2、指针传递:指针传递参数从本质上来说也是值传递,它传递的是一个地址。【值传递过程中,被调函数的形参作为被调函数的局部变量来处理,即在函数内的栈中开辟内存空间以存放由主调函数放进来的实参的值,从而成了实参的一个副本(记住这个,函数内的参数是实参的副本,变量存储的是地址值)】。由于指针传递的是外部实参的地址,当被调函数的形参值发生改变时,自然外部实参值也发生改变。
       
    3、引用传递:被调函数的形参虽然也作为局部变量在栈中开辟了内存空间,但是栈中存放的是由主调函数放进的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中实参变量(实参和形参通过引用,合二为一,说白点就是:一个人,有两个名字那种;后面想会详细说)。因此,形参的任何改动都会直接影响到实参。

    4.引用即“别名”,引用有自己的物理内存地址,该地址中存放的是所引用变量的内存,编译器对引用操作自动会添加取引用操作(*b);用反汇编查看地址时,需要注意编译器的内存地址对其方式,这会影响到对地址的操作。

    2. Java形参实参传递问题

    三句话总结一下:

    1.对象就是传引用

    2.原始类型就是传值

    3.String等immutable类型因为没有提供自身修改的函数,每次操作都是新生成一个对象,所以要特殊对待。可以认为是传值。

    其他参考文章:

    http://www-128.ibm.com/developerworks/cn/java/l-jpointer/index.html

    http://dreamhead.blogbus.com/logs/2005/05/1189478.html

    http://www.javaeye.com/topic/12961

    3.

    引用和指针的一些区别如下:

    1. 可以先创建指针,然后再指向一个目标。而引用在创建的时候就必须指定目标。总得现有这个人,然后这个人才有昵称吧。

    2. 相对于引用来说,指针非常自由,指针可以指向一个目标也可以指向NULL。但是却不能有NULL引用。这不仅违背了引用的设计初衷,而且逻辑上也说不过去。一个事物本身就不存在了,哪来的昵称?就算能有昵称的话,那它本来的名字叫什么?

    3. 一旦为一个变量设立引用以后,这个引用就和这个变量绑定了。换句话说,就是这个引用就不能指向别的变量上。所以引用就相当于变量的属性。试想,给一个人取了绰号以后,总不可能用这个绰号去称呼另一个人吧?如果是这样的话,那么肯定有很多人搞不清楚到底谁叫这个绰号,系统也是。所以当然就不行了。


    转自:http://blog.csdn.net/hactrox/article/details/38974639


    
    展开全文
  • C++:数组形参的传递

    千次阅读 2019-01-15 09:59:57
    不允许拷贝:无法以值传递的方式使用数组形参 使用数组时通常都会转换为指针:当我们为函数传递一个数组时,实际上传递的是指向数组首元素指针。 传参方法 当下有一个数组int j[2]={0,1},我们自写了一个函数 ...

    数组有两个特性:

    • 不允许拷贝:无法以值传递的方式使用数组形参
    • 使用数组时通常都会转换为指针:当我们为函数传递一个数组时,实际上传递的是指向数组首元素的指针。
    1. 传参的方法
      当下有一个数组int j[2]={0,1},我们自写了一个函数 void FindSomeOne(),要求将数组参数传进去。
      有以下两种方式(在函数内部使用时,Point++即可实现指针的移动)
    • void FindSomeOne(const int* Point)
    • void FindSomeOne(const int Point[])
      当我们使用此函数时这样写即可,FindSomeOne(j)。至于形参传递为什么是const int *,是因为我们往往是使用数组里的数据,但并不该表改数组存放的数据,当然修改具体值的时候,只需在形参传递的时候去掉const就可以了。
    1. 数组大小
      数组是以指针的形式传递给函数的,所以函数并不知道数组的确切尺寸,因此调用者应该为此提供一些信息,以防止使用时数组越界。最好的方法是使用标准库规范传参数组是以指针的形式传递给函数的,所以函数并不知道数组的确切尺寸,因此调用者应该为此提供一些信息,以防止使用时数组越界。最好的方法是使用标准库规范传参数组是以指针的形式传递给函数的,所以函数并不知道数组的确切尺寸,因此调用者应该为此提供一些信息,以防止使用时数组越界。最好的方法是使用标准库规范传参数组是以指针的形式传递给函数的,所以函数并不知道数组的确切尺寸,因此调用者应该为此提供一些信息,以防止使用时数组越界。最好的方法是使用标准库规范传参
    void FindSomeOne(const int *beg,const int *end)
    {
    	while(beg!=end){
    		cout<<*beg++<<endl;
    	}
    }
    
    1. const int *aint *const a的区别
      const属于修饰符,关键是看const修饰的位置在哪里
    • const int *a 这里const修饰的是int,而int定义的是一个整值。因此a指向的对象的值是不能通过a来修改的,但是a可以重新赋值(比方说a++),时期指向不同的对象
             const int *a = 0;
             const int b = 1;
             int c = 1;
             a = &b  //  额外:注意不能通过a 来修改 b值
             a = &c  //   额外:虽然c本身不是一个常量
             *a = 2  //error 为题就在这里,不能修改通过 *a 所指向的对象值,最后赋值得对象是c,因此不能通过*a 来修改c值。
    
    • int *const a 这里const修饰的是 a ,a代表的是一个指针地址。因此不能赋给a其他的地址值,但可以修改a指向的值,这有点和cont int *a相反的意味,例子就不说了
    1. 关于const的补充:
    • const 对象的地址只能赋值给指向const 对象的指针* const 对象的地址只能赋值给指向const 对象的指针
    • 指向const 对象的指针可以 被赋 以 一个非const 对象的地址
    • 指向const 得指针常被用作函数的形式参数,保证被传递给函数的实际对象在函数得实际对象在函数中不会被修改
    • 常量在定义后就不能被修改,所以它必须被初始化。未初始化的常量定义将导致编译错误(上面都是在说明const得问题,所以没有赋值,实际语句中要赋值的)
    展开全文
  • 问题描述 1、在go语言中当函数的参数为数组或数组切片时,形参的方式应该怎么确定? 2、不同形式的实参和形参造成的... 传递方式 在函数内对原内容操作结果 说明 array := [[5]]int{1, 2, 3, 4, 5} array ...

    问题描述

    1、在go语言中当函数的参数为数组或数组切片时,形参的方式应该怎么确定?
    2、不同形式的实参和形参造成的结果有何不同(会否对原数组或切片内容产生改变)?

    情况设定及结论

    原内容(数组/切片) 实参形式 形参形式 传递方式 在函数内对原内容操作结果 说明
    array := [5]int{1, 2, 3, 4, 5} array array [5]int 值传递 原内容未改变 传入时复制了一个数组副本
    array := [5]int{1, 2, 3, 4, 5} array[0:] array []int (类似)引用传递 原内容可发生改变 传入时数组切片化了
    array := []int{1, 2, 3, 4, 5} array array []int 引用传递 原内容可发生改变 传入了切片的指针(注:经验证,二维切片同方法)

    相关代码

    情况一:

    package main
    
    import "fmt"
    
    func modify(array [5]int) {
    	array[0] = 10
    	fmt.Println("In modify(), array values:", array)
    }
    
    func main() {
    	array := [5]int{1, 2, 3, 4, 5} //这是一个数组
    	modify(array)
    	fmt.Println("In main(), array values:", array)
    }
    

    运行结果:
    In modify(), array values: [10 2 3 4 5]
    In main(), array values: [1 2 3 4 5]

    情况二:

    package main
    
    import "fmt"
    
    func modify(array []int) {
    	array[0] = 10
    	fmt.Println("In modify(), array values:", array)
    }
    
    func main() {
    	array := [5]int{1, 2, 3, 4, 5}
    	modify(array[0:])
    	fmt.Println("In main(), array values:", array)
    }
    

    运行结果:
    In modify(), array values: [10 2 3 4 5]
    In main(), array values: [10 2 3 4 5]

    情况三:

    package main
    
    import "fmt"
    
    func modify(array []int) {
    	array[0] = 10
    	fmt.Println("In modify(), array values:", array)
    }
    
    func main() {
    	array := []int{1, 2, 3, 4, 5}
    	modify(array)
    	fmt.Println("In main(), array values:", array)
    }
    

    运行结果:
    In modify(), array values: [10 2 3 4 5]
    In main(), array values: [10 2 3 4 5]

    ###脚注
    生成一个脚注1.

    目录

    [TOC]来生成目录:


    1. 这里是 脚注内容. ↩︎

    展开全文
  • 传递方式: 位置传参 序列传参 关键字传参 位置传参:  实际调用参数(实参)对应关系与形式参数(形参)对应关系是按照位置来依次对应  示例 :  def fx(a,b,c):  pass  fx(1,2,3)  序列传参:  序列...
  • python的形参传递方式 1.函数缺省参数 2位置形参 ----->实参,形参,一一对应,不过多描述; 3.星号元组形参 4.命名关键字形参 5.双星号字典形参 #1.函数缺省参数 def fa(name , age = 18 ,sex = '男'): ...
  • 关于函数实参形参传递的几种方式下面用简单打印函数来实现 1.常量传递,实参是常量,形参是变量 #include <stdio.h> #define PI 3 //定义了一个常量PI ,其中值为3 void print(int n); //声明了一个print...
  • 文章已移至 C++ 形参和实参在三中传递方式区别
  • C语言中实参和形参之间数据传递是单向“值传递”,单向传递,只能由实参传给形参,反之不行 输出格式并没有选择%p而是选择了%d,因为十进制数看起来更直观 1 值传递 如果只是传递话: #include //值...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼好吧,加段代码申精吧。Java代码:------------------------------------------------------public class Main {public static void modify(int a) {a = 5;...
  • 此处也是把实参的值赋值给形参(只不过实参的值是一个地址),当我们对形参的值进行修改时,依然不会影响到实参的值。但是此处有个特别重要的一点,形参中的值是一个地址,我们可以通过修改这个地址所指向的内容,.....
  • c语言的形参和实参传递的区别

    千次阅读 多人点赞 2019-02-28 10:52:49
    参数传递,是在程序运行过程中,实际参数就会将参数值传递给相应形式参数,然后在函数中实现对数据处理和返回...被调用函数的形参只有函数被调用时才会临时分配存储单元,一旦调用结束占用内存便会被释放 值...
  • java形参传递情况

    2021-03-02 19:55:53
    说白了,Java只有值传递,网上说什么两种传递方式:值传递和引用传递都不是很准确。要知道所谓引用传递,传递也是指向堆内存中对象“地址值”。都是“值”而已。也就涉及到4个东西——实际参数、形式...
  •  java中参数都是值传递方式(String也不例外,我理解值传递,都是传递实参副本,但是要弄清楚,这里拷贝,拷贝是实参变量地址(栈),而不是实参变量指向对象),其实质是传递实参副本,分析过程如下。...
  • 一、传递形参(函数中只能使用数组参数,无法修改) 1.函数中写法 void func(int array[][10]) { tmp=array[i][j]; } void func(int array[3][10]) { tmp=array[i][j]; } void func(int(*array)[1...
  • 2.当传值调用时,改变的是形参的值,并没有改变实参的值,实参的值可以传递给形参,但是,这个传递是单向的,形参不能传递回实参。 3.当引用调用时,如果参数是对象,无论对对象做了何种操作,都不会改变实参对象的...
  • 这一篇我们来看看没有返回,只靠形参、实参传递参数函数,先来学习最简单一种: 1、传值调用(赋值传递) 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 ...
  • 形参和实参之间三种传递方式

    千次阅读 2011-11-28 19:39:42
    //形参和实参之间三种传递方式 void fun(int i) { i++;} void fun(int &i) { i++;} void fun(int *i) { *i=*i+1;} 若指针指向是数组首地址,则数组元素访问方式 1.数组名[i] 指针名[i] 2.*...
  • /* 变量赋值 变量是基本数据类型时:此时赋值是变量所保存数据值 ...Java中方法参数传递方式只有一种:值传递。将实际参数值副本传入方法内,而参数本身不受影响。 形参是基本数据类型时:...
  • 本文主要针对维数未知二维数组作为函数形参进行传递的形参类型声明问题,具体声明方法如下代码所示; 注意: 下面这种声明方式是错误,编译器会提示m, n unclear,这可能是因为编译器顺序编译原因吧,但只要...
  • 传递形参是实参副本(复制、拷贝),形参改变不会影响实参值,这种方式是很常见。 指针传递形参是指针类型,形参作指针运算后指向就是实参,所以会影响实参值。这种方式也是很常见。 引用传递...
  • 形参与实参之间传递

    千次阅读 2013-10-09 11:45:20
    C语言中,参数的传递方式是“单向值传递”,形参和实参变量各自有不同的存储单元,被调用函数中的形参变量值的变化不会影响实参变量值。 举个例子  #include  void swap(int x,int y)  {  int z...
  • 操作i这个变量不会改变传入参数。 二,引用参数 void RefMethod(ref int i ) 操作i会引起传入参数改变,,入参必须定义值 三,输出参数 void OutMethod(out int i ) 操作i会引起传入参数改变,,入参...
  • C语言-实参到函数形参传递的理解

    千次阅读 2017-10-14 12:08:11
    书上总是对这个C语言参数传递描述:传值方式、传到调用函数是副本,然后就是常规swap函数说明这个问题,但是还是不能以swap描述所有问题,看了这个例子总是给人一种感觉:考虑到要在函数内部改变数据,在调用...
  • ... 值传递形参是实参副本(复制、拷贝),形参改变不会影响实参值,这种方式是很常见。 指针传递形参是指针类型,形参作指针运算后指向就是实参,所以会影响实参...
  • 面向对象本质就是:以类的方式组织代码,以对象组织(封装)数据。 抽象 (抽象就是抽取像一部分给抽出来变成类) 三大特性: 封装 把数据包装起来 继承 子类 继承父类 子继承父所有东西 多态 同一个事物有...
  • c++中常用vector容器作为参数时,有三种传参方式,分别如下(为说明问题,用二维vector): function1(std::vector<std::vector > vec),传值 function2(std::vector<std::vector >& vec),传...
  • 个人认为:这里简单变量应该是指内置类型,内置类型数据在传入函数时,使用值传递方式的效率要高于引用传递和指针传递,因此编译器会采用效率最高方式来实现参数传递,所以选B(当然也允许用户更改),事实上...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,251
精华内容 900
关键字:

形参的传递方式