namespace Me{
class Us{
friend void you();
};
}
According to a book: "Now the function you is a member of the namespace Me".
And also: "If you introduce a friend in the global namespace,the friend is injected globally".
Statement 1: What does it mean it's a member of the namespace?!
Statement 2: So if I add a friend function in a class that is in the global namespace,because I want it to,ALL the other classes that I added in the global namespace will take that class as a friend too?
class Foo {
friend void bar(); //declaration
};
void bar() {
//definition
}void foobar(); //declaration
void foobar() {
//definition
}you got it wrong,the book explained in details the effects of friend,but it appears that friend is applied in another way in a namespace
Caveat: This is not an area of C++ I am very familiar with, but this is my interpretation of what the book says. My compiler happens to agree with me.
Statement 1: What does it mean it's a member of the namespace?!
It means that the function that is friended is Me::you() - that is how you would call it from main(). To friend a global function, then you'd have to write:
void globalFunction();
namespace SomeNamespace
{
class Example
{
friend void ::globalFunction();
};
}
Statement 2: So if I add a friend function in a class that is in the global namespace,because I want it to,ALL the other classes that I added in the global namespace will take that class as a friend too?
No. They are saying that when you use the friend keyword to introduce a function, this is implicitly declaring the function (if it is not already declared). In the case the class offering friendship is not in a namespace, the function implicitly declared is also part of the global namespace:
class Example
{
friend void someFunction();
};
In this example, the friend statement doubles as a declaration of someFunction in the global namespace.
Perhaps the following complete example might be illustrative:
class SomeClass {
// Implicitly declaring "someFunction" in the global namespace
friend void someFunction();
};
namespace SomeNamespace
{
class SomeNamespaceClass
{
// This line wouldn't compile without the (implicit) declaration above
friend void ::someFunction();
// Implicitly declaring "someNamespaceFunction" in SomeNamespace
friend void someNamespaceFunction();
};
}
// We can call these functions in main now, despite not having declared them outside the friend declarations
int main() {
someFunction();
SomeNamespace::someNamespaceFunction();
}
No.you got it wrong,the book explained in details the effects of friend,but it appears that friend is applied in another way in a namespace
If the class is declared within a namespace then the friend function declaration is within that same namespace. It's declared at the same scope as the class. This is what the book is saying.A friend prototype works as a declaration in the scope of the class.
This page, under "Reliance on friend name injection", claims that this behaviour is not standard C++.
