Incrementing iterators: Is ++it more efficient than it++? [duplicate]

by

The reason behind the preincrement being faster is that post-increment has to make a copy of the old value to return. As GotW #2 put it, “Preincrement is more efficient than postincrement, because for postincrement the object must increment itself and then return a temporary containing its old value. Note that this is true even for builtins like int.”

GotW #55 provides the canonical form of postincrement, which shows that it has to do preincrement plus some more work:

T T::operator++(int)
{
  T old( *this ); // remember our original value
  ++*this;        // always implement postincrement
                  //  in terms of preincrement
  return old;     // return our original value
}

As others have noted, it’s possible for some compiler to optimize this away in some cases, but if you’re not using the return value it’s a good idea not to rely on this optimization. Also, the performance difference is likely to be very small for types which have trivial copy constructors, though I think using preincrement is a good habit in C++.

More Related Contents:

  1. Why use iterators instead of array indices?
  2. Why are Standard iterator ranges [begin, end) instead of [begin, end]?
  3. What happens if you call erase() on a map element while iterating from begin to end?
  4. Removing item from vector while iterating?
  5. comparing iterators from different containers
  6. Why use non-member begin and end functions in C++11?
  7. Sorting a vector in descending order
  8. How are iterators and pointers related?
  9. What’s faster, iterating an STL vector with vector::iterator or with at()?
  10. What is the difference between const_iterator and non-const iterator in the C++ STL?
  11. What is an iterator’s default value?
  12. Custom Iterator in C++
  13. Why is “!=” used with iterators instead of “
  14. how portable is end iterator decrement?
  15. Can std::begin work with array parameters and if so, how?
  16. std::vector iterator invalidation
  17. Checking if an iterator is valid
  18. How does std::copy work with stream iterators
  19. Why does a push_back on an std::list change a reverse iterator initialized with rbegin?
  20. Can raw pointers be used instead of iterators with STL algorithms for containers with linear storage?
  21. How to remove constness of const_iterator?
  22. What happens if you increment an iterator that is equal to the end iterator of an STL container
  23. Are const_iterators faster?
  24. How to check that the passed Iterator is a random access iterator?
  25. Do STL iterators guarantee validity after collection was changed?
  26. what is the difference between const_iterator and iterator? [duplicate]
  27. How to increment an iterator by 2?
  28. Types of iterator : Output vs. Input vs. Forward vs. Random Access Iterator
  29. iterator for 2d vector
  30. How can I copy one map into another using std::copy?

Leave a Comment