An expression is a sequence ofoperators and theiroperands, that specifies a computation.

Expression evaluation may produce a result (e.g., evaluation of2+2 produces the result4) and may generate side-effects (e.g. evaluation ofstd::printf("%d",4) prints the character'4' on the standard output).

Each C++ expression is characterized by two independent properties: A type and a value category.

[edit]General

• value categories (lvalue, rvalue, glvalue, prvalue, xvalue(since C++11)) classify expressions by their values
• order of evaluation of arguments and subexpressions specify the order in which intermediate results are obtained

[edit]Operators

• 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 function-style 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. in1+2*3, the operands of operator+ are thesubexpression2*3 and the primary expression1).

Primary expressions are any of the following:

• this
• literals (e.g.2 or"Hello, world")
• identifier expressions, including
  • suitably declaredunqualified identifiers (e.g.n orcout),
  • suitably declaredqualified identifiers (e.g.std::string::npos), and
  • identifiers to be declared indeclarators

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.

[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 orwchar_t

• floating-point literals are values of typefloat,double, orlongdouble
• string literals are sequences of characters of type

• constchar[] orconstwchar_t[]

• boolean literals are values of typebool, that istrue andfalse

[edit]Full-expressions

Aconstituent expression is defined as follows:

• The constituent expression of an expression is that expression.
• The constituent expressions of abrace-enclosed initializer list or of a (possibly parenthesized) expression list are the constituent expressions of the elements of the respective list.
• The constituent expressions of aninitializer that begins with= are the constituent expressions of theinitializer-clause.

int num1=0;num1+=1;// Case 1: the constituent expression of “num += 1” is “num += 1” int arr2[2]={2,22}// Case 2: the constituent expressions//         of “{2, 22}” are “2” and “22”// Case 3: the constituent expressions of “= {2, 22}”//         are the constituent expressions of “{2, 22}”//         (i.e. also “2” and “22”)

Theimmediate subexpressions of an expressionE are

• the constituent expressions ofE’s operands,

• any function call thatE implicitly invokes, or
• ifE is a function call or implicitly invokes a function, the constituent expressions of eachdefault argument used in the call.

Asubexpression of an expressionE is an immediate subexpression ofE or a subexpression of an immediate subexpression ofE.Note that expressions appearing in the “function body” of lambda expressions are not subexpressions of the lambda expression.(since C++11)

The following expressions arefull-expressions :

• unevaluated operands
• constant expressions

• declarators ofsimple declarations ormember initializers, including the constituent expressions of the initializers
• invocations ofdestructors generated at the end of thelifetime of objects other than temporary objects whose lifetime have not been extended

• expressions that are not a subexpression of any another expression and that are not otherwise part of any full-expression

If a language construct is defined to produce an implicit call of a function, a use of the language construct is considered to be an expression for the purposes of this definition. Conversions applied to the result of an expression in order to satisfy the requirements of the language construct in which the expression appears are also considered to be part of the full-expression.

For an initializer, performing the initialization of the entity(including evaluating default member initializers of an aggregate)(since C++14) is also considered part of the full-expression.

[edit]Potentially-evaluated expressions

Potentially-evaluated expressions areODR-use.

[edit]Discarded-value expressions

Adiscarded-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 anyexpression statement, the left-hand operand of the built-in comma operator, or the operand of a cast-expression that casts to the typevoid.

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 avolatile-qualified glvalue and has one of the following forms (built-in meaning required, 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 lvalue is of volatile-qualified class type, a volatile copy constructor is required to initialize the resulting rvalue temporary.

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文