c++ - 后增量与效率的对比C++中的预增量

Question

这个问题在这里已经有了答案:

Is there a performance difference between i++ and ++i in C++? (20 个回答)

关闭 6年前。

我通常认为 preincrement is more efficient than postincrement in C++ .但是当我读这本书时 Game Engine Architecture(2nd ed.)最近，有一段说在 for 循环中，postincrement 比 preincrement 更受欢迎。因为，正如我所引用的，“前置增量在您的代码中引入了一个数据依赖——CPU 必须等待增量操作完成，然后才能在表达式中使用它的值。”这是真的？ (真是颠覆了我对这个问题的看法。)

如果您有兴趣，这里是该部分的引述:

5.3.2.1 Preincrement versus Postincrement

Notice in the above example that we are using C++’s postincrement operator, p++, rather than the preincrement operator, ++p. This is a subtle but sometimes important optimization. The preincrement operator increments the contents of the variable before its (now modified) value is used in the expression. The postincrement operator increments the contents of the variable after it has been used. This means that writing ++p introduces a data dependency into your code -- the CPU must wait for the increment operation to be completed before its value can be used in the expression. On a deeply pipelined CPU, this introduces a stall. On the other hand, with p++ there is no data dependency. The value of the variable can be used immediately, and the increment operation can happen later or in parallel with its use. Either way, no stall is introduced into the pipeline.

Of course, within the “update” expression of a for loop (for(init_expr;
test_expr; update_expr) { ... }), there should be no difference between pre- and postincrement. This is because any good compiler will recognize that the value of the variable isn’t used in update_expr. But in cases where the value is used, postincrement is superior because it doesn’t introduce a stall in the CPU’s pipeline. Therefore, it’s good to get in the habit of always using postincrement, unless you absolutely need the semantics of preincrement.

编辑:添加“上面的例子”。

void processArray(int container[], int numElements)
{
    int* pBegin = &container[0];
    int* pEnd = &container[numElements];
    for (int* p = pBegin; p != pEnd; p++)
    {
        int element = *p;
        // process element...
    }
}

void processList(std::list<int>& container)
{
    std::list<int>::iterator pBegin = container.begin();
    std::list<int>::iterator pEnd = container.end();
    std::list<inf>::iterator p;
    for (p = pBegin; p != pEnd; p++)
    {
        int element = *p;
        // process element...
    }
}

Answer 1

pre-increment introduces a data dependency into your code -- the CPU must wait for the increment operation to be completed before its value can be used in the expression."

这是真的吗？

大多数情况下都是正确的——尽管可能过于严格。预增量不一定会引入数据依赖关系 - 但它可以。

一个简单的说明例子:

a = b++ * 2;

在这里，增量可以与乘法并行执行。递增和乘法的操作数都是立即可用的，并且不依赖于任一操作的结果。

另一个例子:

a = ++b * 2;

这里，乘法必须在自增之后执行，因为乘法的操作数之一取决于自增的结果。

当然，这些语句做的事情稍有不同，因此编译器可能并不总是能够在保持语义相同的情况下将程序从一种形式转换为另一种形式——这就是为什么使用后增量可能会使性能差异。

一个实际的例子，使用循环:

for(int i= 0; arr[i++];)
    count++;

for(int i=-1; arr[++i];) // more typically: (int i=0; arr[i]; ++i;)
    count++;

如果他们推断“后增量生成拷贝”，可能会认为后者必然更快——这在非基本类型的情况下是非常正确的。然而，由于数据依赖性(并且因为 int 是一种基本类型，没有增量运算符的重载函数)，理论上前者可以更有效。是否真的取决于CPU架构，以及优化器的能力。

对于它的值(value) - 在一个简单的程序中，在 x86 架构上，使用启用优化的 g++ 编译器，上述循环具有相同的汇编输出，因此它们在 情况下是完全等效的。 p>

---

经验法则:

如果计数器是基本类型并且没有使用自增的结果，那么使用后自增/前自增没有区别。

如果计数器不是基本类型并且不使用增量结果并且禁用优化，则预增量可能更有效。启用优化后，通常没有区别。

如果计数器是基本类型并且使用了增量的结果，那么从理论上讲，后增量可以稍微更有效 - 在某些 CPU 架构中 - 在某些上下文中 - 使用某些编译器。

如果计数器不是基本类型并且使用增量的结果，则预增量通常比后增量快。另请参阅 R Sahu 对此案的回答。