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

Files changed (1) hide show

tmp/tmp1u0_q3lj/{from.md → to.md} +19 -27

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

@@ -12,11 +12,11 @@ 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)
 is implicitly applied to a single value.
 [*Example 1*:
@@ -39,11 +39,11 @@ int c = X(a);       // OK, a.operator X().operator int()
 #### 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 {
@@ -95,17 +95,10 @@ Z a6 = { 3, 4 };                // error: no implicit conversion
 — *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 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
@@ -124,39 +117,38 @@ 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 {
@@ -208,11 +200,11 @@ void g(X a, X b) {
 The *conversion-type-id* shall not represent a function type nor an
 array type. The *conversion-type-id* in a *conversion-function-id* is
 the longest sequence of tokens that could possibly form a
 *conversion-type-id*.
-[*Note 1*:
 This prevents ambiguities between the declarator operator `*` and its
 expression counterparts.
 [*Example 3*:
@@ -237,11 +229,11 @@ operator int [[noreturn]] ();   // error: noreturn attribute applied to a type
 — *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

 [[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. — *end note*]
 At most one user-defined conversion (constructor or conversion function)
 is implicitly applied to a single value.
 [*Example 1*:
 #### 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.
 [*Example 1*:
 ``` cpp
 struct X {
 — *end example*]
 — *end note*]
 #### Conversion functions <a id="class.conv.fct">[[class.conv.fct]]</a>
 ``` bnf
 conversion-function-id:
     operator conversion-type-id
 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
+noptr-declarator parameters-and-qualifiers
 ```
+where the *noptr-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`; its
+declared return type is the *conversion-type-id* and 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*.
+[*Note 1*: A conversion function is never invoked for implicit or
+explicit conversions of an object to the same object type (or a
+reference to it), to a base class of that type (or a reference to it),
+or to cv `void`. Even though never directly called to perform a
+conversion, such conversion functions can be declared and can
+potentially be reached through a call to a virtual conversion function
+in a base class. — *end note*]
 [*Example 1*:
 ``` cpp
 struct X {
 The *conversion-type-id* shall not represent a function type nor an
 array type. The *conversion-type-id* in a *conversion-function-id* is
 the longest sequence of tokens that could possibly form a
 *conversion-type-id*.
+[*Note 2*:
 This prevents ambiguities between the declarator operator `*` and its
 expression counterparts.
 [*Example 3*:
 — *end example*]
 — *end note*]
+[*Note 3*:
 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

Diff to HTML by rtfpessoa