我的C有点生疏了，所以我提前道歉。就速度而言，我可以理解结果。但是，我对这两个文件是如何得到相同的MD5哈希感到困惑。也许for循环也可以运行，但是下面两行代码不会生成不同的程序集吗?

myArray[i++] = "hello";

vs

myArray[++i] = "hello";

第一个函数将值写入数组，然后将i加1，第二个函数将i加1，然后将值写入数组。我不是汇编专家，但我只是不明白这两行不同的代码如何生成相同的可执行文件。

这只是我的个人意见。

首先:在C中i++和++i之间的差异是可以忽略的。

到细节。

1. 众所周知的c++问题:++i更快

在c++中，如果i是具有重载自增操作符的某种对象，则++i的效率更高。

为什么? 在++i中，对象首先递增，然后可以作为const引用传递给任何其他函数。如果表达式是foo(i++)，这是不可能的，因为现在增量需要在foo()调用之前完成，但旧的值需要传递给foo()。因此，编译器被迫在对原始i执行自增操作符之前复制i。额外的构造函数/析构函数调用是不好的部分。

如上所述，这不适用于基本类型。

2. 鲜为人知的事实是:i++可能更快

如果不需要调用构造函数/析构函数，这在C中总是如此，那么++i和i++应该同样快，对吗?不。他们的速度几乎一样快，但可能有一些小的差异，这是大多数其他答案的错误理解。

How can i++ be faster? The point is data dependencies. If the value needs to be loaded from memory, two subsequent operations need to be done with it, incrementing it, and using it. With ++i, the incrementation needs to be done before the value can be used. With i++, the use does not depend on the increment, and the CPU may perform the use operation in parallel to the increment operation. The difference is at most one CPU cycle, so it is really neglegible, but it is there. And it is the other way round then many would expect.

参考Scott Meyers的《更有效的c++第六条:区分增减操作的前缀和后缀形式》。

对于对象，尤其是对于迭代器，前缀版本总是优于后缀版本。

原因是，如果你看一下操作符的调用模式。

// Prefix
Integer& Integer::operator++()
{
    *this += 1;
    return *this;
}

// Postfix
const Integer Integer::operator++(int)
{
    Integer oldValue = *this;
    ++(*this);
    return oldValue;
}

看看这个例子，很容易看出前缀操作符总是比后缀操作符更有效率。因为需要在临时对象中使用后缀。

这就是为什么当你看到使用迭代器的例子时，他们总是使用前缀版本。

但正如你所指出的，对于int型，实际上没有什么区别，因为编译器优化可以发生。

我已经阅读了这里的大部分答案和许多评论，我没有看到任何一个我能想到的实例，在哪里i++比++ I更有效(也许令人惊讶的是- I比I更有效)。这是针对DEC PDP-11的C编译器!

PDP-11的汇编指令用于寄存器的前减和后增，但没有相反的指令。这些指令允许任何“通用”寄存器用作堆栈指针。所以如果你使用像*(i++)这样的东西，它可以被编译成一个汇编指令，而*(++i)不能。

这显然是一个非常深奥的例子，但它确实提供了后增量更有效的例外(或者我应该说曾经，因为现在对PDP-11 C代码的需求并不多)。

我可以想到一种情况，后缀比前缀增量慢:

想象一个寄存器a的处理器被用作累加器，它是许多指令中使用的唯一寄存器(一些小型微控制器实际上是这样的)。

现在想象一下下面的程序和它们转换成一个假设的程序集:

前缀增量:

a = ++b + c;

; increment b
LD    A, [&b]
INC   A
ST    A, [&b]

; add with c
ADD   A, [&c]

; store in a
ST    A, [&a]

后缀增加:

a = b++ + c;

; load b
LD    A, [&b]

; add with c
ADD   A, [&c]

; store in a
ST    A, [&a]

; increment b
LD    A, [&b]
INC   A
ST    A, [&b]

注意b的值是如何被强制重新加载的。使用前缀增量，编译器可以只增加值并继续使用它，可能避免重新加载它，因为所需的值在增量之后已经在寄存器中。然而，使用后缀增量，编译器必须处理两个值，一个是旧值，一个是增加的值，正如我上面所示，这会导致更多的内存访问。

当然，如果增量的值没有被使用，比如单个i++;语句，编译器可以(并且确实)简单地生成一个增量指令，而不管后缀或前缀的使用。

As a side note, I'd like to mention that an expression in which there is a b++ cannot simply be converted to one with ++b without any additional effort (for example by adding a - 1). So comparing the two if they are part of some expression is not really valid. Often, where you use b++ inside an expression you cannot use ++b, so even if ++b were potentially more efficient, it would simply be wrong. Exception is of course if the expression is begging for it (for example a = b++ + 1; which can be changed to a = ++b;).

如果你担心微观优化，这里有一个额外的观察。递减循环“可能”比递增循环更有效(取决于指令集架构，例如ARM)，给定:

for (i = 0; i < 100; i++)

在每个循环中，你将有一个指令:

i加1。 比较i是否小于100。 如果i小于100，则为条件分支。

而递减循环:

for (i = 100; i != 0; i--)

循环将有一个指令用于以下每一个:

递减i，设置CPU寄存器状态标志。 一个依赖于CPU寄存器状态(Z==0)的条件分支。

当然，这只适用于递减到零!

记得ARM系统开发人员指南。