我试图通过示例说明前缀递增比后缀递增更有效率。
从理论上讲，这是有道理的：i++需要能够返回未递增的原始值并因此存储它，而++i可以返回递增后的值而无需存储先前的值。
但是有没有一个好的实例来展示这一点呢？
我尝试了以下代码：
int array[100];
int main()
{
for(int i = 0; i < sizeof(array)/sizeof(*array); i++)
array[i] = 1;
}
我使用gcc 4.4.0编译它的方式如下：
gcc -Wa,-adhls -O0 myfile.cpp
我再次尝试了一下，将后缀递增改为前缀递增：
for(int i = 0; i < sizeof(array)/sizeof(*array); ++i)
在这两种情况下，结果的汇编代码是完全相同的。
这有点出乎意料。似乎通过关闭优化（使用-O0）应该会有不同的结果来展示这个概念。我错过了什么？是否有更好的例子来说明这一点？
通常情况下，后置自增运算将会导致一个副本的产生，而前置自增则不会。当然，在许多情况下，这将被优化掉，在不能优化时，复制操作也将是可以忽略的（例如对于内置类型）。
这里有一个小例子，展示了后置自增的潜在低效性。
#include <stdio.h>
class foo
{
public:
int x;
foo() : x(0) {
printf( "construct foo()\n");
};
foo( foo const& other) {
printf( "copy foo()\n");
x = other.x;
};
foo& operator=( foo const& rhs) {
printf( "assign foo()\n");
x = rhs.x;
return *this;
};
foo& operator++() {
printf( "preincrement foo\n");
++x;
return *this;
};
foo operator++( int) {
printf( "postincrement foo\n");
foo temp( *this);
++x;
return temp;
};
};
int main()
{
foo bar;
printf( "\n" "preinc example: \n");
++bar;
printf( "\n" "postinc example: \n");
bar++;
}
优化后的构建结果（实际上由于返回值优化，在后置增量情况下删除了第二个复制操作）：
construct foo()
preinc example:
preincrement foo
postinc example:
postincrement foo
copy foo()
一般来说，如果您不需要后置增量的语义，为什么要冒险发生不必要的复制呢？
当然，需要记住自定义的operator++() - 无论是前缀还是后缀变体 - 可以自由地返回任何想要的内容（甚至可以随意操作），我想可能有很多人并不遵循通常的规则。偶尔会遇到返回"void"的实现，这使得通常的语义差异消失了。
对于整数，您不会看到任何区别。您需要使用迭代器或其他一些东西，在其中后缀和前缀真正有所不同。而且您需要打开所有优化，而不是关闭！
++x应该比x++生成更快的代码。 - GManNickG我喜欢遵循“说到做到”的原则。
++i 简单地递增。 i++ 递增并且具有特殊的、非直观的评估结果。只有在明确需要这种行为时，我才使用 i++，而在其他所有情况下都使用 ++i。如果你也遵循这个实践，当你在代码中看到 i++ 时，就会明显地意识到后递增行为确实是有意的。
几点说明：
如果你想展示差异，最简单的选择就是实现这两个运算符，并指出其中一个需要额外的副本，另一个则不需要。
尝试使用while或对返回值进行操作，例如：
#define SOME_BIG_CONSTANT 1000000000
int _tmain(int argc, _TCHAR* argv[])
{
int i = 1;
int d = 0;
DWORD d1 = GetTickCount();
while(i < SOME_BIG_CONSTANT + 1)
{
d += i++;
}
DWORD t1 = GetTickCount() - d1;
printf("%d", d);
printf("\ni++ > %d <\n", t1);
i = 0;
d = 0;
d1 = GetTickCount();
while(i < SOME_BIG_CONSTANT)
{
d += ++i;
}
t1 = GetTickCount() - d1;
printf("%d", d);
printf("\n++i > %d <\n", t1);
return 0;
}
使用 /O2 或 /Ox 在 VS 2005 中编译，我在台式机和笔记本电脑上都尝试过。
在笔记本电脑上稳定得到了大致相似的数据，在台式机上数字有些不同（但速率大致相同）：
i++ > 8xx <
++i > 6xx <
xx 表示数字不同，例如 813 vs 640 - 仍然可以加速约 20%。
还有一个要点 - 如果用 "d = " 替换 "d +="，你会看到一个很棒的优化技巧：
i++ > 935 <
++i > 0 <
然而，它相当具体。但毕竟，我没有看到任何理由改变我的想法并认为没有区别 :)
i 和 d 是整数，你在这里不应该看到任何区别。 - Nathan Fellman这段代码及其注释应该展示两者之间的差异。
class a {
int index;
some_ridiculously_big_type big;
//etc...
};
// prefix ++a
void operator++ (a& _a) {
++_a.index
}
// postfix a++
void operator++ (a& _a, int b) {
_a.index++;
}
// now the program
int main (void) {
a my_a;
// prefix:
// 1. updates my_a.index
// 2. copies my_a.index to b
int b = (++my_a).index;
// postfix
// 1. creates a copy of my_a, including the *big* member.
// 2. updates my_a.index
// 3. copies index out of the **copy** of my_a that was created in step 1
int c = (my_a++).index;
}
你可以看到后缀有一个额外的步骤（步骤1），涉及创建对象的副本。这对内存消耗和运行时间都有影响。这就是为什么前缀对于非基本类型更有效率。
根据一些非常大的类型以及您对增量结果所做的任何操作，您将能够在优化或未优化的情况下看到差异。
#include <cstdio>
#include <ctime>
using namespace std;
#define SOME_BIG_CONSTANT 100000000
#define OUTER 40
int main( int argc, char * argv[] ) {
int d = 0;
time_t now = time(0);
if ( argc == 1 ) {
for ( int n = 0; n < OUTER; n++ ) {
int i = 0;
while(i < SOME_BIG_CONSTANT) {
d += i++;
}
}
}
else {
for ( int n = 0; n < OUTER; n++ ) {
int i = 0;
while(i < SOME_BIG_CONSTANT) {
d += ++i;
}
}
}
int t = time(0) - now;
printf( "%d\n", t );
return d % 2;
}
外层循环是为了让我调整时间以在我的平台上得到合适的结果。
我不再使用VC++，所以我在Windows上编译它：
g++ -O3 t.cpp
然后我通过交替运行它：
a.exe
并且
a.exe 1
我的时序结果在两种情况下大致相同。有时一个版本会比另一个版本快20％，有时则相反。我猜这可能是由于我的系统上运行了其他进程。
好的，所有这些前缀/后缀“优化”只是...一些大误解。
主要的想法是i++返回它的原始副本，因此需要复制该值。
这可能对一些迭代器的低效实现是正确的。然而，在99％的情况下，即使使用STL迭代器，也没有区别，因为编译器知道如何进行优化，实际上迭代器只是看起来像类的指针。当然，对于整数或指针等基本类型也没有区别。
所以...忘了它吧。
编辑：澄清
正如我所提到的，大多数STL迭代器类只是用类包装的指针，具有所有成员函数内联，允许优化这种不相关的复制。
是的，如果您有自己的迭代器没有内联成员函数，那么它可能会运行得更慢。但是，您应该只了解编译器做什么和不做什么。
作为一个小证明，看看这段代码：
int sum1(vector<int> const &v)
{
int n;
for(auto x=v.begin();x!=v.end();x++)
n+=*x;
return n;
}
int sum2(vector<int> const &v)
{
int n;
for(auto x=v.begin();x!=v.end();++x)
n+=*x;
return n;
}
int sum3(set<int> const &v)
{
int n;
for(auto x=v.begin();x!=v.end();x++)
n+=*x;
return n;
}
int sum4(set<int> const &v)
{
int n;
for(auto x=v.begin();x!=v.end();++x)
n+=*x;
return n;
}
将其编译为汇编并比较sum1和sum2，sum3和sum4...
我只能告诉你...使用-02选项，gcc会给出完全相同的代码。
i++应该返回原始值。因为它遵循标准，所以将其称为低效似乎有点奇怪。 - GManNickG
array存储在其元素中的类型，如果你使用sizeof(int)而不是sizeof(*array)，那么你很可能会遇到错误，因为你很可能会忘记在那个地方也进行更改。代码是不断变化的，因此始终要尽可能地使其易于更改，这通常意味着减少需要更改代码的位置的数量，特别是如果那些位置即使你不更改它们也会编译通过（就像在这种情况下一样）。 - HelloGoodbye