精华内容
下载资源
问答
  • 2021-01-13 04:21:24

    值传递和引用传递

    python的值传递不会改变传入参数的值,而引用传递传入的是一个地址,有点类似c的指针,在执行完成之后会改变传入地址所指的值。

    值传递类型如下:

    上面的代码只是将a的值作为参数传递进去,程序执行完之后a的值并未改变

    a = 1

    def change_integer(a):

    a = a + 1

    return a

    print change_integer(a)

    print a

    结果:

    2

    1

    [Finished in 0.1s]

    引用传递的类型如下:

    b = [1, 2, 3]

    def change_list(b):

    b[0]= b[0]+1

    return b

    print change_list(b)

    print b

    结果:

    [2, 2, 3]

    [2, 2, 3]

    [Finished in 0.1s]

    而这里将b的地址传递进去之后,程序执行完之后b的值也随之改变。

    如何解决 变量 : 由 引用传递 变为 值传递??

    方案如下:

    import copy

    b = [1, 2, 3]

    def change_list(b):

    b[0]= b[0]+1

    return b

    print change_list(copy.deepcopy(b))

    print b

    结果:

    [2, 2, 3]

    [1, 2, 3]

    [Finished in 0.1s]

    更多相关内容
  • 主要介绍了Java中值传递和引用传递的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java 中没有引用传递,都是值传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • 当一个变量为一个参数传入方法内部的时候,会有两种不同的传递方式:值传递和引用传递。  值传递的特点:不管方法内部对传进去的参数作任何改变,也不会影响方法外部的变量的值  引用传递的特点:方法内部对传...
  • python中函数参数是引用传递(不是值传递)。对于不可变类型,因变量不能被修改,所以运算时不会影响到变量本身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量. 形参: 函数需要传递的参数 实参...
  • 本篇文章主要是对C#中的引用传递与值传递进行了详细的分析介绍,需要的朋友可以过来参考下,希望对大家有所帮助
  • 主要介绍了Python中 传递传递引用 的区别解析,非常不错,具有参考借鉴价值,需要的朋友参考下吧
  • 如果函数收到的是一个可变对象(比如字典 或者列表)的引用,就能修改对象的原始——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能 直接修改原始对象...
  • 主要介绍了 Java 值传递和引用传递详解及实例代码的相关资料,需要的朋友可以参考下
  • 另一方面,值传递由于形参实参内存地址不一样,有些功能并不能实现(swap()),因此,除了极为简单的函数会使用值传递外,大多数会采用引用传递。而对于指针传递,则在涉及数组的情况下使用较多,因为指针本身会给...
  • 主要介绍了详解java的值传递、地址传递、引用传递的相关资料,需要的朋友可以参考下
  • 值传递(call by value)是最常用的求值策略:函数的形参是被调用时所传实参的副本。修改形参的值并不会影响实参。  按引用传递(call by reference)时,函数的形参接收实参的隐式引用,而不再是副本。这意味着函数...
  • 在传统的观念里,都认为JavaScript函数传递的是引用传递(也称之为指针传递),也有人认为是值传递和引用传递都具备。那么JS的参数传递到底是怎么回事呢?事实上以下的演示也完全可以用于Java 首先来一个比较简单的,...
  • 主要介绍了java通过实例了解值传递和引用传递,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java:按值传递还是按引用传递详细解说
  • 细说值传递引用传递和地址传递 1 实参和形参 形式参数:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。 实际参数:在调用有参函数时,主调函数和被调函数之间有数据传递关系。在...

    细说值传递、引用传递和地址传递

    1 实参和形参

    形式参数:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。

    实际参数:在调用有参函数时,主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时,函数名后面括号中的参数称为“实际参数”。

    func main() {
       i := sum(2, 4) //2,4为实参
       fmt.Println(i)
    }
    
    func sum(a int, b int) int { //a,b为形参
       c := a
       return b + c //a,b,c为形参
    }
    

    2 值传递、引用传递和指针传递:

    值传递:指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。

    引用传递:指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    指针传递:指在调用函数时将实际参数的指针地址直接传递到函数中,类似于引用传递,最大不同就是指针指向的类型不能为null。

    指针传递和引用传递的不同:指针就是地址变量,所以引用相当于把地址常量作为参数,指针相当于把地址变量作为参数。

    2.1 Go语言演示

    type Obj struct {
       Id   int
       Name string
    }
    
    func main() {
    	//值传递和引用传递测试
    	fmt.Println("值传递...")
    	v1 := 2
    	v2 := Obj{2, "ls"}
    	fmt.Println(v1, v2)
    	updateVal(v1, v2)
    	fmt.Println(v1, v2)
    
    	//指针传递测试
    	fmt.Println("指针传递...")
    	v3 := 2
    	v4 := Obj{2, "ls"}
    	fmt.Println(v3, v4)
    	updateValPoint(&v3, &v4)
    	fmt.Println(v3, v4)
    }
    
    //值传递
    func updateVal(v1 int, v2 Obj) {
       v1 = 1
       v2 = Obj{1, "zs"}
    }
    
    //引用传递
    func updateValPoint(v1 *int, v2 *Obj) {
       *v1 = 12
       *v2 = Obj{1, "zs"}
    }
    

    输出:

    值传递...
    2 {2 ls}
    2 {2 ls}
    指针传递...
    2 {2 ls}
    12 {1 zs}
    
    

    2.2 Java语言演示

    public static void main(String[] args) {
        System.out.println("值传递1");
        int v1 = 2;
        String v2 = "zz";
        Obj v3 = new Obj(2, "ls");
        System.out.println(v1 + "--" + v2 + "--" + v3);
        updateValue(v1, v2, v3);
        System.out.println(v1 + "--" + v2 + "--" + v3);
    
        System.out.println("值传递2");
        int v4 = 2;
        String v5 = "zz";
        Obj v6 = new Obj(2, "ls");
        System.out.println(v4 + "--" + v5 + "--" + v6);
        updateValuePoint(v4, v5, v6);
        System.out.println(v4 + "--" + v5 + "--" + v6);
    }
    
    public static void updateValue(int v1, String v2, Obj v3) {
        v1 = 1;
        v2 = "ww";
        v3 = new Obj(1, "zs");
        v3.setId(1);
        v3.setName("zs");
    }
    
    public static void updateValuePoint(int v1, String v2, Obj v3) {
        v1 = 1;
        v2 = "ww";
        v3.setId(1);
        v3.setName("zs");
    }
    
    @AllArgsConstructor
    @ToString
    @Data
    static class Obj {
        public int id;
        public String name;
    }
    

    输出:

    2--zz--Main.Obj(id=2, name=ls)
    2--zz--Main.Obj(id=2, name=ls)
    2--zz--Main.Obj(id=2, name=ls)
    2--zz--Main.Obj(id=1, name=zs)
    

    3 总结下

    在Java方法中参数列表有两种类型的参数,基本类型和引用类型。

    基本类型:值存放在局部变量表中,无论如何修改只会修改当前栈帧的值,方法执行结束对方法外不会做任何改变;此时需要改变外层的变量,必须返回主动赋值。

    引用数据类型:指针存放在局部变量表中,调用方法的时候,副本引用压栈,赋值仅改变副本的引用。但是如果通过操作副本引用的值,修改了引用地址的对象,此时方法以外的引用此地址对象当然被修改。(两个引用,同一个地址,任何修改行为2个引用同时生效)。

    这两种类型都是将外面的参数变量拷贝一份到局部变量中,基本类型为值拷贝,引用类型就是将引用地址拷贝一份。

    参考文章

    https://www.cnblogs.com/lingyejun/p/11028808.html

    https://blog.csdn.net/belongtocode/article/details/107713117

    展开全文
  • JavaScript有5种基本的数据类型,分别是:布尔、null、undefined、String和Number。这篇文章主要介绍了JavaScript的值传递和引用传递,需要的朋友可以参考下
  • java中的值传递和引用传递

    千次阅读 2021-12-07 20:07:09
    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。一般java中的基础类型数据传递都是值传递引用传递(Pass By Reference或者Call By Reference)...

    个人理解,可能会有错误之处,请仔细甄别,谨慎参考!如有错误或不同见解请指出!

    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。一般java中的基础类型数据传递都是值传递。
    引用传递(Pass By Reference或者Call By Reference)一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。一般java中实例(包装)对象的传递是引用传递。

    一、基本类型和引用类型在内存中的不同之处

    int num = 10;
    String str = "hello";


    如图所示,num是基本类型,值就直接保存在变量中。而str是引用类型,变量中保存的只是实际对象的地址。一般称这种变量为"引用",引用指向实际对象,实际对象中保存着内容。

    二、赋值时内存的变化

    int num = 24;
    String str = "world";

    对于基本类型num,赋值运算符会直接改变变量的值,原来的值被覆盖掉。对于引用类型str,赋值运算符会改变引用中所保存的地址,原来的地址被覆盖掉。但是原来的对象(“hello” 字符串对象)不会被改变。(没有被任何引用所指向的对象是垃圾,会被垃圾回收器回收)

    三、调用方法时发生了什么,参数传递基本上就是赋值操作

    第一个例子:基本类型

    void change(int value) {
        value = 100;
    }
    change(num); // num 没有被改变

    第二个例子:引用类型没有使用改变自身方法的方法

    void change(String a) {
        a = "唐";
    }
    change(str); // str没有被改变

    或:

    StringBuilder stri = new StringBuilder("唐");
    void change(StringBuilder builder) {
        builder = new StringBuilder("宋");
    }
    change(stri); // stri没有被改变,还是 "唐"。

     第三个例子:引用类型使用了改变自身方法的方法

    StringBuilder stri = new StringBuilder("明");
    void change(StringBuilder builder) {
        builder.append("清");
    }
    change(stri); // stri被改变了,变成了"清"。

    第三个例子的图解:


    builder.append("清")之后

    参考:

    java基本数据类型传递与引用传递区别详解_zejian的博客-CSDN博客_java值传递和引用传递java的值传递和引用传递在面试中一般都会都被涉及到,今天我们就来聊聊这个问题,首先我们必须认识到这个问题一般是相对函数而言的,也就是java中的方法参数,那么我们先来回顾一下在程序设计语言中有关参数传递给方法(或函数)的两个专业术语:按值调用(call by value)按引用调用(call by reference)所谓的按值调用表示方法接收的是调用着提https://blog.csdn.net/javazejian/article/details/51192130

     

    展开全文
  • 主要介绍了JAVA参数传递方式,结合实例形式分析了java按值传递引用传递区别及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了java到底是值传递还是引用传递的相关知识,本文通过几个例子给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • #值传递和引用传递 python中数据类型有:整形,字条串,元组,列表,字典,集合 不可变数据类型:当该数据类型对应变量的值变化,值对应的内存地址 也发生变化,这个值就为不可变数据类型 可变数据类型:当该数据...
  • 主要为大家详细介绍了Java值传递和引用传递,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 在网上看到的一个帖子解释Java的按值传递和引用传递,感觉挺全面,就转过来,以供以后学习参考:1:按值传递是什么指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:public class TempTest {private ...

    在网上看到的一个帖子解释Java的按值传递和按引用传递,感觉挺全面,就转过来,以供以后学习参考:

    1:按值传递是什么

    指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

    public class TempTest {

    private void test1(int a){

    //做点事情

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    int a = 3;

    t.test1(a);//这里传递的参数a就是按值传递

    }

    }

    按值传递重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。

    示例如下:

    public class TempTest {

    private void test1(int a){

    a = 5;

    System.out.println("test1方法中的a="+a);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    int a = 3;

    t.test1(a);//传递后,test1方法对变量值的改变不影响这里的a

    System.out.println(”main方法中的a=”+a);

    }

    }

    运行结果是:

    test1方法中的a=5

    main方法中的a=3

    2:按引用传递是什么

    指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。

    示例如下:

    public class TempTest {

    private void test1(A a){

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    t.test1(a); //这里传递的参数a就是按引用传递

    }

    }

    class A{

    public int age = 0;

    }

    3:按引用传递的重要特点

    传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

    示例如下:

    public class TempTest {

    private void test1(A a){

    a.age = 20;

    System.out.println("test1方法中的age="+a.age);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    a.age = 10;

    t.test1(a);

    System.out.println(”main方法中的age=”+a.age);

    }

    }

    class A{

    public int age = 0;

    }

    运行结果如下:

    test1方法中的age=20

    main方法中的age=20

    4:理解按引用传递的过程——内存分配示意图

    要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

    用上面的例子来进行分析:

    (1):运行开始,运行第13行,创建了一个A的实例,内存分配示意如下:

    54a0568a5d9606540e518e2b8cab94c8.png

    (2):运行第14行,是修改A实例里面的age的值,运行后内存分配示意如下:

    a715c6ec20dfa322a1b7c7fa10ccbe64.png

    (3):运行第15行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:

    1d7be5d20efce302a892de89f8b2fabe.png

    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    7a2eda57f0edefbaeb5f9df31fe9fe1b.png

    也就是说:是两个变量都指向同一个空间。

    (4):运行第5行,为test1方法中的变量a指向的A实例的age进行赋值,完成后形成的新的内存示意图如下:

    fdc8684a6d3391b85ca954f59df64e16.png

    此时A实例的age值的变化是由test1方法引起的

    (5):运行第6行,根据此时的内存示意图,输出test1方法中的age=20

    (6):运行第16行,根据此时的内存示意图,输出main方法中的age=20

    5:对上述例子的改变

    理解了上面的例子,可能有人会问,那么能不能让按照引用传递的值,相互不影响呢?就是test1方法里面的修改不影响到main方法里面呢?

    方法是在test1方法里面新new一个实例就可以了。改变成下面的例子,其中第3行为新加的:

    public class TempTest {

    private void test1(A a){

    a = new A();//新加的一行

    a.age = 20;

    System.out.println("test1方法中的age="+a.age);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    a.age = 10;

    t.test1(a);

    System.out.println(”main方法中的age=”+a.age);

    }

    }

    class A{

    public int age = 0;

    }

    运行结果为:

    test1方法中的age=20

    main方法中的age=10

    为什么这次的运行结果和前面的例子不一样呢,还是使用内存示意图来理解一下

    6:再次理解按引用传递

    (1):运行开始,运行第14行,创建了一个A的实例,内存分配示意如下:

    ceb3a77a2f344dba3bc44a060d57cf0b.png

    (2):运行第15行,是修改A实例里面的age的值,运行后内存分配示意如下:

    6c4c0604f69b0510cc345966115e4acb.png

    (3):运行第16行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:

    21d35b40deac615ef33a3ac3b5006f6f.png

    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    3788844b7146e37ad44bb464b728c182.png

    也就是说:是两个变量都指向同一个空间。

    (4):运行第5行,为test1方法中的变量a重新生成了新的A实例的,完成后形成的新的内存示意图如下:

    4e8936d48de35397adcd4619a61e6d2b.png

    (5):运行第6行,为test1方法中的变量a指向的新的A实例的age进行赋值,完成后形成的新的内存示意图如下:

    aa9eb5c0c01a6604d8f802d2224b146e.png

    注意:这个时候test1方法中的变量a的age被改变,而main方法中的是没有改变的。

    (6):运行第7行,根据此时的内存示意图,输出test1方法中的age=20

    (7):运行第17行,根据此时的内存示意图,输出main方法中的age=10

    7:说明

    (1):“在Java里面参数传递都是按值传递”这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递。

    (2):在Java里面只有基本类型和按照下面这种定义方式的String是按值传递,其它的都是按引用传递。就是直接使用双引号定义字符串方式:String str = “Java私塾”;

    原文链接:https://blog.csdn.net/zzp_403184692/article/details/8184751

    展开全文
  • 内存分为栈区(stack)堆区(heap) ,如果将内存看成一本书,栈好比是书的目录,而堆就是书的内容,基本类型可以看成内容非常少,只要目录就可以概括,而引用类型就相当与内容非常多的文章,需要在书的目录上保存...
  • 以下是对c#方法中调用参数的值传递方式和引用传递方式,以及ref与out的区进行了详细的分析介绍,需要的朋友可以过来参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,131,240
精华内容 852,496
关键字:

引用传递和常引用传递