Re: Overload resolution and user defined conversion function
On 15 Jun., 11:10, CornedBee <wasti.r...@gmx.net> wrote:
On Jun 12, 12:41 am, Rodolfo Lima <rodo...@rodsoft.org> wrote:
[..]
template <class T>
struct A
{
friend void foo(A a) {}
};
template <class T>
struct B
{
operator A<T>() const { return A<T>(); }
};
int main()
{
foo(A<int>()); // OK
foo(B<int>()); // error: foo was not declared in this scope
}
This one is interesting. I believe that the problem here is that the
friend function is simply not considered during the lookup the second
time around, because A<T> is not an associated class of B<T>. It might
also be that in the context of the second lookup, the definition of
A<int> isn't required to be instantiated, so the friend function isn't
declared. But in this case, I'm not sure. Friend lookup rules in
template contexts are weird.
Weird is a reasonable attribute here ;-) The reason for the failure
is that we have the effect of (all quotes from FCD)
14.5.4 [temp.friend]/4:
"When a function is defined in a friend function declaration in a
class template, the function is instantiated when the function is
used."
and of the look-up rules described in 14.6.5 [temp.inject]/1:
"As with non-template classes, the names of namespace-scope
friend functions of a class template specialization are not visible
during an ordinary lookup unless explicitly declared at
namespace scope (11.4). Such names may be found under the
rules for associated classes (3.4.2)."
Checking 3.4.2 [basic.lookup.argdep]/2, we see that B<int> is not
an associated class of A<int> (as you say).
Note that [temp.friend]/4 was recently clarified by core defect:
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#329
Before that change, the friend function would always be instantiated
and would thus participate.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]