Постепенное увеличение в C++ - Когда использовать x ++ или ++ x?

Из cppreference при увеличении итераторов:

Вы должны предпочесть предварительное увеличение оператор (++ iter) для постинкремента оператор (iter ++), если вы не собираетесь использовать старое значение. Пост-инкремент is generally implemented as follows:

   Iter operator++(int)   {
     Iter tmp(*this); // store the old value in a temporary object
     ++*this;         // call pre-increment
     return tmp;      // return the old value   }

Obviously, it's less efficient than pre-increment.

Pre-increment does not generate the temporary object. This can make a significant difference if your object is expensive to create.

Scott Meyers tells you to prefer prefix except on those occasions where logic would dictate that postfix is appropriate.

"More Effective C++" item #6 - that's sufficient authority for me.

For those who don't own the book, here are the pertinent quotes. From page 32:

From your days as a C programmer, you may recall that the prefix form of the increment operator is sometimes called "increment and fetch", while the postfix form is often known as "fetch and increment." The two phrases are important to remember, because they all but act as formal specifications...

And on page 34:

If you're the kind who worries about efficiency, you probably broke into a sweat when you first saw the postfix increment function. That function has to create a temporary object for its return value and the implementation above also creates an explicit temporary object that has to be constructed and destructed. The prefix increment function has no such temporaries...

Я просто хочу заметить, что сгенерированный код будет таким же неправильным, если вы используете пре / пост приращение, где семантика (до / после) не имеет значения.

пример:

pre.cpp:

#include <iostream>

int main()
{
  int i = 13;
  i++;
  for (; i < 42; i++)
    {
      std::cout << i << std::endl;
    }
}

post.cpp:

#include <iostream>

int main()
{

  int i = 13;
  ++i;
  for (; i < 42; ++i)
    {
      std::cout << i << std::endl;
    }
}

_

$> g++ -S pre.cpp
$> g++ -S post.cpp
$> diff pre.s post.s   
1c1
<   .file   "pre.cpp"
---
>   .file   "post.cpp"

Самая важная вещь, о которой следует помнить, imo, заключается в том, что x ++ должен возвращать значение до того, как действительно произошло приращение, поэтому он должен сделать временную копию объекта ( до приращения). Это менее эффективно, чем ++ x, который увеличивается на месте и возвращается.

Еще одна вещь, о которой стоит упомянуть, заключается в том, что большинство компиляторов смогут оптимизировать такие ненужные вещи, когда это возможно, например, оба варианта приведут к на тот же код здесь:

for (int i(0);i<10;++i)
for (int i(0);i<10;i++)

Я согласен с @BeowulfOF, хотя для ясности я всегда рекомендовал бы разделить утверждения, чтобы логика была абсолютно ясной, например:

i++;
x += i;

или

x += i;
i++;

Итак, я отвечу, если вы напишете чистый код, тогда это редко имеет значение (а если это имеет значение, то ваш код, вероятно, недостаточно ясен).

Просто хотел еще раз подчеркнуть, что ++ x, как ожидается, будет быстрее , чем x ++, (особенно если x - объект произвольного типа), поэтому, если не требуется по логическим причинам следует использовать ++ x.

You explained the difference correctly. It just depends on if you want x to increment before every run through a loop, or after that. It depends on your program logic, what is appropriate.

An important difference when dealing with STL-Iterators (which also implement these operators) is, that it++ creates a copy of the object the iterator points to, then increments, and then returns the copy. ++it on the other hand does the increment first and then returns a reference to the object the iterator now points to. This is mostly just relevant when every bit of performance counts or when you implement your own STL-iterator.

Edit: fixed the mixup of prefix and suffix notation