It's my esteemed privilege to try and repair some old legacy code (or at least gather enough evidence to convince the powers at be to let my team rewrite it)...in digging through this code (which is devoid of comments) I've come across something that seems a bit weird. Here's a paraphrasing of the declaration:

[source]

class foo

{

public:

class event;

private:

class request

{

friend class event;

public:

doStuff();

private:

LOTS OF INTERNAL METHODS

}

class response

{

friend class event;

public:

doStuff();

private:

LOTS OF INTERNAL METHODS

}

}

[/source]

Now, I've seen nested class definitions before, and I've seen the friend keyword in use before, but I've never seen the friend keyword used like this. There are several other classes with this very structure, unspecified class 'event' friended to 'response' and 'request' and others. Is the goal to instantiate foo1, foo2, etc. then iterate over unspecified object pointers, controlling them through this 'event interface'?

Maybe it's a design paradigm one of you has seen in the past (and not just something this programmer made up) so I thought I'd ask. What could be gained from this? (Other than some obfuscation, which isn't out of the question.) Naturally it's hard (maybe impossible) to determine what the point is without the code base (which I can't share directly). However, these classes aren't instantiated in the code I have because it's a library, and while I technically know what the library accomplishes, I'm now at a loss as to how I might wield it.

Oh, I found a comment. It says "// TODO: FIX". It's the only one. I lol'd.

So, possibly you've seen this or have a sharper imagination than I. In any case, thanks in advance for your time. :)

Are there any other references to Foo::Event anywhere, or does it not exist?

The disappointing answer to this is, no. I'm grepping for instances of 'Event' over the tree and it's just not there. It's a library with no clear way to use it. (I am in the purely political process right now of getting my hands on a functional example.) The classes are never instantiated.

If nothing else, when I do get an example instantiation and usage, I'll share it here. (Assuming I don't convince people to let us replace it.)

This could have been added before Event was added, then Event never got used. There's nothing here that would prevent compilation without Event being defined somewhere. All it pre-declares is that there may be a class called Foo::Event that can access the private variables of Request and Response. If this then hasn't been implemented later on, it won't make any difference to anything.

Commenting out both "friend class event;" and doing a complete rebuild would fail to compile if Event actually is being used and is accessing private member variables, and the compiler will and tell you what file and linenumber event is being used to access the private member variables. You could do that to track down where Event actually is.

In the interest of a direct answer: that's a forward declaration wrapped in a friend clause.

class Foo {
    friend Event;
};

class Event {};

Compiler error - error C2433: 'Event' : 'friend' not permitted on data declarations

class Foo {
    friend class Event;
};

class Event {};

No problem! Equivalent to:

class Event;

class Foo {
    friend Event;
};

class Event {};

Apologies if this was obvious. If your question has to do with why it's being used like that, I haven't the faintest idea. It appears event, request and response are tightly coupled for some reason

Is there a chance that foo is a template class?