Merge branch 'main' into patch-2

Author: timsong-cpp

source/algorithms.tex

@@ -246,6 +246,13 @@
 return n;
 \end{codeblock}
 
+\pnum
+In the description of the algorithms,
+given an iterator \tcode{a} whose difference type is \tcode{D}, and
+an expression \tcode{n} of integer-like type other than \cv{} \tcode{D},
+the semantics of \tcode{a + n} and \tcode{a - n} are, respectively,
+those of \tcode{a + D(n)} and \tcode{a - D(n)}.
+
 \pnum
 In the description of algorithm return values,
 a sentinel value \tcode{s} denoting the end of a range \range{i}{s}
@@ -3939,17 +3946,24 @@
 
 \pnum
 \complexity
-If the types of \tcode{first1}, \tcode{last1}, \tcode{first2}, and \tcode{last2}:
+If
 \begin{itemize}
 \item
+  the types of \tcode{first1}, \tcode{last1}, \tcode{first2}, and \tcode{last2}
   meet the
   \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  and \tcode{last1 - first1 != last2 - first2}
   for the overloads in namespace \tcode{std};
 \item
-  pairwise model \libconcept{sized_sentinel_for}\iref{iterator.concept.sizedsentinel}
-  for the overloads in namespace \tcode{ranges},
+ the types of \tcode{first1}, \tcode{last1}, \tcode{first2}, and \tcode{last2}
+ pairwise model \libconcept{sized_sentinel_for}\iref{iterator.concept.sizedsentinel}
+  and \tcode{last1 - first1 != last2 - first2}
+  for the first overload in namespace \tcode{ranges},
+\item
+   \tcode{R1} and \tcode{R2} each model \libconcept{sized_range} and
+   \tcode{ranges::distance(r1) != ranges::distance(r2)}
+   for the second overload in namespace \tcode{ranges},
 \end{itemize}
-and \tcode{last1 - first1 != last2 - first2},
 then no applications of the corresponding predicate and each projection;
 otherwise,
 \begin{itemize}
@@ -4054,9 +4068,17 @@
 \complexity
 No applications of the corresponding predicate and projections if:
 \begin{itemize}
+\item
+for the first overload,
+\begin{itemize}
 \item \tcode{S1} and \tcode{I1} model \tcode{\libconcept{sized_sentinel_for}<S1, I1>},
 \item \tcode{S2} and \tcode{I2} model \tcode{\libconcept{sized_sentinel_for}<S2, I2>}, and
-\item \tcode{last1 - first1 != last2 - first2}.
+\item \tcode{last1 - first1 != last2 - first2};
+\end{itemize}
+\item
+for the second overload,
+\tcode{R1} and \tcode{R2} each model \libconcept{sized_range}, and
+\tcode{ranges::distance(r1) != ranges::distance(r2)}.
 \end{itemize}
 Otherwise, exactly \tcode{last1 - first1} applications
 of the corresponding predicate and projections

source/basic.tex

@@ -865,6 +865,32 @@
 \end{itemize}
 \end{note}
 
+\pnum
+Two non-static member functions have
+\defnadjx{corresponding}{object parameters}{object parameter} if:
+\begin{itemize}
+\item
+exactly one is an implicit object member function
+with no \grammarterm{ref-qualifier} and
+the types of their object parameters\iref{dcl.fct},
+after removing top-level references,
+are the same, or
+\item
+their object parameters have the same type.
+\end{itemize}
+Two non-static member function templates have
+\defnadjx{corresponding}{object parameters}{object parameter} if:
+\begin{itemize}
+\item
+exactly one is an implicit object member function
+with no \grammarterm{ref-qualifier} and
+the types of their object parameters,
+after removing any references,
+are equivalent, or
+\item
+the types of their object parameters are equivalent.
+\end{itemize}
+
 \pnum
 Two declarations \defn{correspond}
 if they (re)introduce the same name,
@@ -885,25 +911,23 @@
 each declares a function or function template, except when
 \begin{itemize}
 \item
-both declare functions with the same parameter-type-list,
+both declare functions with the same non-object-parameter-type-list,
 \begin{footnote}
 An implicit object parameter\iref{over.match.funcs}
 is not part of the parameter-type-list.
 \end{footnote}
 equivalent\iref{temp.over.link} trailing \grammarterm{requires-clause}s
 (if any, except as specified in \ref{temp.friend}), and,
 if both are non-static members,
-the same \grammarterm{cv-qualifier}s (if any) and
-\grammarterm{ref-qualifier} (if both have one), or
+they have corresponding object parameters, or
 \item
 both declare function templates with equivalent
-parameter-type-lists,
+non-object-parameter-type-lists,
 return types (if any),
 \grammarterm{template-head}s, and
 trailing \grammarterm{requires-clause}s (if any), and,
 if both are non-static members,
-the same \grammarterm{cv-qualifier}s (if any) and
-\grammarterm{ref-qualifier} (if both have one).
+they have corresponding object parameters.
 \end{itemize}
 \end{itemize}
 \begin{note}
@@ -923,16 +947,23 @@
 \begin{codeblock}
 typedef int Int;
 enum E : int { a };
-void f(int);            // \#1
-void f(Int) {}          // defines \#1
-void f(E) {}            // OK: another overload
+void f(int);                    // \#1
+void f(Int) {}                  // defines \#1
+void f(E) {}                    // OK: another overload
 
 struct X {
   static void f();
-  void f() const;       // error: redeclaration
+  void f() const;               // error: redeclaration
   void g();
-  void g() const;       // OK
-  void g() &;           // error: redeclaration
+  void g() const;               // OK
+  void g() &;                   // error: redeclaration
+
+  void h(this X&, int);
+  void h(int) &&;               // OK: another overload
+  void j(this const X&);
+  void j() const&;              // error: redeclaration
+  void k();
+  void k(this X&);              // error: redeclaration
 };
 \end{codeblock}
 \end{example}
@@ -2947,9 +2978,10 @@
 \indextext{memory model|(}%
 The fundamental storage unit in the \Cpp{} memory model is the
 \defn{byte}.
-A byte is at least large enough to contain any member of the basic
-\indextext{character set!basic execution}%
-execution character set\iref{lex.charset}
+A byte is at least large enough to contain
+the ordinary literal encoding of any element of the basic
+\indextext{character set!basic literal}%
+literal character set\iref{lex.charset}
 and the eight-bit code units of the Unicode
 \begin{footnote}
 Unicode\textregistered\ is a registered trademark of Unicode, Inc.
@@ -4849,8 +4881,6 @@
 Type \keyword{char} is a distinct type
 that has an \impldef{underlying type of \tcode{char}} choice of
 ``\tcode{\keyword{signed} \keyword{char}}'' or ``\tcode{\keyword{unsigned} \keyword{char}}'' as its underlying type.
-The values of type \keyword{char} can represent distinct codes
-for all members of the implementation's basic character set.
 The three types \keyword{char}, \tcode{\keyword{signed} \keyword{char}}, and \tcode{\keyword{unsigned} \keyword{char}}
 are collectively called
 \defnadjx{ordinary character}{types}{type}.
@@ -4911,10 +4941,10 @@
 
 \pnum
 \indextext{type!integral}%
-Types
-\keyword{bool},
-\keyword{char}, \keyword{wchar_t},
-\keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, and
+The types \keyword{char}, \keyword{wchar_t},
+\keyword{char8_t}, \keyword{char16_t}, and \keyword{char32_t}
+are collectively called \defnadjx{character}{types}{type}.
+The character types, \keyword{bool},
 the signed and unsigned integer types,
 and cv-qualified versions\iref{basic.type.qualifier} thereof,
 are collectively termed

source/classes.tex

@@ -997,15 +997,15 @@
 \indextext{member function!volatile}%
 \indextext{member function!const volatile}%
 \begin{note}
-A non-static member function can be declared with
+An implicit object member function can be declared with
 \grammarterm{cv-qualifier}{s}, which affect the type of the \keyword{this}
 pointer\iref{expr.prim.this},
 and/or a \grammarterm{ref-qualifier}\iref{dcl.fct};
 both affect overload resolution\iref{over.match.funcs}
 \end{note}
 
 \pnum
-A non-static member function may be declared
+An implicit object member function may be declared
 virtual\iref{class.virtual} or pure virtual\iref{class.abstract}.
 
 \rSec2[special]{Special member functions}
@@ -1832,9 +1832,7 @@
 The implicitly-declared copy/move assignment operator for class
 \tcode{X}
 has the return type
-\tcode{X\&};
-it returns the object for which the assignment operator is invoked, that is,
-the object assigned to.
+\tcode{X\&}.
 An implicitly-declared copy/move assignment operator is an
 inline public member of its class.
 
@@ -1996,6 +1994,11 @@
 the object that is the source of the copy,
 a corresponding object $o$ nested within the destination is created,
 and the lifetime of $o$ begins before the copy is performed.
+
+\pnum
+The implicitly-defined copy/move assignment operator for a class
+returns the object for which the assignment operator is invoked,
+that is, the object assigned to.
 \indextext{assignment operator!move|)}
 \indextext{assignment operator!copy|)}
 
@@ -2484,7 +2487,7 @@
 \nontermdef{conversion-declarator}\br
     ptr-operator \opt{conversion-declarator}
 \end{bnf}
-shall have no parameters and
+shall have no non-object parameters and
 specifies a conversion from \tcode{X} to
 the type specified by the \grammarterm{conversion-type-id},
 interpreted as a \grammarterm{type-id}\iref{dcl.name}.
@@ -3723,6 +3726,10 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+The \grammarterm{ref-qualifier}, or lack thereof, of an overriding function
+shall be the same as that of the overridden function.
+
 \pnum
 The return type of an overriding function shall be either identical to
 the return type of the overridden function or \defnx{covariant}{return type!covariant} with