我正在尝试对 += 进行运算符重载，但我做不到。我只能对 + 进行运算符重载。

怎么会？

编辑

这不起作用的原因是我有一个 Vector 类(带有 X 和 Y 字段)。考虑以下示例。

vector1 += vector2;

如果我的运算符重载设置为:

public static Vector operator +(Vector left, Vector right)
{
    return new Vector(right.x + left.x, right.y + left.y);
}

然后结果不会添加到vector1，而是vector1 也将成为一个全新的Vector by reference。

最佳答案

Overloadable Operators , 来自 MSDN:

Assignment operators cannot be overloaded, but +=, for example, is evaluated using +, which can be overloaded.

更重要的是，赋值运算符都不能被重载。我认为这是因为会对垃圾收集和内存管理产生影响，这是 CLR 强类型世界中潜在的安全漏洞。

尽管如此，让我们看看运算符到底是什么。据著名Jeffrey Richter's book ，每种编程语言都有自己的运算符列表，这些运算符列表是在特殊的方法调用中编译的，而 CLR 本身对运算符一无所知。因此，让我们看看 + 和 += 运算符背后到底有什么。

看这段简单的代码:

Decimal d = 10M;
d = d + 10M;
Console.WriteLine(d);

让我们查看此指令的 IL 代码:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldloc.0
  IL_000a:  ldc.i4.s   10
  IL_000c:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0011:  call       valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::op_Addition(valuetype [mscorlib]System.Decimal,
                                                                                                valuetype [mscorlib]System.Decimal)
  IL_0016:  stloc.0

现在让我们看看这段代码:

Decimal d1 = 10M;
d1 += 10M;
Console.WriteLine(d1);

为此的 IL 代码:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldloc.0
  IL_000a:  ldc.i4.s   10
  IL_000c:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0011:  call       valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::op_Addition(valuetype [mscorlib]System.Decimal,
                                                                                                valuetype [mscorlib]System.Decimal)
  IL_0016:  stloc.0

他们是平等的!因此，+= 运算符只是C# 程序的语法糖，您可以简单地重载+ 运算符。

例如:

class Foo
{
    private int c1;

    public Foo(int c11)
    {
        c1 = c11;
    }

    public static Foo operator +(Foo c1, Foo x)
    {
        return new Foo(c1.c1 + x.c1);
    }
}

static void Main(string[] args)
{
    Foo d1 =  new Foo (10);
    Foo d2 = new Foo(11);
    d2 += d1;
}

此代码将被编译并成功运行为:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void ConsoleApplication2.Program/Foo::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldc.i4.s   11
  IL_000b:  newobj     instance void ConsoleApplication2.Program/Foo::.ctor(int32)
  IL_0010:  stloc.1
  IL_0011:  ldloc.1
  IL_0012:  ldloc.0
  IL_0013:  call       class ConsoleApplication2.Program/Foo ConsoleApplication2.Program/Foo::op_Addition(class ConsoleApplication2.Program/Foo,
                                                                                                          class ConsoleApplication2.Program/Foo)
  IL_0018:  stloc.1

更新:

根据您的更新 - 正如@EricLippert 所说，您确实应该将向量作为不可变对象(immutable对象)。两个向量相加的结果是一个新向量，而不是第一个大小不同的向量。

如果出于某种原因你需要改变第一个向量，你可以使用这个重载(但对我来说，这是非常奇怪的行为):

public static Vector operator +(Vector left, Vector right)
{
    left.x += right.x;
    left.y += right.y;
    return left;
}

关于 `+=` 的 C# 运算符重载？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6587107/