备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

深刻理解C#的传值调用和传引用调用

2017-10-17 1093
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

传值调用和传引用调用是几乎所有主流语言都会涉及到的问题，下面我谈谈我对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;
}

运行结果如下：

2011051823155221.png

看起来似乎上面代码中实验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;
}

则运行结果为：

2011051823171086.png

实验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. 如果调用的函数中没有对参数重新进行了地址分配，直接就是使用了传递的参数，那么执行结果类似传引用调用


本文转自wang_yb博客园博客，原文链接：http://www.cnblogs.com/wang_yb/archive/2011/05/18/2050574.html，如需转载请自行联系原作者
文章标签：
C#
关键词：
C#传值
zting科技
目录
相关文章
爱吃芋圆的兔子
|
10月前
|
C#
【C#视频】方法重载、函数重载、传值
【C#视频】方法重载、函数重载、传值
爱吃芋圆的兔子
38 0
鱼找水需要时间
|
JSON 前端开发 JavaScript
C# MVC 向页面传值方式
C# MVC 向页面传值方式
鱼找水需要时间
66 0
游客lopnqntuhj7l2
|
C#
C#窗口之间的传值
C#窗口之间的传值
游客lopnqntuhj7l2
78 0
C#窗口之间的传值
优惠码领取
|
Android开发 容器
C#-Xamarin的Activity传值与Fragment引用
C#-Xamarin的Activity传值与Fragment引用前言 我们学习任何一个新框架时，肯定都需要学习它的子页面用法，因为子页面是封装公共内容最好的容器。 在Xamarin里子页面为Fragment，翻译过来是片段的意思。
优惠码领取
1239 0
技术小美
|
C#
C# Winform窗体间传值
技术小美
1067 0
文艺小青年
|
C#
[C#] winform 子窗体向父窗体传值
文艺小青年
1021 0
技术小胖子
|
C#
C# WinForm 父窗体 子窗体 传值
技术小胖子
1955 0
swjian1997
|
C#
C# 窗体间传值
Form1: 父窗体, Form2: 子窗体。 1.父窗体接收子窗体的返回值： public partial class Form1: Form { private void btnOpen_Click(object sender, EventArgs e) ...
swjian1997
871 0
guitar_zp
|
C#
[C#] winform 子窗体向父窗体传值
父窗框mainForm;子窗体childForm,利用事件进行传值在子窗体中的操作： public event EventHandler accept; public string value; private void btnStart_Click(object sender, EventArgs e) { 　　value=txtName.
guitar_zp
910 0
pensir
winform+c#之窗体之间的传值
窗体传值可以分为两类。1、主窗体往子窗体传值有两种方法，一种是在子窗体提供重载构造函数，利用重载构造函数传递值，适用于传值数量比较少；第二种是，在子窗体中定义一个主窗体对象，然后就可以接收到主窗体的属性值了，适用于传值数量大。
pensir
957 0