Other operators

A collection of operators that do not fit into any of the other major categories.

Function call

The function call expression has the form.

where.

The behavior of the function call expression depends on whether the prototype of the function being called is in scope at the point of call.

Call to a function with a prototype

void f(char* p, int x) {}
int main(void)
{
    f("abc", 3.14); // array to pointer and float to int conversions
}

void f(); // no prototype
int main(void)
{
    f(1, 1.0f); // UB unless f is defined to take an int and a double
}
void f(int a, double c) {}

Notes

The evaluations of expression that designates the function to be called and all arguments are unsequenced with respect to each other (but there is a sequence point before the body of the function begins executing).

(*pf[f1()]) (f2(), f3() + f4()); // f1, f2, f3, f4 may be called in any order

Although function call is only defined for pointers to functions, it works with function designators due to the function-to-pointer implicit conversion.

int f(void) { return 1; }
int (*pf)(void) = f;
int main(void)
{
    f();    // convert f to pointer, then call
    (&f)(); // create a pointer to function, then call
 
    pf();    // call the function
    (*pf)(); // obtain the function designator, convert to pointer, then calls
 
    (****f)(); // convert to pointer, obtain the function, repeat 4x, then call
    (****pf)(); // also OK
}

Functions that ignore unused arguments, such as printf, must be called with a prototype in scope (the prototype of such functions necessarily uses the trailing ellipsis parameter) to avoid invoking undefined behavior.

The current standard wording of the semantics of preparing function parameters is defective, because it specifies that parameters are assigned from arguments while calling, which incorrectly rejects const-qualified paratemeter or member types, and inappropriately applies the semantics of volatile which is unimplementable for function parameters on many platforms. A post-C11 defect report DR 427 proposed change of such semantics from assignment to initialization, but was closed as not-a-defect.

extern int identifier(); // returns int and has no prototype

main() {
    int n = atoi("123"); // implicitly declares atoi as int atoi()
}

Comma operator

The comma operator expression has the form.

where.

First, the left operand, lhs, is evaluated and its result value is discarded.

Then, a sequence point takes place, so that all side effects of lhs are complete.

Then, the right operand, rhs, is evaluated and its result is returned by the comma operator as a non-lvalue.

Notes

The type of the lhs may be void (that is, it may be a call to a function that returns void, or it can be an expression cast to void).

The comma operator may be lvalue in C++, but never in C.

The comma operator may return a struct (the only other expressions that return structs are compound literals, function calls, assignments, and the conditional operator).

In the following contexts, the comma operator cannot appear at the top level of an expression because the comma has a different meaning:

• argument list in a function call
• initializer expression or initializer list
• generic selection

If the comma operator has to be used in such context, it must be parenthesized:

// int n = 2,3; // error, comma assumed to begin the next declarator
// int a[2] = {1,2,3}; // error: more initializers than elements
int n = (2,3), a[2] = {(1,2),3}; // OK
 
f(a, (t=3, t+2), c); // OK, first, stores 3 in t, then calls f with three arguments

Top-level comma operator is also disallowed in array bounds.

// int a[2,3]; // error
int a[(2,3)]; // OK, VLA array of size 3 (VLA because (2,3) is not a constant expression)

Comma operator is not allowed in constant expressions, regardless of whether it's on the top level or not.

// static int n = (1,2); // Error: constant expression cannot call the comma operator

Cast operator

See cast operator.

Conditional operator

The conditional operator expression has the form.

where.

Only the following expressions are allowed as expression-true and expression-false.

• two expressions of any arithmetic type
• two expressions of the same struct or union type
• two expressions of void type
• two expressions of pointer type, pointing to types that are compatible, ignoring cvr-qualifiers

• one expression is a pointer and the other is the null pointer constant (such as NULL) or a nullptr_t value (since C23)
• one expression is a pointer to object and the other is a pointer to void (possibly qualified)

#define ICE(x) (sizeof(*(1 ? ((void*)((x) * 0l)) : (int*)1)))
 
// if x is an Integer Constant Expression then macro expands to
 
 sizeof(*(1 ? NULL : (int *) 1))  // (void *)((x)*0l)) -> NULL
 
// according to point (4) this further converts into
 
 sizeof(int)
 
// if x is not an Integer Constant Expression then macro expands to
// according to point (6)
 
 (sizeof(*(void *)(x))           // Error due incomplete type

Notes

The conditional operator is never an lvalue expression, although it may return objects of struct/union type. The only other expressions that may return stucts are assignment, comma, function call, and compound literal.

Note that in C++, it may be an lvalue expression.

See operator precedence for the details on the relative precedence of this operator and assignment.

Conditional operator has right-to-left associativity, which allows chaining.

#include <assert.h>
 
enum vehicle { bus, airplane, train, car, horse, feet };
 
enum vehicle choose(char arg)
{
    return arg == 'B' ? bus      :
           arg == 'A' ? airplane :
           arg == 'T' ? train    :
           arg == 'C' ? car      :
           arg == 'H' ? horse    :
                        feet     ;
}
 
int main(void)
{
    assert(choose('H') == horse && choose('F') == feet);
}

sizeof operator

See sizeof operator.

_Alignof operator

See _Alignof operator.

References

• C17 standard (ISO/IEC 9899:2018):
• 6.5.2.2 Function calls (p: 58-59)
• 6.5.3.4 The sizeof and _Alignof operators (p: 64-65)
• 6.5.4 Cast operators (p: 65-66)
• 6.5.15 Conditional operator (p: 71-72)
• 6.5.17 Comma operator (p: 75)
• C11 standard (ISO/IEC 9899:2011):
• 6.5.2.2 Function calls (p: 81-82)
• 6.5.3.4 The sizeof and _Alignof operators (p: 90-91)
• 6.5.4 Cast operators (p: 91)
• 6.5.15 Conditional operator (p: 100)
• 6.5.17 Comma operator (p: 105)
• C99 standard (ISO/IEC 9899:1999):
• 6.5.2.2 Function calls (p: 71-72)
• 6.5.3.4 The sizeof operator (p: 80-81)
• 6.5.4 Cast operators (p: 81)
• 6.5.15 Conditional operator (p: 90-91)
• 6.5.17 Comma operator (p: 94)
• C89/C90 standard (ISO/IEC 9899:1990):
• 3.3.2.2 Function calls
• 3.3.3.4 The sizeof operator
• 3.3.4 Cast operators
• 3.3.15 Conditional operator
• 3.3.17 Comma operator

See also

• Operator precedence