Expressions

An expression is a sequence of operators and their operands, that specifies a computation.

Expression evaluation may produce a result (e.g., evaluation of 2+2 produces the result 4), may generate side-effects (e.g. evaluation of printf("%d",4) sends the character '4' to the standard output stream), and may designate objects or functions.

General

• value categories (lvalue, non-lvalue object, function designator) classify expressions by their values
• order of evaluation of arguments and subexpressions specifies the order in which intermediate results are obtained

Operators

• operator precedence defines the order in which operators are bound to their arguments
• alternative representations are alternative spellings for some operators

Conversions

• Implicit conversions take place when types of operands do not match the expectations of operators
• Casts may be used to explicitly convert values from one type to another.

Other

• constant expressions can be evaluated at compile time and used in compile-time context (non-VLA array sizes, static initializers, etc)
• generic selections can execute different expressions depending on the types of the arguments
• Floating-point expressions may raise exceptions and report errors as specified in math_errhandling
• The standard #pragmas FENV_ACCESS, FP_CONTRACT, and CX_LIMITED_RANGE as well as the floating-point evaluation precision and rounding direction control the way floating-point expressions are executed.

Primary expressions

The operands of any operator may be other expressions or they may be primary expressions (e.g. in 1+2*3, the operands of operator+ are the subexpression 2*3 and the primary expression 1).

Primary expressions are any of the following:

Any expression in parentheses is also classified as a primary expression: this guarantees that the parentheses have higher precedence than any operator.

Constants and literals

Constant values of certain types may be embedded in the source code of a C program using specialized expressions known as literals (for lvalue expressions) and constants (for non-lvalue expressions)

• integer constants are decimal, octal, or hexadecimal numbers of integer type.
• character constants are individual characters of type int suitable for conversion to a character type or of type char16_t, char32_t, (since C11)or wchar_t
• floating constants are values of type float, double, or long double
• string literals are sequences of characters of type char[], char16_t[], char32_t[], or wchar_t[] that represent null-terminated strings
• compound literals are values of struct, union, or array type directly embedded in program code

Unevaluated expressions

The operands of the sizeof operator , the _Alignof operator, and the controlling expression of a generic selection, (since C11) are expressions that are not evaluated (unless they are VLAs) (since C99). Thus, size_t n = sizeof(printf("%d", 4)); does not perform console output.

References