Expressions - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Expressions

From cppreference.com
< cpp‎ | language

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

#### [edit] 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

### [edit] 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.

#### [edit] 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

#### [edit] Memory allocation

- new expression allocates memory dynamically
- delete expression deallocates memory dynamically

#### [edit] 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

### [edit] 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

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

#### [edit] 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, which may be narrow, multibyte, or wide
- 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)

### [edit] Unevaluated expressions

The operands of the four operators `typeid`, `sizeof`, `noexcept`, and `decltype` are expressions that are not evaluated, 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)

### [edit] 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.

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/language/expressions&oldid=71533"