按价值传递？

Question

我在传递 C# 函数参数时遇到问题。

我想知道如何让 C# 函数按值接受参数（以制作原始对象的副本）。

我认为这是 C# 处理这些事情的默认方式，但在以下代码中：

using System;
using System.Collections.Generic;
using System.Linq;
class MaximumElement
{
    static void Main(string[] args)
    {
        Stack<int> numbers = new Stack<int>();
        int n = int.Parse(Console.ReadLine());
        for (int i = 0; i < n; i++)
        {
            string input = Console.ReadLine();
            switch (input)
            {
                case "2": numbers.Pop(); break;
                case "3": Console.WriteLine(maxElement(numbers)); break;
                default:
                    string[] argz = input.Split(' ');
                    numbers.Push(int.Parse(argz[1]));
                    break;
            }
        }
    }


    public static int maxElement(Stack<int> stack)
    {
        int max = stack.Peek();
        for (int i = 0; i < stack.Count; i++)
        {
            if (max >= stack.Peek())
            {
                stack.Pop();
            }
            else if (max < stack.Peek())
            {
                max = stack.Pop();
            }
        }
        return max;
    }
}

我的 maxElement() 函数实际上改变了我传递给它的原始堆栈，解决它的唯一方法是手动复制我在函数内部传递给函数的堆栈. 感谢您提前回复:)

Answer 1

不要将 value 或 reference 的传递参数与 value types 和 reference types 混合。这是初学者的常见错误，您需要清楚地了解这两者虽然在某种程度上相关，但却是语言的完全不同的特征。

我可能不会使用精确的术语，因为英语不是我的语言，但我希望我能理解这个想法：

• 值类型：变量是值本身。当您编写以下内容时：int i = 1; 变量 i 包含值 1。
• 引用类型：变量是指向内存中对象所在位置的引用。也就是说，当你说string s = "Hello";s不包含"Hello"时，它包含了存储"Hello"的内存地址。

那么当你按值传递参数时会发生什么（C# 中的默认值）。我们有两种可能：

• 参数是一个值类型：你得到一个变量的副本，这意味着 如果你传递 i = 1 你会收到一个 copy 这也是 包含1，但两者都是不同的对象。

  这在处理可变值类型时很明显，例如System.Drawing.Point：

  Point point = new Point(0, 0);
  
  Frob(point);
  var b = point.X == 1 && point.Y == 1; //False, point does not change.
  
  void Frob(Point p) { p.Offset(1, 1); } // p is a copy of point and therefore contains a copy of the value stored in point, not the value itself.
  

• 参数是一个引用类型：你得到一个变量的副本，这意味着你得到一个对内存地址的引用的副本，但是这个副本指向的对象是一样的。这就是你所处的场景。

  Foo foo = new Foo();
  foo.Blah = 1;
  
  Frob(foo);
  var b = foo.Blah == 2; //True, foo.Blah has been modified.
  
  void Frob(Foo f) { foo.Blah = 2; } //both foo and f point to the same object.
  

  请注意，在这两种情况下，您都不能修改 what 引用所指向的内容。这行不通：

  string s = "hello";
  foo(s);
  var b = s == "bye"; //false, s still points to the original string
  
  void Foo(string str)
  {
      str = "bye";
  }
  

现在，如果我们通过引用传递会发生什么？好吧，主要区别在于您传递的是变量本身，而不是副本。这意味着在值类型的情况下，您传递的是原始值，而在引用类型的情况下，是原始地址，而不是副本。这允许以下操作：

    //Value type
    Point point = new Point(0, 0);

    Frob(ref point);
    var b = point.X == 1 && point.Y == 1; //True, point and p are the same variable.

    void Frob(ref Point p) { p.Offset(1, 1); }

和

    //Value or reference type
    string s = "hello";
    foo(ref s);
    var b = s == "bye"; //true

    void Foo(ref string str)
    {
        str = "bye";
    }

希望这可以澄清差异。

Answer 2

这有点复杂。来自 MSDN (https://msdn.microsoft.com/en-us/library/s6938f28.aspx)：

引用类型的变量不直接包含它的数据；它包含对其数据的引用。当您通过值传递引用类型参数时，可以更改引用指向的数据，例如类成员的值。但是，您不能更改引用本身的值；也就是说，您不能使用相同的引用来为新类分配内存并让它在块之外持续存在。为此，请使用 ref 或 out 关键字传递参数。为简单起见，以下示例使用 ref.

这是他们提供的代码示例：

static void Change(int[] pArray)
{
    pArray[0] = 888;  // This change affects the original element.
    pArray = new int[5] {-3, -1, -2, -3, -4};   // This change is local.

现在，如果您在参数上使用 ref 关键字

static void Change(ref int[] pArray)
{
    pArray[0] = 888;  // This change affects the original element.
    pArray = new int[5] {-3, -1, -2, -3, -4};   // This change also affects the original

因此，考虑到这些事情，您可以...

public static int maxElement(Stack<int> stack)
{
    stack = new Stack<int>(stack); // Now changes will be local

    int max = stack.Peek();
    for (int i = 0; i < stack.Count; i++)
    {
        if (max >= stack.Peek())
        {
            stack.Pop();
        }
        else if (max < stack.Peek())
        {
            max = stack.Pop();
        }
    }
    return max;
}

Answer 3

您需要制作 Stack 的副本，如果浅层副本有效，您可以使用 Clone() 方法。