Thread: Friend of namespace or of namespace function?

Originally Posted by whiteflags

I need to go back to my example.

The compiler basically works in top down fashion, so we have:

Code:

namespace foo {
   class yourclass;
   void bar ( yourclass & obj );
}
class foo::yourclass
{
   public:
   friend void bar ( yourclass & obj );
   // ...
};

void foo::bar ( yourclass & obj )
{
   // ...
}

Now, comment out "class yourclass;" and compile: you get an error about how yourclass was not declared in this scope. Demystified, that means that the compiler to this point has no idea what the identifier yourclass is. This effects anything that depends on yourclass; IOW, because yourclass is not declared, the parameter of foo::bar() and by extension that bar() cannot be declared. So, yeah, you have to declare things in some capacity, before you attempt to use them.

If we understand this, then we understand that "class yourclass;" should come before the namespace, because the declaration has to come before the prototype, which is in the namespace. It's the grammar of C++. It's not me.

Also, part of the problem comes with the use of friend. I'm guessing, and don't really want to go into the details, that you are using friend for its intended purpose, such that any friend functions of yourclass would need to be friends, because they have yourclass parameter(s) and need access to private (or otherwise restricted) yourclass members. Most uses of friend can be made optional.

Well, my namespace function which is going to be a friend of the class does not take a parameter to an object of the class. I made it a friend just so it could access a couple of private members of the class. It doesn't need to operate on a class object, and therefore, in my case, there is no real need for a class declaration, only a definition which follows the namespace with the function prototypes in it.

Originally Posted by whiteflags

I'm starting to lose track of what we are talking about, but if your function needs access to members of yourclass in any capacity it is necessary for the compiler to know what yourclass is, at that point, when it translates your source.

Right. And if I understand the "friend" concept right, you can declare an external function as a friend inside the class definition, and that allows the external function declared as a friend to do stuff with protected or private members of the class. I just assumed that the friend declaration prototype is supposed to mimic the function declaration prototype in the namespace, if the function declared as friend is a namespace function, i.e. so that the function declared as a friend inside the class needs to be declared first (which is what Elysia hinted at) outside the class (which I assumed to mean ABOVE the class definition).