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

Files changed (1) hide show

tmp/tmphtx6447q/{from.md → to.md} +92 -25

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

@@ -9,58 +9,67 @@ 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]]).
-See  [[over.match]] for a discussion of the use of conversions in
-function calls as well as examples below.
 At most one user-defined conversion (constructor or conversion function)
 is implicitly applied to a single value.
 ``` cpp
 struct X {
   operator int();
 };
 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()
 ```
 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.
 ``` cpp
 struct X {
   operator int();
 };
 struct Y : X {
     operator char();
 };
 void f(Y& a) {
-  if (a) {          // ill-formed:
-                    // X::operator int() or Y::operator char()
   }
 }
 ```
 ### 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 to the type of
-its class. Such a constructor is called a *converting constructor*.
 ``` cpp
 struct X {
     X(int);
     X(const char*, int =0);
@@ -74,37 +83,52 @@ void f(X arg) {
   f(3);             // f(X(3))
   f({1, 2});        // f(X(1,2))
 }
 ```
 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. A default constructor may be an explicit constructor;
-such a constructor will be used to perform default-initialization or
-value-initialization ([[dcl.init]]).
 ``` cpp
 struct Z {
   explicit Z();
   explicit Z(int);
   explicit Z(int, int);
 };
 Z a;                            // OK: default-initialization performed
 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
 ```
 A non-explicit copy/move constructor ([[class.copy]]) is a converting
-constructor. An implicitly-declared copy/move constructor is not an
-explicit constructor; it may be called for implicit type conversions.
 ### 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
@@ -123,22 +147,26 @@ conversion-type-id:
 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. No
-return type can be specified. If a conversion function is a member
-function, 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]
 ``` cpp
 struct X {
   operator int();
 };
 void f(X a) {
   int i = int(a);
   i = (int)a;
@@ -147,16 +175,20 @@ void f(X a) {
 ```
 In all three cases the value assigned will be converted by
 `X::operator int()`.
 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.
 ``` cpp
 class Y { };
 struct Z {
   explicit operator Y() const;
 };
@@ -173,25 +205,60 @@ void g(X a, X b) {
   if (a) {
   }
 }
 ```
 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 possible sequence of *conversion-declarator*s. This prevents
-ambiguities between the declarator operator \* and its expression
-counterparts.
 ``` cpp
 &ac.operator int*i; // syntax error:
                     // parsed as: &(ac.operator int *)i
                     // not as: &(ac.operator int)*i
 ```
 The `*` is the pointer declarator and not the multiplication operator.
 Conversion functions are inherited.
 Conversion functions can be virtual.
-Conversion functions cannot be declared `static`.

 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)
 is implicitly applied to a single value.
+[*Example 1*:
 ``` cpp
 struct X {
   operator int();
 };
 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 {
   operator int();
 };
 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 {
     X(int);
     X(const char*, int =0);
   f(3);             // f(X(3))
   f({1, 2});        // f(X(1,2))
 }
 ```
+— *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 {
   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*]
+— *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
 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
+(possibly cv-qualified) void.[^2]
+[*Example 1*:
 ``` cpp
 struct X {
   operator int();
+  operator auto() -> short;     // error: trailing return type
 };
 void f(X a) {
   int i = int(a);
   i = (int)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 { };
 struct Z {
   explicit operator Y() const;
 };
   if (a) {
   }
 }
 ```
+— *end example*]
 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*:
 ``` cpp
 &ac.operator int*i; // syntax error:
                     // parsed as: &(ac.operator int *)i
                     // not as: &(ac.operator int)*i
 ```
 The `*` is the pointer declarator and not the multiplication operator.
+— *end example*]
+This rule also prevents ambiguities for attributes.
+[*Example 4*:
+``` cpp
+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>
+  operator auto() const { return 1.2; }     // error: conversion function template
+};
+```
+— *end example*]

Diff to HTML by rtfpessoa