Thread: template function instantiation

Thanks Elysia,


Sorry I do not agree your below quoted text. I have made a program to make the discussion clear. For example, in the following code,

1. I think f is instantised when we define function g, and T is int, deduced by the definition of g;
2. You think it is f (100) inside main which instantise function f with parameter type t to int.

Code:

#include <iostream>

using namespace std;

template <class T> void f(T a) {g (a);}

void g (int a)
{
	cout << a << endl;
}

int main()
{	
	f (100);
	return 0;
}

Do I correctly describe both mine and yours ideas?

If yes, please read the words from Bjarne, section C.13.8.3 Point of Instantiation Binding

Code:

template class <T> void f (T a) { g(a); }
void g (int);
void h()
{
    extern g (double);
    f (2);
}

Bjarne said, the point of instantiation for f<int> is just before h(), so the g() called in f() is the global g(int) rather than the local g (double).

Seems your points conflict with Bjarne's? :-)

Any comments?

Originally Posted by Elysia

If you listen, you'll know that the compiler will not deduce a template type depending on the contents of the function itself.

regards,
George

Hi CornedBee,


I do not quite agree with you since your points conflict with Bjarne's points?

For the following code he provided, he mentioned,

--------------------
the point of instantiation for f<int>() is just before h(), so the g() called in f() is the global g (int) rather than the local g (double).
--------------------

I think Bjarne mean the declaration of g(int) will instantise f to f <int> just before h() (I think it is called instantise a template function by its content deduction?). But your below quoted comments is, declaration of g(int) never instantising f to f<int>?

If you think Bjarne is wrong, how do you prove it? Could you provide some pseudo code please?

Code:

// section C.13.8.3 Point of Instantiatant Binding

template <class T> void f (T a) { g(a); }

void g(int);

void h()
{
	extern g (double);
	f (2);
}

Originally Posted by CornedBee

This is wrong. g's definition does not even acknowledge the existence of f, so why would it cause its instantiation?

regards,
George

Hi CornedBee,


If function f is instantised inside h, when we call f(2), Bjarne should say it is instantised after h(), but he said actually "the point of instantiation for f<int>() is just before h()". Please notice the word "before". It is conflicting with your point of instantiation inside h point.

However, I do not say you are incorrect. I am also confused currently. Could you prove it is not g(int) before h(), but f(2) inside h() instantise f to f<int> pleae (with some pseudo code)?

Originally Posted by CornedBee

Bjarne's not wrong; your interpretation of what he said is. You somehow got the notion that it's g's declaration that instantiates f, which is nonsense. It's the call to f in h that instantiates f.

regards,
George

Thanks CornedBee,

Originally Posted by CornedBee

You misunderstand what "point of instantiation" means. The PoI isn't the point of code that causes instantiation of the function. The PoI is where, conceptually, the generated code is placed.

Your description is clear. Question answered.


regards,
George