Performance difference between ++iterator and iterator++?

Question

My workmate claims that for object types preincrement is more efficient than post increment

e.g.

std::vector<std::string> vec;  ... insert a whole bunch of strings into vec ...  // iterate over and do stuff with vec.  Is this more efficient than the next  // loop? std::vector<std::string>::iterator it; for (it = vec.begin(); it != vec.end(); ++it){  }  // iterate over and do stuff with vec.  Is this less efficient than the previous loop? std::vector<std::string>::iterator it; for (it = vec.begin(); it != vec.end(); it++){  } 

Answer 1

Postincrement must return the value the iterator had BEFORE it was incrementing; so, that previous value needs to be copied somewhere before altering it with the increment proper, so it's available to return. The extra work may be a little or a lot, but it certainly can't be less than zero, compared to a preincrement, which can simply perform the incrementing and then return the just-altered value -- no copying // saving // etc necessary.

So, unless you specifically MUST have postincrement (because you're using the "value before increment" in some way), you should always use preincrement instead.

Answer 2

The default increment operators will look like this:

class X {     X operator++(int)  // Post increment     {         X  tmp(*this);         this->operator++(); // Call pre-increment on this.         return tmp;     }     X& operator++()  // Pre increment     {         // Do operation for increment.         return *this;     } }; 

Notice the Post-increment is defined in terms of the Pre-increment. So Post-increment does the same work plus some extra. Usually this is construct a copy and then return the copy via a copy (Note the Pre-increment can return itself by reference but the Post-increment can not).