53

使用类似的东西之间是否有任何性能差异

for(int i = 0; i < 10; i++) { ... }

和

for(int i = 0; i < 10; ++i) { ... }

或者编译器是否能够以在功能相同的情况下同样快的方式进行优化？

编辑：之所以问这个问题是因为我与一位同事讨论过它，而不是因为我认为它在任何实际意义上都是有用的优化。它主要是学术性的。

4

9 回答 9

39

在这种情况下，生成的 ++i 和 i++ 中间代码没有区别。鉴于此程序：

class Program
{
    const int counter = 1024 * 1024;
    static void Main(string[] args)
    {
        for (int i = 0; i < counter; ++i)
        {
            Console.WriteLine(i);
        }

        for (int i = 0; i < counter; i++)
        {
            Console.WriteLine(i);
        }
    }
}

两个循环生成的 IL 代码相同：

  IL_0000:  ldc.i4.0
  IL_0001:  stloc.0
  // Start of first loop
  IL_0002:  ldc.i4.0
  IL_0003:  stloc.0
  IL_0004:  br.s       IL_0010
  IL_0006:  ldloc.0
  IL_0007:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_000c:  ldloc.0
  IL_000d:  ldc.i4.1
  IL_000e:  add
  IL_000f:  stloc.0
  IL_0010:  ldloc.0
  IL_0011:  ldc.i4     0x100000
  IL_0016:  blt.s      IL_0006
  // Start of second loop
  IL_0018:  ldc.i4.0
  IL_0019:  stloc.0
  IL_001a:  br.s       IL_0026
  IL_001c:  ldloc.0
  IL_001d:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0022:  ldloc.0
  IL_0023:  ldc.i4.1
  IL_0024:  add
  IL_0025:  stloc.0
  IL_0026:  ldloc.0
  IL_0027:  ldc.i4     0x100000
  IL_002c:  blt.s      IL_001c
  IL_002e:  ret

也就是说，JIT 编译器有可能（尽管极不可能）可以在某些上下文中进行一些优化，从而使一个版本优于另一个版本。但是，如果有这样的优化，它可能只会影响循环的最终（或者可能是第一次）迭代。

简而言之，您描述的循环结构中控制变量的简单预增量或后增量的运行时间没有区别。

于 2009-01-22T03:19:29.027 回答
8

如果你问这个问题，你是在试图解决错误的问题。

要问的第一个问题是“如何通过提高软件运行速度来提高客户对软件的满意度？” 答案几乎从不“使用 ++i 而不是 i++”，反之亦然。

来自 Coding Horror 的帖子“硬件很便宜，程序员很贵”：

优化规则：
规则 1：不要这样做。
规则 2（仅适用于专家）：暂时不要这样做。
——马杰克逊

我读到规则 2 的意思是“首先编写满足客户需求的干净、清晰的代码，然后在速度太慢的地方加快速度”。++ivs.不太可能i++成为解决方案。

于 2009-01-22T03:31:49.270 回答
7

啊……又开了。好的。这是交易。

ILDASM 是一个开始，但不是结束。关键是：JIT 将为汇编代码生成什么？

这就是你想要做的。

拿几个你想看的样本。显然，如果您愿意，您可以对它们进行挂钟计时 - 但我假设您想知道的不仅仅是这些。

这是不明显的。C# 编译器会生成一些 MSIL 序列，这些序列在很多情况下都不是最优的。它调整为处理这些和其他语言的怪癖的 JIT。问题：只有有人注意到的“怪癖”被调整了。

您真的想制作一个示例，让您的实现可以尝试，返回到 main（或任何地方）、Sleep() 或您可以附加调试器的地方，然后再次运行例程。

您不想在调试器下启动代码，否则 JIT 将生成未优化的代码 - 听起来您想知道它在真实环境中的行为方式。JIT 这样做是为了最大化调试信息并最小化当前源位置的“跳来跳去”。永远不要在调试器下启动性能评估。

好的。因此，一旦代码运行一次（即：JIT 已为其生成代码），然后在睡眠期间附加调试器（或其他）。然后查看为这两个例程生成的 x86/x64。

我的直觉告诉我，如果您按照您的描述使用 ++i/i++ - 即：在不重复使用右值结果的独立表达式中 - 不会有区别。但是，去发现并查看所有整洁的东西会不会很有趣！:)

于 2009-01-22T00:05:41.713 回答
7

正如 Jim Mischel所示，编译器将为两种编写 for 循环的方式生成相同的 MSIL。

但就是这样：没有理由推测 JIT 或执行速度测量。如果两行代码生成相同的 MSIL，它们不仅执行相同，而且实际上是相同的。

任何可能的 JIT 都无法区分循环，因此生成的机器代码也必须相同。

于 2009-01-22T06:07:53.120 回答
3

有一段具体的代码和 CLR 版本吗？如果是这样，对其进行基准测试。如果没有，那就算了。微优化等等……此外，您甚至不能确定不同的 CLR 版本会产生相同的结果。

于 2009-01-22T00:29:26.360 回答
2

除了其他答案之外，如果您i的不是int. 在 C++中，如果它是具有运算符++()和++(int)重载的类的对象，那么它可能会产生影响，并且可能会产生副作用。在这种情况下，性能++i 应该更好（取决于实现）。

于 2009-01-22T06:30:20.360 回答
0

根据这个答案，i++ 使用的 CPU 指令比 ++i 多。但这是否会导致性能差异，我不知道。

由于任何一个循环都可以很容易地重写为使用后增量或前增量，我猜编译器将始终使用更有效的版本。

于 2009-01-21T22:38:28.113 回答
0 
  static void Main(string[] args) {
     var sw = new Stopwatch(); sw.Start();
     for (int i = 0; i < 2000000000; ++i) { }
     //int i = 0;
     //while (i < 2000000000){++i;}
     Console.WriteLine(sw.ElapsedMilliseconds);

3 次运行的平均值：
对于使用 i++：1307 对于使用 ++i：1314

使用 i++ 时：1261 使用 ++i 时：1276

那是 2,53 Ghz 的赛扬 D。每次迭代大约需要 1.6 个 CPU 周期。这要么意味着 CPU 每个周期执行超过 1 条指令，要么意味着 JIT 编译器展开了循环。i++ 和 ++i 之间的差异仅为每次迭代 0.01 个 CPU 周期，可能是由后台的 OS 服务造成的。

于 2009-01-22T00:50:29.267 回答
-1

两者之间没有区别，原因是循环比较是在递增/递减语句之后的单独语句。例子 ;

for(int i=0; i<3; i++){
    System.out.println(i)
}

这如下所示，

步骤初始化：i = 0

Step Compare :i < 3为真则执行loop块

步进增量：i = i++;或i = ++i;

Step Copmare Again : 由于 Java 在下一步中进行比较。i++ 和 ++i 都给出相同的结果。例如，如果 i = 0，则递增后 i 将变为 1。

这就是为什么前增量或后增量在循环中的行为相同的原因。

于 2019-11-04T16:27:34.167 回答