5

Possible Duplicate:
Forward declaration of nested types/classes in C++

For simple cross-references of classes it is feasable to predeclare the classnames and use it as reference. In this way the representation is a pointer. But in case I want to cross-reference a nested class of both (look at the example below), I will run into trouble, because there seems to be no way to predeclare a nested class.

So my question is: Is there a way to predeclare nested classes so that my example could work?

If not: Is there a common workaround for that, that doesn't uglyfy the code too much?

// Need to predeclare it to use it inside 'First'
class Second;
class Second::Nested; // Wrong

// Definition for my 'First' class
class First
{
public:
    Second::Nested* sested; // I need to use the nested class of the 'Second' class.
                            // Therefore I need to predeclare the nested class.
    class Nested { };
};

// Definition for my 'Second' class
class Second
{
public:
    First::Nested* fested; // I need to use the nested class of the 'First' class.
                           // This is okay.
    class Nested { };
};
Community
  • 1
  • 1
Christoph Meißner
  • 1,511
  • 2
  • 21
  • 40
  • Okay - If I would have looked for "declare" I would have found this answer. (That it isn't possible.) Thats it. Thanks. But for the moment I think about a workaround. Unnesting conflicts with another `class Nested` of my namespace. And renaming obfuscate the user of the interface. – Christoph Meißner May 13 '12 at 11:28

1 Answers1

4

In short, the answer is no.

But you should have looked first for a similar question...

EDIT: a possible workaround might be wrapping both classes in another class, and forward delcaring the nested classes inside the wrapper.

class Wrapper
{
public:

   // Forward declarations
   class FirstNested;
   class SecondNested;

   // First class
   class First
   {
   public:
      SecondNested* sested;
   };

   // Second class
   class Second
   {
   public:
      FirstNested* fested;
   };
};

This way you'll have to implement Wrapper::A and Wrapper::B while still isolating them from whatever namespace you're imlpementing.

Community
  • 1
  • 1
Eitan T
  • 32,660
  • 14
  • 72
  • 109
  • I've looked that question, but there is no solution but unnesting. I am sure that there must be another - better solution for that problem. Something like a pattern, that doesn't disturb the relations of the classes. – Christoph Meißner May 13 '12 at 11:34
  • It looks okay for the example above. In this case I accept it. Furthermore I still will have to find another solution, because I need to do such crossnestings multiple times, so that I can't put all my classes into a wrapper class. Thinking about a nested class inside a nested class, this is again no solution. – Christoph Meißner May 13 '12 at 11:46
  • You'll have to create shared classes for such cases, there is no other option (or rethink your design). – Eitan T May 13 '12 at 11:47