Expressions

 

C

Language

headers

Type support

Dynamic memory management

Error handling

Program utilities

Variadic function support

Date and time utilities

Strings library

Algorithms

Numerics

Input/output support

Localization support

Thread support (C11)

Atomic operations (C11)

Technical Specifications

 

C language

ASCII chart

Basic concepts

translation phases

comment

identifier

scope

lifetime

name space

type

arithmetic types

object

main function

memory model

Keywords

Preprocessor

Statements

Expressions

Initialization

Declarations

Functions

Miscellaneous

history of C

Technical Specifications

 

Expressions

General

value category

evaluation order and sequence points

constant expressions

implicit conversions

generic selection (C11)

constants and literals

integer constant

floating constant

character constant

string literal

compound literal (C99)

operators

operator precedence

member access and indirection

logical operators

comparison operators

arithmetic operators

assignment operators

increment and decrement

function call, comma, conditional operator

sizeof

alignof (C11)

cast operators

 

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)

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

1) Constants and literals (e.g. 2 or "Hello, world")

2) Suitably declared identifiers (e.g. n or printf)

3) Generic selections

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

• 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

See also

C++ documentation for Expressions