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

[edit]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 isin scope at the point of call.

[edit]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 prototypeint main(void){    f(1,1.0f);// UB unless f is defined to take an int and a double}void f(int a,double c){}

[edit]Notes

The evaluations ofexpression that designates the function to be called and all arguments areunsequenced 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 thefunction-to-pointer implicit conversion.

int f(void){return1;}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 asprintf, must be called with a prototype in scope (the prototype of such functions necessarily uses thetrailing 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 parameter or member types, and inappropriately applies the semantics of volatile which is unimplementable for function parameters on many platforms. A post-C11 defect reportDR427 proposed change of such semantics from assignment to initialization, but was closed as not-a-defect.

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

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

[edit]Comma operator

The comma operator expression has the form

where

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

Then, asequence point takes place, so that all side effects oflhs are complete.

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

[edit]Notes

The type of thelhs may bevoid (that is, it may be a call to a function that returnsvoid, or it can be an expressioncast tovoid)

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 orinitializer 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 elementsint 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]; // errorint a[(2,3)];// OK, VLA array of size 3 (VLA because (2,3) is not a constant expression)

Comma operator is not allowed inconstant 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

[edit]Cast operator

Seecast operator

[edit]Conditional operator

The conditional operator expression has the form

where

Only the following expressions are allowed asexpression-true andexpression-false

• two expressions of anyarithmetic type
• two expressions of the samestruct orunion type
• two expressions of void type
• two expressions of pointer type, pointing to types that arecompatible, ignoring cvr-qualifiers

• one expression is a pointer and the other is the null pointer constant (such asNULL)or anullptr_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

[edit]Notes

The conditional operator is never anlvalue expression, although it may return objects of struct/union type. The only other expressions that may return structs areassignment,comma,function call, andcompound literal.

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

Seeoperator 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);}

[edit]sizeof operator

Seesizeof operator

[edit]_Alignof operator

See_Alignof operator

[edit]typeof operators

Seetypeof operators

[edit]References

[edit]See also

• Operator precedence

• In other languages

• العربية
• Česky
• Deutsch
• Español
• Français
• Italiano
• 日本語
• 한국어
• Polski
• Português
• Русский
• Türkçe
• 中文