It means that you're doing something in graphics.h that requires knowledge of the full definition of struct Game, but you're only including the forward definition. Typical examples are passing an instance by value, or accessing a member. Either include the full definition, or better yet, move those parts that need the internals into grahpics.c (if this is possible).

In include/graphics.h

class Graphics : public Game {/*...*/};

You didn't include 'include/game.h' there, so it has no idea how to inherit the Graphics class from the Game class. A forward declaration will not work there.

In include/game.h

class Game
{
    public:
        Game();
        ~Game();

        void Run();
        void Error( const char* format, ... );

        Graphics* gfx;

    private:

};

You didn't include 'include/graphics.h' or 'include/fwd/graphics.h' there, so it has no idea what a Graphics* is.

As an aside, making separate headers for forward declarations is silly. If you need a forward declaration in some other header, just write it there.

Why would anyone think to look in stdafx.h? I thought that was some kind of MSVC thing...

Only include what actually needs to be included, don't just mash everything into a single header and then include that everywhere.

I see the problem now. stdafx.h includes both include/game.h and include/graphics.h, both of which include stdafx.h. Circular inclusion bad...

So game.h looks like :

So game.h tries to include itself, but it's header guards prevent it from actually being included. The next thing that happens is that include/graphics.h is included, but class Game hasn't been completely declared yet, resulting in an invalid use of incomplete type struct Game.

Something similar happens in graphics.h.

Only include what is completely necessary for each file.

If you need a forward declaration, do it in the header that needs it.

I got it all working now guys. Thanks for your help

I shall defiantly be keeping that in mind from now on