Re: Function pointer as template argument
On Dec 29, 7:41 pm, ym...@hotmail.com wrote:
On Dec 29, 6:43 pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
The practical answer, taking into account that the rules
for friend function definitions in classes were changed
during standardization, and that about 0% of C++
programmers know them, is to avoid using that feature.
Note that in this case, it is not the rules for friend function
definitions in classes that were changed, but the rules for name
lookup, in general. But you're probably right that most C++
programmers don't know them. (Not 0%, of course. I know of at
least three people who know them. All of whom work for EDG:-).)
Fair enough. I find friend function definitions inside class
(templates) useful. Most of the time, the rules in the
standard do the RightThing(tm), at least for me. But I
always have one of the arguments to be of the type of the
class (i.e., I use those friends for operator<< or
operator<).
That's the key. The Barton-Nackman techique depends on it, and
is wide-spread enough that the committee considered not breaking
it a make or break criteron for any changes.
Also, there's no problem with defining a friend function inside
a class IF the function is correctly declared outside the class.
The problem is that in this case, it's not one function he
wants, but an infinite number of them, so this solution isn't
applicable in this case. (In other cases, it's the way to go.)
Another solution would be to declare and define func as a
function template (outside the class template), and make the
instantiation a friend.
Here, we have the added trickyness that func() is called
with two doubles and nothing hints at A<double> as the point
where this version of func() is declared. I agree that (a)
Comeau is probably right and (b) one is better off staying
away from those cases.
Thank you for testing the code on the Comeau compiler, but I
fail to understand why func is undefined, since the following
code compiles and runs just fine on gcc:
//-------------------------------------------------------------
template<typename T> struct A {
template<typename T2> struct B {};
template<typename T2> friend const B<T2> func(T x, T2 y){return B<T2>
();};
};
int main() {
A<double> a,b;
func(1.2,1.3);
return 0;}
//-------------------------------------------------------------
It shouldn't. The code is clearly illegal, under the current
rules. (It was legal under the pre-standard rules, which
predated namespaces.)
I don't know what changing the return type changes how the
compiler handles this, but it is clearly an error in the
compiler.
The only difference here is in the return value of func, so as
I understand it, it should not influence whether func is
defined or not. Can anyone say what exactly makes the
difference between the two cases?
The difference is probably that Alf compiled the code on a very
close to standards conformant compiler, and you're compiling on
g++, and you've hit a bug in g++. (The g++ development team
will accept the bug report no questions asked. As Kai-Uwe said,
any time the compiler core dumps, it is a bug.) As for the
version which compiles with g++, you've have to ask them; I
think that from version 4.0 on, they would consider it a bug.
(I.e. they intended for this to work correctly from 4.0 on.)
--
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