including nested classes

Question

I have a container class with several iterators as nested classes. The structure is something ilke this:

class Grid
{
protected:
    class Iterator
    {
        Iterator(Grid* g) : grid(g){}
        Grid* grid;
    }
    class MoreIterator : public Iterator
    {
    }
}

Now I wanted to move the iterators in a header file of their own, to clean up the containers code.

class Grid
{
protected:
#include "griditerators.h"
}

So far this compiles without errors. But:

In QtCreator the lines

Iterator(Grid* g) : grid(g){}
Grid* grid;

are marked as errors, telling me "Grid is not a type name".

I thought I could solve that with a forward declaration in the griditerator.h file:

class Grid;
class Iterator
{
    Iterator(Grid* g) : grid(g){}
    Grid* grid;
}

But that gives me a compile error: Class Grid has the same name as the class in which it is declared.

Replacing the forward declaration with #include "grid.h" works. But I somehow think that's ugly.

So I have two working options. One shows ugly errors in my IDE, the other I just don't like that much.

I tried other variations, where the include isn't within the enclosing class, but that failed to compile for different reasons.

So my question is: Are there any "best practices" or include patterns to handle nested classes that are too large to keep them within their enclosing class file?

For example would there be a way to declare a nested class like:

class Grid::Iterator

Answer 1

Don't put the nested class declaration in a separate header file. It's bad design and will confuse the hell out of anyone else who has to maintain your code. If the nested class is too big, unnest it and put it in it's own compilation unit (h/cpp combo).

Answer 2

It is easy to add nested class implementation in a separate file. I do it all the time, but you will still need to declare the nested class in it's owner. Do the following:

    class Grid
    {
    protected:
        class Iterator;
        class MoreIterator;
    };

Then in a you separate cpp or header file you will need to implement your nested classes the following way:

class Grid::Iterator
{
    Iterator(Grid* g) : grid(g){}
    Grid* grid;
}
class Grid::MoreIterator : public Iterator
{
}

The cool thing about this is that class Grid does not need to know the details of the two nested classes, but the two nested classes know the details of class Grid and will have access rights to the private data in class Grid just like any method that is a member of class Grid.