CS253 Increment

Pre-/Post-Increment/Decrement

This example is bad. Don’t do this:

int n = 1;
cout << ++n * ++n << endl;

c.cc:2: warning: operation on 'n' may be undefined
9

Another bad example

Don’t do this, either:

short nums[] = {1, 2, 3, 4};

short *p = nums;
cout << *p++ << ' ';
cout << *p++ << '\n';

p = nums;
cout << *p++ << ' ' << *p++ << '\n';

c.cc:8: warning: operation on 'p' may be undefined
1 2
1 2

Why not?

Why not? Because, in both cases, the variable is being modified twice in the same expression.

<< is an operator, just like + is.
cout << a << b is one expression.
- same as (cout << a) << b
  - same as operator<<(operator<<(cout,a), b)
C++ does not determine the order of execution of the various parts of the expression, except for a few special cases:
- && || ?:
- , (the binary comma operator, not function arguments)

Another Example

int a() { cout << 'A'; return 1; }
int b() { cout << 'B'; return 2; }

int main() {
    cout << a()+b() << '\n';    // Might print AB or maybe BA.
    cout << a() << b() << '\n'; // Might print A1B2, AB12, BA12
    return 0;
}

AB3
A1B2

Experiments don’t matter

You cannot determine the “correct” result by experimentation.

The compiler might do it in one order today, and in a different order tomorrow.
The next version of the compiler might do it differently.
It might depend on what other variables have been declared.
A different compiler might do things in a different order.

How to do it right

Break apart expressions, perhaps using explicit temporaries, to determine the order of evaluation of sub-expressions:

int a() { cout << 'A'; return 1; }
int b() { cout << 'B'; return 2; }

int main() {
    int c = a();        // Will print A
    c += b();           // Will print B
    cout << a();        // Will print A1
    cout << b();        // Will print B2
    return 0;
}

ABA1B2

CS253: Software Development with C++

Spring 2018