深刻理解C#的傳值調用和傳引用調用

標籤：http   ar   os   使用   sp   for   strong   div   on   

傳值調用和傳引用調用是幾乎所有主流語言都會涉及到的問題，下面我談談我對C#中傳值調用和傳引用調用的理解。

1. 一般對C#中傳值調用和傳引用調用的理解

• 如果傳遞的參數是基元類型（int，float等）或結構體（struct），那麼就是傳值調用。
• 如果傳遞的參數是類（class）那麼就是傳引用調用。
• 如果傳遞的參數前有ref或者out關鍵字，那麼就是傳引用調用。

驗證樣本的代碼如下：

 

 

 

view sourceprint?

01    using System;

02   

03    public class ArgsByRefOrValue

04    {

05        public static void Main(string[] args)

06        {

07            // 實驗1. 傳值調用--基元類型

08            int i = 10;

09            Console.WriteLine("before call ChangeByInt: i = " + i.ToString());

10            ChangeByInt(i);

11            Console.WriteLine("after call ChangeByInt: i = " + i.ToString());

12   

13            Console.WriteLine("==============================================");

14            // 實驗2. 傳值調用--結構體

15            Person_val p_val = new Person_val();

16            p_val.name = "old val name";

17            Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);

18            ChangeByStruct(p_val);

19            Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);

20   

21            Console.WriteLine("==============================================");

22            // 實驗3. 傳引用調用--類

23            Person_ref p_ref = new Person_ref();

24            p_ref.name = "old ref name";

25            Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);

26            ChangeByClass(p_ref);

27            Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);

28   

29            Console.WriteLine("==============================================");

30            // 實驗4. 傳引用調用--利用ref

31            Person_ref p = new Person_ref();

32            p.name = "old ref name";

33            Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);

34            ChangeByClassRef(ref p);

35            Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);

36   

37            Console.ReadKey(true);

38        }

39   

40        static void ChangeByInt(int i)

41        {

42            i = i + 10;

43            Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());

44        }

45   

46        static void ChangeByStruct(Person_val p_val)

47        {

48            p_val.name = "new val name";

49            Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);

50        }

51   

52        static void ChangeByClass(Person_ref p_ref)

53        {

54            p_ref.name = "new ref name";

55            Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);

56        }

57   

58        static void ChangeByClassRef(ref Person_ref p)

59        {

60            p.name = "new ref name";

61            Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);

62        }

63    }

64   

65    public struct Person_val

66    {

67        public string name;

68    }

69   

70    public class Person_ref

71    {

72        public string name;

73    }

 

運行結果如下：

 

 

看起來似乎上面代碼中實驗3和實驗4是一樣的，即對於類（class）來說，不管加不加ref或out，都是傳引用調用。

其實，這隻是表面的現象，只要稍微改一下代碼，結果就不一樣了。

修改上面代碼，再增加兩個實驗。

 

001  using System;

002 

003  public class ArgsByRefOrValue

004  {

005      public static void Main(string[] args)

006      {

007          // 實驗1. 傳值調用--基元類型

008          int i = 10;

009          Console.WriteLine("before call ChangeByInt: i = " + i.ToString());

010          ChangeByInt(i);

011          Console.WriteLine("after call ChangeByInt: i = " + i.ToString());

012 

013          Console.WriteLine("==============================================");

014          // 實驗2. 傳值調用--結構體

015          Person_val p_val = new Person_val();

016          p_val.name = "old val name";

017          Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);

018          ChangeByStruct(p_val);

019          Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);

020 

021          Console.WriteLine("==============================================");

022          // 實驗3. 傳引用調用--類

023          Person_ref p_ref = new Person_ref();

024          p_ref.name = "old ref name";

025          Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);

026          ChangeByClass(p_ref);

027          Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);

028 

029          Console.WriteLine("==============================================");

030          // 實驗4. 傳引用調用--利用ref

031          Person_ref p = new Person_ref();

032          p.name = "old ref name";

033          Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);

034          ChangeByClassRef(ref p);

035          Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);

036 

037          Console.WriteLine("==============================================");

038          // 實驗5. 傳引用調用--類 在調用的函數重新new一個對象

039          Person_ref p_ref_new = new Person_ref();

040          p_ref_new.name = "old new ref name";

041          Console.WriteLine("before call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);

042          ChangeByClassNew(p_ref_new);

043          Console.WriteLine("after call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);

044 

045          Console.WriteLine("==============================================");

046          // 實驗6. 傳引用調用--利用ref 在調用的函數重新new一個對象

047          Person_ref p_new = new Person_ref();

048          p_new.name = "old new ref name";

049          Console.WriteLine("before call ChangeByClassRefNew: p_new.name = " + p_new.name);

050          ChangeByClassRefNew(ref p_new);

051          Console.WriteLine("after call ChangeByClassRefNew: p_new.name = " + p_new.name);

052 

053          Console.ReadKey(true);

054      }

055 

056      static void ChangeByInt(int i)

057      {

058          i = i + 10;

059          Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());

060      }

061 

062      static void ChangeByStruct(Person_val p_val)

063      {

064          p_val.name = "new val name";

065          Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);

066      }

067 

068      static void ChangeByClass(Person_ref p_ref)

069      {

070          p_ref.name = "new ref name";

071          Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);

072      }

073 

074      static void ChangeByClassRef(ref Person_ref p)

075      {

076          p.name = "new ref name";

077          Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);

078      }

079 

080      static void ChangeByClassNew(Person_ref p_ref_new)

081      {

082          p_ref_new = new Person_ref();

083          p_ref_new.name = "new ref name";

084          Console.WriteLine("when calling ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);

085      }

086 

087      static void ChangeByClassRefNew(ref Person_ref p_new)

088      {

089          p_new = new Person_ref();

090          p_new.name = "new ref name";

091          Console.WriteLine("when calling ChangeByClassRefNew: p_new.name = " + p_new.name);

092      }

093  }

094 

095  public struct Person_val

096  {

097      public string name;

098  }

099 

100  public class Person_ref

101  {

102      public string name;

103  }

 

則運行結果為：

 

實驗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. 如果調用的函數中沒有對參數重新進行了地址分配，直接就是使用了傳遞的參數，那麼執行結果類似傳引用調用

深刻理解C#的傳值調用和傳引用調用