[class.conv] - C++20 → C++23

Files changed (1) hide show

tmp/tmpxpkhsn4c/{from.md → to.md} +84 -57

tmp/tmpxpkhsn4c/{from.md → to.md} RENAMED Viewed

@@ -1,16 +1,18 @@
 ### Conversions <a id="class.conv">[[class.conv]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
 conversions* and are used for implicit type conversions [[conv]], for
-initialization [[dcl.init]], and for explicit type conversions (
-[[expr.type.conv]], [[expr.cast]], [[expr.static.cast]]).
-User-defined conversions are applied only where they are unambiguous (
-[[class.member.lookup]], [[class.conv.fct]]). Conversions obey the
-access control rules [[class.access]]. Access control is applied after
 ambiguity resolution [[basic.lookup]].
 [*Note 1*: See  [[over.match]] for a discussion of the use of
 conversions in function calls as well as examples below. — *end note*]
@@ -28,36 +30,11 @@ struct Y {
   operator X();
 };
 Y a;
 int b = a;          // error: no viable conversion (a.operator X().operator int() not considered)
-int c = X(a);       // OK: a.operator X().operator int()
-```
-— *end example*]
-User-defined conversions are used implicitly only if they are
-unambiguous. A conversion function in a derived class does not hide a
-conversion function in a base class unless the two functions convert to
-the same type. Function overload resolution [[over.match.best]] selects
-the best conversion function to perform the conversion.
-[*Example 2*:
-``` cpp
-struct X {
-  operator int();
-};
-struct Y : X {
-    operator char();
-};
-void f(Y& a) {
-  if (a) {          // error: ambiguous between X::operator int() and Y::operator char()
-  }
-}
 ```
 — *end example*]
 #### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
@@ -88,13 +65,13 @@ void f(X arg) {
 [*Note 1*:
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax
-[[dcl.init]] or where casts ([[expr.static.cast]], [[expr.cast]]) are
 explicitly used; see also  [[over.match.copy]]. A default constructor
-may be an explicit constructor; such a constructor will be used to
 perform default-initialization or value-initialization [[dcl.init]].
 [*Example 2*:
 ``` cpp
@@ -102,19 +79,19 @@ struct Z {
   explicit Z();
   explicit Z(int);
   explicit Z(int, int);
 };
-Z a;                            // OK: default-initialization performed
-Z b{};                          // OK: direct initialization syntax used
 Z c = {};                       // error: copy-list-initialization
 Z a1 = 1;                       // error: no implicit conversion
-Z a3 = Z(1);                    // OK: direct initialization syntax used
-Z a2(1);                        // OK: direct initialization syntax used
-Z* p = new Z(1);                // OK: direct initialization syntax used
-Z a4 = (Z)1;                    // OK: explicit cast used
-Z a5 = static_cast<Z>(1);       // OK: explicit cast used
 Z a6 = { 3, 4 };                // error: no implicit conversion
 ```
 — *end example*]
@@ -122,18 +99,15 @@ Z a6 = { 3, 4 };                // error: no implicit conversion
 A non-explicit copy/move constructor [[class.copy.ctor]] is a converting
 constructor.
 [*Note 2*: An implicitly-declared copy/move constructor is not an
-explicit constructor; it may be called for implicit type
 conversions. — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
-A member function of a class `X` having no parameters with a name of the
-form
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
 ```
@@ -145,20 +119,44 @@ conversion-type-id:
 ``` bnf
 conversion-declarator:
     ptr-operator conversion-declaratorₒₚₜ
 ```
 specifies a conversion from `X` to the type specified by the
-*conversion-type-id*. Such functions are called *conversion functions*.
-A *decl-specifier* in the *decl-specifier-seq* of a conversion function
-(if any) shall be neither a *defining-type-specifier* nor `static`. The
-type of the conversion function [[dcl.fct]] is “function taking no
-parameter returning *conversion-type-id*”. A conversion function is
-never used to convert a (possibly cv-qualified) object to the (possibly
-cv-qualified) same object type (or a reference to it), to a (possibly
-cv-qualified) base class of that type (or a reference to it), or to
-cv `void`.[^6]
 [*Example 1*:
 ``` cpp
 struct X {
@@ -190,13 +188,13 @@ class Y { };
 struct Z {
   explicit operator Y() const;
 };
 void h(Z z) {
-  Y y1(z);          // OK: direct-initialization
   Y y2 = z;         // error: no conversion function candidate for copy-initialization
-  Y y3 = (Y)z;      // OK: cast notation
 }
 void g(X a, X b) {
   int i = (a) ? 1+a : 0;
   int j = (a&&b) ? a+b : i;
@@ -239,18 +237,47 @@ operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
 — *end example*]
 — *end note*]
-Conversion functions are inherited.
 Conversion functions can be virtual.
 A conversion function template shall not have a deduced return type
 [[dcl.spec.auto]].
-[*Example 5*:
 ``` cpp
 struct S {
   operator auto() const { return 10; }      // OK
   template<class T>

 ### Conversions <a id="class.conv">[[class.conv]]</a>
+#### General <a id="class.conv.general">[[class.conv.general]]</a>
 Type conversions of class objects can be specified by constructors and
 by conversion functions. These conversions are called *user-defined
 conversions* and are used for implicit type conversions [[conv]], for
+initialization [[dcl.init]], and for explicit type conversions
+[[expr.type.conv]], [[expr.cast]], [[expr.static.cast]].
+User-defined conversions are applied only where they are unambiguous
+[[class.member.lookup]], [[class.conv.fct]]. Conversions obey the access
+control rules [[class.access]]. Access control is applied after
 ambiguity resolution [[basic.lookup]].
 [*Note 1*: See  [[over.match]] for a discussion of the use of
 conversions in function calls as well as examples below. — *end note*]
   operator X();
 };
 Y a;
 int b = a;          // error: no viable conversion (a.operator X().operator int() not considered)
+int c = X(a);       // OK, a.operator X().operator int()
 ```
 — *end example*]
 #### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
 [*Note 1*:
 An explicit constructor constructs objects just like non-explicit
 constructors, but does so only where the direct-initialization syntax
+[[dcl.init]] or where casts [[expr.static.cast]], [[expr.cast]] are
 explicitly used; see also  [[over.match.copy]]. A default constructor
+can be an explicit constructor; such a constructor will be used to
 perform default-initialization or value-initialization [[dcl.init]].
 [*Example 2*:
 ``` cpp
   explicit Z();
   explicit Z(int);
   explicit Z(int, int);
 };
+Z a;                            // OK, default-initialization performed
+Z b{};                          // OK, direct initialization syntax used
 Z c = {};                       // error: copy-list-initialization
 Z a1 = 1;                       // error: no implicit conversion
+Z a3 = Z(1);                    // OK, direct initialization syntax used
+Z a2(1);                        // OK, direct initialization syntax used
+Z* p = new Z(1);                // OK, direct initialization syntax used
+Z a4 = (Z)1;                    // OK, explicit cast used
+Z a5 = static_cast<Z>(1);       // OK, explicit cast used
 Z a6 = { 3, 4 };                // error: no implicit conversion
 ```
 — *end example*]
 A non-explicit copy/move constructor [[class.copy.ctor]] is a converting
 constructor.
 [*Note 2*: An implicitly-declared copy/move constructor is not an
+explicit constructor; it can be called for implicit type
 conversions. — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
 ```
 ``` bnf
 conversion-declarator:
     ptr-operator conversion-declaratorₒₚₜ
 ```
+A declaration whose *declarator-id* has an *unqualified-id* that is a
+*conversion-function-id* declares a *conversion function*; its
+*declarator* shall be a function declarator [[dcl.fct]] of the form
+``` bnf
+ptr-declarator '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+   ref-qualifier-seqₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
+```
+where the *ptr-declarator* consists solely of an *id-expression*, an
+optional *attribute-specifier-seq*, and optional surrounding
+parentheses, and the *id-expression* has one of the following forms:
+- in a *member-declaration* that belongs to the *member-specification*
+  of a class or class template but is not a friend declaration
+  [[class.friend]], the *id-expression* is a *conversion-function-id*;
+- otherwise, the *id-expression* is a *qualified-id* whose
+  *unqualified-id* is a *conversion-function-id*.
+A conversion function shall have no non-object parameters and shall be a
+non-static member function of a class or class template `X`; it
 specifies a conversion from `X` to the type specified by the
+*conversion-type-id*, interpreted as a *type-id* [[dcl.name]]. A
+*decl-specifier* in the *decl-specifier-seq* of a conversion function
+(if any) shall not be a *defining-type-specifier*.
+The type of the conversion function is “`noexcept`ₒₚₜ  function taking
+no parameter *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  returning
+*conversion-type-id*”.
+A conversion function is never used to convert a (possibly cv-qualified)
+object to the (possibly cv-qualified) same object type (or a reference
+to it), to a (possibly cv-qualified) base class of that type (or a
+reference to it), or to cv `void`.[^6]
 [*Example 1*:
 ``` cpp
 struct X {
 struct Z {
   explicit operator Y() const;
 };
 void h(Z z) {
+  Y y1(z);          // OK, direct-initialization
   Y y2 = z;         // error: no conversion function candidate for copy-initialization
+  Y y3 = (Y)z;      // OK, cast notation
 }
 void g(X a, X b) {
   int i = (a) ? 1+a : 0;
   int j = (a&&b) ? a+b : i;
 — *end example*]
 — *end note*]
+[*Note 2*:
+A conversion function in a derived class hides only conversion functions
+in base classes that convert to the same type. A conversion function
+template with a dependent return type hides only templates in base
+classes that correspond to it [[class.member.lookup]]; otherwise, it
+hides and is hidden as a non-template function. Function overload
+resolution [[over.match.best]] selects the best conversion function to
+perform the conversion.
+[*Example 5*:
+``` cpp
+struct X {
+  operator int();
+};
+struct Y : X {
+    operator char();
+};
+void f(Y& a) {
+  if (a) {          // error: ambiguous between X::operator int() and Y::operator char()
+  }
+}
+```
+— *end example*]
+— *end note*]
 Conversion functions can be virtual.
 A conversion function template shall not have a deduced return type
 [[dcl.spec.auto]].
+[*Example 6*:
 ``` cpp
 struct S {
   operator auto() const { return 10; }      // OK
   template<class T>

Diff to HTML by rtfpessoa