C#如何处理运算符重载

Question

假设我在 C# 中有一个复数类，它的加法运算符是这样定义的。

public static Complex operator +(Complex c1, Complex c2) 
 {
      return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
 }

并像这样使用。

 Complex c1, c2, c3, c4;

 c1 = new Complex(...)
 ...
 c4 = new Complex(...)

 Complex csum = c1 + c2 + c3 + c4;

现在，我的问题是 C# 编译器+运行时将如何处理这个问题。显然，它看起来会做这样的事情。

 ct1 = c1 + c2; // ct1 is a temporary object created by the compiler
 ct2 = ct1 + c3;
 csum = ct2 + c4;

或者它是否足够聪明地意识到它可以像这样以更好的方式（更少创建新的临时对象）来做到这一点。

 ct = c1 + c2;
 ct += c3;
 csum = ct + c4; 

Answer 1

除了有一个命名的局部变量之外，单个表达式与单独的语句等效（就生成的代码而言）。 JIT 可能会优化它，但编译器不能。请注意，如果Complex 是一个值类型，那么它实际上并不涉及分配对象¹。

值得注意的是，+ 运算符是专门为 C# 中的 string 处理的（它由语言指定；它不在框架本身中）正是为了避免这种事情：x + y + z 是（或在至少可以) 转换为string.Concat(x, y, z) 以避免创建临时字符串。

---

¹ “对象”是指带有对象头（类型引用、同步块等）的内存区域，后跟在堆上分配的字段，而不是“值类型” value”，它只包括数据本身，可能在堆上或栈上。堆栈/堆部分当然是implementation detail，但可能很重要......我相信区分“只是一个值类型值”和“一个完整的对象”是合理的 .

Answer 2

关于编译输出，您推断的逐步过程都不正确。 CLR 是一个堆栈机器，由于一次将所有四个相加的代码并不表示需要将中间总计作为命名变量单独分配，因此它会在适当的位置更新运行总计（或者更确切地说，弹出并推送顶部堆栈元素）。

您的两个逐步版本都需要相同数量的实际操作；一元加法版本只需要少一个局部变量分配。

以下是通过将四个输入复数相加的三种不同方法生成的实际 IL。请注意，在我的版本中，我将 Complex 类（我假设您从 How to: Use Operator Overloading to Create a Complex Number Class (C# Programming Guide) 提升）更改为保存两个 double 值而不是两个 ints。为简洁起见，我在 C# 和 IL 代码中都省略了 c1..c4 的声明。简而言之，两种推断的逐步方法都需要两个额外的stloc.s（将一个值推送到变量列表）和ldloc.s（从变量列表中检索一个值）调用。

原文：将所有四个连续添加：

C#：

Complex csum = c1 + c2 + c3 + c4;

IL：

// MultipleAdd : 5 Locals, maxstack 3
IL_0068:  nop
IL_0069:  ldloc.0
IL_006a:  ldloc.1
IL_006b:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0070:  ldloc.2
IL_0071:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0076:  ldloc.3
IL_0077:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_007c:  stloc.s    csum
IL_007e:  ret

推论 1：三个二进制加法

C#：

Complex ct1 = c1 + c2; 
Complex ct2 = ct1 + c3;  
Complex csum = ct2 + c4; 

IL：

// BinaryAdd : 7 Locals, maxstack 3
IL_0068:  nop
IL_0069:  ldloc.0
IL_006a:  ldloc.1
IL_006b:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0070:  stloc.s    ct1
IL_0072:  ldloc.s    ct1
IL_0074:  ldloc.2
IL_0075:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_007a:  stloc.s    ct2
IL_007c:  ldloc.s    ct2
IL_007e:  ldloc.3
IL_007f:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0084:  stloc.s    csum
IL_0086:  ret 

推理 2：一元加法

C#：

Complex ct = c1 + c2; 
ct += c3; 
Complex csum = ct + c4;

IL：

// UnaryAdd : 6 Locals, maxstack 3
IL_0068:  nop
IL_0069:  ldloc.0
IL_006a:  ldloc.1
IL_006b:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0070:  stloc.s    ct
IL_0072:  ldloc.s    ct
IL_0074:  ldloc.2
IL_0075:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_007a:  stloc.s    ct
IL_007c:  ldloc.s    ct
IL_007e:  ldloc.3
IL_007f:  call       valuetype Test.Complex Test.Complex::op_Addition(valuetype Test.Complex,
                                                                    valuetype Test.Complex)
IL_0084:  stloc.s    csum
IL_0086:  ret