/C

# 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

Common operators
assignment increment
decrement
arithmetic logical comparison member
access
other

`a = b a += b a -= b a *= b a /= b a %= b a &= b a |= b a ^= b a <<= b a >>= b`.

`++a --a a++ a--`

`+a -a a + b a - b a * b a / b a % b ~a a & b a | b a ^ b a << b a >> b`.

`!a a && b a || b`.

`a == b a != b a < b a > b a <= b a >= b`.

`a[b] *a &a a->b a.b`.

`a(...) a, b (type) a ? : sizeof _Alignof` (since C11).

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

### 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:

1) Constants and literals (e.g. `2` or `"Hello, world"`)
2) Suitably declared identifiers (e.g. `n` or `printf`)

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.

• C11 standard (ISO/IEC 9899:2011):
• 6.5 Expressions (p: 76-105)
• 6.6 Constant expressions (p: 106-107)
• C99 standard (ISO/IEC 9899:1999):
• 6.5 Expressions (p: 67-94)
• 6.6 Constant expressions (p: 95-96)
• C89/C90 standard (ISO/IEC 9899:1990):
• 3.3 EXPRESSIONS
• 3.4 CONSTANT EXPRESSIONS