the right operand is a pointer to data member of non-reference type,

which identify members of a given

\tcode{T}''.

A pointer to member shall not point to a static member

of a class\iref{class.static},

a member with reference type,

or

``\cv{}~\tcode{void}''.

\item the function type to which a pointer to member points,

The result of the conversion points to the same member as the pointer to

member before the conversion took place, but it points to the base class

member as if it were a member of the derived class. The result points to

expression\iref{expr.mptr.oper} pointing to a function member; the call is as a member of

containing the original member, the resulting pointer to member points

to the original member. Otherwise, the behavior is undefined.

of class \tcode{C} of type \tcode{T}'' and is a prvalue pointing to \tcode{C::m}.

The binary operator \tcode{.*} binds its second operand, which shall be

of type ``pointer to member of \tcode{T}'' to its first operand, which shall be

a glvalue

of

class \tcode{T} or of a class of which \tcode{T} is an unambiguous and

accessible base class. The result the object or a function to which the second operand points.

The binary operator \tcode{->*} binds its second operand, which shall be

of type ``pointer to member of \tcode{T}'' to its first operand, which shall be of

type ``pointer to \tcode{U}''

where \tcode{U} is either \tcode{T} or

a class of which \tcode{T}

is an unambiguous and accessible base class.

The expression \tcode{E1->*E2} is converted into the equivalent form

\tcode{(*(E1)).*E2}.

Abbreviating \grammarterm{pm-expression}\tcode{.*}\grammarterm{cast-expression} as \tcode{E1.*E2}, \tcode{E1}

is called the \defn{object expression}.

If the dynamic type of \tcode{E1} does not

contain the member to which

\tcode{E2} points, the behavior is undefined.

Otherwise, the expression \tcode{E1} is sequenced before the expression \tcode{E2}.

The restrictions on cv-qualification, and the manner in which

the cv-qualifiers of the operands are combined to produce the

cv-qualifiers of the result, are the same as the rules for

\tcode{E1.E2} given in~\ref{expr.ref}.

It is not possible to use a pointer to member that points to a

int S::* pm = &S::i; // \tcode{pm} points to \tcode{mutable} member \tcode{S::i}

If the result of \tcode{.*} or \tcode{->*} is a function, then that

result can be used only as the operand for the function call operator

\tcode{()}.

calls the member function denoted by \tcode{ptr_to_mfct} for the object

In a \tcode{.*} expression whose object expression is an rvalue, the program is

ill-formed if the second operand is a pointer to member function

whose \grammarterm{ref-qualifier} is \tcode{\&},

unless its \grammarterm{cv-qualifier-seq} is \tcode{const}.

In a \tcode{.*}

expression whose object expression is an lvalue, the program is ill-formed if the second

operand is

a pointer to member function

whose \grammarterm{ref-qualifier} is \tcode{\&\&}.

The result of a \tcode{.*} expression

whose second operand is a pointer to a data member is an lvalue if the first

operand is an lvalue and an xvalue otherwise. The result of a \tcode{.*} expression whose

second operand is a pointer to a member function is a prvalue.

If the second operand is the null

member pointer value\iref{conv.mem}, the behavior is undefined.

If one points to a member of class \tcode{C1} and the other points to a member

If both point to (possibly different) members of the same union\iref{class.union},

Otherwise, two pointers to members compare equal if they would point to the same member of

it does not point to an immediate function, and

if it attempts to form a pointer-to-member to

they are of pointer-to-member type and they point to the same class member

and the type of the member pointed to.