postfix and prefix increment operator in a for loop [duplicate]

Answer 1

There is no difference for unsigned. However, there would be a difference for classes with overloaded operator++, because it would call its different overloads (usually, the postfix operator creates a copy of the class, which means it may be slower).

Would using >>= 1U instead of /=2 make any difference?

Probably not. Its semantics are the same for unsigned, and the compilers usually treat them equally and can change one into another if it's faster.

Answer 2

It does not make any difference to the value of col within the loop - assuming col is a primitive value. If col was a class, the prefix and postfix '++' operators might be overloaded to do two different things, although I would consider it bad practice. Consider the following example:

#include <iostream>

using namespace std;

int main() {
    for(int i = 0; i < 10; i++) {
        cout << i << endl;
    }

    cout << endl;

    for(int i = 0; i < 10; ++i) {
        cout << i << endl;
    }

}

Both of these just print out 0 to 9, despite the fact that you pre-increment in one, and post-increment in the other. The incrementation of i happens at the end of each run of the loop whether or not you use pre or post increment. I believe pre-incrementing is more efficient, since - and I may be wrong here - the compiler does not then need to use a temporary variable^1., but this would only be noticeable if you are looping for a very long time (and of course 'More computing sins are committed in the name of efficiency than for any other single reason'.)

As for question 2:

Question 2 : Would using >>= 1U instead of =/2 make any difference ?

Unlikely. Bit shifting would be faster if the compiler did not optimise, but chances are that your compiler will optimise this into a bit shift.

As a side note, I generally find doing unsigned variableName (that is, dropping the int) bad practice - although C++ will shove in an int anywhere one is missing, it is less readable to me.

1.: Stephen in the comments (a different Stephen ;) ) notes that - "Pre-increment is more efficient for standard library container iterators, but it's no different for primitive types, since copying an integer is cheaper than copying a larger iterator (in particular std::set and std::map iterators)."