0

I am unable to understand the difference between

  1. Passing pointers as function arguments
  2. Passing pointers as non type template parameter

Can you please help understand what optimization is achieved by choosing 2 (Particularly from the context of fast delegates as explained here and as used here)?

Some of my confusions surrounding the use of pointers as non type parameters are

  1. When pointers are resolved at compile time how does the compiler know what the pointer is pointing to?
  2. How is a member function pointer resolved at compile time when member functions can be virtual?
Nicol Bolas
  • 449,505
  • 63
  • 781
  • 982
Discretizer
  • 53
  • 1
  • 8

1 Answers1

2

When pointers are resolved at compile time how does the compiler know what the pointer is pointing to?

Because that's how templates work. For all of their complexity, the basic idea of a template is very simple.

A template is a (smart) macro. When you instantiate a template, you are basically creating a copy of the template, where every use of the template parameters is replaced by the corresponding arguments passed at instantiation-time.

So this:

template<func_ptr ptr>
void func1();
{
  ptr();
}

func1<some_func>();

Is functionally equivalent to this:

void func2()
{
  some_func();
}

func2();

How does the compiler know that func2 will call some_func? Because that's literally what you wrote in the code. How does the compiler know that func1<some_func> will call some_func? Because that's literally what you wrote in the code when you named it func1<some_func>.

How is a member function pointer resolved at compile time when member functions can be virtual?

That all depends on what you mean by "resolved".

Assuming that the class the function is invoking the member pointer on is not final (you can't inherit from a final class, so the compiler knows exactly which function to call), the compiler cannot determine exactly which override will be called.

However, the compiler does know where that override is. Assuming we're talking about a vtable-based implementation of virtual functions, a member pointer contain an index into the vtable that the compiler would use to find the actual override function. But if the member pointer is known at compile time, that means the index is also known at compile-time. So the compiler need not dynamically index into the table; it can statically index it.

So in a way, it can be considered to have "resolved" the override at compile time. At least, to the extent possible.

Nicol Bolas
  • 449,505
  • 63
  • 781
  • 982
  • Thanks for the reply. I was doing a bit more research and found the following https://en.cppreference.com/w/cpp/language/template_parameters A template parameter object shall have constant destruction. https://stackoverflow.com/questions/5687540/non-type-template-parameters The variable whose pointer is passed in must have external linkage. So do function pointers have external linkage too in every scope? – Discretizer Jun 10 '21 at 04:02
  • @Discretizer: Functions are not objects, so function pointers don't point to variables. – Nicol Bolas Jun 10 '21 at 04:03
  • In your function example is there a difference between pass the function pointer as argument vs template parameter? There seems to be no optimization unless the function gets inlined in some way. – Discretizer Jun 10 '21 at 04:07
  • @Discretizer: Linkage hasn’t been a template argument requirement since C++17. – Davis Herring Jun 10 '21 at 04:42
  • @DavisHerring: I tried this code https://wandbox.org/permlink/lye49MDyPXAZWJ6i It gives me an error while compiling with C++20. The error goes away if I make the s static or declare it in the global scope as demonstrated here. https://stackoverflow.com/questions/5687540/non-type-template-parameters – Discretizer Jun 10 '21 at 04:53
  • 1
    @Discretizer: Making a local variable `static` doesn’t give it linkage, but it does give it static **storage duration**, which *is* required. – Davis Herring Jun 10 '21 at 06:05