Re: Scope of a friend function defined inside a class definition + a doubt
"Peter" <pilarp@poczta.onet.pl>
However, it's perfectly legal to place the DEFINITION of a friend
function inside the definition of our class:
class foo
{
friend void friendly_function() {some code} // definition inside a
class definition
};
My questions are:
1. What is the scope of friendly_function() now?
It's at "namespace scope" (IOW just outside the class), but not visible
except through ADL. You can check its presense: declare an illegal overload
(same params, different return type) and it will be rejected.
2. What is the purpose of defining a friend function inside a
definition of a class which befriends it? It seems quite confusing and
illogical to me, my intuition tells me only a declaration should be
allowed there.
The function you wrote does not make sense of course -- it has no params so
ADL never finds it.
This feature is used mostly for operators related to the class or something
around. like operator << for streaming, binary operator +, and so on.
Certainly you can have a set of overloaded free functions with a good name
in a framework -- say serialize, some accessor shim, etc.
After all, why would anyone define a function which is
NOT a member of a class inside that class?
google for why we want to define operator + as a nonbember rather than
member.
Here comes my doubt. I have two, almost identical, snippets of code:
Which are certainly far from identical...
#include <iostream>
using namespace std;
class foo
{
int x;
friend void friendly_function(){} //empty DEFINITION
};
int main()
{
friendly_function();
return 0;
}
which doesn't compile: g++ and Comeau give an error message about
"friendly_function" identifier not being visible in main(),
Well told.
Visual C++
seems to be more precise: " 'friendly_function': candidate function(s)
not
accessible could be the friend function at :
'friendly_function' [may be found via
argument-dependent lookup]".
An this one gives you all the possible hints. If you don't know what the
message means look it up for more details. I'm sure pasting it in google
provides a ton of explanation.
Interestingly though, the following fragment is compiled by all three:
#include <iostream>
using namespace std;
class foo
{
int x;
friend void friendly_function(foo&){} // empty
DEFINITION, like before
};
int main()
{
foo obj;
friendly_function(obj);
return 0;
}
As you can see, the only difference is that previously
friendly_function() took no arguments and now an object of foo class
is passed to it by reference. Why does such a small change change the
scope of friendly_function()?
The first one is void, and the other has an argument of user defined type --
so argument dependent lookup applies, and will add the related namespaces of
all its arguments. finding the function where it is, in foo's namespace.
(it would be conveniently found even if foo lived in some buried
namespacewithout qualification.