N3624 - Pointer comparison vs qualification conversions

In the additions to [expr], terms like T1, C1, where typeset in code font.

"pointers to member" was replaced by "pointers to members" in accordance with
existing practice in the standard.

Author: Stefanus Du Toit

source/classes.tex

@@ -1161,7 +1161,8 @@
 to inspect the common initial sequence of any of standard-layout struct members;
 see~\ref{class.mem}. \exitnote The size of a union is sufficient to contain the largest
 of its non-static data members. Each non-static data member is allocated
-as if it were the sole member of a struct.
+as if it were the sole member of a struct. All non-static data members of a
+union object have the same address.
 
 \pnum
 \indextext{member function!\idxcode{union}}%

source/expressions.tex

@@ -236,6 +236,82 @@
 conversions as described in~\ref{expr.cast},~\ref{expr.static.cast}
 and~\ref{expr.ass}.}
 
+\pnum
+The \term{cv-combined type} of two types \tcode{T1} and \tcode{T2}
+is a type \tcode{T3}
+similar to \tcode{T1} whose cv-qualification signature~(\ref{conv.qual}) is:
+\begin{itemize}
+\item
+for every $j > 0$, \cv$_{3,j}$ is the union of
+\cv$_{1,j}$ and \cv$_{2,j}$;
+
+\item
+if the resulting \cv$_{3,j}$ is different from
+\cv$_{1,j}$ or \cv$_{2,j}$, then
+\tcode{const} is added to every \cv$_{3,k}$ for $0 < k < j$.
+\end{itemize}
+
+\enternote Given similar types \tcode{T1} and \tcode{T2}, this
+construction ensures that
+both can be converted to \tcode{T3}. \exitnote
+The \term{composite pointer type} of
+two operands \tcode{p1} and
+\tcode{p2} having types \tcode{T1} and \tcode{T2}, respectively, where at least one is a
+pointer or pointer to member type or
+\tcode{std::nullptr_t}, is:
+
+\begin{itemize}
+\item
+if both \tcode{p1} and \tcode{p2} are null pointer constants,
+\tcode{std::nullptr_t};
+
+\item
+if either \tcode{p1} or \tcode{p2} is a null pointer constant, \tcode{T2} or \tcode{T1},
+respectively;
+
+\item
+if \tcode{T1} or \tcode{T2} is ``pointer to \cvqual{cv1} \tcode{void}'' and the
+other type is ``pointer to \cvqual{cv2} T'', ``pointer to \cvqual{cv12}
+\tcode{void}'', where \cvqual{cv12} is the union of \cvqual{cv1}
+and \cvqual{cv2};
+
+\item
+if \tcode{T1} is ``pointer to \cvqual{cv1} \tcode{C1}'' and \tcode{T2} is ``pointer to
+\cvqual{cv2} \tcode{C2}'', where \tcode{C1} is reference-related to \tcode{C2} or \tcode{C2} is
+reference-related to \tcode{C1}~(\ref{dcl.init.ref}), the cv-combined type
+of \tcode{T1} and \tcode{T2} or the cv-combined type of \tcode{T2} and \tcode{T1},
+respectively;
+
+\item
+if \tcode{T1} is ``pointer to member of \tcode{C1} of type \cvqual{cv1} U1'' and \tcode{T2} is
+``pointer to member of \tcode{C2} of type \cvqual{cv2} U2'' where \tcode{C1} is
+reference-related to \tcode{C2} or \tcode{C2} is reference-related to
+\tcode{C1}~(\ref{dcl.init.ref}), the cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type
+of \tcode{T1} and \tcode{T2}, respectively;
+
+\item
+if \tcode{T1} and \tcode{T2} are similar multi-level mixed pointer and pointer to
+member types~(\ref{expr.qual}), the cv-combined type of \tcode{T1} and
+\tcode{T2};
+
+\item
+otherwise, a program that necessitates the determination of a
+composite pointer type is ill-formed.
+\end{itemize}
+
+\enterexample
+\begin{codeblock}
+typedef void *p;
+typedef const int *q;
+typedef int **pi;
+typedef const int **pci;
+\end{codeblock}
+
+The composite pointer type of \tcode{p} and \tcode{q} is ``pointer to \tcode{const void}''; the
+composite pointer type of \tcode{pi} and \tcode{pci} is ``pointer to \tcode{const} pointer to
+\tcode{const int}''.
+\exitexample
+
 \rSec1[expr.prim]{Primary expressions}%
 \indextext{expression!primary|(}
 
@@ -3557,102 +3633,49 @@
     relational-expression \terminal{>=} shift-expression
 \end{bnf}
 
-The operands shall have arithmetic, enumeration, or pointer type, or type \tcode{std::nullptr_t}. The
+The operands shall have arithmetic, enumeration, or pointer type. The
 operators \tcode{<} (less than), \tcode{>} (greater than), \tcode{<=}
 (less than or equal to), and \tcode{>=} (greater than or equal to) all
 yield \tcode{false} or \tcode{true}. The type of the result is
 \tcode{bool}.
 
 \pnum
 The usual arithmetic conversions are performed on operands of arithmetic
-or enumeration type. Pointer conversions~(\ref{conv.ptr}) and
-qualification conversions~(\ref{conv.qual}) are performed on pointer
-operands (or on a pointer operand and a null pointer constant, or on two
-null pointer constants, at least one of which is non-integral) to bring
-them to their \term{composite pointer type}. If one operand is a
-null pointer constant, the composite pointer type is
-\tcode{std::nullptr_t} if the other operand is also a null pointer constant or,
-if the other operand is a pointer,
-the type of the
-other operand. Otherwise, if one of the operands has type ``pointer to
-\cvqual{cv1} \tcode{void},'' then the other has type ``pointer to
-\cvqual{cv2} \term{T}'' and the composite pointer type is ``pointer to
-\cvqual{cv12} \tcode{void},'' where \cvqual{cv12} is the union of
-\cvqual{cv1} and \cvqual{cv2}. Otherwise, the composite pointer type is
-a pointer type similar~(\ref{conv.qual}) to the type of one of the
-operands, with a cv-qualification signature~(\ref{conv.qual}) that is
-the union of the cv-qualification signatures of the operand types.
-\enternote 
-\indextext{comparison!void* pointer@\tcode{void*} pointer}%
-this implies
-that any pointer can be compared to a null pointer constant and that any
-object pointer can be compared to a pointer to (possibly cv-qualified)
-\tcode{void}.
-\exitnote 
-\enterexample 
+or enumeration type. If both operands are pointers, pointer
+conversions~(\ref{conv.ptr}) and qualification conversions~(\ref{conv.qual})
+are performed to bring
+them to their composite pointer type (Clause~\ref{expr}).
+After conversions, the operands shall have the same type.
 
-\begin{codeblock}
-void *p;
-const int *q;
-int **pi;
-const int *const *pci;
-void ct() {
-  p <= q;           // Both converted to \tcode{const void*} before comparison
-  pi <= pci;        // Both converted to \tcode{const int *const *} before comparison
-}
-\end{codeblock}
-\exitexample 
-\indextext{comparison!pointer}%
-\indextext{comparison!pointer~to function}%
-Pointers to objects or functions of the same type (after pointer
-conversions) can be compared, with a result defined as follows:
+\pnum
+Comparing pointers to objects is defined as follows:
 
 \begin{itemize}
-\item If two pointers \tcode{p} and \tcode{q} of the same type point to
-the same object or function, or both point one past the end of the same
-array, or are both null, then \tcode{p<=q} and \tcode{p>=q} both yield
-\tcode{true} and \tcode{p<q} and \tcode{p>q} both yield \tcode{false}.
-
-\item If two pointers \tcode{p} and \tcode{q} of the same type point to
-different objects that are not members of the same object or elements of
-the same array or to different functions, or if only one of them is
-null, the results of \tcode{p<q}, \tcode{p>q}, \tcode{p<=q}, and
-\tcode{p>=q} are unspecified.
-
-\item If two pointers point to non-static data members of the same
-object, or to subobjects or array elements of such members, recursively,
+\item If two pointers point to different elements of the same array, or to
+subobjects thereof, the pointer to the element with the higher subscript
+compares greater.
+
+\item If one pointer points to an element of an array, or to a subobject
+thereof, and another pointer points one past the last element of the array, the
+latter pointer compares greater.
+
+\item If two pointers point to different non-static data members of the same
+object, or to subobjects of such members, recursively,
 the pointer to the later declared member compares greater provided the
 two members
 have the same access control (Clause~\ref{class.access})
 and provided their class is not a union.
 
-\indextext{comparison!undefined pointer}%
-\item If two pointers point to non-static data members of the same
-object
-with different access control (Clause~\ref{class.access})
-the result is unspecified.
-
-\item If two pointers point to non-static data members of the same union object,
-they compare equal (after conversion to \tcode{void*}, if necessary). If
-two pointers point to elements of the same array or one beyond the end
-of the array, the pointer to the object with the higher subscript
-compares higher.
-
-\indextext{comparison!unspecified pointer}%
-\indextext{comparison!pointer}%
-\item Other pointer comparisons are unspecified.
 \end{itemize}
 
 \pnum
-Pointers to \tcode{void} (after pointer conversions) can be compared, with a result
-defined as follows: If both pointers represent the same address or are both the null
-pointer value, the result is \tcode{true} if the operator is \tcode{<=} or \tcode{>=}
-and \tcode{false} otherwise; otherwise the result is unspecified.
-
-\pnum
-If two operands of type \tcode{std::nullptr_t} are compared, the result is
-\tcode{true} if the operator is \tcode{<=} or \tcode{>=}, and \tcode{false}
-otherwise.
+If two operands \tcode{p} and \tcode{q} compare equal~(\ref{expr.eq}),
+\tcode{p<=q} and \tcode{p>=q} both yield \tcode{true} and \tcode{p<q} and
+\tcode{p>q} both yield \tcode{false}. Otherwise, if a pointer \tcode{p}
+compares greater than a pointer \tcode{q}, \tcode{p>=q}, \tcode{p>q},
+\tcode{q<=p}, and \tcode{q<p} all yield \tcode{true} and \tcode{p<=q},
+\tcode{p<q}, \tcode{q>=p}, and \tcode{q>p} all yield \tcode{false}.
+Otherwise, the result of each of the operators is unspecified.
 
 \pnum
 If both operands (after conversions) are of arithmetic or enumeration type, each
@@ -3673,42 +3696,48 @@
 
 \pnum
 The \tcode{==} (equal to) and the \tcode{!=} (not equal to) operators
-have the same semantic restrictions, conversions, and result type as the
-relational operators except for their lower precedence and truth-value
-result.
-\enternote 
-\tcode{a<b == c<d} is \tcode{true} whenever \tcode{a<b} and \tcode{c<d}
-have the same truth-value.
-\exitnote 
+group left-to-right. The operands shall have arithmetic, enumeration, pointer,
+or pointer to member type, or type \tcode{std::nullptr_t}. The operators
+\tcode{==} and \tcode{!=} both yield \tcode{true} or \tcode{false}, i.e., a
+result of type \tcode{bool}. In each case below, the operands shall have the
+same type after the specified conversions have been applied.
+
 \indextext{comparison!pointer}%
 \indextext{comparison!pointer~to function}%
-Pointers of the same type (after pointer
-conversions) can be compared for equality. Two pointers of the same type
-compare equal if and only if they are both null, both point to the same
+\pnum
+If at least one of the operands is a pointer, pointer
+conversions~(\ref{conv.ptr}) and qualification conversions~(\ref{conv.qual})
+are performed on both operands to bring them to their composite pointer type
+(Clause~\ref{expr}). Comparing pointers is defined as follows:
+Two pointers compare equal if they are both null, both point to the same
 \indextext{address}%
-function, or both represent the same address~(\ref{basic.compound}).
+function, or both represent the same address~(\ref{basic.compound}), otherwise
+they compare unequal.
 
 \pnum
-In addition, pointers to members can be compared, or a pointer to member
-and a null pointer constant. Pointer to member
+If at least one of the operands is a pointer to member, pointer to member
 conversions~(\ref{conv.mem}) and qualification
-conversions~(\ref{conv.qual}) are performed to bring them to a common
-type. If one operand is a null pointer constant, the common type is the
-type of the other operand. Otherwise, the common type is a pointer to
-member type similar~(\ref{conv.qual}) to the type of one of the
-operands, with a cv-qualification signature~(\ref{conv.qual}) that is
-the union of the cv-qualification signatures of the operand types.
-\enternote 
-this implies that any pointer to member can be compared to a null
-pointer constant.
-\exitnote 
-If both operands are null, they compare equal. Otherwise if only one is
-null, they compare unequal. Otherwise if either is a pointer to a
-virtual member function, the result is unspecified. Otherwise they
-compare equal if and only if they would refer to the same member of the
-same most derived object~(\ref{intro.object}) or the same subobject if
+conversions~(\ref{conv.qual}) are performed on both operands to bring them to
+their composite pointer type (Clause~\ref{expr}).
+Comparing pointers to members is defined as follows:
+
+\begin{itemize}
+\item
+If two pointers to members are both the null member pointer value, they compare
+equal.
+
+\item
+If only one of two pointers to members is the null member pointer value, they
+compare unequal.
+
+\item
+If either is a pointer to a virtual member function, the result is unspecified.
+
+\item
+Two pointers to members compare equal if they would refer to the same member of
+the same most derived object~(\ref{intro.object}) or the same subobject if
 indirection with a hypothetical object of the associated
-class type were performed.
+class type were performed, otherwise they compare unequal.
 \enterexample 
 
 \begin{codeblock}
@@ -3726,15 +3755,25 @@
 int (D::*pdr)() = pr;
 bool x = (pdl == pdr);          // \tcode{false}
 \end{codeblock}
-\exitexample 
+\exitexample
+\end{itemize}
+
+\pnum
+Two operands of type \tcode{std::nullptr_t} or one operand of type
+\tcode{std::nullptr_t} and the other a null pointer constant compare equal.
 
 \pnum
-If two operands of type \tcode{std::nullptr_t} are compared, the result is
-\tcode{true} if the operator is \tcode{==}, and \tcode{false} otherwise.
+If two operands compare equal, the result is \tcode{true} for
+\tcode{operator==} and \tcode{false} for \tcode{operator!=}. If two operands
+compare unequal, the result is \tcode{false} for \tcode{operator==} and
+\tcode{true} for \tcode{operator!=}. Otherwise, the result of each of the
+operators is unspecified.
 
 \pnum
-Each of the operators shall yield \tcode{true} if the specified relationship is
-true and \tcode{false} if it is false.
+If both operands are of arithmetic or enumeration type, the usual arithmetic
+conversions are performed on both operands; each of the operators shall yield
+\tcode{true} if the specified relationship is true and \tcode{false} if it is
+false.
 
 \rSec1[expr.bit.and]{Bitwise AND operator}%
 \indextext{expression!bitwise~AND}%
@@ -3975,20 +4014,22 @@
 the usual arithmetic conversions are performed to bring them to a common
 type, and the result is of that type.
 
-\item The second and third operands have pointer type, or one has
-pointer type and the other is a null pointer constant, or both are
-null pointer constants, at least one of which is non-integral; pointer
+\item One or both of the second and third operands have pointer type; pointer
 conversions~(\ref{conv.ptr}) and qualification
 conversions~(\ref{conv.qual}) are performed to bring them to their
-composite pointer type~(\ref{expr.rel}). The result is of the composite
+composite pointer type (Clause~\ref{expr}). The result is of the composite
 pointer type.
 
-\item The second and third operands have pointer to member type, or one
-has pointer to member type and the other is a null pointer constant;
+\item One or both of the second and third operands have pointer to member type;
 pointer to member conversions~(\ref{conv.mem}) and qualification
-conversions~(\ref{conv.qual}) are performed to bring them to a common
-type, whose cv-qualification shall match the cv-qualification of either
-the second or the third operand. The result is of the common type.
+conversions~(\ref{conv.qual}) are performed to bring them to their composite
+pointer type (Clause~\ref{expr}). The result is of the composite pointer type.
+
+\item
+Both the second and third operands have type \tcode{std::nullptr_t} or one has
+that type and the other is a null pointer constant. The result is of type
+\tcode{std::nullptr_t}.
+
 \end{itemize}
 
 \rSec1[expr.ass]{Assignment and compound assignment operators}%

source/overloading.tex

@@ -3461,8 +3461,8 @@
 \end{codeblock}
 
 \pnum
-For every \term{T}, where \term{T} is an enumeration type, a pointer type, or
-\tcode{std::nullptr_t}, there exist candidate operator functions of the form
+For every \term{T}, where \term{T} is an enumeration type or a pointer type,
+there exist candidate operator functions of the form
 
 \begin{codeblock}
 bool    operator<(@\term{T}@, @\term{T}@);
@@ -3474,8 +3474,8 @@
 \end{codeblock}
 
 \pnum
-For every pointer to member type \term{T} there exist candidate operator functions of
-the form
+For every pointer to member type \term{T} or type \tcode{std::nullptr_t} there
+exist candidate operator functions of the form
 
 \begin{codeblock}
 bool    operator==(@\term{T}@, @\term{T}@);

source/utilities.tex

@@ -5793,7 +5793,7 @@
 
 \begin{itemdescr}
 \pnum\returns \tcode{less<V>()(a.get(), b.get())},
-where \tcode{V} is the composite pointer type~(\ref{expr.rel}) of \tcode{T*} and \tcode{U*}.
+where \tcode{V} is the composite pointer type (Clause~\ref{expr}) of \tcode{T*} and \tcode{U*}.
 
 \pnum \enternote
 Defining a comparison operator allows \tcode{shared_ptr} objects to be