[over.best.ics.general] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp182nnt98/{from.md → to.md} +23 -23

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

@@ -9,17 +9,17 @@ single expression [[dcl.init]], [[dcl.init.ref]].
 Implicit conversion sequences are concerned only with the type,
 cv-qualification, and value category of the argument and how these are
 converted to match the corresponding properties of the parameter.
-[*Note 1*: Other properties, such as the lifetime, storage class,
-alignment, accessibility of the argument, whether the argument is a
-bit-field, and whether a function is deleted [[dcl.fct.def.delete]], are
-ignored. So, although an implicit conversion sequence can be defined for
-a given argument-parameter pair, the conversion from the argument to the
-parameter might still be ill-formed in the final
-analysis. — *end note*]
 A well-formed implicit conversion sequence is one of the following
 forms:
 - a standard conversion sequence [[over.ics.scs]],
@@ -76,40 +76,40 @@ parameter.
 [*Note 3*: When the parameter has a class type, this is a conceptual
 conversion defined for the purposes of [[over]]; the actual
 initialization is defined in terms of constructors and is not a
 conversion. — *end note*]
-Any difference in top-level cv-qualification is subsumed by the
-initialization itself and does not constitute a conversion.
-[*Example 2*: A parameter of type `A` can be initialized from an
-argument of type `const A`. The implicit conversion sequence for that
-case is the identity sequence; it contains no “conversion” from
-`const A` to `A`. — *end example*]
-When the parameter has a class type and the argument expression has the
-same type, the implicit conversion sequence is an identity conversion.
-When the parameter has a class type and the argument expression has a
-derived class type, the implicit conversion sequence is a
-derived-to-base conversion from the derived class to the base class. A
-derived-to-base conversion has Conversion rank [[over.ics.scs]].
 [*Note 4*: There is no such standard conversion; this derived-to-base
 conversion exists only in the description of implicit conversion
 sequences. — *end note*]
 When the parameter is the implicit object parameter of a static member
 function, the implicit conversion sequence is a standard conversion
 sequence that is neither better nor worse than any other standard
 conversion sequence.
 In all contexts, when converting to the implicit object parameter or
 when converting to the left operand of an assignment operation only
 standard conversion sequences are allowed.
-[*Note 5*: When converting to the explicit object parameter, if any,
-user-defined conversion sequences are allowed. — *end note*]
 If no conversions are required to match an argument to a parameter type,
 the implicit conversion sequence is the standard conversion sequence
 consisting of the identity conversion [[over.ics.scs]].

 Implicit conversion sequences are concerned only with the type,
 cv-qualification, and value category of the argument and how these are
 converted to match the corresponding properties of the parameter.
+[*Note 1*: Other properties, such as the lifetime, storage duration,
+linkage, alignment, accessibility of the argument, whether the argument
+is a bit-field, and whether a function is deleted
+[[dcl.fct.def.delete]], are ignored. So, although an implicit conversion
+sequence can be defined for a given argument-parameter pair, the
+conversion from the argument to the parameter might still be ill-formed
+in the final analysis. — *end note*]
 A well-formed implicit conversion sequence is one of the following
 forms:
 - a standard conversion sequence [[over.ics.scs]],
 [*Note 3*: When the parameter has a class type, this is a conceptual
 conversion defined for the purposes of [[over]]; the actual
 initialization is defined in terms of constructors and is not a
 conversion. — *end note*]
+When the cv-unqualified version of the type of the argument expression
+is the same as the parameter type, the implicit conversion sequence is
+an identity conversion. When the parameter has a class type and the
+argument expression has a (possibly cv-qualified) derived class type,
+the implicit conversion sequence is a derived-to-base conversion from
+the derived class to the base class. A derived-to-base conversion has
+Conversion rank [[over.ics.scs]].
 [*Note 4*: There is no such standard conversion; this derived-to-base
 conversion exists only in the description of implicit conversion
 sequences. — *end note*]
+[*Example 2*: An implicit conversion sequence from an argument of type
+`const A` to a parameter of type `A` can be formed, even if overload
+resolution for copy-initialization of `A` from the argument would not
+find a viable function [[over.match.ctor]], [[over.match.viable]]. The
+implicit conversion sequence for that case is the identity sequence; it
+contains no “conversion” from `const A` to `A`. — *end example*]
 When the parameter is the implicit object parameter of a static member
 function, the implicit conversion sequence is a standard conversion
 sequence that is neither better nor worse than any other standard
 conversion sequence.
 In all contexts, when converting to the implicit object parameter or
 when converting to the left operand of an assignment operation only
 standard conversion sequences are allowed.
+[*Note 5*: When a conversion to the explicit object parameter occurs,
+it can include user-defined conversion sequences. — *end note*]
 If no conversions are required to match an argument to a parameter type,
 the implicit conversion sequence is the standard conversion sequence
 consisting of the identity conversion [[over.ics.scs]].

Diff to HTML by rtfpessoa