[temp.arg.explicit] - C++17 → C++20

Files changed (1) hide show

tmp/tmp_3u1cuag/{from.md → to.md} +31 -63

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

@@ -1,11 +1,12 @@
 ### Explicit template argument specification <a id="temp.arg.explicit">[[temp.arg.explicit]]</a>
 Template arguments can be specified when referring to a function
-template specialization by qualifying the function template name with
-the list of *template-argument*s in the same way as *template-argument*s
-are specified in uses of a class template specialization.
 [*Example 1*:
 ``` cpp
 template<class T> void sort(Array<T>& v);
@@ -26,24 +27,28 @@ void g(double d) {
 }
 ```
 — *end example*]
 A template argument list may be specified when referring to a
 specialization of a function template
 - when a function is called,
 - when the address of a function is taken, when a function initializes a
   reference to function, or when a pointer to member function is formed,
 - in an explicit specialization,
 - in an explicit instantiation, or
 - in a friend declaration.
-Trailing template arguments that can be deduced ([[temp.deduct]]) or
 obtained from default *template-argument*s may be omitted from the list
-of explicit *template-argument*s. A trailing template parameter pack (
-[[temp.variadic]]) not otherwise deduced will be deduced to an empty
 sequence of template arguments. If all of the template arguments can be
 deduced, they may all be omitted; in this case, the empty template
 argument list `<>` itself may also be omitted. In contexts where
 deduction is done and fails, or in contexts where deduction is not done,
 if a template argument list is specified and it, along with any default
@@ -55,27 +60,27 @@ template specialization.
 ``` cpp
 template<class X, class Y> X f(Y);
 template<class X, class Y, class ... Z> X g(Y);
 void h() {
-  int i = f<int>(5.6);          // Y is deduced to be double
-  int j = f(5.6);               // ill-formed: X cannot be deduced
-  f<void>(f<int, bool>);        // Y for outer f deduced to be int (*)(bool)
-  f<void>(f<int>);              // ill-formed: f<int> does not denote a single function template specialization
-  int k = g<int>(5.6);          // Y is deduced to be double, Z is deduced to an empty sequence
-  f<void>(g<int, bool>);        // Y for outer f is deduced to be int (*)(bool),
-                                // Z is deduced to an empty sequence
 }
 ```
 — *end example*]
 [*Note 1*:
 An empty template argument list can be used to indicate that a given use
 refers to a specialization of a function template even when a
-non-template function ([[dcl.fct]]) is visible that would otherwise be
 used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
@@ -96,23 +101,23 @@ there are corresponding *template-parameter*s unless one of the
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
 template<class ... Args> void f2();
 void g() {
   f<int,const char*,double>("aa",3.0);
-  f<int,const char*>("aa",3.0); // Z is deduced to be double
-  f<int>("aa",3.0);             // Y is deduced to be const char*, and Z is deduced to be double
   f("aa",3.0);                  // error: X cannot be deduced
   f2<char, short, int, long>(); // OK
 }
 ```
 — *end example*]
-Implicit conversions (Clause  [[conv]]) will be performed on a function
-argument to convert it to the type of the corresponding function
-parameter if the parameter type contains no *template-parameter*s that
-participate in template argument deduction.
 [*Note 2*:
 Template parameters do not participate in template argument deduction if
 they are explicitly specified. For example,
@@ -130,63 +135,26 @@ void g() {
 ```
 — *end note*]
 [*Note 3*: Because the explicit template argument list follows the
-function template name, and because conversion member function templates
-and constructor member function templates are called without using a
-function name, there is no way to provide an explicit template argument
-list for these function templates. — *end note*]
-[*Note 4*:
-For simple function names, argument dependent lookup (
-[[basic.lookup.argdep]]) applies even when the function name is not
-visible within the scope of the call. This is because the call still has
-the syntactic form of a function call ([[basic.lookup.unqual]]). But
-when a function template with explicit template arguments is used, the
-call does not have the correct syntactic form unless there is a function
-template with that name visible at the point of the call. If no such
-name is visible, the call is not syntactically well-formed and
-argument-dependent lookup does not apply. If some such name is visible,
-argument dependent lookup applies and additional function templates may
-be found in other namespaces.
-[*Example 4*:
-``` cpp
-namespace A {
-  struct B { };
-  template<int X> void f(B);
-}
-namespace C {
-  template<class T> void f(T t);
-}
-void g(A::B b) {
-  f<3>(b);          // ill-formed: not a function call
-  A::f<3>(b);       // well-formed
-  C::f<3>(b);       // ill-formed; argument dependent lookup applies only to unqualified names
-  using C::f;
-  f<3>(b);          // well-formed because C::f is visible; then A::f is found by argument dependent lookup
-}
-```
-— *end example*]
-— *end note*]
 Template argument deduction can extend the sequence of template
 arguments corresponding to a template parameter pack, even when the
 sequence contains explicitly specified template arguments.
-[*Example 5*:
 ``` cpp
 template<class ... Types> void f(Types ... values);
 void g() {
-  f<int*, float*>(0, 0, 0);     // Types is deduced to the sequence int*, float*, int
 }
 ```
 — *end example*]

 ### Explicit template argument specification <a id="temp.arg.explicit">[[temp.arg.explicit]]</a>
 Template arguments can be specified when referring to a function
+template specialization that is not a specialization of a constructor
+template by qualifying the function template name with the list of
+*template-argument*s in the same way as *template-argument*s are
+specified in uses of a class template specialization.
 [*Example 1*:
 ``` cpp
 template<class T> void sort(Array<T>& v);
 }
 ```
 — *end example*]
+Template arguments shall not be specified when referring to a
+specialization of a constructor template ([[class.ctor]],
+[[class.qual]]).
 A template argument list may be specified when referring to a
 specialization of a function template
 - when a function is called,
 - when the address of a function is taken, when a function initializes a
   reference to function, or when a pointer to member function is formed,
 - in an explicit specialization,
 - in an explicit instantiation, or
 - in a friend declaration.
+Trailing template arguments that can be deduced [[temp.deduct]] or
 obtained from default *template-argument*s may be omitted from the list
+of explicit *template-argument*s. A trailing template parameter pack
+[[temp.variadic]] not otherwise deduced will be deduced as an empty
 sequence of template arguments. If all of the template arguments can be
 deduced, they may all be omitted; in this case, the empty template
 argument list `<>` itself may also be omitted. In contexts where
 deduction is done and fails, or in contexts where deduction is not done,
 if a template argument list is specified and it, along with any default
 ``` cpp
 template<class X, class Y> X f(Y);
 template<class X, class Y, class ... Z> X g(Y);
 void h() {
+  int i = f<int>(5.6);          // Y deduced as double
+  int j = f(5.6);               // error: X cannot be deduced
+  f<void>(f<int, bool>);        // Y for outer f deduced as int (*)(bool)
+  f<void>(f<int>);              // error: f<int> does not denote a single function template specialization
+  int k = g<int>(5.6);          // Y deduced as double; Z deduced as an empty sequence
+  f<void>(g<int, bool>);        // Y for outer f deduced as int (*)(bool),
+                                // Z deduced as an empty sequence
 }
 ```
 — *end example*]
 [*Note 1*:
 An empty template argument list can be used to indicate that a given use
 refers to a specialization of a function template even when a
+non-template function [[dcl.fct]] is visible that would otherwise be
 used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 ``` cpp
 template<class X, class Y, class Z> X f(Y,Z);
 template<class ... Args> void f2();
 void g() {
   f<int,const char*,double>("aa",3.0);
+  f<int,const char*>("aa",3.0); // Z deduced as double
+  f<int>("aa",3.0);             // Y deduced as const char*; Z deduced as double
   f("aa",3.0);                  // error: X cannot be deduced
   f2<char, short, int, long>(); // OK
 }
 ```
 — *end example*]
+Implicit conversions [[conv]] will be performed on a function argument
+to convert it to the type of the corresponding function parameter if the
+parameter type contains no *template-parameter*s that participate in
+template argument deduction.
 [*Note 2*:
 Template parameters do not participate in template argument deduction if
 they are explicitly specified. For example,
 ```
 — *end note*]
 [*Note 3*: Because the explicit template argument list follows the
+function template name, and because constructor templates [[class.ctor]]
+are named without using a function name [[class.qual]], there is no way
+to provide an explicit template argument list for these function
+templates. — *end note*]
 Template argument deduction can extend the sequence of template
 arguments corresponding to a template parameter pack, even when the
 sequence contains explicitly specified template arguments.
+[*Example 4*:
 ``` cpp
 template<class ... Types> void f(Types ... values);
 void g() {
+  f<int*, float*>(0, 0, 0);     // Types deduced as the sequence int*, float*, int
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa