Re: Function pointer as template argument
On Dec 30, 7:56 pm, "Joe Smith" <unknown_kev_...@hotmail.com> wrote:
James Kanze wrote:
I was asking why the new code, that defines the function
outside of the class does not work, even when the friend
declaration is omited.
In other words, why does Comeau not like the following:
----------------------------------
template<typename T,typename T2> T addw(T x,T2 y) {return x+(T)y;}
template<typename T> struct A {
template<typename T2,T (* const operation)(T,T2)> struct B {};
};
template<typename T,typename T2>
const typename A<T>::template B<T2,addw<T,T2> > func(T x, T2 y) {
return typename A<T>::template B<T2,addw<T,T2> >();
}
int main() {
A<double> a,b;
func(1.2,1.3);
return 0;
}
----------------------------------
I get the following error:
------
"ComeauTest.c", line 14: error: no instance of function template "func"
matches the
argument list
The argument types that you used are: (double, double)
func(1.2,1.3);
------
This looks to me like a bug in Comeau.
If I change the line to "func<double,double>(1.2,1.3);", I
still get the same error.
Because it doesn't change anything?
Note that even in this case, template argument deduction occurs,
and can fail. But none of the reasons given for failure seem to
apply here: there can't be any ambiguity with regards to the
type (which in fact was also true in the previous version), and
none of the cases in the list in =A714.8.2/2 (Those following the
statement "Type deduction may fail for the following reasons:")
seem to apply.
If I replace func's definition with:
-----------------
template<typename T>
const typename A<T>::template B<double,addw<T,double> > func(T x, double =
y)
{
return typename A<T>::template B<double,addw<T,double> >();}
-----------------
I still get the error.
On the other hand, the following replacement works:
-----------------
template<typename T2>
const typename A<double>::template B<T2,addw<double,T2> > func(double x, =
T2
y) {
return typename A<double>::template B<T2,addw<double,T2> >();}
-----------------
And of course, a non-template func works just fine.
What is going on here?
I'd report a compiler bug to Comeau. With the three
cases---there's probably a good hint in them as to where the bug
is (for someone who knows the compilers internals, of course).
(Note, for example, that in the last case, the template A is
resolved when the function template func is defined; in the
other two cases, only when it is instantiated. I would guess
that these are handled in different places in the compiler.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34