Unspecified evaluation order for function arguments in C

Question

C leaves the order in which function arguments and operands of most operators are evaluated unspecified, and it leaves sequencing of side effects to sequence points. This documented unspecified behavior means the same source can be legal yet produce different observable results across implementations and optimization levels.

The goal is to characterize the portability boundary for code that must remain consistent across compilers and targets. The constraint is the standard's intentional lack of ordering guarantees, which creates an unresolved decision for developers about whether to rely on observed behavior or rewrite to avoid dependence.

Does the C standard provide any sequencing guarantees for argument evaluation beyond sequence points? Which expressions are guaranteed to have a defined evaluation order in current standards? When does reliance on a particular order become non-portable across conforming implementations?

Muntasir · Answer

Evaluation Order and Sequencing in C
The C standard provides no sequencing guarantees for the evaluation of function arguments. The order in which arguments are evaluated is unspecified, meaning the compiler is free to evaluate them in any order (left-to-right, right-to-left, or otherwise) without violating the language specification.

Guaranteed Evaluation Orders
While function arguments are unspecified, the C standard does define a strict evaluation order for a small subset of expressions:

Logical Operators: The && (Logical AND) and || (Logical OR) operators guarantee short-circuiting. The left operand is evaluated first; the right operand is evaluated only if the result is not yet determined.
  The Comma Operator: In an expression like (expr1, expr2), expr1 is guaranteed to be evaluated and its side effects completed before expr2 is evaluated.

Portability Boundaries and Risks
Reliance on a specific evaluation order becomes non-portable the moment a single function call contains multiple arguments that modify or read the same variable. This is a critical distinction between unspecified behavior and undefined behavior:

Scenario
      Classification
      Result

Arguments are independent; order varies by compiler.
      Unspecified
      Legal, but results may differ across targets.

One argument modifies a variable that another argument reads.
      Undefined
      Illegal; may cause crashes or unpredictable data.

Verification and Remediation
To verify if your code depends on unspecified behavior, you can use a simple diagnostic function to print arguments. Note that the order they appear in the function body is determined by the calling convention (e.g., stack growth), not the evaluation order.

// Potential portability risk: side effects in arguments
void check(int a, int b) { printf("%d, %d\n", a, b); }

int main() {
    int x = 0;
    // UNPORTABLE: Order of x++ is unspecified
    check(++x, ++x);
    return 0;
}

To ensure portability, move expressions with side effects into separate statements before the function call:
int a = ++x;
int b = ++x;
check(a, b); // Guaranteed and portable

Unspecified evaluation order for function arguments in C

1 answer

Evaluation Order and Sequencing in C

Guaranteed Evaluation Orders

Portability Boundaries and Risks

Verification and Remediation

Your perspective belongs here.

1 question comment

Scenario	Classification	Result
Arguments are independent; order varies by compiler.	Unspecified	Legal, but results may differ across targets.
One argument modifies a variable that another argument reads.	Undefined	Illegal; may cause crashes or unpredictable data.