Friend of namespace or of namespace function?

Hey,
I was wondering if you could make either a namespace or a function of a namespace a friend of a class.

You cannot make an entire namespace a friend. You can make any function you want a friend, however, inside a namespace or not.

Quote:

---

Originally Posted by Elysia

You cannot make an entire namespace a friend. You can make any function you want a friend, however, inside a namespace or not.

---

Ok, thanks. And is it better to put the namespace with said friend function of class before or after class definition?

The declaration of the function needs to be available prior to the friend declaration.

Quote:

---

Originally Posted by Elysia

The declaration of the function needs to be available prior to the friend declaration.

---

Ahh, ok. So before then.
I would have liked to have it after, but oh well...

You can define it afterwards, but you need the declaration before.

Quote:

---

Originally Posted by Elysia

You can define it afterwards, but you need the declaration before.

---

How would I do that? Just write:

Code:

---

namespace NAMESPACE_NAME {
    //function1 prototype here
    //function2 prototype here
  //etc...
}

---

before the class definition, and then write

Code:

---

namespace NAMESPACE_NAME {
    //function1 definition here
    //function2 definition here
    //etc...
}

---

after the class definition?

Yes, the same as you would do with any function.

You simply need to have the prototype in the namespace.

Code:

---

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

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

---

Is that what you mean by "after"?

Quote:

---

Originally Posted by whiteflags

You simply need to have the prototype in the namespace.

Code:

---

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

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

---

Is that what you mean by "after"?

---

No. My namespace that I'm writing does not include the class. The class is separate from the namespace. By "after", I meant all namespace functions' definitions would come after the class definition. But thanks for showing me I did not have to write namespace after the class definition. I just have to write FUNCTION_TYPE NAMESPACE_NAME::FUNCTION_NAME(...) { //... } for each function of the namespace.

Quote:

---

No. My namespace that I'm writing does not include the class.

---

In that case, the class's forward declaration is simply placed outside the namespace before the prototype, which is in the namespace.

Quote:

---

Originally Posted by whiteflags

In that case, the class's forward declaration is simply placed outside the namespace before the prototype, which is in the namespace.

---

Which prototype are we talking about? Sorry, the wording of your post confused me. :)

OK, by definition, a prototype is a function signature such as

void bar ( yourclass & obj )

followed by a semicolon. You could also say "function prototype", but AFAIK, only functions have prototypes anyway.

A forward declaration is for types. You simply name the type with one of the class-key keywords (which is in chapter 9 of the standard, if that helps) such as

class yourclass;

I thought I was being clear. I'm sorry for the confusion.

Quote:

---

Originally Posted by whiteflags

OK, by definition, a prototype is a function signature such as

void bar ( yourclass & obj )

followed by a semicolon. You could also say "function prototype", but AFAIK, only functions have prototypes anyway.

A forward declaration is for types. You simply name the type with one of the class-key keywords (which is in chapter 9 of the standard, if that helps) such as

class yourclass;

I thought I was being clear. I'm sorry for the confusion.

---

I know what a prototype is. I was just wondering which one you were talking about. I guess you were talking about the function prototypes of the namespace, but I don't see why a class forward declaration would be useful here. That's the part I was really confused about, but I said the wrong thing. Why would you put a class declaration followed by a namespace with function prototypes, followed by a class definition, followed by a namespace with function definitions (or just namespace function definitions)? Can't I just do a namespace with function prototypes, followed by a class definition, followed by a namespace with function definitions (or just namespace function definitions), and forget about using a class forward declaration?

EDIT: Another thing...
I decided to write just the namespace function definitions after the class definition (as opposed to the namespace with the function definitions approach), but one of my namespace functions requires a typedef'd type in one of its parameters. The typedef is local to the namespace. In that function's definition after the class's definition, do I need to specify the namespace name followed by double semicolons and the typedef name instead of just using the typedef name for the type of the function parameter?

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.

Quote:

---

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.

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.

Quote:

---

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).

OK, well all of that has nothing to do with whether yourclass is declared or not. In my example, a forward declaration allows me to arrange the code the way I did. It is necessary.

It's probably not necessary for your function because it doesn't take a parameter of type yourclass. I didn't know that until way later. When you originally said you don't see how a forward declaration was useful here, I took "here" to mean that you were talking about my example and not your own code. So I hope that explains my thinking.