Post-Increment

This example is bad. Don’t do this:

#include <iostream>
using namespace std;

int main() {
   int n = 1;
   cout << ++n * ++n << endl;
}

Don’t do this, either:

#include <iostream>
using namespace std;

int main() {
   short nums[] = {1, 2, 3, 4};

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

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

Why not? Because, in both cases, the variable is being modified twice in the same expression. cout << a << b is one expression. << is an operator, just like + is. C++ does not determine the order of execution of the various parts of the expression, except for a few special cases.

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

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

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.

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
    }