C # Fundamentals: Value types, reference types, and ref keywords

View Plaincopy to Clipboardprint?

1. int a = ten, B = 20;
2. void swap (int x, int y)
3. {
4. int temp = x;
5. x = y;
6. y = temp;
7. }

If you simply call this swap, such as swap (A, b), then you simply cannot exchange the values of the two variables, because both x and Y are formal parameters, and X and Y are freed when the swap returns. But if this is the definition of swap:

View Plaincopy to Clipboardprint?

1. void Swap (int& x, int& y)
2. {
3. int temp = x;
4. x = y;
5. y = temp;
6. }

The same as x and A,y and B point to the same memory address, then the operation of X is equivalent to the operation of A. So in C #, this effect is obvious for value types.

View Plaincopy to Clipboardprint?

2. Class Program
4. {
6. static void Test (ref int b)
8. {
10. b = 2;
12. }
16. static void Main (string[] args)
18. {
20. int b = 1;
22. Test (ref B);
24. Console.WriteLine (b);
26. }
28. }

The output at this point is 2, that is, b in the test method points to the same memory address as B in main, then the operation on TEST.B is the main.b operation. If you change the program to:

View Plaincopy to Clipboardprint?

2. Class Program
4. {
6. static void Test (int b)
8. {
10. b = 2;
12. }
16. static void Main (string[] args)
18. {
20. int b = 1;
22. Test (b);
24. Console.WriteLine (b);
26. }
28. }

Then the output is still 1, because test.b is not a main.b reference, that is, a single parameter. Now look at the effect of the reference type:

View Plaincopy to Clipboardprint?

2. Class TestClass
4. {
6. public int B;
8. }
12. Class Program
14. {
16. static void Test (TestClass b)
18. {
20. B.B = 2;
22. }
26. static void Main (string[] args)
28. {
30. TestClass B = new TestClass ();
32. b.b = 1;
34. Test (b);
36. Console.WriteLine (B.B);
38. }
40. }

The above code, the output is 2, because B is a reference type, when you only need to modify the members of B, add the same as the REF keyword. The reference type itself does not contain data, and it only maintains a reference to the data.

Therefore, using the ref parameter, the effect on a value type object is obvious, and for reference types, you do not need to use the REF keyword if you want to modify the data inside the reference type, otherwise, when the called function internally needs to change the reference itself, such as to reposition the reference to the object inside the function, You need to use the REF keyword.

C # Fundamentals: Value types, reference types, and ref keywords