x = x + 1对x + = 1

Question

我的印象是这两个命令导致相同的结果,即将X递增1,但后者可能更有效.

如果这不正确,请解释差异.

如果它是正确的,为什么后者更有效率？他们不应该编译到同一个IL吗？

谢谢.

Answer 1

从MSDN库+ =:

使用此运算符与指定result = result + expression几乎相同,只是结果仅计算一次.

所以它们不相同,这就是x + = 1效率更高的原因.

更新:我刚刚注意到我的MSDN Library链接是JScript页面而不是VB页面,它不包含相同的引用.

因此,经过进一步的研究和测试,该答案不适用于VB.NET.我错了.这是一个示例控制台应用程序:

Module Module1

Sub Main()
    Dim x = 0
    Console.WriteLine(PlusEqual1(x))
    Console.WriteLine(Add1(x))
    Console.WriteLine(PlusEqual2(x))
    Console.WriteLine(Add2(x))
    Console.ReadLine()
End Sub

Public Function PlusEqual1(ByVal x As Integer) As Integer
    x += 1
    Return x
End Function

Public Function Add1(ByVal x As Integer) As Integer
    x = x + 1
    Return x
End Function

Public Function PlusEqual2(ByVal x As Integer) As Integer
    x += 2
    Return x
End Function

Public Function Add2(ByVal x As Integer) As Integer
    x = x + 2
    Return x
End Function

End Module

PlusEqual1和Add1的IL确实相同:

.method public static int32 Add1(int32 x) cil managed
{
.maxstack 2
.locals init (
    [0] int32 Add1)
L_0000: nop 
L_0001: ldarg.0 
L_0002: ldc.i4.1 
L_0003: add.ovf 
L_0004: starg.s x
L_0006: ldarg.0 
L_0007: stloc.0 
L_0008: br.s L_000a
L_000a: ldloc.0 
L_000b: ret 
}

IL for PlusEqual2和Add2几乎完全相同:

.method public static int32 Add2(int32 x) cil managed
{ 
.maxstack 2
.locals init (
    [0] int32 Add2)
L_0000: nop 
L_0001: ldarg.0 
L_0002: ldc.i4.2 
L_0003: add.ovf 
L_0004: starg.s x
L_0006: ldarg.0 
L_0007: stloc.0 
L_0008: br.s L_000a
L_000a: ldloc.0 
L_000b: ret 
}

Answer 2

我写了一个简单的控制台应用:

static void Main(string[] args)
{
    int i = 0;
    i += 1;
    i = i + 1;
    Console.WriteLine(i);
}

我用反射器拆卸它,这是我得到的:

private static void Main(string[] args)
{
    int i = 0;
    i++;
    i++;
    Console.WriteLine(i);
}

他们是一样的.

Answer 3

他们编译成相同的,第二个更容易打字.

Answer 4

重要:

+=在一般语言中,指定评估的答案肯定是正确的.但是在VB.NET中,我假设XOP中指定的是变量或属性.

他们可能会编译成同一个IL.

更新(以解决可能的争议):

VB.NET是一种编程语言的规范.任何符合规范中定义的编译器都可以是VB.NET实现.如果您编辑MS VB.NET编译器的源代码以生成X += 1案例的蹩脚代码,您仍将符合VB.NET规范(因为它没有说明它是如何工作的.它只是说效果将完全相同,这使得生成相同的代码是合乎逻辑的.

虽然编译器很可能(我觉得它确实如此)为两者生成相同的代码,但它是相当复杂的软件.哎呀,你甚至不能保证编译器在编译两次相同的代码时生成完全相同的代码!

您可以100%安全地说(除非您非常了解编译器的源代码)是一个好的编译器应该生成相同的代码,性能方面,可能是也可能不是完全相同的代码.

Answer 5

这么多猜测!即使是使用Reflector thingy的结论也不一定正确,因为它可以在反汇编时进行优化.

那你们为什么没有人只看一下IL代码呢？看看下面的C#程序:

static void Main(string[] args)
{
    int x = 2;
    int y = 3;
    x += 1;
    y = y + 1;
    Console.WriteLine(x);
    Console.WriteLine(y);
}

此代码段编译为:

.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 25 (0x19)
.maxstack 2
.locals init ([0] int32 x,
[1] int32 y)
// some commands omitted here

IL_0004: ldloc.0
IL_0005: ldc.i4.1
IL_0006: add
IL_0007: stloc.0

IL_0008: ldloc.1
IL_0009: ldc.i4.1
IL_000a: add
IL_000b: stloc.1

// some commands omitted here
}

正如你所看到的,它实际上是完全一样的.为什么呢？因为IL的目的是告诉做什么,而不是如何做.优化将是JIT编译器的工作.顺便说一句,它在VB.Net中是一样的