Order of evaluation in C++ function parameters

In C++, when we pass multiple arguments to a function, a common question arises, in what order are these arguments evaluated? Is it from left to right, right to left, or does it depend on the compiler?

In this article, we will learn how function parameter evaluation works in C++, why the order of evaluation is important, and how it can vary across different compilers.

Is the Order of Evaluation Defined in C++?

The C++ standard does not guarantee a fixed order of evaluation for function arguments. This means compilers are free to evaluate arguments from left to right, right to left, or in any arbitrary order.

For example:

void func(int, int);  
int a = 5;
func(a++, a++);

In the above case, whether the first or second a++ is evaluated first depends entirely on the compiler being used. This can lead to different results on different platforms.

C++ Program to Demonstrate Evaluation Order

Let's take a more detailed example to better understand the behavior. We'll use a function that accepts three parameters and observe how the order of evaluation affects the output.

#include <iostream>
using namespace std;

void test_function(int x, int y, int z) {
   cout << "The value of x: " << x << endl;
   cout << "The value of y: " << y << endl;
   cout << "The value of z: " << z << endl;
}

int main() {
   int a = 10;
   test_function(a++, a++, a++);
   return 0;
}

Possible Output

The possible output of the above example is:

The value of x: 12
The value of y: 11
The value of z: 10

In the above output, it appears that the arguments were evaluated from right to left. The value of z is assigned first, then y, and finally x. However, this behavior is not guaranteed and may vary depending on the compiler and optimization settings.

Why Understanding Evaluation Order Matters

When writing portable and predictable code, it's best to avoid expressions with side effects (like a++) inside function calls with multiple parameters. Undefined or unspecified behavior can lead to hard-to-debug issues in large codebases.

Another Example of Evaluation Order in Function Parameters

Let's look at another simple example using a function that takes two arguments. This will help us understand how even small changes in the code can produce different results based on the evaluation order.

#include <iostream>
using namespace std;

void display(int x, int y) {
    cout << "x = " << x << ", y = " << y << endl;
}

int main() {
    int a = 1;
    display(a++, ++a);
    return 0;
}

Possible Output

The possible output of the above example is:

x = 2, y = 3

In the above program, a++ returns 1 (then increments a to 2), and ++a increments a to 3 and returns 3. But depending on whether a++ is evaluated before or after ++a, the output can change.