8 Expressions [expr]

8.5 Compound expressions [expr.compound]

8.5.1 Postfix expressions [expr.post]

8.5.1.5 Class member access [expr.ref]

A postfix expression followed by a dot . or an arrow ->, optionally followed by the keyword template ([temp.names]), and then followed by an id-expression, is a postfix expression.
The postfix expression before the dot or arrow is evaluated;67 the result of that evaluation, together with the id-expression, determines the result of the entire postfix expression.
For the first option (dot) the first expression shall be a glvalue having class type.
For the second option (arrow) the first expression shall be a prvalue having pointer to class type.
In both cases, the class type shall be complete unless the class member access appears in the definition of that class.
[Note
:
If the class is incomplete, lookup in the complete class type is required to refer to the same declaration ([basic.scope.class]).
end note
]
The expression E1->E2 is converted to the equivalent form (*(E1)).E2; the remainder of [expr.ref] will address only the first option (dot).68
In either case, the id-expression shall name a member of the class or of one of its base classes.
[Note
:
Because the name of a class is inserted in its class scope ([class]), the name of a class is also considered a nested member of that class.
end note
]
[Note
:
[basic.lookup.classref] describes how names are looked up after the . and -> operators.
end note
]
Abbreviating postfix-expression.id-expression as E1.E2, E1 is called the object expression.
If E2 is a bit-field, E1.E2 is a bit-field.
The type and value category of E1.E2 are determined as follows.
In the remainder of [expr.ref], cq represents either const or the absence of const and vq represents either volatile or the absence of volatile.
cv represents an arbitrary set of cv-qualifiers, as defined in [basic.type.qualifier].
If E2 is declared to have type “reference to T”, then E1.E2 is an lvalue; the type of E1.E2 is T.
Otherwise, one of the following rules applies.
  • If E2 is a static data member and the type of E2 is T, then E1.E2 is an lvalue; the expression designates the named member of the class.
    The type of E1.E2 is T.
  • If E2 is a non-static data member and the type of E1 is “cq1 vq1 X”, and the type of E2 is “cq2 vq2 T”, the expression designates the named member of the object designated by the first expression.
    If E1 is an lvalue, then E1.E2 is an lvalue; otherwise E1.E2 is an xvalue.
    Let the notation vq12 stand for the “union” of vq1 and vq2; that is, if vq1 or vq2 is volatile, then vq12 is volatile.
    Similarly, let the notation cq12 stand for the “union” of cq1 and cq2; that is, if cq1 or cq2 is const, then cq12 is const.
    If E2 is declared to be a mutable member, then the type of E1.E2 is “vq12 T.
    If E2 is not declared to be a mutable member, then the type of E1.E2 is “cq12 vq12 T.
  • If E2 is a (possibly overloaded) member function, function overload resolution is used to determine whether E1.E2 refers to a static or a non-static member function.
    • If it refers to a static member function and the type of E2 is “function of parameter-type-list returning T”, then E1.E2 is an lvalue; the expression designates the static member function.
      The type of E1.E2 is the same type as that of E2, namely “function of parameter-type-list returning T.
    • Otherwise, if E1.E2 refers to a non-static member function and the type of E2 is “function of parameter-type-list cv ref-qualifier returning T”, then E1.E2 is a prvalue.
      The expression designates a non-static member function.
      The expression can be used only as the left-hand operand of a member function call ([class.mfct]).
      [Note
      :
      Any redundant set of parentheses surrounding the expression is ignored ([expr.prim]).
      end note
      ]
      The type of E1.E2 is “function of parameter-type-list cv returning T.
  • If E2 is a nested type, the expression E1.E2 is ill-formed.
  • If E2 is a member enumerator and the type of E2 is T, the expression E1.E2 is a prvalue.
    The type of E1.E2 is T.
If E2 is a non-static data member or a non-static member function, the program is ill-formed if the class of which E2 is directly a member is an ambiguous base ([class.member.lookup]) of the naming class ([class.access.base]) of E2.
[Note
:
The program is also ill-formed if the naming class is an ambiguous base of the class type of the object expression; see [class.access.base].
end note
]
If the class member access expression is evaluated, the subexpression evaluation happens even if the result is unnecessary to determine the value of the entire postfix expression, for example if the id-expression denotes a static member.
Note that (*(E1)) is an lvalue.