C++ Notes: Function Call Order

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 

// functions/call-order.cpp -- Illustrates order of calls.
// Fred Swartz 2003-09-02

#include <iostream>
using namespace std;
//--------------------------------- prototypes
int even(int a);
int odd(int b);
int ulam(int c);

//--------------------------------- main
int main() {
    // What does each statement print?
    cout << odd(4)              << endl;
    cout << (even(2) + odd(3))  << endl; // (Note 1)
    cout << ulam(ulam(ulam(5))) << endl; // (Note 2)
}
 

//---------------------------------- even
int even(int a) {
    cout << "even(" << a << ")" << endl;
    return a/2;
}

//---------------------------------- odd
int odd(int b) {
    cout << "odd(" << b << ")" << endl;
    return 3*b + 1;
}

//---------------------------------- ulam
int ulam(int c) {  
    cout << "ulam(" << c << ")" << endl;
    if (c%2 == 0) {
       return even(c);
    }else{
       return odd(c);
    }
}

Notes

1. Order Ambiguity. The order of evaluation of operands is not defined in C++ (unlike Java where it's strictly left to right). It's possible for the rightmost call to be made before the leftmost call. Here are two possible orders of execution.

   // Original: cout << (even(2) + odd(3)) << endl;
   int t1 = even(2); // left before right operand eval.
   int t2 = odd(3);
   cout << t1+t2 << endl;

   or

   // Original: cout << (even(2) + odd(3)) << endl;
   int t2 = odd(3); // right before left operand eval.
   int t1 = even(2);
   cout << t1+t2 << endl;

   I've see it done both ways in various compilers, so this is a real portability issue. However, the order is only important if both functions have interacting side-effects (I/O, change globals, ...).
2. Use intermediate variables for clarity. If it's difficult to understand an expression, compute it in pieces. The compiler does this internally. One of the above examples can be rewritten.

   //Original: cout << ulam(ulam(ulam(5))) << endl << endl;
   int t1 = ulam(5);   // the inner call must be made first.
   int t2 = ulam(t1);  // that result is used to make the next call.
   int t3 = ulam(t2);  // only now can we make the outer function call.
   cout << t3 << endl << endl;