Difference between revisions of "c/language/expressions"
m (→Constants and literals) |
m (→Other: typo) |
||
| Line 20: | Line 20: | ||
====Other==== | ====Other==== | ||
| − | * {{rlp|constant expression}}s can be evaluated at compile time and used in compile-time context ({{rev inl| | + | * {{rlp|constant expression}}s can be evaluated at compile time and used in compile-time context ({{rev inl|since=c99|non-VLA }}array sizes, static initializers, etc) |
{{rrev|since=c11| | {{rrev|since=c11| | ||
* {{rlp|generic|generic selections}} can execute different expressions depending on the types of the arguments | * {{rlp|generic|generic selections}} can execute different expressions depending on the types of the arguments | ||
Revision as of 19:28, 3 October 2020
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.
Contents |
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 |
+a |
!a |
a == b |
a[b] |
a(...) |
- 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 (since C99)array sizes, static initializers, etc)
|
(since C11) |
|
(since C99) |
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:
| (since C11) |
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, or (since C11)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[],(since C11) or wchar_t[] that represent null-terminated strings
|
(since C99) |
Unevaluated expressions
The operands of the sizeof operator 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.
|
The operands of the |
(since C11) |
References
- C17 standard (ISO/IEC 9899:2018):
- 6.5 Expressions (p: 55-75)
- 6.6 Constant expressions (p: 76-77)
- 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
|
