C++ Logo

std-proposals

Advanced search

Re: [std-proposals] template params of a function template

From: Lénárd Szolnoki <cpp_at_[hidden]>
Date: Wed, 10 Jul 2024 20:06:21 +0100
On 10/07/2024 18:54, Tiago Freire via Std-Proposals wrote:
> I’m going to be honest, haven’t looked at this in that close of a detail.
>
> But here is something that standout quite obviously.
>
> Addresses of functions are not constant expressions, and template
> arguments are required to be a constant expression known at compile time

Addresses of functions are constant expressions.

>
> There’s no guarantee that the addresses of different functions are
> distinct,

It is in fact guaranteed, although AFAIK there are non-conforming
implementations.

> or have a certain order, that they exist at all, and in
> certain case they might not even be known until runtime.
>
> So, I have absolutely no idea how you would envision this to work.
>
> *From:*Std-Proposals <std-proposals-bounces_at_[hidden]> *On Behalf
> Of *organicoman via Std-Proposals
> *Sent:* Wednesday, July 10, 2024 19:39
> *To:* Andrey Semashev via Std-Proposals <std-proposals_at_[hidden]>
> *Cc:* organicoman <organicoman_at_[hidden]>
> *Subject:* Re: [std-proposals] template params of a function template
>
> >> template<void(*)(int)>
>
> >> struct A { // impl };
>
> >You can't. A function pointer points to a >function. You can't have a
>
> >pointer to a function template. So, at the >point when A is instantiated,
>
> >the function pointer must be either null or >point to a function, whether
>
> >it was generated as a result of a function >template instantiation or was
>
> >never a template to begin with.
>
> Yet a function pointer is compile time constant, that means we can
> examine its properties at compile time. And the template arguments are
> among these properties.
>
> This is related to type erasure.
>
> I think the compiler should allow a way to access the template arguments
> of a function pointer.
>
> Because when we pass a function pointer generated from a function
> template usually we do
>
> A<foo<T1,T2>> a;
>
> Which is mandatory to avoid overload ambiguity.
>
> And at this point, we see clearly the template arguments, and i don't
> see why the compiler can't see them!
>
> Sent from my Galaxy
>
>

Received on 2024-07-10 19:06:24