Friend functions in namespaces

A friend prototype works as a declaration in the scope of the class.

class Foo {
  friend void bar(); //declaration
};
 
void bar() {
 //definition
}

just like

void foobar(); //declaration
 
void foobar() {
  //definition
}

What friend does is that the function prototyped has access to all of the class' members, even the private or protected ones. It's an external function with internal access. Your book is just doing a poor job of explaining it.

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();
}
 

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

No.

A friend prototype works as a declaration in the scope of the class.

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.

rip-off got it as well.

I don't think the book is correct, or it is talking about a specific compiler. To make rip-off's code compile in GCC 4.7.2 I had to declare someFunction() before namespace SomeNamespace and declare SomeNamespace::someNamespaceFunction() before main.

This page, under "Reliance on friend name injection", claims that this behaviour is not standard C++.

rip-off your first post clarifies it,thanks.