有意的问题是关于什么时候结果是未使用的(这从C的问题中很明显)。有人能解决这个问题吗，因为这个问题是“社区维基”?

关于过早优化，Knuth经常被引用。这是正确的。但是Donald Knuth永远不会用你现在看到的那些可怕的代码来辩护。见过Java整数(不是int)中的a = b + c吗?这相当于3次装箱/开箱转换。避免这样的事情很重要。无用地写i++而不是++i也是同样的错误。 编辑:正如phresnel在评论中所言，这可以总结为“过早的优化是邪恶的，过早的悲观也是”。

甚至人们更习惯于i++这一事实也是一个不幸的C遗产，是由K&R的一个概念错误造成的(如果你遵循意图论点，这是一个合乎逻辑的结论;为K&R辩护因为他们是K&R是毫无意义的，他们很伟大，但作为语言设计师他们并不伟大;C设计中存在无数错误，从gets()到strcpy()，再到strncpy() API(它应该从第一天开始就有strlcpy() API)。

顺便说一句，我是那些不太习惯c++的人之一，觉得c++ I读起来很烦人。尽管如此，我仍然使用它，因为我承认它是正确的。

我想指出Andrew Koenig最近在Code Talk上发表的一篇出色的文章。

http://dobbscodetalk.com/index.php?option=com_myblog&show=Efficiency-versus-intent.html&Itemid=29

在我们公司，我们也在适用的情况下使用++iter的一致性和性能。但Andrew提出了关于意图与性能的忽略细节。有时我们想用iter++而不是++iter。

所以，首先决定你的意图，如果pre或post不重要，那么使用pre，因为它将有一些性能优势，避免创建额外的对象并抛出它。

说编译器不能优化掉后缀情况下的临时变量副本是不完全正确的。用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)] 

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

是的。有。

++操作符可以定义为函数，也可以不定义为函数。对于基本类型(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)都必须创建一个副本，编译器对此无能为力。当有选择时，使用运算符++();这样就不需要保存副本。在很多增量(大循环?)和/或大对象的情况下，它可能很重要。

@Ketan

.．.加薪忽略了关于意图和性能的细节。有时我们想用iter++而不是++iter。

Obviously post and pre-increment have different semantics and I'm sure everyone agrees that when the result is used you should use the appropriate operator. I think the question is what should one do when the result is discarded (as in for loops). The answer to this question (IMHO) is that, since the performance considerations are negligible at best, you should do what is more natural. For myself ++i is more natural but my experience tells me that I'm in a minority and using i++ will cause less metal overhead for most people reading your code.

毕竟，这就是语言不叫“c++ C”的原因。[*]

[*]插入关于c++ C是一个更合乎逻辑的名称的必要讨论。

有意的问题是关于什么时候结果是未使用的(这从C的问题中很明显)。有人能解决这个问题吗，因为这个问题是“社区维基”?

关于过早优化，Knuth经常被引用。这是正确的。但是Donald Knuth永远不会用你现在看到的那些可怕的代码来辩护。见过Java整数(不是int)中的a = b + c吗?这相当于3次装箱/开箱转换。避免这样的事情很重要。无用地写i++而不是++i也是同样的错误。 编辑:正如phresnel在评论中所言，这可以总结为“过早的优化是邪恶的，过早的悲观也是”。

甚至人们更习惯于i++这一事实也是一个不幸的C遗产，是由K&R的一个概念错误造成的(如果你遵循意图论点，这是一个合乎逻辑的结论;为K&R辩护因为他们是K&R是毫无意义的，他们很伟大，但作为语言设计师他们并不伟大;C设计中存在无数错误，从gets()到strcpy()，再到strncpy() API(它应该从第一天开始就有strlcpy() API)。

顺便说一句，我是那些不太习惯c++的人之一，觉得c++ I读起来很烦人。尽管如此，我仍然使用它，因为我承认它是正确的。