Hi, Peter.  In my  first example, the corresponding declarator-id is <...args>, So the P is  T,  however I my second example,  there's no declarator-id here, only abstract-declarator-id that denote <...>, but the rule says that the type of declarator-id is P. so what is the P of T... in the second example

<std-discussion-request@lists.isocpp.org> 于 2020年7月16日周四 下午11:34写道:
Send Std-Discussion mailing list submissions to
        std-discussion@lists.isocpp.org

To subscribe or unsubscribe via the World Wide Web, visit
        https://lists.isocpp.org/mailman/listinfo.cgi/std-discussion
or, via email, send a message with subject or body 'help' to
        std-discussion-request@lists.isocpp.org

You can reach the person managing the list at
        std-discussion-owner@lists.isocpp.org

When replying, please edit your Subject line so it is more specific
than "Re: Contents of Std-Discussion digest..."


Today's Topics:

   1. Any progress with P0537? How to proceed? (Deniz Bahadir)
   2. It seems to a wording defect about template argument
      deduction for function parameter pack (jim x)
   3. The standard does not specify when to supply default
      arguments as template arguments (jim x)
   4. Re: It seems to a wording defect about template argument
      deduction for function parameter pack (Peter Sommerlad (C++))
   5. Re: The standard does not specify when to supply default
      arguments as template arguments (Peter Sommerlad (C++))


----------------------------------------------------------------------

Message: 1
Date: Thu, 16 Jul 2020 12:06:16 +0200
From: Deniz Bahadir <deniz.bahadir@benocs.com>
To: std-discussion@lists.isocpp.org
Subject: [std-discussion] Any progress with P0537? How to proceed?
Message-ID: <e6aa8508-9f5f-9510-115d-6bbd2729e96f@benocs.com>
Content-Type: text/plain; charset=utf-8; format=flowed

Hello everyone,

I was lately playing around with symbol visibility and C++ attributes in
Clang and I stumbled over a problem that was described by Matthew
Woehlke in his proposal paper P0537 ("Allow Attributes on Template
Explicit Instantiations").

Clang currently does not allow C++ attributes at explicit template
instantiations [1], because the C++ standard explicitly says that it
would be illegal.
However, it would be needed if one wants to make such an explicitly
instantiated type visible from outside the shared library it is compiled
in (using C++ attribute syntax).

E.g., the following is not supported by Clang:

```
template <typename T>
T foo(T) { return 0; }

template [[gnu::visibility("default")]]
int foo<int>(int);
```

However, using the compiler-specific syntax is accepted by Clang:

```
template <typename T>
T foo(T) { return 0; }

template __attribute__((gnu::visibility("default")))
int foo<int>(int);
```

By the way, GCC accepts both.

In the associated Clang bug-ticket [1] Matthew mentions his proposal
P0537 [2] and the result of the EWG poll from 2017 Kona committee
meeting [3].

There seemed to be consensus that P0537 points out a C++ defect and that
all compilers should support C++ attributes at explicit template
instantiations (as does GCC).

However, I was unable to find this mentioned in any C++ defect report.
In fact, the problematic sentence is still in the latest draft for
C++20. And Clang still does not support it with the upcoming Clang 11.


Does anyone know what is missing to get this into the list of C++
defects or to remove the problematic sentence from the C++ standard
entirely? (Who has to proceed how?)


Thanks for your insights,
Deniz Bahadir


[1] https://bugs.llvm.org/show_bug.cgi?id=29094
[2] https://wg21.link/p0537
[3] https://bugs.llvm.org/show_bug.cgi?id=29094#c5


--
BENOCS GmbH
Dipl.-Inform. Deniz Bahadir
Reuchlinstr. 10 D
10553 Berlin
Germany
Phone: +49 - 30 / 577 0004-22
Email: deniz.bahadir@benocs.com
www.benocs.com

Board of Management: Stephan Schr?der, Dr.-Ing. Ingmar Poese
Commercial Register: Amtsgericht Bonn HRB 19378


------------------------------

Message: 2
Date: Thu, 16 Jul 2020 22:28:34 +0800
From: jim x <xmh970252187@gmail.com>
To: std-discussion@lists.isocpp.org
Subject: [std-discussion] It seems to a wording defect about template
        argument deduction for function parameter pack
Message-ID:
        <CAANczrd3Q=2WpWcinWDUck41vXPn0vH6ThK0wJgH5q__MKv9_g@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

Consider the below code:

template<typename...T>
void func(T...args){
}
int main(){
  func(1,2.0,'c');
}

 there's a rule that applied to it to deduce these template arguments for
this function template (call). It is:
>For a function parameter pack that occurs at the end of the
parameter-declaration-list, deduction is performed for each remaining
argument of the call, taking the type P of the declarator-id of the
function parameter pack as the corresponding function template parameter
type. Each deduction deduces template arguments for subsequent positions in
the template parameter packs expanded by the function parameter pack.

That means for the parameter-declaration T...args, it declares a function
template park, hence the function parameter type that is used to against
the type of function argument is T because ...args is the declarator-id of
this declaration. So, for this function call func(1,2.0,'c'), template
parameter pack T would be the set consists of {int,double,char}.

However, consider the following variant:

template<typename...T>
void func(T...){
}
int main(){
  func(1,2.0,'c');
}

There's no declarator-id here, just an abstract-declarator that denote the
..., How would the quote be applied to this case? What's the corresponding
function parameter type here?  It seems to be a wording defect for this
case.
-------------- next part --------------
HTML attachment scrubbed and removed

------------------------------

Message: 3
Date: Thu, 16 Jul 2020 22:36:34 +0800
From: jim x <xmh970252187@gmail.com>
To: std-discussion@lists.isocpp.org
Subject: [std-discussion] The standard does not specify when to supply
        default arguments as template arguments
Message-ID:
        <CAANczreSLdJ_E4ZQmQweNAwZP3wsdCBsy=xiFxGaPpE3x9dokQ@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

template<typename T, typename U = T>
struct Test{};

template<typename T>
void func(Test<T> /*#1*/){
}

Consider the above code, at the point of #1, Does the template-id Test<T>
require a template argument for corresponding template parameter U? The
only quote that mentioned default argument  in the standard is the
following :

>When a simple-template-id does not name a function, a default
template->argument is **implicitly instantiated** when the value of that
default argument >is needed. [ Example:
>template<typename T, typename U = int> struct S { };
>S* p; // the type of p is S<bool, int>*
>The default argument for U is instantiated to form the type S<bool, int>*.
>? end example ]

However at the point of #1, The specialization of Test<T> is just a part of
a function template definition, that is, there's no instantiation occuring
here. So, the above quote seems to be not suitable for this case.

In the standard, there's a quote explicitly specified when to supply
default arguments as arguments for function call, that is:

> If an initializer-clause is specified in a parameter-declaration this
initializer-clause is used as a default argument. Default arguments will be
used in calls where trailing arguments are missing.

So, Is it necessary to formulate a formally terminology to cover this case?
such as

>A default template-argument is a template-argument ([temp.arg]) specified
after = in a template-parameter. Default arguments will be used in
template-id where trailing arguments are missing and the corresponding
template parameter does not participate in template argument deduction.
-------------- next part --------------
HTML attachment scrubbed and removed

------------------------------

Message: 4
Date: Thu, 16 Jul 2020 17:19:00 +0200
From: "Peter Sommerlad (C++)" <peter.cpp@sommerlad.ch>
To: jim x via Std-Discussion <std-discussion@lists.isocpp.org>
Subject: Re: [std-discussion] It seems to a wording defect about
        template argument deduction for function parameter pack
Message-ID: <5db0c956-414c-04d3-479f-cb5d1473c3ff@sommerlad.ch>
Content-Type: text/plain; charset=utf-8; format=flowed

Jim

jim x via Std-Discussion wrote on 16.07.20 16:28:
> Consider the below code:
>
> template<typename...T>
> void func(T...args){
> }
> int main(){
>  ? func(1,2.0,'c');
> }
>
>  ?there's a rule that applied to it to deduce these template arguments
> for this function template (call). It is:
>  >For a function parameter pack that occurs at the end of the
> parameter-declaration-list, deduction is performed for each remaining
> argument of the call, taking the type P of the declarator-id of the
> function parameter pack as the corresponding function template parameter
> type. Each deduction deduces template arguments for subsequent positions
> in the template parameter packs expanded by the function parameter pack.
>
> That means for the parameter-declaration T...args, it declares a
> function template park, hence the function parameter type that is used
> to against the type of function argument is T because ...args is the
> declarator-id of this declaration. So, for this function call
> func(1,2.0,'c'), template parameter pack T would be the set consists of
> {int,double,char}.
>
> However, consider the following variant:
>
> template<typename...T>
> void func(T...){
> }
> int main(){
>  ? func(1,2.0,'c');
> }
>
> There's no declarator-id here, just an abstract-declarator that denote
> the ..., How would the quote be applied to this case? What's the
> corresponding function parameter type here?? It seems to be a wording
> defect for this case.
>
>

What you are asking here corresponds to the situation where in a
function definition you omit names for parameters that are unused int
the function. So there is exactly the same thing happening as in your
first example.

Peter.



--
Peter Sommerlad

Better Software: Consulting, Training, Reviews
Modern, Safe & Agile C++

peter.cpp@sommerlad.ch
+41 79 432 23 32


------------------------------

Message: 5
Date: Thu, 16 Jul 2020 17:33:52 +0200
From: "Peter Sommerlad (C++)" <peter.cpp@sommerlad.ch>
To: jim x via Std-Discussion <std-discussion@lists.isocpp.org>
Subject: Re: [std-discussion] The standard does not specify when to
        supply default arguments as template arguments
Message-ID: <469da6d1-025a-28d4-2422-1df1f5b8f3e8@sommerlad.ch>
Content-Type: text/plain; charset=utf-8; format=flowed

Jim,

since func is also a template, the instantiation happens when func is
instantiated, e.g., when it is called. A dependent template is
instantiated when the surrounding template gets instantiated. That is
the reason for the sometimes confusing C++ error messages when a nested
inner template instantiation fails, due to a missing requirement of the
arguments passed down, or a programming error.

Regards
Peter.

jim x via Std-Discussion wrote on 16.07.20 16:36:
> template<typename T, typename U = T>
> struct Test{};
>
> template<typename T>
> void func(Test<T> /*#1*/){
> }
>
> Consider the above code, at the point of #1, Does the template-id
> Test<T> require a template argument for corresponding template parameter
> U? The only quote that mentioned default argument? in the standard is
> the following :
>
>  >When a simple-template-id does not name a function, a default
> template->argument is **implicitly instantiated** when the value of that
> default argument >is needed. [?Example:
>  >template<typename T, typename U = int> struct S { };
>  >S* p; // the type of p is S<bool, int>*
>  >The default argument for U is instantiated to form the type S<bool,
> int>*. ?>??end example?]
>
> However at the point of #1, The specialization of Test<T> is just a part
> of a function template definition, that is, there's no instantiation
> occuring here. So, the above quote seems to be not suitable for this case.
>
> In the standard, there's a quote explicitly specified when to supply
> default arguments as arguments for function call, that is:
>
>  > If an initializer-clause is specified in a parameter-declaration this
> initializer-clause is used as a default argument. Default arguments will
> be used in calls where trailing arguments are missing.
>
> So, Is it necessary to formulate a formally terminology to cover this
> case? such as
>
>  >A default template-argument is a template-argument ([temp.arg])
> specified after = in a template-parameter. Default arguments will be
> used in template-id where trailing arguments are missing and the
> corresponding template parameter does not participate in template
> argument deduction.
>
>


--
Peter Sommerlad

Better Software: Consulting, Training, Reviews
Modern, Safe & Agile C++

peter.cpp@sommerlad.ch
+41 79 432 23 32


------------------------------

Subject: Digest Footer

Std-Discussion mailing list
Std-Discussion@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-discussion


------------------------------

End of Std-Discussion Digest, Vol 16, Issue 23
**********************************************