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.

There’s no guarantee that the addresses of different functions are distinct, 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@lists.isocpp.org> On Behalf Of organicoman via Std-Proposals
Sent: Wednesday, July 10, 2024 19:39
To: Andrey Semashev via Std-Proposals <std-proposals@lists.isocpp.org>
Cc: organicoman <organicoman@yahoo.fr>
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