3

大多数消息来源说，在 c# 中重载 ++ 和 -- 运算符会导致同时重载后缀和前缀。但看起来他们的行为仍然不同。

class Counter
{
    public Counter(int v = 0)
    {
        this.v = v;
    }
    public Counter(Counter c)
    {
        v = c.v;
    }
    public int GetValue() { return v; }
    public static Counter operator ++(Counter c)
    {
        c.v++;
        return new Counter(c);
    }
    private int v;
}


class Program
{
    public static void Main()
    {
        Counter c1 = new Counter(1);

        Counter c2 = c1++;

        Counter c3 = ++c1;

        c3++;

        System.Console.WriteLine("c1 = {0}", c1.GetValue());
        System.Console.WriteLine("c2 = {0}", c2.GetValue());
        System.Console.WriteLine("c3 = {0}", c3.GetValue());
    }
}

奇妙的是，尽管重载operator ++返回了原始类的副本，但在本例中c1，它c3成为对同一对象的引用，而c2指向不同的对象（c1=4, c2=2, c3=4此处）。更改Counter c3 = ++c1;为Counter c3 = c1++;输出c1=3, c2=2, c3=4。

那么，后缀和前缀递增/递减之间的确切区别是什么以及它如何影响重载？这些运算符对类和原始类型的行为方式相同吗？

4

1 回答 1

12

这是在 C# 中实现递增和递减的错误方法。如果你做错了，你会得到疯狂的结果；你做错了，你得到了疯狂的结果，所以系统正常工作。:-)

巧合的是，上周我写了一篇关于这个主题的文章：

http://ericlippert.com/2013/09/25/bug-guys-meets-math-from-scratch/

正如评论者 dtb 指出的那样，正确的实现是：

    public static Counter operator ++(Counter c)
    {
        return new Counter(c.v + 1);
    }

在 C# 中，自增运算符不得改变其参数。相反，它必须只计算增加的​​值并返回它，而不会产生任何副作用。变异变量的副作用将由编译器处理。

有了这个正确的实现，你的程序现在是这样的：

    Counter c1 = new Counter(1);

现在调用 c1 引用的对象W。W.v是 1。

    Counter c2 = c1++;

这具有以下语义：

temp = c1
c1 = operator++(c1) // create object X, set X.v to 2
c2 = temp

所以c1现在指的是X，c2指的是W。 W.v是 1 和X.v2。

    Counter c3 = ++c1;

这具有以下语义

temp = operator++(c1) // Create object Y, set Y.v to 3
c1 = temp
c3 = temp

所以 c1 和 c3 现在都引用 object Y，并且Y.v是 3。

    c3++;

这具有以下语义

c3 = operator++(c3) // Create object Z, set Z.v to 4

因此，当烟雾全部清除时：

c1.v = 3 (Y)
c2.v = 1 (W)
c3.v = 4 (Z)

并且X是孤儿。

这应该给出与你有c1,c2和c3普通整数完全相同的结果。

于 2013-10-02T15:49:49.290 回答