说编译器不能优化掉后缀情况下的临时变量副本是不完全正确的。用VC进行的快速测试表明，至少在某些情况下，它可以做到这一点。

在下面的例子中，生成的代码对于前缀和后缀是相同的，例如:

#include <stdio.h>

class Foo
{
public:

    Foo() { myData=0; }
    Foo(const Foo &rhs) { myData=rhs.myData; }

    const Foo& operator++()
    {
        this->myData++;
        return *this;
    }

    const Foo operator++(int)
    {
        Foo tmp(*this);
        this->myData++;
        return tmp;
    }

    int GetData() { return myData; }

private:

    int myData;
};

int main(int argc, char* argv[])
{
    Foo testFoo;

    int count;
    printf("Enter loop count: ");
    scanf("%d", &count);

    for(int i=0; i<count; i++)
    {
        testFoo++;
    }

    printf("Value: %d\n", testFoo.GetData());
}

无论您使用的是++testFoo还是testfoo++，都将得到相同的结果代码。事实上，无需从用户读取计数，优化器将整个事情归结为一个常数。所以这个:

for(int i=0; i<10; i++)
{
    testFoo++;
}

printf("Value: %d\n", testFoo.GetData());

结果如下:

00401000  push        0Ah  
00401002  push        offset string "Value: %d\n" (402104h) 
00401007  call        dword ptr [__imp__printf (4020A0h)] 

因此，虽然后缀版本肯定会更慢，但如果你不使用它，优化器可能会足够好，可以摆脱临时副本。

当您将操作符视为值返回函数以及它们的实现方式时，++i和i++之间的性能差异将更加明显。为了更容易理解发生了什么，下面的代码示例将使用int，就像它是一个结构体一样。

++i对变量加1，然后返回结果。这可以就地完成，并且只需要最少的CPU时间，在许多情况下只需要一行代码:

int& int::operator++() { 
     return *this += 1;
}

但是i++就不一样了。

后递增(i++)通常被视为在递增之前返回原始值。但是，函数只能在完成时返回结果。因此，有必要创建一个包含原始值的变量的副本，增加变量，然后返回包含原始值的副本:

int int::operator++(int& _Val) {
    int _Original = _Val;
    _Val += 1;
    return _Original;
}

当增量前和增量后之间没有功能差异时，编译器可以执行优化，使两者之间没有性能差异。但是，如果涉及到结构或类等复合数据类型，则在增量后调用复制构造函数，如果需要深度复制，则不可能执行此优化。因此，前增量通常比后增量更快，需要的内存更少。

即使在没有性能优势的内置类型上也应该使用++i的原因是为了给自己养成一个好习惯。

下面是自增操作符位于不同转换单元时的基准测试。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。

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

++i比i = i +1快，因为在i = i +1中发生了两个操作，第一个递增，第二次将其赋值给一个变量。但是在i++中只进行增量操作。

++i -更快，不使用返回值 i++ -使用返回值更快

当不使用返回值时，编译器保证不会在++i的情况下使用临时类型。不保证更快，但保证不会变慢。

当使用返回值i++时，允许处理器同时推送 增量和左侧进入管道，因为它们彼此不依赖。i可能会使管道停止，因为处理器无法启动左侧，直到增量前操作已经蜿蜒完成。同样，也不保证会出现管道失速，因为处理器可能会找到其他有用的东西来插入。