explicit template instantation

[sasanet]

hy, tnx for reading.
please tell me why my explicit instantation won't work

#include <iostream>
using namespace std;

template <class rtype, class elem>   // template definition
rtype func (elem* x) {
	return x [0];
}

template double func<double, float>(float*);  // explicit instantation

int main () {

	float arr [100];
	arr [0] = 49;
	double c = func (arr); //error
	return 0;
}

if I put this code on line 15:
double c = func<double, float> (arr); // now works
then there is no point of using explicit instantaion wright?

how to use this corectly?

[moorecm]

This looks tricky, so forgive me if this isn't all that helpful. I'm just going to "think out-loud" a bit.

First, I don't think line 15 would be able to implicitly determine the return type of func. Sure, you assign it to a double, but I think func would execute without that context. Similar to how you got it to work, see if specifying the return type helps:
double c = func<double> (arr); // try me

Second, assuming that doesn't work, an array of float and a float pointer are not the same thing (in some contexts they are but I'm not sure about this one). You could try casting arr to a float pointer on line 15 to see if this is the problem. If that works, consider using a dynamic array, or changing the signature to accept a float[]. I bet it's not a mater of explicit instantiation, it's a matter of no match for that formal parameter elem pointer.

Hope this helps.

[sasanet]

you say:

First, I don't think line 15 would be able to implicitly determine the return type of func. Sure, you assign it to a double, but I think func would execute without that context. Similar to how you got it to work, see if specifying the return type helps:
double c = func<double> (arr); // try me

yes specifing return type only, solves the problem but I wanna know what is the purpose of explicit instantation then ??

why function can't execute if I allready have specified return type in explicit instantation, why do I need to do that again every time I call this function?

explicit inst. shall do that for all function call in this file wright??

[jsmith]

explicit inst. shall do that for all function call in this file wright??

No. What if you had two explicit instantiations which differed only by return type?

I think you are misunderstanding the purpose of explicit instantiations. Explicit instantiations are useful when you want to put the body of a template function (or member function of template class) inside its own translation unit (cpp file). The problem is that without knowing the actual types of the template parameters, the compiler can't generate any code for that cpp file since it does not know how the functions will be called (ie, it doesn't know the actual types) from other .cpp files.

To get around that, one of two workarounds is usually chosen. Either you put the body of the template function inside the header file so that at the callpoint of said function the compiler can then implicitly instantiate the template function (read: actually compile it to executable code), or in the .cpp file containing the template function you make some explicit instantiations. This tells the compiler that the template function will be instantiated with the given types, so it can actually generate executable code.

[sasanet]

ok I get it now :D
nice explanation, thank to u I'm free to move to next chapter "class template" :D
tnx.