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) and may generate side-effects (e.g. evaluation of
std::printf("%d",4) prints the character
'4' on the standard output).
|assignment|| increment |
|arithmetic||logical||comparison|| member |
| || || || || || ||
The operands of any operator may be other expressions or primary expressions (e.g. in
1+2*3, the operands of operator+ are the subexpression
2*3 and the primary expression
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. Parentheses preserve value, type, and value category.
Literals are the tokens of a C++ program that represent constant values embedded in the source code.
const char32_t(since C++11)
const char8_t(since C++20)
bool, that is
nullptris the pointer literal which specifies a null pointer value (since C++11)
The operands of the operators
decltype (since C++11) are expressions that are not evaluated (unless they are polymorphic glvalues and are the operands of
typeid), since these operators only query the compile-time properties of their operands. Thus,
std::size_t n = sizeof(std::cout << 42); does not perform console output.
The unevaluated operands are considered to be full expressions even though they are syntactically operands in a larger expression (for example, this means that
The requires-expressions are also unevaluated expressions.
An invocation of an immediate function is always evaluated, even in an unevaluated operand.
A discarded-value expression is an expression that is used for its side-effects only. The value calculated from such expression is discarded. Such expressions include the full expression of any expression statement, the left-hand argument of the built-in comma operator, or the argument of a cast-expression that casts to the type
Array-to-pointer and function-to-pointer conversions are never applied to the value calculated by a discarded-value expression. The lvalue-to-rvalue conversion is applied if and only if the expression is a volatile-qualified glvalue and has one of the following forms (built-in meaning required, possibly parenthesized).
In addition, if the lvalue is of volatile-qualified class type, a volatile copy-constructor is required to initialize the resulting rvalue temporary.
If the expression is a non-void prvalue (after any lvalue-to-rvalue conversion that might have taken place), temporary materialization occurs.
Compilers may issue warnings when an expression other than cast to
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.