@Mark:我删除了我之前的答案，因为它有点轻率，仅凭这一点就应该被打反对票。实际上，我认为这是一个很好的问题，因为它问了很多人的想法。

通常的答案是++i比i++快，毫无疑问，但更大的问题是“什么时候应该关心?”

如果增量迭代器所花费的CPU时间小于10%，那么您可能不会在意。

如果增量迭代器所花费的CPU时间百分比大于10%，则可以查看哪些语句正在进行该迭代。看看你是否可以只增加整数而不是使用迭代器。你有可能做到，虽然在某种意义上可能不太理想，但很有可能你会节省花在那些迭代器上的所有时间。

我曾经见过一个例子，其中迭代器增量消耗了超过90%的时间。在这种情况下，采用整数递增法将执行时间减少了这么多。(即优于10倍加速)

@Mark:我删除了我之前的答案，因为它有点轻率，仅凭这一点就应该被打反对票。实际上，我认为这是一个很好的问题，因为它问了很多人的想法。

通常的答案是++i比i++快，毫无疑问，但更大的问题是“什么时候应该关心?”

如果增量迭代器所花费的CPU时间小于10%，那么您可能不会在意。

如果增量迭代器所花费的CPU时间百分比大于10%，则可以查看哪些语句正在进行该迭代。看看你是否可以只增加整数而不是使用迭代器。你有可能做到，虽然在某种意义上可能不太理想，但很有可能你会节省花在那些迭代器上的所有时间。

我曾经见过一个例子，其中迭代器增量消耗了超过90%的时间。在这种情况下，采用整数递增法将执行时间减少了这么多。(即优于10倍加速)

下面是自增操作符位于不同转换单元时的基准测试。g++ 4.5编译器。

现在先忽略样式问题

// a.cc
#include <ctime>
#include <array>
class Something {
public:
    Something& operator++();
    Something operator++(int);
private:
    std::array<int,PACKET_SIZE> data;
};

int main () {
    Something s;

    for (int i=0; i<1024*1024*30; ++i) ++s; // warm up
    std::clock_t a = clock();
    for (int i=0; i<1024*1024*30; ++i) ++s;
    a = clock() - a;

    for (int i=0; i<1024*1024*30; ++i) s++; // warm up
    std::clock_t b = clock();
    for (int i=0; i<1024*1024*30; ++i) s++;
    b = clock() - b;

    std::cout << "a=" << (a/double(CLOCKS_PER_SEC))
              << ", b=" << (b/double(CLOCKS_PER_SEC)) << '\n';
    return 0;
}

O (n)增加

Test

// b.cc
#include <array>
class Something {
public:
    Something& operator++();
    Something operator++(int);
private:
    std::array<int,PACKET_SIZE> data;
};


Something& Something::operator++()
{
    for (auto it=data.begin(), end=data.end(); it!=end; ++it)
        ++*it;
    return *this;
}

Something Something::operator++(int)
{
    Something ret = *this;
    ++*this;
    return ret;
}

结果

在虚拟机上使用g++ 4.5的结果(计时以秒为单位):

Flags (--std=c++0x)       ++i   i++
-DPACKET_SIZE=50 -O1      1.70  2.39
-DPACKET_SIZE=50 -O3      0.59  1.00
-DPACKET_SIZE=500 -O1    10.51 13.28
-DPACKET_SIZE=500 -O3     4.28  6.82

O(1)增加

Test

现在让我们看看下面的文件:

// c.cc
#include <array>
class Something {
public:
    Something& operator++();
    Something operator++(int);
private:
    std::array<int,PACKET_SIZE> data;
};


Something& Something::operator++()
{
    return *this;
}

Something Something::operator++(int)
{
    Something ret = *this;
    ++*this;
    return ret;
}

它对增量没有任何影响。这模拟了增量具有恒定复杂度的情况。

结果

结果现在变化很大:

Flags (--std=c++0x)       ++i   i++
-DPACKET_SIZE=50 -O1      0.05   0.74
-DPACKET_SIZE=50 -O3      0.08   0.97
-DPACKET_SIZE=500 -O1     0.05   2.79
-DPACKET_SIZE=500 -O3     0.08   2.18
-DPACKET_SIZE=5000 -O3    0.07  21.90

结论

属性

如果不需要前一个值，请养成使用预递增的习惯。即使与内置类型保持一致，您也会习惯它，如果您用自定义类型替换内置类型，也不会有遭受不必要性能损失的风险。

Semantic-wise

i++表示递增i，但我对之前的值感兴趣。 ++i表示自增i，我对当前值感兴趣或者自增i，对之前的值不感兴趣。再说一次，你会习惯的，即使你现在还不习惯。

Knuth。

过早的优化是万恶之源。过早的悲观也是如此。

两者都一样快;) 如果你想在处理器上进行相同的计算，只是计算的顺序不同。

例如，以下代码:

#include <stdio.h>

int main()
{
    int a = 0;
    a++;
    int b = 0;
    ++b;
    return 0;
}

生产以下组件:

0x0000000100000f24 <main+0>: push %rbp 0x0000000100000f25 <main+1>: mov %rsp，%rbp 0x0000000100000f28 <main+4>: movl $0x0，-0x4(%rbp) 0x0000000100000f2f <main+11>: incl -0x4(%rbp) 0x0000000100000f32 <main+14>: movl $0x0，-0x8(%rbp) 0x0000000100000f39 <main+21>: incl -0x8(%rbp) 0x0000000100000f3c <main+24>: mov $0x0，%eax 0x0000000100000f41 <main+29>: leaveq .日志含义 0x0000000100000f42 <main+30>: retq

你可以看到，对于a++和b++，它是一个包含助记符，所以它是相同的操作;)

++i比i++快，因为它不返回值的旧副本。

它也更直观:

x = i++;  // x contains the old value of i
y = ++i;  // y contains the new value of i 

这个C语言的例子输出的是“02”而不是你所期望的“12”:

#include <stdio.h>

int main(){
    int a = 0;
    printf("%d", a++);
    printf("%d", ++a);
    return 0;
}

c++也是一样:

#include <iostream>
using namespace std;

int main(){
    int a = 0;
    cout << a++;
    cout << ++a;
    return 0;
}

是的。有。

++操作符可以定义为函数，也可以不定义为函数。对于基本类型(int, double，…)，操作符是内置的，因此编译器可能能够优化您的代码。但对于定义了++运算符的对象，情况就不一样了。

操作符++(int)函数必须创建一个副本。这是因为postfix ++被期望返回一个与它所保存的值不同的值:它必须将其值保存在一个临时变量中，自增其值并返回临时值。在操作符++()，前缀++的情况下，不需要创建一个副本:对象可以自增，然后简单地返回自己。

下面是关于这一点的一个例子:

struct C
{
    C& operator++();      // prefix
    C  operator++(int);   // postfix

private:

    int i_;
};

C& C::operator++()
{
    ++i_;
    return *this;   // self, no copy created
}

C C::operator++(int ignored_dummy_value)
{
    C t(*this);
    ++(*this);
    return t;   // return a copy
}

每次调用操作符++(int)都必须创建一个副本，编译器对此无能为力。当有选择时，使用运算符++();这样就不需要保存副本。在很多增量(大循环?)和/或大对象的情况下，它可能很重要。