Expressions (C++)

An expression is a sequence of operators, operands, and punctuators that specifies a computation. The formal syntax, listed in CodeGear C++ expressions, indicates that expressions are defined recursively: subexpressions can be nested without formal limit. (However, the compiler will report an out-of-memory error if it can't compile an expression that is too complex.)

Note: CodeGear C++ expressions show how identifiers and operators are combined to form grammatically legal "phrases."

Expressions are evaluated according to certain conversion, grouping, associativity, and precedence rules that depend on the operators used, the presence of parentheses, and the data types of the operands. The standard conversions are detailed in Methods used in standard arithmetic conversions. The way operands and subexpressions are grouped does not necessarily specify the actual order in which they are evaluated by the compiler (see Evaluation order).

Expressions can produce an lvalue, an rvalue, or no value. Expressions might cause side effects whether they produce a value or not

The precedence and associativity of the operators are summarized in Associativity and precedence of CodeGear C++ operators. The grammar in CodeGear C++ expressions, completely defines the precedence and associativity of the operators.

CodeGear C++ expressions

Copy Code

primary-expression:
    literal
    this (C++ specific)
    :: identifier (C++ specific)
    :: operator-function-name (C++ specific)
    :: qualified-name (C++ specific)
    (expression)
    name

teral:
    integer-constant
    character-constant
    floating-constant
    string-literal
name:
    identifier
    operator-function-name (C++ specific)
    conversion-function-name (C++ specific)

~ class-name (C++ specific)
    qualified-name (C++ specific)

qualified-name: (C++ specific)
    qualified-class-name :: name
postfix-expression:
    primary-expression
    postfix-expression  [ expression ]
    postfix-expression  (<expression—list>)
   simple-type-name (<expression-list>) (C++ specific)

postfix-expression  .  name
    postfix-expression  ->  name
    postfix-expression  ++

postfix-expression  --
    const_cast < type-id > ( expression ) (C++ specific)
    dynamic_cast < type-id > ( expression ) (C++ specific)
    reinterpret_cast < type-id > ( expression ) (C++ specific)
    static_cast < type-id > ( expression ) (C++ specific)
    typeid ( expression ) (C++ specific)
    typeid ( type-name ) (C++ specific)
expression-list:
    assignment-expression
    expression-list  ,  assignment-expression
unary-expression:
    postfix-expression
    ++ unary-expression
    - - unary-expression
    unary-operator  cast-expression
    sizeof unary-expression
    sizeof ( type-name )
    allocation-expression (C++ specific)
    deallocation-expression (C++ specific)
unary-operator: one of & * + - !
allocation-expression: (C++ specific)
    <::> new <placement> new-type-name <initializer>
    <::> new <placement> (type-name) <initializer>
placement: (C++ specific)
   (expression-list)
new-type-name: (C++ specific)
   type-specifiers <new-declarator>
new-declarator: (C++ specific)
   ptr-operator <new-declarator>
   new-declarator [<expression>]
deallocation-expression: (C++ specific)
    <::> delete cast-expression
    <::> delete [] cast-expression
cast-expression:
    unary-expression
    ( type-name )  cast-expression

pm-expression:
    cast-expression
    pm-expression .* cast-expression (C++ specific)
    pm-expression ->* cast-expression (C++ specific)
multiplicative-expression:
    pm-expression
    multiplicative-expression  *  pm-expression
    multiplicative-expression  /  pm-expression
    multiplicative-expression  %  pm-expression
additive-expression:
    multiplicative-expression
    additive-expression  +  multiplicative-expression
    additive-expression  -  multiplicative-expression
shift-expression:
additive-expression
    shift-expression  <<  additive-expression
    shift-expression  >>  additive-expression
relational-expression:
    shift-expression
    relational-expression  <   shift-expression
    relational-expression  >   shift-expression
    relational-expression  <=  shift-expression
    relational-expression  >=  shift-expressionequality-expression:
    relational-expression
    equality expression  ==  relational-expression
    equality expression  !=  relational-expression
AND-expression:
    equality-expression
    AND-expression  &  equality-expression
exclusive-OR-expression:
    AND-expression
    exclusive-OR-expression ^ AND-expression
inclusive-OR-expression:
    exclusive-OR-expression
    inclusive-OR-expression | exclusive-OR-expression
logical-AND-expression:

inclusive-OR-expression
    logical-AND-expression && inclusive-OR-expression
logical-OR-expression:
    logical-AND-expression
    logical-OR-expression || logical-AND-expression
conditional-expression:
    logical-OR-expression
    logical-OR-expression ? expression : conditional-expression
assignment-expression:
    conditional-expression
    unary-expression  assignment-operator  assignment-expression
assignment-operator: one of

=   *=  /=  %=  +=  -=

<<    =>   >=   &=  ^=  |=
expression:
    assignment-expression
    expression , assignment-expression
constant-expression:
    conditional-expression

What do you think about this topic? Send feedback!