Expressions

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

C++ language

 

Expressions

General

value categories (lvalue, rvalue, xvalue)

order of evaluation (sequence points)

constant expressions

unevaluated expressions

primary expressions

lambda-expression(C++11)

Literals

integer literals

floating-point literals

boolean literals

character literals including escape sequences

string literals

null pointer literal(C++11)

user-defined literal(C++11)

Operators

Assignment operators: a=b, a+=b, a-=b, a*=b, a/=b, a%=b, a&=b, a|=b, a^=b, a<<=b, a>>=

Increment and decrement: ++a, --a, a++, a--

Arithmetic operators: +a, -a, a+b, a-b, a*b, a/b, a%b, ~a, a&b, a|b, a^b, a<<b, a>>b

Logical operators: a||b, a&&b, !a

Comparison operators: a==b, a!=b, a<b, a>b, a<=b, a>=b

Member access operators: a[b], *a, &a, a->b, a.b, a->*b, a.*b

Other operators: a(...), a,b, (T)a, a?b:c

Alternative representations of operators

Precedence and associativity

Fold expression(C++17)

new-expression

delete-expression

throw-expression

alignof

sizeof

sizeof...(C++11)

typeid

noexcept(C++11)

Operator overloading

Conversions

Implicit conversions

const_cast

static_cast

reinterpret_cast

dynamic_cast

Explicit conversions (T)a, T(a)

User-defined conversion

 

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

General

• value categories (lvalue, rvalue, glvalue, prvalue, xvalue) classify expressions by their values
• order of evaluation of arguments and subexpressions specify 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->*b a.*b	a(...) a, b (type) a ? :
Special operators
static_cast converts one type to another compatible type dynamic_cast converts virtual base class to derived class const_cast converts type to compatible type with different cv qualifiers reinterpret_cast converts type to incompatible type new allocates memory delete deallocates memory sizeof queries the size of a type sizeof... queries the size of a parameter pack (since C++11) typeid queries the type information of a type noexcept checks if an expression can throw an exception (since C++11) alignof queries alignment requirements of a type (since C++11)

• operator precedence defines the order in which operators are bound to their arguments
• alternative representations are alternative spellings for some operators
• operator overloading makes it possible to specify the behavior of the operators with user-defined classes.

Conversions

• standard conversions implicit conversions from one type to another
• const_cast conversion
• static_cast conversion
• dynamic_cast conversion
• reinterpret_cast conversion
• explicit cast conversion using C-style cast notation and functional notation
• user-defined conversion makes it possible to specify conversion from user-defined classes

Memory allocation

• new expression allocates memory dynamically
• delete expression deallocates memory dynamically

Other

• constant expressions can be evaluated at compile time and used in compile-time context (template arguments, array sizes, etc)
• sizeof
• alignof
• typeid
• throw-expression

Primary expressions

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 1).

Primary expressions are any of the following:

1) Literals (e.g. 2 or "Hello, world")

2) Suitably declared unqualified identifiers (e.g. n or cout)

3) Suitably declared qualified identifiers (e.g. std::string::npos)

4) Lambda-expressions (C++11)

5) Fold-expressions (C++17)

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

Literals

Literals are the tokens of a C++ program that represent constant values embedded in the source code.

• integer literals are decimal, octal, hexadecimal or binary numbers of integer type.
• character literals are individual characters of type char, char16_t, char32_t, or wchar_t
• floating-point literals are values of type float, double, or long double
• string literals are sequences of characters of type const char[], const char16_t[], const char32_t[], or const wchar_t[]
• boolean literals are values of type bool, that is true and false
• nullptr is the pointer literal which specifies a null pointer value (since C++11)
• user-defined literals are constant values of user-specified type (since C++11)

Unevaluated expressions

The operands of the four operators typeid, sizeof, noexcept, and 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 sizeof(T()) requires an accessible T::~T)

(since C++14)

The requires-expressions(concepts TS) are also unevaluated expressions.

Discarded-value expressions

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 comma operator, or the argument of a cast-expression that casts to the type void.

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 (in other words, a memory read), however, is applied, but only if the expression is a volatile-qualified glvalue and has one of the following forms (possibly parenthesized)

• id-expression
• array subscript expression
• class member access expression
• indirection
• pointer-to-member operation
• conditional expression where both the second and the third operands are one of these expressions,
• comma expression where the right operand is one of these expressions.

In addition, if the expression is of class type, it needs a volatile copy-constructor to initialize the resulting rvalue temporary.