Comma

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

expression1 , expression2

​

Mechanics and Evaluation Rules

• Sequence Point: The comma operator introduces a sequence point immediately after the evaluation of the left operand. All side effects of expression1 (such as variable assignments or increments) are guaranteed to be fully complete before the evaluation of expression2 begins.
• Value Category: In C, the result of a comma expression is strictly an rvalue. Because it is not an lvalue, a comma expression cannot be placed on the left side of an assignment operator.

int a = 1, b = 2;
(a, b) = 5; // Constraint violation in C: the result of (a, b) is not an lvalue

• Precedence: It possesses the lowest precedence of all operators in the C language. Consequently, it binds less tightly than assignment operators, requiring explicit parenthesization when used in complex expressions to avoid unintended parsing.
• Associativity: It evaluates strictly left-to-right. When chained (expr1, expr2, expr3), the compiler evaluates expr1, discards it, evaluates expr2, discards it, and finally evaluates and returns expr3.
• Discarded Value: Because the result of the left operand is discarded, expression1 is evaluated solely for its side effects. If expression1 yields no side effects, its evaluation is functionally inert.

​

Precedence Behavior

int a, b;

// The assignment operator has higher precedence than the comma operator.
// Parsed as: (a = 1) , 2;
// 'a' is assigned 1. The overall expression evaluates to 2, which is discarded.
a = 1, 2; 

// Parentheses force the comma operator to evaluate first.
// Parsed as: b = (1 , 2);
// The 1 is evaluated and discarded. 'b' is assigned the result of the right operand (2).
b = (1, 2); 

​

Operator vs. Syntactic Separator

• Function argument lists: my_function(a, b, c)
• Variable declarations: int x = 5, y = 10;
• Initializer lists: int arr[] = {1, 2, 3};
• Macro arguments: MAX(x, y)
• Enum declarations: enum Colors { RED, GREEN, BLUE };

• Unsequenced Contexts: In function argument lists, the order of evaluation of the separated expressions is unspecified, while the evaluations themselves are unsequenced with respect to each other. Modifying the same variable in multiple arguments without an intervening sequence point results in undefined behavior.
• Indeterminately Sequenced Contexts: In initializer lists, the evaluation of the initialization expressions is indeterminately sequenced.
• Sequenced Contexts: In variable declarations, the C standard dictates a sequence point at the end of each full expression (the initializer itself). This guarantees that the initialization of one variable is fully complete before the evaluation of the next begins (e.g., in int a = 1, b = a;, the sequence point after the initializer 1 ensures a is fully initialized before b = a is evaluated).
• Compile-Time and Preprocessor Contexts:
  • Macro arguments: Macro arguments are not evaluated during preprocessing; they are merely substituted as text tokens. Any runtime evaluation order depends entirely on where and how those tokens are placed in the expanded code.
  • Enum declarations: Enumerator values must be compile-time constant expressions, which cannot contain side effects. Therefore, they do not introduce sequence points, and runtime evaluation order does not apply to them.

// The comma acts as a separator.
// The function receives two arguments. The evaluation order of 'a' and 'b' is unspecified.
function_call(a, b);

// The first comma acts as an operator; the second acts as a separator.
// The function receives two arguments. 
// Argument 1: The result of the comma expression (evaluates 'a', returns 'b').
// Argument 2: 'c'.
function_call((a, b), c);