更好的答案是++i有时会更快，但绝不会变慢。

每个人似乎都认为i是一个常规的内置类型，比如int。在这种情况下，将没有可测量的差异。

然而，如果i是复型，那么你很可能会发现一个可测量的差异。对于i++，您必须在递增类之前复制它。根据复制中涉及的内容，它确实可能会变慢，因为使用++i可以只返回最终值。

Foo Foo::operator++()
{
  Foo oldFoo = *this; // copy existing value - could be slow
  // yadda yadda, do increment
  return oldFoo;
}

另一个区别是，使用++i，您可以选择返回一个引用而不是一个值。同样，根据复制对象所涉及的内容，这可能会更慢。

在现实世界中，迭代器的使用就是可能发生这种情况的一个例子。复制迭代器不太可能成为应用程序中的瓶颈，但养成使用++i而不是i++的习惯仍然是一个很好的实践，因为i++的结果不会受到影响。

在C语言中，如果结果未被使用，编译器通常可以将它们优化为相同。

然而，在c++中，如果使用提供自己的++操作符的其他类型，前缀版本可能比后缀版本更快。因此，如果不需要后缀语义，最好使用前缀操作符。

简短的回答:

i++和++i在速度上没有任何区别。一个好的编译器不应该在这两种情况下生成不同的代码。

长一点的回答:

其他答案都没有提到的是，++i和i++之间的区别只在它所找到的表达式中有意义。

对于for(i=0;我< n;i++)， i++在它自己的表达式中是单独的:在i++之前有一个序列点，在它之后有一个。因此，生成的唯一机器码是“将i增加1”，并且它是如何与程序的其余部分进行排序的。所以如果你把它改成前缀++，这一点关系都没有，你仍然会得到机器代码“将i增加1”。

++i和i++之间的差异只在数组[i++] = x;与数组[++i] = x;有些人可能会争辩说，后缀在这样的操作中会更慢，因为i所在的寄存器稍后必须重新加载。但是请注意，编译器可以自由地以任何它喜欢的方式对你的指令进行排序，只要它不像C标准所说的那样“破坏抽象机器的行为”。

所以当你假设数组[i++] = x;被翻译成机器代码为:

将i的值存储在寄存器A中。 存储寄存器B中数组的地址。 将A和B相加，将结果存储在A中。 在这个由A表示的新地址上，存储x的值。 在寄存器A //中存储i的值是低效的，因为这里有额外的指令，我们已经做过一次了。 增量寄存器A。 在i中存储寄存器A。

编译器也可以更有效地生成代码，例如:

将i的值存储在寄存器A中。 存储寄存器B中数组的地址。 添加A和B，将结果存储在B中。 增量寄存器A。 在i中存储寄存器A。 ．.． //其余的代码。

只是因为作为一个C程序员，你被训练成认为后缀++发生在结尾，所以机器代码不需要以这种方式排序。

所以在C语言中，前缀++和后缀++没有区别。现在，作为一个C程序员，你应该知道的是，有些人在某些情况下不一致地使用前缀，而在其他情况下不一致地使用后缀，没有任何理由。这表明他们不确定C语言是如何工作的，或者他们对这门语言的了解不正确。这总是一个不好的迹象，它反过来表明他们在他们的程序中做出了其他有问题的决定，基于迷信或“宗教教条”。

“前缀++总是更快”确实是一个错误的教条，在准C程序员中很常见。

执行摘要:没有。

i++可能比++ I慢，因为I的旧值 可能需要保存以备以后使用，但实际上都是现代的 编译器将对其进行优化。

我们可以通过查看这个函数的代码来证明这一点， 都是++i和i++。

$ cat i++.c
extern void g(int i);
void f()
{
    int i;

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

}

文件是一样的，除了++i和i++:

$ diff i++.c ++i.c
6c6
<     for (i = 0; i < 100; i++)
---
>     for (i = 0; i < 100; ++i)

我们将编译它们，并获得生成的汇编器:

$ gcc -c i++.c ++i.c
$ gcc -S i++.c ++i.c

我们可以看到生成的对象和汇编程序文件都是相同的。

$ md5 i++.s ++i.s
MD5 (i++.s) = 90f620dda862cd0205cd5db1f2c8c06e
MD5 (++i.s) = 90f620dda862cd0205cd5db1f2c8c06e

$ md5 *.o
MD5 (++i.o) = dd3ef1408d3a9e4287facccec53f7d22
MD5 (i++.o) = dd3ef1408d3a9e4287facccec53f7d22

首先:在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.

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

想象一个寄存器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;).