c# 传值调用和传引用调用

传值调用和传引用调用是几乎所有主流语言都会涉及到的问题,下面我谈谈我对C#中传值调用和传引用调用的理解。

1. 一般对C#中传值调用和传引用调用的理解

  • 如果传递的参数是基元类型(int,float等)或结构体(struct),那么就是传值调用。
  • 如果传递的参数是类(class)那么就是传引用调用。
  • 如果传递的参数前有ref或者out关键字,那么就是传引用调用。

验证示例的代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
using System;
 
public class ArgsByRefOrValue
{
    public static void Main(string[] args)
    {
        // 实验1. 传值调用--基元类型
        int i = 10;
        Console.WriteLine("before call ChangeByInt: i = " + i.ToString());
        ChangeByInt(i);
        Console.WriteLine("after call ChangeByInt: i = " + i.ToString());
 
        Console.WriteLine("==============================================");
        // 实验2. 传值调用--结构体
        Person_val p_val = new Person_val();
        p_val.name = "old val name";
        Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);
        ChangeByStruct(p_val);
        Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);
 
        Console.WriteLine("==============================================");
        // 实验3. 传引用调用--类
        Person_ref p_ref = new Person_ref();
        p_ref.name = "old ref name";
        Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);
        ChangeByClass(p_ref);
        Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);
 
        Console.WriteLine("==============================================");
        // 实验4. 传引用调用--利用ref
        Person_ref p = new Person_ref();
        p.name = "old ref name";
        Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);
        ChangeByClassRef(ref p);
        Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);
 
        Console.ReadKey(true);
    }
 
    static void ChangeByInt(int i)
    {
        i = i + 10;
        Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());
    }
 
    static void ChangeByStruct(Person_val p_val)
    {
        p_val.name = "new val name";
        Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);
    }
 
    static void ChangeByClass(Person_ref p_ref)
    {
        p_ref.name = "new ref name";
        Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);
    }
 
    static void ChangeByClassRef(ref Person_ref p)
    {
        p.name = "new ref name";
        Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);
    }
}
 
public struct Person_val
{
    public string name;
}
 
public class Person_ref
{
    public string name;
}

运行结果如下:

看起来似乎上面代码中实验3实验4是一样的,即对于类(class)来说,不管加不加ref或out,都是传引用调用。

其实,这只是表面的现象,只要稍微改一下代码,结果就不一样了。

修改上面代码,再增加两个实验。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
using System;
 
public class ArgsByRefOrValue
{
    public static void Main(string[] args)
    {
        // 实验1. 传值调用--基元类型
        int i = 10;
        Console.WriteLine("before call ChangeByInt: i = " + i.ToString());
        ChangeByInt(i);
        Console.WriteLine("after call ChangeByInt: i = " + i.ToString());
 
        Console.WriteLine("==============================================");
        // 实验2. 传值调用--结构体
        Person_val p_val = new Person_val();
        p_val.name = "old val name";
        Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);
        ChangeByStruct(p_val);
        Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);
 
        Console.WriteLine("==============================================");
        // 实验3. 传引用调用--类
        Person_ref p_ref = new Person_ref();
        p_ref.name = "old ref name";
        Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);
        ChangeByClass(p_ref);
        Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);
 
        Console.WriteLine("==============================================");
        // 实验4. 传引用调用--利用ref
        Person_ref p = new Person_ref();
        p.name = "old ref name";
        Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);
        ChangeByClassRef(ref p);
        Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);
 
        Console.WriteLine("==============================================");
        // 实验5. 传引用调用--类 在调用的函数重新new一个对象
        Person_ref p_ref_new = new Person_ref();
        p_ref_new.name = "old new ref name";
        Console.WriteLine("before call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
        ChangeByClassNew(p_ref_new);
        Console.WriteLine("after call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
 
        Console.WriteLine("==============================================");
        // 实验6. 传引用调用--利用ref 在调用的函数重新new一个对象
        Person_ref p_new = new Person_ref();
        p_new.name = "old new ref name";
        Console.WriteLine("before call ChangeByClassRefNew: p_new.name = " + p_new.name);
        ChangeByClassRefNew(ref p_new);
        Console.WriteLine("after call ChangeByClassRefNew: p_new.name = " + p_new.name);
 
        Console.ReadKey(true);
    }
 
    static void ChangeByInt(int i)
    {
        i = i + 10;
        Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());
    }
 
    static void ChangeByStruct(Person_val p_val)
    {
        p_val.name = "new val name";
        Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);
    }
 
    static void ChangeByClass(Person_ref p_ref)
    {
        p_ref.name = "new ref name";
        Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);
    }
 
    static void ChangeByClassRef(ref Person_ref p)
    {
        p.name = "new ref name";
        Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);
    }
 
    static void ChangeByClassNew(Person_ref p_ref_new)
    {
        p_ref_new = new Person_ref();
        p_ref_new.name = "new ref name";
        Console.WriteLine("when calling ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
    }
 
    static void ChangeByClassRefNew(ref Person_ref p_new)
    {
        p_new = new Person_ref();
        p_new.name = "new ref name";
        Console.WriteLine("when calling ChangeByClassRefNew: p_new.name = " + p_new.name);
    }
}
 
public struct Person_val
{
    public string name;
}
 
public class Person_ref
{
    public string name;
}

则运行结果为:

实验5的运行结果似乎说明即使参数是类(class),只要不加ref,也是传值调用。

下面就引出了我的理解。

2. 没有ref时,即使参数为引用类型(class)时,也可算是一种传值调用

参数为引用类型时,传递的是该引用类型的地址的一份拷贝,“该引用类型的地址的一份拷贝”即为传值调用的“值”。

注意这里说传递的是该引用类型的地址的一份拷贝,而不是引用类型的地址。

下面将用图的形式来说明以上实验3,实验5和实验6中内存的情况。

2.1 首先是实验3

实验3的内存图如下,实参是函数ChangeByClass外的Person_ref对象,形参是函数ChangeByClass内的Person_ref对象。

捕获 

从图中我们可以看出实参new出来之后就在托管堆上分配了内存,并且在栈上保存了对象的指针。

调用函数ChangeByClass后,由于没有ref参数,所以将栈上的实参p_val拷贝了一份作为形参,注意这里p_val(实参)p_val(形参)是指向托管堆上的同一地址。

所以说没有ref时,即使参数为引用类型(class)时,也可算是一种传值调用,这里的值就是托管堆中对象的地址(0x1000)。

调用函数ChangeByClass后,通过p_val(形参)修改了name属性的值,由于p_val(实参)p_val(形参)是指向托管堆上的同一地址,所以函数外的p_val(实参)的name属性也被修改了。

捕获

2.2 然后是实验5

上面的实验3从执行结果来看似乎是传引用调用,因为形参的改变导致了实参的改变。

下面的实验5就可以看出,p_val(形参)p_val(实参)并不是同一个变量,而是p_val(实参)的一个拷贝。

捕获

从图中可以看出第一步还是和实验3一样,但是在调用函数ChangeByClassNew后,就不一样了。

函数ChangeByClassNew中,对p_val(形参)重新分配了内存(new操作),使其指向了新的地址(0x1100),如下图:

捕获

所以p_val(形参)的name属性改了时候,p_val(实参)的name属性还是没变。

2.3 最后是实验6

我觉得实验6是真正的传引用调用。不废话了,直接上第一个图。

捕获

参数中加了ref关键字之后,其实传递的不是托管堆中对象的地址(0x1000),而是栈上p_val(实参)的地址(0x0001)。

所以这里实参和形参都是栈上的同一个东西,没有什么区别了。我觉得这才是真正的传引用调用。

然后调用了函数ChangeByClassRefNew,函数中对p_val(形参)重新分配了内存(new操作),使其指向了新的地址(0x1100)。

捕获

由于p_val(形参)就是p_val(实参),所以p_val(形参)的name属性改变后,函数ChangeByClassRefNew外的p_val(实参)的name属性也被改变了。

而原先分配的对象(地址0x1000)其实已经没有被引用了,随时会被GC回收。

3. 结论

  • 如果传递的参数是基元类型(int,float等)或结构体(struct),那么就是传值调用。
  • 如果传递的参数前有ref或者out关键字,那么就是传引用调用。
  • 如果传递的参数是类(class)并且没有ref或out关键字:
    1. 如果调用的函数中对参数重新进行了地址分配(new操作),那么执行结果类似传值调用
    2. 如果调用的函数中没有对参数重新进行了地址分配,直接就是使用了传递的参数,那么执行结果类似传引用调用
  • 传值调用传引用调用

    03-14

    初学者,在看core java (中文版)rn在4.5中看到解释传值调用与传引用调用的区别,并解释JAVA是传值调用,使用了下面的例子,我不太明白第二个方法(tripleSalary)与第三个方法(swap)的不同结果的原因,即同是使用对象参数,为何第二个方法可以改变引用对象参数的状态,而第三个方法则不可以。(说得有点乱,希望大家有耐心看一下源代码)rn非常感谢。rnrnpublic class ParamTestrnrn public static void main(String[] args)rn rn /*rn *Test 1:Methods can't modify numeric parametersrn */rn System.out.println("Testing tripleValue:");rn double percent = 10;rn System.out.println("Before: percent =" + percent);rn tripleValue(percent);rn System.out.println("After: percent = " + percent);rn rn /*rn *Test 2: Methods can change the state of object rn * parametersrn */rn System.out.println("\nTesting tripleSalary:");rn Employee harry = new Employee("Harry",50000);rn System.out.println("Before: salary =" + harry.getSalary());rn tripleSalary(harry);rn System.out.println("After: salary =" + harry.getSalary());rn rn /*rn *Test 3: Methods can't attach new objects to rn * object parametersrn */rn System.out.println("\nTesting swap:");rn Employee a = new Employee("Alice",70000);rn Employee b = new Employee("Bob",60000);rn System.out.println("Before: a =" + a.getName());rn System.out.println("Before: b =" + b.getName());rn swap(a,b);rn System.out.println("After: a =" + a.getName());rn System.out.println("After: b =" + b.getName());rn rn rn rn public static void tripleValue(double x) //doesn't workrn rn x = 3 * x;rn System.out.println("End of method: x=" + x);rn rn rn public static void tripleSalary(Employee x) //worksrn rn x.raiseSalary(200);rn System.out.println("End of method: salary =" + x.getSalary());rn rn rn public static void swap(Employee x, Employee y)rn rn Employee temp = x;rn x = y;rn y = temp;rn System.out.println("End of method: x=" + x.getName());rn System.out.println("End of method: y=" + y.getName());rn rn rn rnrnrn结果:rnTesting tripleValue:rnBefore: percent =10.0rnEnd of method: x=30.0rnAfter: percent = 10.0rnrnTesting tripleSalary:rnBefore: salary =50000.0rnEnd of method: salary =150000.0rnAfter: salary =150000.0rnrnTesting swap:rnBefore: a =AlicernBefore: b =BobrnEnd of method: x=BobrnEnd of method: y=AlicernAfter: a =AlicernAfter: b =Bobrn 论坛

    没有更多推荐了,返回首页