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

如果你担心微观优化，这里有一个额外的观察。递减循环“可能”比递增循环更有效(取决于指令集架构，例如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系统开发人员指南。

请不要让“哪个更快”的问题成为使用哪个的决定因素。你可能永远不会关心那么多，此外，程序员的阅读时间比机器的时间要昂贵得多。

使用任何对阅读代码的人最有意义的方法。

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

更好的答案是++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++的结果不会受到影响。

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

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

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

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

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

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

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

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