Comma

The comma operator (,) is a binary operator that evaluates its left operand as a void expression, introduces a sequence point, discards the resulting value, and then evaluates its right operand. The overall type and value of the comma expression are strictly those of the right operand, and the result is never an lvalue.

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

Because of its lowest-level precedence, the comma operator interacts uniquely with assignment.

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

The comma character (,) is overloaded in C syntax. It only functions as the comma operator when used within an expression. In other contexts, it acts as a syntactic separator.

The comma is a separator (not an operator) in the following contexts:

• 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 };

When the comma acts as a separator, the evaluation order and presence of sequence points are dictated entirely by the specific language construct, not by the comma operator:

• 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.

To invoke the comma operator within a context where it would normally act as a separator, the expression must be explicitly enclosed in parentheses:

// 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);

Master C with Deep Grasping Methodology!

Learn More