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

Files changed (1) hide show

tmp/tmpe4325s5r/{from.md → to.md} +29 -31

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

@@ -1,17 +1,17 @@
-## 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 (Clause
-[[conv]]), for initialization ([[dcl.init]]), and for explicit type
-conversions ([[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 (Clause  [[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*]
 At most one user-defined conversion (constructor or conversion function)
@@ -27,21 +27,21 @@ struct X {
 struct Y {
   operator X();
 };
 Y a;
-int b = a;          // error, a.operator X().operator int() not tried
 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 {
@@ -51,23 +51,22 @@ struct X {
 struct Y : X {
     operator char();
 };
 void f(Y& a) {
-  if (a) {          // ill-formed: X::operator int() or Y::operator char()
   }
 }
 ```
 — *end example*]
-### Conversion by constructor <a id="class.conv.ctor">[[class.conv.ctor]]</a>
-A constructor declared without the *function-specifier* `explicit`
-specifies a conversion from the types of its parameters (if any) to the
-type of its class. Such a constructor is called a *converting
-constructor*.
 [*Example 1*:
 ``` cpp
 struct X {
@@ -88,15 +87,15 @@ void f(X arg) {
 — *end example*]
 [*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
 struct Z {
@@ -119,25 +118,25 @@ Z a6 = { 3, 4 };                // error: no implicit conversion
 — *end example*]
 — *end note*]
-A non-explicit copy/move constructor ([[class.copy]]) 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
 ```
 ``` bnf
 conversion-type-id:
     type-specifier-seq conversion-declaratorₒₚₜ
@@ -150,16 +149,16 @@ 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
-(possibly cv-qualified) void.[^2]
 [*Example 1*:
 ``` cpp
 struct X {
@@ -177,15 +176,14 @@ void f(X a) {
 In all three cases the value assigned will be converted by
 `X::operator int()`.
 — *end example*]
-A conversion function may be explicit ([[dcl.fct.spec]]), in which case
-it is only considered as a user-defined conversion for
-direct-initialization ([[dcl.init]]). Otherwise, user-defined
-conversions are not restricted to use in assignments and
-initializations.
 [*Example 2*:
 ``` cpp
 class Y { };
@@ -193,11 +191,11 @@ struct Z {
   explicit operator Y() const;
 };
 void h(Z z) {
   Y y1(z);          // OK: direct-initialization
-  Y y2 = z;         // ill-formed: copy-initialization
   Y y3 = (Y)z;      // OK: cast notation
 }
 void g(X a, X b) {
   int i = (a) ? 1+a : 0;
@@ -245,12 +243,12 @@ operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
 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 {

+### 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*]
 At most one user-defined conversion (constructor or conversion function)
 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 {
 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>
+A constructor that is not explicit [[dcl.fct.spec]] specifies a
+conversion from the types of its parameters (if any) to the type of its
+class. Such a constructor is called a *converting constructor*.
 [*Example 1*:
 ``` cpp
 struct X {
 — *end example*]
 [*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
 struct Z {
 — *end example*]
 — *end note*]
+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
 ```
 ``` bnf
 conversion-type-id:
     type-specifier-seq 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 {
 In all three cases the value assigned will be converted by
 `X::operator int()`.
 — *end example*]
+A conversion function may be explicit [[dcl.fct.spec]], in which case it
+is only considered as a user-defined conversion for
+direct-initialization [[dcl.init]]. Otherwise, user-defined conversions
+are not restricted to use in assignments and initializations.
 [*Example 2*:
 ``` cpp
 class Y { };
   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;
 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 {

Diff to HTML by rtfpessoa